求推荐Scala最佳CLI解析器及类sbt console的REPL开发工具

Great question! When building CLI tools and custom REPLs in Scala, there are some fantastic options in the ecosystem that fit different needs—whether you prioritize type safety, minimal boilerplate, or functional programming paradigms. Let me break down the best picks for you:

Here are the top choices, each with distinct strengths:

• Scopt
  The gold standard for type-safe CLI parsing in Scala. It’s lightweight, intuitive, and leverages case classes to model your configuration. You define your options with a fluent API, and Scopt handles validation, usage text generation, and argument parsing automatically. Perfect for most projects where you want full control without unnecessary complexity.
  Example snippet:

  import scopt.OParser
  
  case class Config(name: String = "", age: Int = 0, verbose: Boolean = false)
  
  val builder = OParser.builder[Config]
  val parser = {
    import builder._
    OParser.sequence(
      programName("myapp"),
      head("myapp", "1.0"),
      opt[String]('n', "name").required().action((x, c) => c.copy(name = x)).text("Name is required"),
      opt[Int]('a', "age").action((x, c) => c.copy(age = x)).text("Age of the user"),
      opt[Unit]('v', "verbose").action((_, c) => c.copy(verbose = true)).text("Enable verbose mode"),
      help("help").text("Prints this usage text")
    )
  }
  
  OParser.parse(parser, args, Config()) match {
    case Some(config) => println(s"Hello ${config.name}, you're ${config.age} years old")
    case None => // Handle parsing errors
  }
  

• CaseApp
  If you hate boilerplate, CaseApp is your go-to. It uses Scala macros to automatically generate a CLI parser from a case class—no need to manually define options or usage text. It also supports subcommands, version flags, and remaining arguments out of the box. Ideal for projects where you want to get up and running quickly with minimal code.
  Example snippet:

  import caseapp._
  
  @AppName("myapp")
  @AppVersion("1.0")
  case class MyAppConfig(
    name: String,
    age: Option[Int] = None,
    verbose: Boolean = false
  )
  
  object MyApp extends CaseApp[MyAppConfig] {
    def run(config: MyAppConfig, args: RemainingArgs): Unit = {
      println(s"Hello ${config.name}, age: ${config.age.getOrElse("unknown")}")
    }
  }
  

• Decline
  Built for functional Scala developers, Decline is based on Cats and Cats Effect. It offers a purely functional API for defining CLI options, with strong type safety and support for effectful operations. If your project uses functional programming patterns (like IO monads), Decline integrates seamlessly without feeling forced.
  Example snippet:

  import cats.effect.IO
  import decline._
  
  object MyApp extends CommandIOApp("myapp", "A simple Scala CLI tool") {
    val nameOpt: Opts[String] = Opts.option[String]("name", "Your name").required
    val ageOpt: Opts[Option[Int]] = Opts.option[Int]("age", "Your age").optional
    val verboseOpt: Opts[Boolean] = Opts.flag("verbose", "Enable verbose mode").orFalse
  
    override def main: Opts[IO[Unit]] = (nameOpt, ageOpt, verboseOpt).mapN { (name, age, verbose) =>
      IO {
        println(s"Hello $name, age: ${age.getOrElse("unknown")}")
        if (verbose) println("Verbose mode enabled!")
      }
    }
  }
  

For a rich, interactive REPL experience that lets you work with your application’s code (just like sbt console), here are the best options:

• Ammonite REPL
  The most popular enhanced Scala REPL out there. It supports syntax highlighting, tab completion, multi-line editing, and can easily load your application’s class files or dependencies. You can start it with your project’s classpath using:

  amm --classpath target/scala-2.13/classes
  

  If you want to embed a custom REPL directly into your application, Ammonite provides an API to do so. Example:

  import ammonite.Main
  
  object MyAppREPL extends App {
    // Pass your application's classpath to the REPL
    val classpath = sys.props("java.class.path").split(java.io.File.pathSeparator).toList
    Main.main(Array("--classpath", classpath.mkString(java.io.File.pathSeparator)))
  }
  

• Scala CLI REPL
  If you’re using Scala CLI (the modern alternative to sbt for small to medium projects), its built-in REPL is lightweight and integrates perfectly with your project. You can start it with your project’s code using:

  scala-cli repl --classpath target/scala-2.13/classes
  

  It supports instant dependency loading and works seamlessly with Scala 2 and Scala 3.

• sbt Console (for sbt projects)
  Don’t overlook the tool you already mentioned! If your project uses sbt, running sbt console directly loads your project’s classes, dependencies, and build settings into the REPL. It’s the simplest option if you’re already in the sbt ecosystem, and you can even customize it via sbt settings (like adding default imports or initial setup code).

内容的提问来源于stack exchange，提问作者Amir Hossein Javan