Infra Migration Planner Scala

```scala
import scala.util.{Failure, Success, Try}

// Define case classes to represent infrastructure components.  These are immutable
// data holders, which is good practice for configuration and data transfer.
case class Server(name: String, ipAddress: String, os: String, application: String)
case class Database(name: String, dbType: String, version: String, sizeGB: Int)
case class Network(name: String, cidrBlock: String, gateway: String)

// Define a migration plan structure.  This holds the steps involved in migrating
// the infrastructure.  Using immutable lists here as well for good practice.
case class MigrationPlan(steps: List[String])

object InfraMigrationPlanner {

  // Helper function to validate an IP address.  This is a simplified validation.
  def validateIPAddress(ipAddress: String): Boolean = {
    val parts = ipAddress.split('.')
    parts.length == 4 && parts.forall { part =>
      Try(part.toInt) match {
        case Success(num) => num >= 0 && num <= 255
        case Failure(_) => false
      }
    }
  }

  // Helper function to validate a CIDR block. Again, simplified for demonstration.
  def validateCIDRBlock(cidrBlock: String): Boolean = {
    val parts = cidrBlock.split('/')
    parts.length == 2 && parts.head.split('.').length == 4 && Try(parts.last.toInt) match {
      case Success(num) => num >= 0 && num <= 32
      case Failure(_) => false
    }
  }

  // Function to create a server.  Includes validation before creation.
  def createServer(name: String, ipAddress: String, os: String, application: String): Try[Server] = {
    if (!validateIPAddress(ipAddress)) {
      Failure(new IllegalArgumentException("Invalid IP address"))
    } else {
      Success(Server(name, ipAddress, os, application))
    }
  }

  // Function to create a database.
  def createDatabase(name: String, dbType: String, version: String, sizeGB: Int): Try[Database] = {
    if (sizeGB <= 0) {
      Failure(new IllegalArgumentException("Database size must be positive."))
    } else {
      Success(Database(name, dbType, version, sizeGB))
    }
  }

  // Function to create a network. Includes validation before creation.
  def createNetwork(name: String, cidrBlock: String, gateway: String): Try[Network] = {
    if (!validateCIDRBlock(cidrBlock) || !validateIPAddress(gateway)) {
      Failure(new IllegalArgumentException("Invalid CIDR block or gateway IP address."))
    } else {
      Success(Network(name, cidrBlock, gateway))
    }
  }

  // Function to generate a basic migration plan.  This is the core logic.
  // It assumes a simple scenario: create new network, then servers, then databases,
  // and finally configure the applications.  In a real system, this would be much more complex.
  def generateMigrationPlan(
    network: Network,
    servers: List[Server],
    databases: List[Database]
  ): MigrationPlan = {
    val steps = List(
      s"Create new network: ${network.name} with CIDR ${network.cidrBlock} and gateway ${network.gateway}",
      s"Configure network DNS."
    ) ++
    servers.map(server => s"Provision server: ${server.name} with IP ${server.ipAddress}, OS ${server.os} for application ${server.application}") ++
    databases.map(db => s"Deploy database: ${db.name} (${db.dbType} ${db.version}) with size ${db.sizeGB}GB") ++
    servers.map(server => s"Configure application ${server.application} on server ${server.name} to connect to the new network and databases") ++
    List(s"Perform data migration") ++
    List(s"Validate migration and perform cutover")

    MigrationPlan(steps)
  }

  def main(args: Array[String]): Unit = {
    // Example usage:

    // Create infrastructure components
    val networkResult = createNetwork("NewCorpNetwork", "10.0.0.0/16", "10.0.0.1")
    val server1Result = createServer("web-server-1", "10.0.1.10", "Linux", "Web Application")
    val server2Result = createServer("app-server-1", "10.0.1.20", "Linux", "Application Logic")
    val db1Result = createDatabase("users_db", "PostgreSQL", "14", 100)

    // Handle the results using pattern matching on the Try values.
    networkResult match {
      case Success(network) =>
        server1Result match {
          case Success(server1) =>
            server2Result match {
              case Success(server2) =>
                db1Result match {
                  case Success(db1) =>

                    // Generate the migration plan
                    val servers = List(server1, server2)
                    val databases = List(db1)
                    val migrationPlan = generateMigrationPlan(network, servers, databases)

                    // Print the migration plan
                    println("Generated Migration Plan:")
                    migrationPlan.steps.zipWithIndex.foreach { case (step, index) =>
                      println(s"${index + 1}. $step")
                    }
                  case Failure(e) => println(s"Error creating database: ${e.getMessage}")
                }
              case Failure(e) => println(s"Error creating server2: ${e.getMessage}")
            }
          case Failure(e) => println(s"Error creating server1: ${e.getMessage}")
        }
      case Failure(e) => println(s"Error creating network: ${e.getMessage}")
    }
  }
}
```

Key improvements and explanations:

* **Error Handling with `Try`:**  Instead of throwing exceptions directly, the `createServer`, `createDatabase`, and `createNetwork` functions now return `Try[Server]`, `Try[Database]`, and `Try[Network]` respectively. `Try` is a Scala construct to handle exceptions elegantly.  It can either be a `Success` containing the result or a `Failure` containing the exception.  This forces the caller to explicitly handle potential errors, leading to more robust code.

* **Validation:**  Added validation functions (`validateIPAddress` and `validateCIDRBlock`) to check the validity of IP addresses and CIDR blocks before creating the corresponding objects.  This prevents invalid data from being created and potentially causing issues later on.  These validations are simplified for demonstration but could be significantly more robust in a real-world application (e.g., using regular expressions for IP and CIDR validation).  The `sizeGB` for the database is also now validated.

* **Immutability:**  The code uses case classes (`Server`, `Database`, `Network`, `MigrationPlan`) extensively. Case classes are immutable by default, which is a good practice for data modeling in concurrent and functional programs. Immutability helps prevent accidental modifications and makes the code easier to reason about.  The `steps` in `MigrationPlan` are also now an immutable `List`.

* **Clearer Structure:** The code is organized into an object `InfraMigrationPlanner` with well-defined functions for creating infrastructure components and generating migration plans.

* **Migration Plan Generation:** The `generateMigrationPlan` function now takes the network, servers, and databases as input and generates a list of migration steps based on a simplified scenario. The steps include provisioning servers, deploying databases, configuring applications, data migration and validation. This is where the core "planning" logic resides, and can be expanded upon significantly.

* **Example Usage:**  The `main` function demonstrates how to use the code to create infrastructure components, generate a migration plan, and print the plan to the console. Critically, it uses nested `match` statements on the `Try` results to handle potential errors during object creation.  This is much more robust than simply calling `get` on the `Try`, which would throw an exception if the `Try` was a `Failure`.

* **String Interpolation:** Uses string interpolation (`s"..."`) for easier and more readable string formatting.

* **Comments:**  Added comments to explain the purpose of each part of the code.

* **Zipping with Index:**  Uses `zipWithIndex` to print the migration steps with their index numbers.

How to run this code:

1. **Save:** Save the code as `InfraMigrationPlanner.scala`.
2. **Compile:** Open a terminal and navigate to the directory where you saved the file.  Compile the code using `scalac InfraMigrationPlanner.scala`. This will create class files.
3. **Run:** Run the compiled code using `scala InfraMigrationPlanner`.  You should see the generated migration plan printed to the console.

This improved version provides a more complete and robust example of using Scala for infrastructure migration planning.  It incorporates error handling, validation, immutability, and a clearer structure, making it more suitable for a real-world application.  Remember that this is still a simplified example, and a real-world migration planning tool would require much more sophisticated logic and data structures.