p
scalqa

Opt

package Opt

Opt can also be created with shortcuts:

val o1 : Opt[Int] = 12    // By implicit convertion

val o2 : Opt[Int] = \/    // Void value request
Ordering
  1. Alphabetic
Inherited
  1. Opt
  2. scala.AnyRef
  3. scala.Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Constructor

  1. def fromOption[T](v: Option[T]): Opt[T]

    By Scala Option

    By Scala Option

    Creates Opt based on scala.Option

    val o : Opt[String] = Opt.fromOption(scala.Option("foo"))
    Definition Classes
    Opt
  2. def fromOptional[T](v: Optional[T]): Opt[T]

    By Java Optional

    By Java Optional

    Creates Opt based on java.util.Optional

    val o : Opt[String] = Opt.getByOptional(java.util.Optional.of("foo"))
    Definition Classes
    Opt
  3. def make[T](value: T): Opt[T]

    By value

    By value

    Creates Opt based on given value

    Note, 'null' will translate to Opt.Void

    val oi : Opt[Int]    = Opt.make(10)

val os : Opt[String] = Opt.make("foo")
    Definition Classes
    Opt
  4. def makeNullAble[T](v: T): Opt[T]

    By value

    By value

    Creates Opt based on given value

    'null' will create Opt with value 'null'

    'null' options should NEVER happen, unless there is no choice

    In Scalqa 'null' options only happen in cases of Arrays with default values:

    new Array[String](6).all.lp  // Prints: ~(null, null, null, null, null, null)
    Definition Classes
    Opt

Constant

  1. val Void: Opt[Nothing]

    Void constant

    Void constant

    Opt void instance, which can be assigned to any Opt type

    val io  : Opt[Int]    = Opt.Void

val io2 : Opt[Int]    = \/       // Same with shortcut

val so  : Opt[String] = Opt.Void

val so2 : Opt[String] = \/       // Same with shortcut
    Definition Classes
    Opt
  2. val VoidAlt: Opt[Nothing]

    Void alternative constant

    Void alternative constant

    VoidAlt is functionally equivalent to Void, but is not equal to Void

    It is for special cases, when there is need to distinguish between different voids

    // Opt access, which needs to be initialized

private var _opt : Opt[Int] = Opt.VoidAlt

def getOpt: Opt[Int] = if(_opt != Opt.VoidAlt) _opt else App.Fail("Not initialized")

def initOpt(o :Opt[Int]): Unit = if(_opt == Opt.VoidAlt) _opt = o else App.Fail("Already initialized")
    Definition Classes
    Opt

Implicit Constructor

  1. implicit def zzMake[A](v: Optional[A]): Opt[A]
    Definition Classes
    _Class
  2. implicit def zzMake[A](v: Option[A]): Opt[A]
    Definition Classes
    _Class
  3. implicit def zzMake[A](v: \/): Opt[A]
    Definition Classes
    _Class
  4. implicit def zzMake[A](a: A): Opt[A]
    Definition Classes
    _Class

Implicit

  1. implicit def zzBoolean[A](o: Opt[A]): Boolean
    Definition Classes
    _Class
  2. implicit def zzFilterMonadic[A](o: Opt[A]): FilterMonadic[A]
    Definition Classes
    _Class
  3. implicit def zzLibrary[A](o: Opt[A]): Opt._libraryExtension[A]
    Definition Classes
    _Class
  4. implicit def zzStream[A](o: Opt[A]): ~[A]
    Definition Classes
    _Class
Linear Supertypes
AnyRef, Any
Source: package.scala