Opt

Alias to "stream"

Value filter and converter

Discards value if given partial function is not defined

Otherwise value is converted to the function result

  val o: Opt[String] = "foo"

  o.collect { case v if v.startsWith("a") => "bar" }.tp // Prints: \/

  o.collect { case v if v.startsWith("f") => "bar" }.tp // Prints: Opt(bar)

Note: If Opt is empty, it is returned as is

Note: collect is similar to mapOpt, but is less efficient, because PartialFunction has to be evaluated twice

Check contains

Returns 'true' if option contains given value

'false' - otherwise

  val o : Opt[String] = "foo"

  o.contains("foo").tp  // Prints: true

  o.contains("bar").tp  // Prints: false

Default value

Does nothing if option already contains a value

For void option, returns a new option with given value

   var o : Opt[String] = "foo"

   o.default("bar").tp // Prints: Opt(foo)

   o=VOID

   o.default("bar").tp // Prints: Opt(bar)

Reversed filter

Discards value if it satisfies given predicate

 val o : Opt[String] = "foo"

 o.drop(_.length > 2).tp  // Prints: Opt(VOID)

 o.drop(_.length > 3).tp  // Prints: Opt(foo)

Reversed value filter

Discards value if it is equal to given value

 val o : Opt[String] = "foo"

 o.dropOnly("foo").tp  // Prints: Opt(VOID)

 o.dropOnly("bar").tp  // Prints: Opt(foo)

Reversed void filter

Discards value if it is void, so the option itself becomes void

 val s : Stream[String]     =VOID

 var o : Opt[Stream[String]] = s

 o.tp  // Prints: Opt(Stream())

 o = o.dropVoid

 o.tp  // Prints: Opt(VOID)

Legacy filter

Discards value if it does not pass given filter function

Note: take is usually used instead.

Convert or default

This is a synthetic operation:

val o: Opt[String]=VOID

o.foldAs(0)(_.length)

// same as

o.map(_.length) or 0

foldAs is more readable if mapping code is substantial:

o.foldAs(0){ v =>
  var l = v.length
  if     (l > 1000) l = 1000
  else if(l < 0)    l = 0
  l
}

Process nonexistent value

Executes given function if option is void

Returns option itself

Process option value

Executes given function with option value

Does nothing if option is void

Returns option itself

Get value

Returns value or fails if option is void

Note: This method is not widely used except for debugging and examples. or is the main way to resolve value

Void check

Returns true if value is void and false otherwise

Note: This operation is implicitly available for all types. It is explicit here to indicate efficient implementation.

Convert value

Creates new option with value converted by the given function

Void option allways yeilds void option

   "Abc".?.map(_.length)  // Prints: Int.Opt(3)

Note. Operation returns specialized options for primitive values

Optional map

Creates new option with value converted by optional function.

Void option allways yeilds void option

"a"  .?.mapOpt(s => if(s.length > 2) s.toUpperCase else VOID).tp      // Prints Opt(VOID)
"abc".?.mapOpt(s => if(s.length > 2) s.toUpperCase else VOID).tp      // Prints Opt(ABC)

"a"  .?.mapOpt(s => if(s.length > 2) s.length else VOID).tp           // Prints Int.Opt(VOID)
"abc".?.mapOpt(s => if(s.length > 2) s.length else VOID).tp           // Prints Int.Opt(3)

"abc".?.mapOpt{
  case s if s.length > 2 => s.toUpperCase
  case _                 => VOID
}.tp

Note. In case of matching, the last default case must be given, so it becomes regular (not a partial) function

Mix two option values

If either option is void, the void option is returned

Otherwise, the given function is applied with both values, resulting in a valued option

 val io: Int.Opt = 4

 var so: Opt[String]=VOID


 so.mix(io, _ * _).tp  // Prints Opt(VOID)

 so = "abc_"

 so.mix(io, _ * _).tp // Prints Opt(abc_abc_abc_abc_)

Not void check

Returns true if value is not void and false otherwise

Note: This operation is implicitly available for all types. It is explicit here to indicate efficient implementation.

Value or default

Returns option value, or if option is void, given default value

var o : Opt[String] = "foo"

(o or "bar").tp     // Prints foo

o=VOID

(o or "bar").tp     // Prints bar

Default option

Returns this option if it is not void or given option otherwise

var o  : Opt[String] = "foo"
var o2 : Opt[String] = "bar"

(o orOpt o2).tp     // Prints Opt(foo)

o=VOID

(o orOpt o2).tp     // Prints Opt(bar)

Process value or no value

Executes given function with option value or second given function if option is void

Returns option itself

Make specialized option

Converts this option to specialized on primitive type

The operation will not compile if converting to a reference type

 var o  : Opt[Int] = 12
 var io : Int.Opt  = o.raw

Stream

Returns single value stream or empty stream, if option is void

Filter

Discards value if it does not satisfy given predicate

 val o : Opt[String] = "foo"

 o.take(_.length < 2).tp  // Prints: Opt(VOID)

 o.take(_.length > 2).tp  // Prints: Opt(foo)

Value filter

Discards value if it is not equal to given value

 val o : Opt[String] = "foo"

 o.takeOnly("foo").tp  // Prints: Opt(foo)

 o.takeOnly("bar").tp  // Prints: Opt(VOID)

Value filter and type converter

Discards value if it does not belong to the given type

Note, the result is mapped to the given type

  val o: Opt[Any] = "1"

  println(o.takeType[String]) // Prints: Opt(1)

  println(o.takeType[Int])    // Prints: \/

Note: If Opt is empty, it is returned as is

Make Java Optional

Converts this option to java.util.Optional

Make Scala Option

Converts this option to scala.Option