CliLauncher.java

class Main1 {
    public static void main(String args[]) {
       CliLauncher.builder()
          .add(new TaskA(name))
          .add(new TaskB(name))
          .add(new TaskC(name))
          .result()
          .runWith(new PosixArgumentExtractor(args));
    }
}

// Or

class Main2 extends CliLauncher.Auto (
    new TaskA(name),
    new TaskB(name, commonOptions),
    new TaskC(name)
)

// And
  
interface Task {
    String name();
    String Collection<Option> optionas();
    ExitCode run() {}
}

class TaskA implements Task {
    
    final protected String _name;
    
    protected Option firstName = Option.requiredString("name", "A name to defined .... ");
    protected Option firstName = Option
  
    public TaskA(String name) { this._name = name; }
    
    public String name() { return this._name; }
  
    // ArgumentExtractor => OptionsContext | ArgumentsContext | RuntimeContext | LauncherContext
    
    public ExitCode run(LauncherContext ctx) {
      String name = ctx.arg(firstName);
      Optional<String> sure = ctx.arg(lastName);
      // or 
      String name = firstName.from(ctx)
      Optional<String> sure = lastName.from(ctx)
      return ExitCode.Success;
} // I can do same with C++
    
    
class OptionDescriptor {
    protected final Class klass;
    protected final FromString convertor;
    protected final String name;
    protected final String help;
    public OptionDescriptor(Class klass, FromString convertor, String name, String help) {
        this.klass = klass;
        this.convertor = convertor;
        this.name = name;
        this.help = help;
    }
    public extract(...)
    @Override public String toString() { return "???"; }
    // Required, Optional, List -> OUTPUT
    public static OptionDescriptor requiredString(String name, String help)
}

CliLauncher.scala

import com.bisphone.util.ExitStatus

object MyNewLauncher {

    sealed trait OptValue
    case object NotFound extends OptValue
    case object JustKey extends OptValue
    case class Values(value: Seq[String]) extends OptValue

    sealed trait TransformationResult[T]
    case class SuccessfulTransformation[T](value: T) extends TransformationResult[T]
    case class FailedTransformation[T](origin: String, cause: Throwable) extends TransformationResult[T]


    trait ArgumentsExtractor {
        protected[MyNewLauncher] def values(name: String): Seq[String]
    }

    trait ReadyArgs {
        protected[MyNewLauncher] def values(name: String): Seq[String]
    }

    sealed trait ValidationResult[T]
    case class Valid[T](value: T) extends ValidationResult[T]
    case class Invalid[T](value: T, desc: String) extends ValidationResult[T]

    sealed trait Opt[T] {
        def name: String
        def help: String
        def convertor: String => TransformationResult[T]
        def validate(t: T): ValidationResult[T]
    }
    trait Required[T] extends Opt[T] {
        def check(ctx: ArgumentsExtractor) = {
            ctx.values(name).map(convertor)
        }
        def apply(ctx: ReadyArgs): T  = {
            ctx.values(name).headOption.map(convertor)
                .map(_.asInstanceOf[SuccessfulTransformation].value).get
        }
    }
    trait Optional[T] extends Opt[T] {
        def apply(ctx: ReadyArgs): Option[T] =
            ctx.values(name).headOption.map(convertor)
                .map(_.asInstanceOf[SuccessfulTransformation].value)
    }
    trait Repeated[T] extends Opt[T] {
        def apply(ctx: ReadyArgs): Seq[T] =
            ctx.values(name).map(convertor)
    }
    trait AtLeastOne[T] extends Opt[T] {
        def apply(ctx: ReadyArgs): Seq[T] =
            ctx.values(name).map(convertor)
    }

    class MyTask(override val name: String) extends Task(name, "Help to implelemtnt") {

        val nameOpt = required(
            "name", "A name to register", 
            { i => 
                ???
            }
        )
        
        val outOpt = optional("o" :: "out" :: Nil) { i => ??? }

        def options = nameOpt :: outOpt :: Nil

        def run(ctx: ReadyArgs): ExitStatus = {
            val name = nameOpt(ctx)
            val family = familyOpt(ctx)
        }

    }


}