How does one inherit or reuse options?

[dblock]

Forgive a scala noob, this is probably trivial and is basically the unanswered SO http://stackoverflow.com/questions/34026943/extending-scopt-optionparser-in-scala.

I have some base options:

trait BaseOpts {
  def reticulate: Boolean
}

case class Opts(
  reticulate = true
) extends BaseOpts

abstract class Job {

  def parseOpts(args: Array[String]): Opts = {
    val parser = new scopt.OptionParser[Opts]("scopt") {
      head("scopt", "3.x")
      opt[String]("reticulate") action { (x, c) =>
        c.copy(reticulate = x)
      } text ("reticulate splines")
    }

    parser.parse(args, Opts())
      .getOrElse(throw new Exception("Error parsing cli args"))
  }
}

I'd like to extend Job along with Opts.

case class SplineOpts(
  maxSplines:   Int = 10000
) extends Opts(reticulate = true);

object SplineJob extends Job {
  override def parseOpts(args: Array[String]): SplineOpts = {
  }
}

So far I'm stuck here, this signature below is String, SplineOpts -> Opts, which is wrong, I want SplineOpts.

    val parser = new scopt.OptionParser[SplineOpts]("scopt") {
      opt[String]("maxSplines") action { (x, c) =>
        c.copy(maxSplines = x.toInt)
      } text ("max number of splines")
    }

Maybe there's an overall better strategy for adding more options than a base and parsing them?

[dblock]

I was able to combine two parsers into one set of options, see http://stackoverflow.com/a/43001193/123094, but that is far from ideal. I'd like to be able to actually inherit a parser from another or combine them in some way that produces a single case class set of options.

[aappddeevv]

@i think the final parser needs to be a union of all the types that would eventually be parsed so you could split the "config" type up (an abstract type) if you want to but they need to come together at some point in the lowest level class.

You could then just compose things based on passing around the parser instance and importing the dsl functions to "add" a component's options prior to the actual parsing.

// Unit signals we are mutating
def addOptions(op: scopt.OptionParser[FinalType]): Unit = {
  import op._
  cmd("blah")
  note("blah")
  ...
}

Having said that you could also probably pull the option processing out of the class entirely.

[dportabella]

any idea of how to solve this issue?

[aappddeevv]

just do as described above, there are a couple methods. The parser object has a DSL that mutates internal structures so write a function that takes the parser object and import those DSL functions. The rest of the function uses those DSL functions to “add” your reusable parser options. There are a couple of other issues that covers this as well. Because of the dsl design, you do not declare options outside the context of a parser object.

[dportabella]

is it possible to have a minimal complete working example, please?

[aappddeevv]

https://github.com/aappddeevv/dynamics-client/blob/master/cli/src/main/scala/dynamics/cli/CommandLine.scala

[eed3si9n]

Released scopt 4.0.0-RC2 with more composable OParser. See http://eed3si9n.com/scopt4 for details.