Opt 

As Stream

Returns Stream with single value or empty

Process option, both: value or no value

Takes two functions, one to process value, another - no value case

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"

println(o.collect { case v if v.startsWith("a") => "bar" }) // Prints: Opt.Void

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

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

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

Check contains

Returns 'true' only if there is value and it is equal to the given parameter

'false' - otherwise

val o : Opt[String] = "foo"

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

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

Default value

Only if there is no value, creates new option with default value

var o : Opt[String] = "foo"

o = o.default("bar")

println(o)  // Prints: Opt(foo)

o = \/

o = o.default("bar")

println(o)  // Prints: Opt(bar)

Reversed filter

Discards value if it passes given filtering function

val o : Opt[String] = "foo"

println(o.let(_.length > 2)  // Prints: Opt.Void

println(o.let(_.length > 3)  // Prints: Opt(foo)

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

Check for value

Returns true if this option holds value, 'false' - otherwise

Check if empty

Returns true if this option holds no value, 'false' - otherwise

Main filter

Discards value if it does not pass given filtering function

val o : Opt[String] = "foo"

println(o.let(_.length > 2)  // Prints: Opt(foo)

println(o.let(_.length > 3)  // Prints: Opt.Void

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

Filter and converter

Discards value if given function returns Opt.Void

Otherwise value is converted to the function result

val o: Opt[String] = "foo"

println(o.letMap(v => if (v.startsWith("a")) "bar" else \/)) // Prints: Opt.Void

println(o.letMap {
  case v if v.startsWith("f") => "bar"
  case _                      => \/
})                                                           // Prints: Opt(bar)

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

Mix filter

If either this or that Opt is void, Opt.Void is returned

Otherwise, mixed value is returned

val o5: Opt[Int] = 5
val ov: Opt[Int] = \/

println(o5.letMix(ov)(_ * _)) // Prints: Opt.Void

println(ov.letMix(o5)(_ * _)) // Prints: Opt.Void

println(o5.letMix(o5)(_ * _)) // Prints: Opt(25)

// same as

println(for(x <- o5; y <- o5) yeild x * y) // Prints: Opt(25)

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

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.letType[String]) // Prints: Opt(1)

println(o.letType[Int])    // Prints: Opt.Void

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

Convert value

Creates new option with value converted by the given function

println(Opt.make(2).map(_ * 10))  // Prints: Opt(20)

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

Value or default

Returns value, or if none, then given default

var o : Opt[String] = "foo"

println(o or "bar")    // Prints: foo

o = \/                 // assigning Opt.Void

println(o or "bar")    // Prints: bar

Value or default

Returns value, or if none, then given default

Note. This is similar to or, but orElse is not strictly typed. As a rule, always use or, but if it does not work use orElse

class Foo
class Bar extends Foo

val o : Opt[Bar] = \/

val v1 : Foo = o or new Foo     // Fails to compile

val v2 : Foo = o orElse new Foo // Compiles fine

Default option

Returns this Opt, or if it is void, then given default

Note. This is similar to orOpt, but orElseOpt is not strictly typed. As a rule, always use orOpt, but if it does not work use orElseOpt

class Foo
class Bar extends Foo

val bo : Opt[Bar] = \/
val fo : Opt[Foo] = \/

val v1 : Opt[Foo] = bo orOpt fo      // Fails to compile

val v2 : Opt[Foo] = bo orElseOpt fo  // Compiles fine

Default option

Returns this Opt, or if it is void, then given default

var o1 : Opt[String] = "foo"
val o2 : Opt[String] = "bar"

println(o1 orOpt o2)  // Prints: Opt(foo)

o1 = \/

println(o1 orOpt o2)  // Prints: Opt(bar)

Replace value

Creates new option with value replaced with newValue

println(Opt.make("foo").swap("bar"))  // Prints: Opt(bar)

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

To Option

Converts to scala.Option

To Optional

Converts to java.util.Optional

Convert to String

Returns "Opt.Void" or "Opt(" + value + ")" String

Value

Returns value, or if void - fails