ConsParser

Instance Constructors

new ConsParser(arg: Arg, argParser: ArgParser[H], default: () ⇒ Option[H], tail: Aux[T, DT])

Type Members

type D = ::[Option[H], DT]

Intermediate result type.
Intermediate result type.
Used during parsing, while checking the arguments one after the other.
If parsing succeeds, a T can be built from the D at the end of parsing.

Definition Classes
ConsParser → Parser

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val arg: Arg
val argParser: ArgParser[H]
val args: Seq[Arg]

Arguments this parser accepts.
Arguments this parser accepts.
Used to generate help / usage messages.

Definition Classes
ConsParser → Parser
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val default: () ⇒ Option[H]
final def detailedParse(args: Seq[String]): Either[Error, (::[H, T], RemainingArgs)]

Keeps the remaining args before and after a possible -- separated
Keeps the remaining args before and after a possible -- separated

Definition Classes
Parser
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def get(d: D): Either[Error, ::[H, T]]

Get the final result from the final intermediate value.
Get the final result from the final intermediate value.
Typically fails if some mandatory arguments were not specified, so are missing in d, preventing building a T out of it.
returns
in case of success, a T wrapped in scala.Right; else, an error message, wrapped in caseapp.core.Error and scala.Left

Definition Classes
ConsParser → Parser
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def init: D

Initial value used to accumulate parsed arguments.
Initial value used to accumulate parsed arguments.

Definition Classes
ConsParser → Parser
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def map[U](f: (::[H, T]) ⇒ U): Aux[U, D]

Definition Classes
Parser
def mapHead[I](f: (H) ⇒ I): Aux[::[I, T], D]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def parse(args: Seq[String]): Either[Error, (::[H, T], Seq[String])]

Definition Classes
Parser
def step(args: List[String], d: ::[Option[H], (tail)#D]): Either[(Error, List[String]), Option[(D, List[String])]]

Process the next argument.
Process the next argument.
If some arguments were successfully processed (third case in return below), the returned remaining argument sequence must be shorter than the passed args.
This method doesn't fully process args. It tries just to parse *one* argument (typically one option --foo and its value bar, so two elements from args - it can also be only one element in case of a flag), if possible. If you want to fully process a sequence of arguments, see parse or detailedParse.
returns
if no argument were parsed, Right(None); if an error occurred, an error message wrapped in caseapp.core.Error and scala.Left; else the next intermediate value and the remaining arguments wrapped in scala.Some and scala.Right.

Definition Classes
ConsParser → Parser
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val tail: Aux[T, DT]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def withHelp: Parser[WithHelp[::[H, T]]]

Creates a Parser accepting help / usage arguments, out of this one.
Creates a Parser accepting help / usage arguments, out of this one.

Definition Classes
Parser

Related Doc: package parser

final case class ConsParser[H, T <: HList, DT <: HList](arg: Arg, argParser: ArgParser[H], default: () ⇒ Option[H], tail: Aux[T, DT]) extends Parser[::[H, T]] with Product with Serializable

Instance Constructors

new ConsParser(arg: Arg, argParser: ArgParser[H], default: () ⇒ Option[H], tail: Aux[T, DT])

Type Members

type D = ::[Option[H], DT]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val arg: Arg

val argParser: ArgParser[H]

val args: Seq[Arg]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val default: () ⇒ Option[H]

final def detailedParse(args: Seq[String]): Either[Error, (::[H, T], RemainingArgs)]

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

def get(d: D): Either[Error, ::[H, T]]

final def getClass(): Class[_]

def init: D

final def isInstanceOf[T0]: Boolean

final def map[U](f: (::[H, T]) ⇒ U): Aux[U, D]

def mapHead[I](f: (H) ⇒ I): Aux[::[I, T], D]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def parse(args: Seq[String]): Either[Error, (::[H, T], Seq[String])]

def step(args: List[String], d: ::[Option[H], (tail)#D]): Either[(Error, List[String]), Option[(D, List[String])]]

final def synchronized[T0](arg0: ⇒ T0): T0

val tail: Aux[T, DT]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def withHelp: Parser[WithHelp[::[H, T]]]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from Parser[::[H, T]]

Inherited from AnyRef

Inherited from Any

Ungrouped