Idiomatic way to use command-line parameters in Scala script

Question

I would like to create a generic Scala script template (using Conscript). The script should take command-line options, for example a flag "-v" to enable verbose mode.

In say a Perl script, I would create a global variable $verbose, which I would set to true or false (or rather 1 or 0) depending if the flag is present. I understand that setting global variables in a script is not the Scala way.

Consider the following example:

object Main {
  def main(args: Array[String]) {
    val options = parseOptions(args);  // some way of parsing

    // how to use 'options' in the remainder of the script?
  }
}

How to do it? One way I could see is to keep the option value as context variables in a closure, i.e., access them from nested functions. However, the problem with using nested functions is that I can't write unit tests for them. Another straightforward way would be to pass the options along with every function call, but that seems unwieldy.

Any suggestions?

Rich · Accepted Answer · 2016-10-28 12:43:57Z

5

For parsing options, you can use https://github.com/scopt/scopt, but I see that you're actually asking how to use a Config object that an options parser might return.

I think you need to pass the Config object around; it is a dependency of the code which uses it and code ought to have its dependencies provided directly where possible, rather than via global variables, as you note.

If you want to save some typing, you can pass it implicitly, i.e.

case class Config(verbose: Boolean)

object Main {
  def main(args: Array[String]) {
    implicit val config: Config = parseOptions(args); // some way of parsing

    new FooComponent().doSomeStuff()
  }
}

class FooComponent()(implicit config: Config) {

  def doSomeStuff() {
    ... stuff
    if (config.verbose) {
      println(...)
    }
    ...
  }
}

You also can use the IoC pattern so that separate modules don't depend on Main.Config, but instead expose an interface declaring what config they need that Config will implement.

i.e.

case class Config(verbose: Boolean) extends FooHandler.Config {
  def printFooInfo: Boolean = verbose
}

object Main {
  def main(args: Array[String]) {
    val config: Config = parseOptions(args);  // some way of parsing

    FooHandler.handleFoo(config)
  }
}

// This looks contrived with small code, but works well if
// your codebase is large and FooHandler is far away from Main
object FooHandler {
  trait Config {
    def printFooInfo: Boolean
  }

  def handleFoo(config: Config) {
    ... stuff
    if (config.printFooInfo) {
      println(...)
    }
    ...
  }
}

edited Oct 28, 2016 at 12:43

answered Oct 28, 2016 at 12:24

Rich

15.5k3 gold badges73 silver badges126 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Marius K Over a year ago

Thanks. How would you use, then, the config object returned by scopt's OptionParser.parse() function?

Daenyth Over a year ago

Update the answer to post an example of how it helps to avoid this being a link-only answer

Marius K Over a year ago

Thanks, I think the version using implicit will do very nicely in my case!

Collectives™ on Stack Overflow

Idiomatic way to use command-line parameters in Scala script

1 Answer 1

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related