OptArg

OptArg is like Opt except it's intended to be used to type-safely express optional method/constructor parameters while at the same time avoiding having to explicitly wrap arguments when passing them (thanks to the implicit conversion from A to OptArg[A]). For example:

def takesMaybeString(str: OptArg[String] = OptArg.Empty) = ???

takesMaybeString()         // default empty value is used
takesMaybeString("string") // no explicit wrapping into OptArg required

Note that like Opt, OptArg assumes its underlying value to be non-null and null is translated into OptArg.Empty.
It is strongly recommended that OptArg type is used ONLY in signatures where implicit conversion A => OptArg[A] is intended to work. You should not use OptArg as a general-purpose "optional value" type - other types like Opt, NOpt and scala.Option serve that purpose. For this reason OptArg deliberately does not have any "transforming" methods like map, flatMap, orElse, etc. Instead it's recommended that OptArg is converted to Opt, NOpt or scala.Option as soon as possible (using toOpt, toNOpt and toOption methods).

Linear Supertypes

Serializable, Serializable, AnyVal, Any

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

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

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def contains[A1 >: A](elem: A1): Boolean

Annotations
@inline()
def exists(p: (A) ⇒ Boolean): Boolean

Annotations
@inline()
def fold[B](ifEmpty: ⇒ B)(f: (A) ⇒ B): B

Annotations
@inline()
def forEmpty(sideEffect: ⇒ Unit): OptArg[A]

Apply side effect only if OptArg is empty.
Apply side effect only if OptArg is empty. It's a bit like foreach for OptArg.Empty
sideEffect
- code to be executed if optArg is empty
returns
the same optArg
Annotations
@inline()
Example:
1. captionOptArg.forEmpty(logger.warn("caption is empty")).foreach(setCaption)
def forall(p: (A) ⇒ Boolean): Boolean

Annotations
@inline()
def foreach[U](f: (A) ⇒ U): Unit

Annotations
@inline()
def get: A

Annotations
@inline()
def getClass(): Class[_ <: AnyVal]

Definition Classes
AnyVal → Any
def getOrElse[B >: A](default: ⇒ B): B

Annotations
@inline()
def isDefined: Boolean

Annotations
@inline()
def isEmpty: Boolean

Annotations
@inline()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterator: Iterator[A]

Annotations
@inline()
def nonEmpty: Boolean

Annotations
@inline()
def orNull[B >: A](implicit ev: <:<[Null, B]): B

Annotations
@inline()
def toLeft[X](right: ⇒ X): Either[A, X]

Annotations
@inline()
def toList: List[A]

Annotations
@inline()
def toNOpt: NOpt[A]

Annotations
@inline()
def toOpt: Opt[A]

Annotations
@inline()
def toOptRef[B >: Null](implicit boxing: Boxing[A, B]): OptRef[B]

Annotations
@inline()
def toOption: Option[A]

Annotations
@inline()
def toRight[X](left: ⇒ X): Either[X, A]

Annotations
@inline()
def toString(): String

Definition Classes
OptArg → Any

Related Docs: object OptArg | package misc

final class OptArg[+A] extends AnyVal with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def contains[A1 >: A](elem: A1): Boolean

def exists(p: (A) ⇒ Boolean): Boolean

def fold[B](ifEmpty: ⇒ B)(f: (A) ⇒ B): B

def forEmpty(sideEffect: ⇒ Unit): OptArg[A]

def forall(p: (A) ⇒ Boolean): Boolean

def foreach[U](f: (A) ⇒ U): Unit

def get: A

def getClass(): Class[_ <: AnyVal]

def getOrElse[B >: A](default: ⇒ B): B

def isDefined: Boolean

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def iterator: Iterator[A]

def nonEmpty: Boolean

def orNull[B >: A](implicit ev: <:<[Null, B]): B

def toLeft[X](right: ⇒ X): Either[A, X]

def toList: List[A]

def toNOpt: NOpt[A]

def toOpt: Opt[A]

def toOptRef[B >: Null](implicit boxing: Boxing[A, B]): OptRef[B]

def toOption: Option[A]

def toRight[X](left: ⇒ X): Either[X, A]

def toString(): String

Inherited from Serializable

Inherited from Serializable

Inherited from AnyVal

Inherited from Any

Ungrouped