OrElse

Instance Constructors

new OrElse(left: Options[A], right: Options[B])

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
final def ++[A1 >: Either[A, B], B](that: Options[B])(implicit zippable: Zippable[Either[A, B], B]): Options[Out]

Definition Classes
Options
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def ??(that: String): Options[Either[A, B]]

Definition Classes
Options
def alias(name: String, names: String*): Options[Either[A, B]]

Definition Classes
Options
final def as[B, C, D, E, F, G, Z](f0: (B, C, D, E, F, G) ⇒ Z)(implicit ev: <:<[Either[A, B], (B, C, D, E, F, G)]): Options[Z]

Definition Classes
Options
final def as[B, C, D, E, F, Z](f0: (B, C, D, E, F) ⇒ Z)(implicit ev: <:<[Either[A, B], (B, C, D, E, F)]): Options[Z]

Definition Classes
Options
final def as[B, C, D, E, Z](f: (B, C, D, E) ⇒ Z)(implicit ev: <:<[Either[A, B], (B, C, D, E)]): Options[Z]

Definition Classes
Options
final def as[B, C, D, Z](f: (B, C, D) ⇒ Z)(implicit ev: <:<[Either[A, B], (B, C, D)]): Options[Z]

Definition Classes
Options
final def as[B, C, Z](f: (B, C) ⇒ Z)(implicit ev: <:<[Either[A, B], (B, C)]): Options[Z]

Definition Classes
Options
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def collect[B](message: String)(f: PartialFunction[Either[A, B], B]): Options[B]

Definition Classes
Options
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] )
final def fold[B, C, D, E, F, G, Z](f1: (B) ⇒ Z, f2: (C) ⇒ Z, f3: (D) ⇒ Z, f4: (E) ⇒ Z, f5: (F) ⇒ Z, f6: (G) ⇒ Z)(implicit ev: <:<[Either[A, B], Either[Either[Either[Either[Either[B, C], D], E], F], G]]): Options[Z]

Definition Classes
Options
final def fold[B, C, D, E, F, Z](f1: (B) ⇒ Z, f2: (C) ⇒ Z, f3: (D) ⇒ Z, f4: (E) ⇒ Z, f5: (F) ⇒ Z)(implicit ev: <:<[Either[A, B], Either[Either[Either[Either[B, C], D], E], F]]): Options[Z]

Definition Classes
Options
final def fold[B, C, D, E, Z](f1: (B) ⇒ Z, f2: (C) ⇒ Z, f3: (D) ⇒ Z, f4: (E) ⇒ Z)(implicit ev: <:<[Either[A, B], Either[Either[Either[B, C], D], E]]): Options[Z]

Definition Classes
Options
final def fold[B, C, D, Z](f1: (B) ⇒ Z, f2: (C) ⇒ Z, f3: (D) ⇒ Z)(implicit ev: <:<[Either[A, B], Either[Either[B, C], D]]): Options[Z]

Definition Classes
Options
final def fold[B, C, Z](f1: (B) ⇒ Z, f2: (C) ⇒ Z)(implicit ev: <:<[Either[A, B], Either[B, C]]): Options[Z]

Definition Classes
Options
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def helpDoc: HelpDoc

Definition Classes
OrElse → Options
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val left: Options[A]
final def map[B](f: (Either[A, B]) ⇒ B): Options[B]

Definition Classes
Options
final def mapOrFail[B](f: (Either[A, B]) ⇒ Either[ValidationError, B]): Options[B]

Definition Classes
Options
final def mapTry[B](f: (Either[A, B]) ⇒ B): Options[B]

Definition Classes
Options
def modifySingle(f: SingleModifier): Options[Either[A, B]]

Definition Classes
OrElse → Options
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 optional(desc: String): Options[Option[Either[A, B]]]

Definition Classes
Options
final def orElse[A1 >: Either[A, B]](that: Options[A1]): Options[A1]

Definition Classes
Options
final def orElseEither[B](that: Options[B]): Options[Either[Either[A, B], B]]

Definition Classes
Options
val right: Options[B]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def synopsis: UsageSynopsis

Definition Classes
OrElse → Options
def uid: Option[String]

Definition Classes
OrElse → Options
def validate(args: List[String], conf: CliConfig): IO[ValidationError, (List[String], Either[A, B])]

Definition Classes
OrElse → Options
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( ... )
def withDefault[A1 >: Either[A, B]](value: A1, valueDescription: String): Options[A1]

Definition Classes
Options
def withDefault[A1 >: Either[A, B]](value: A1): Options[A1]

Definition Classes
Options
final def |[A1 >: Either[A, B]](that: Options[A1]): Options[A1]

Definition Classes
Options

Related Doc: package Options

final case class OrElse[A, B](left: Options[A], right: Options[B]) extends Options[Either[A, B]] with Product with Serializable

Instance Constructors

new OrElse(left: Options[A], right: Options[B])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ++[A1 >: Either[A, B], B](that: Options[B])(implicit zippable: Zippable[Either[A, B], B]): Options[Out]

final def ==(arg0: Any): Boolean

def ??(that: String): Options[Either[A, B]]

def alias(name: String, names: String*): Options[Either[A, B]]

final def as[B, C, D, E, F, G, Z](f0: (B, C, D, E, F, G) ⇒ Z)(implicit ev: <:<[Either[A, B], (B, C, D, E, F, G)]): Options[Z]

final def as[B, C, D, E, F, Z](f0: (B, C, D, E, F) ⇒ Z)(implicit ev: <:<[Either[A, B], (B, C, D, E, F)]): Options[Z]

final def as[B, C, D, E, Z](f: (B, C, D, E) ⇒ Z)(implicit ev: <:<[Either[A, B], (B, C, D, E)]): Options[Z]

final def as[B, C, D, Z](f: (B, C, D) ⇒ Z)(implicit ev: <:<[Either[A, B], (B, C, D)]): Options[Z]

final def as[B, C, Z](f: (B, C) ⇒ Z)(implicit ev: <:<[Either[A, B], (B, C)]): Options[Z]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def collect[B](message: String)(f: PartialFunction[Either[A, B], B]): Options[B]

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

final def fold[B, C, D, E, F, G, Z](f1: (B) ⇒ Z, f2: (C) ⇒ Z, f3: (D) ⇒ Z, f4: (E) ⇒ Z, f5: (F) ⇒ Z, f6: (G) ⇒ Z)(implicit ev: <:<[Either[A, B], Either[Either[Either[Either[Either[B, C], D], E], F], G]]): Options[Z]

final def fold[B, C, D, E, F, Z](f1: (B) ⇒ Z, f2: (C) ⇒ Z, f3: (D) ⇒ Z, f4: (E) ⇒ Z, f5: (F) ⇒ Z)(implicit ev: <:<[Either[A, B], Either[Either[Either[Either[B, C], D], E], F]]): Options[Z]

final def fold[B, C, D, E, Z](f1: (B) ⇒ Z, f2: (C) ⇒ Z, f3: (D) ⇒ Z, f4: (E) ⇒ Z)(implicit ev: <:<[Either[A, B], Either[Either[Either[B, C], D], E]]): Options[Z]

final def fold[B, C, D, Z](f1: (B) ⇒ Z, f2: (C) ⇒ Z, f3: (D) ⇒ Z)(implicit ev: <:<[Either[A, B], Either[Either[B, C], D]]): Options[Z]

final def fold[B, C, Z](f1: (B) ⇒ Z, f2: (C) ⇒ Z)(implicit ev: <:<[Either[A, B], Either[B, C]]): Options[Z]

final def getClass(): Class[_]

def helpDoc: HelpDoc

final def isInstanceOf[T0]: Boolean

val left: Options[A]

final def map[B](f: (Either[A, B]) ⇒ B): Options[B]

final def mapOrFail[B](f: (Either[A, B]) ⇒ Either[ValidationError, B]): Options[B]

final def mapTry[B](f: (Either[A, B]) ⇒ B): Options[B]

def modifySingle(f: SingleModifier): Options[Either[A, B]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def optional(desc: String): Options[Option[Either[A, B]]]

final def orElse[A1 >: Either[A, B]](that: Options[A1]): Options[A1]

final def orElseEither[B](that: Options[B]): Options[Either[Either[A, B], B]]

val right: Options[B]

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

def synopsis: UsageSynopsis

def uid: Option[String]

def validate(args: List[String], conf: CliConfig): IO[ValidationError, (List[String], Either[A, B])]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withDefault[A1 >: Either[A, B]](value: A1, valueDescription: String): Options[A1]

def withDefault[A1 >: Either[A, B]](value: A1): Options[A1]

final def |[A1 >: Either[A, B]](that: Options[A1]): Options[A1]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from Options[Either[A, B]]

Inherited from AnyRef

Inherited from Any

Ungrouped