Option

enum Option[t: Type] with Eq, Order, ToStringSource

case Nonecase Some(t)

The Option type.

An option represents an optional value. The constructor None represents an absent value, whereas the constructor Some(v) represents the value v.

Instances

instance Applicative[Option]Source

instance CommutativeMonoid[Option[a]] with CommutativeMonoid[a]Source

instance CommutativeSemiGroup[Option[a]] with CommutativeSemiGroup[a]Source

instance Eq[Option[t]] with Eq[t]Source

instance Filterable[Option]Source

instance Foldable[Option]Source

instance ForEach[Option[a]]Source

instance Formattable[Option[a]] with Formattable[a]Source

instance FromJson[Option[a]] with FromJson[a]Source

JNull decodes to None; any other value is decoded with FromJson[a] and wrapped in Some. The path is left unchanged — Option does not introduce a structural step.

instance Functor[Option]Source

instance Hash[Option[a]] with Hash[a]Source

instance Iterable[Option[a]]Source

instance JoinLattice[Option[t]] with JoinLattice[t]Source

instance LowerBound[Option[t]]Source

instance MeetLattice[Option[t]] with MeetLattice[t]Source

instance Monad[Option]Source

instance MonadZero[Option]Source

instance MonadZip[Option]Source

instance Monoid[Option[a]] with Monoid[a]Source

instance Order[Option[t]] with Order[t]Source

instance PartialOrder[Option[t]] with PartialOrder[t]Source

instance SemiGroup[Option[a]] with SemiGroup[a]Source

instance ToJson[Option[a]] with ToJson[a]Source

instance ToString[Option[t]] with ToString[t]Source

instance Traversable[Option]Source

instance UnorderedFoldable[Option]Source

instance Witherable[Option]Source

Definitions

def ap(f: Option[a -> b \ ef], x: Option[a]): Option[b] \ ef§ Source

If both arguments are Some, return a Some containing the result of applying the function inside f to the value inside x. Otherwise return None.

def count(f: a -> Bool \ ef, o: Option[a]): Int32 \ ef§ Source

Returns 1 if o is Some(v) and the predicate f(v) evaluates to true. Otherwise returns 0.

def empty(): Option[a]§ Source

Returns the empty option variant None.

def exists(f: a -> Bool \ ef, o: Option[a]): Bool \ ef§ Source

Returns true if o is Some(v) and the predicate f(v) evaluates to true. Otherwise returns false.

def filter(f: a -> Bool \ ef, o: Option[a]): Option[a] \ ef§ Source

Returns o if o is Some(v) and the predicate f(v) is true. Otherwise returns None.

def find(f: a -> Bool, o: Option[a]): Option[a]§ Source

Returns o if o is Some(v) and the predicate f(v) evaluates to true. Otherwise returns None.

The function f must be pure.

def flatMap(f: a -> Option[b] \ ef, o: Option[a]): Option[b] \ ef§ Source

Returns f(v) if o is Some(v). Otherwise returns None.

def flatten(o: Option[Option[a]]): Option[a]§ Source

Returns v if o is Some(v). Otherwise returns None.

def fold(o: Option[a]): a with Monoid[a]§ Source

Returns the result of applying combine to all the elements in o, using empty as the initial value.

def foldLeft(f: b -> (a -> b \ ef), z: b, o: Option[a]): b \ ef§ Source

Returns f(z, v) if o is Some(v). Otherwise returns z.

def foldLeftM(f: b -> (a -> Option[b] \ ef), s: b, l: List[a]): Option[b] \ ef§ Source

Returns the result of applying f to a start value s and the elements in l going from left to right.

If at any step applying f fails (i.e. it produces a None value) the traversal of l is short-circuited and None is returned.

If f is successfully applied to all the elements in l the result is of the form: Some(f(...f(f(s, x1), x2)..., xn)).

def foldMap(f: a -> b \ ef, o: Option[a]): b \ ef with Monoid[b]§ Source

Returns the result of mapping each element and combining the results.

def foldRight(f: a -> (b -> b \ ef), o: Option[a], z: b): b \ ef§ Source

Returns f(v, z) if o is Some(v). Otherwise returns z.

def foldRightM(f: a -> (b -> Option[b] \ ef), s: b, l: List[a]): Option[b] \ ef§ Source

Returns the result of applying f to a start value s and the elements in l going from right to left.

If at any step applying f fails (i.e. it produces a None value) the traversal of l is short-circuited and None is returned.

If f is successfully applied to all elements in l the result is of the form: Some(f(x1, ...f(xn-1, f(xn, s))...)).

def forAll(f: a -> Bool \ ef, o: Option[a]): Bool \ ef§ Source

Returns true if o is Some(v) and the predicate f(v) evaluates to true or if o is None.

Otherwise returns false.

def forEach(f: a -> Unit \ ef, o: Option[a]): Unit \ ef§ Source

Applies f to v if o is Some(v). Otherwise does nothing.

def getOrAbort(o: Option[a]): a \ Abort§ Source

Returns v if o is Some(v). Otherwise aborts with a stack trace.

def getWithDefault(d: a, o: Option[a]): a§ Source

Returns v if o is Some(v). Otherwise returns d.

def isEmpty(o: Option[a]): Bool§ Source

Returns true iff o is None.

def iterator(rc: Region[r], o: Option[a]): Iterator[a, r, r] \ r§ Source

Returns an iterator over o with 1 element or an empty iterator if o is None.

def map(f: a -> b \ ef, o: Option[a]): Option[b] \ ef§ Source

Returns Some(f(v)) if o is Some(v). Otherwise returns None.

def map10(f: t1 -> (t2 -> (t3 -> (t4 -> (t5 -> (t6 -> (t7 -> (t8 -> (t9 -> (t10 -> u \ ef))))))))), o1: Option[t1], o2: Option[t2], o3: Option[t3], o4: Option[t4], o5: Option[t5], o6: Option[t6], o7: Option[t7], o8: Option[t8], o9: Option[t9], o10: Option[t10]): Option[u] \ ef

§ Source

Applies the 10-ary function f to the values in o1, o2, ... o10.

Returns None if any of o1, o2, ... o10 are None.

def map2(f: t1 -> (t2 -> u \ ef), o1: Option[t1], o2: Option[t2]): Option[u] \ ef§ Source

Applies the binary function f to the values in o1 and o2.

Returns None if either o1 or o2 are None.

def map3(f: t1 -> (t2 -> (t3 -> u \ ef)), o1: Option[t1], o2: Option[t2], o3: Option[t3]): Option[u] \ ef§ Source

Applies the ternary function f to the values in o1, o2 and o3.

Returns None if any of o1, o2 and o3 are None.

def map4(f: t1 -> (t2 -> (t3 -> (t4 -> u \ ef))), o1: Option[t1], o2: Option[t2], o3: Option[t3], o4: Option[t4]): Option[u] \ ef

§ Source

Applies the 4-ary function f to the values in o1, o2, o3 and o4.

Returns None if any of o1, o2, o3 and o4 are None.

def map5(f: t1 -> (t2 -> (t3 -> (t4 -> (t5 -> u \ ef)))), o1: Option[t1], o2: Option[t2], o3: Option[t3], o4: Option[t4], o5: Option[t5]): Option[u] \ ef

§ Source

Applies the 5-ary function f to the values in o1, o2, ... o5.

Returns None if any of o1, o2, ... o5 are None.

def map6(f: t1 -> (t2 -> (t3 -> (t4 -> (t5 -> (t6 -> u \ ef))))), o1: Option[t1], o2: Option[t2], o3: Option[t3], o4: Option[t4], o5: Option[t5], o6: Option[t6]): Option[u] \ ef

§ Source

Applies the 6-ary function f to the values in o1, o2, ... o6.

Returns None if any of o1, o2, ... o6 are None.

def map7(f: t1 -> (t2 -> (t3 -> (t4 -> (t5 -> (t6 -> (t7 -> u \ ef)))))), o1: Option[t1], o2: Option[t2], o3: Option[t3], o4: Option[t4], o5: Option[t5], o6: Option[t6], o7: Option[t7]): Option[u] \ ef

§ Source

Applies the 7-ary function f to the values in o1, o2, ... o7.

Returns None if any of o1, o2, ... o7 are None.

def map8(f: t1 -> (t2 -> (t3 -> (t4 -> (t5 -> (t6 -> (t7 -> (t8 -> u \ ef))))))), o1: Option[t1], o2: Option[t2], o3: Option[t3], o4: Option[t4], o5: Option[t5], o6: Option[t6], o7: Option[t7], o8: Option[t8]): Option[u] \ ef

§ Source

Applies the 8-ary function f to the values in o1, o2, ... o8.

Returns None if any of o1, o2, ... o8 are None.

def map9(f: t1 -> (t2 -> (t3 -> (t4 -> (t5 -> (t6 -> (t7 -> (t8 -> (t9 -> u \ ef)))))))), o1: Option[t1], o2: Option[t2], o3: Option[t3], o4: Option[t4], o5: Option[t5], o6: Option[t6], o7: Option[t7], o8: Option[t8], o9: Option[t9]): Option[u] \ ef

§ Source

Applies the 9-ary function f to the values in o1, o2, ... o9.

Returns None if any of o1, o2, ... o9 are None.

def nonEmpty(o: Option[a]): Bool§ Source

Returns true iff o is Some.

def orAbort(o: Option[a]): Unit \ Abort§ Source

Aborts with a stack trace if o is None.

def point(x: a): Option[a]§ Source

Returns Some(x).

def replace(src: { src = a }, dst: { dst = a }, o: Option[a]): Option[a] with Eq[a]§ Source

Returns Some(dst) if o is Some(src). Otherwise returns o.

def sequence(l: List[Option[a]]): Option[List[a]]§ Source

Returns Some(v1 :: v2 :: ... :: vn) if each of xs_i is Some(v_i). Otherwise returns None.

def sum(o: Option[Int32]): Int32§ Source

Returns v if o is Some(v) else 0.

def sumWith(f: a -> Int32 \ ef, o: Option[a]): Int32 \ ef§ Source

Returns f(v) if o is Some(v) else 0.

def toErr(d: t, o: Option[e]): Result[e, t]§ Source

Returns the Option value Err(e) if o is Some(e). Otherwise returns Ok(d).

def toFailure(d: t, o: Option[e]): Validation[e, t]§ Source

Returns e into Validation's Failure if o is Some(e). Otherwise returns Success(d).

def toList(o: Option[a]): List[a]§ Source

Returns a one-element list of the value v if o is Some(v). Otherwise returns the empty list.

def toMap(o: Option[(k, v)]): Map[k, v] with Order[k]§ Source

Returns a singleton map with the mapping k -> v if o is Some((k, v)). Otherwise returns the empty map.

def toMapWith(f: a -> b, s: Option[a]): Map[a, b] with Order[a]§ Source

Returns a map with elements of s as keys and f applied as values.

def toOk(e: e, o: Option[t]): Result[e, t]§ Source

Returns the Option value Ok(v) if o is Some(v). Otherwise returns Err(e).

def toSet(o: Option[a]): Set[a] with Order[a]§ Source

Returns a one-element set of the value v if o is Some(v). Otherwise returns the empty set.

def toSuccess(e: e, o: Option[t]): Validation[e, t]§ Source

Returns the Validation value Success(v) if o is Some(v). Otherwise lifts e into Validation's Failure.

def traverse(f: a -> Option[b] \ ef, l: List[a]): Option[List[b]] \ ef§ Source

Returns Some(v1 :: v2 :: ... v :: vn) if each of f(l_i) is Some(v_i). Otherwise returns None.

def traverseX(f: a -> Option[b] \ ef, l: List[a]): Option[Unit] \ ef§ Source

Returns Some() if each of f(l_i) is Some(_). Otherwise returns None.

This function is the "forgetful" version of traverse, use it when you want the effect of applying f to each element but do not care about collecting the results.

def unzip(o: Option[(a, b)]): (Option[a], Option[b])§ Source

Returns (Some(v1), Some(v2)) if o is Some((v1, v2)). Otherwise returns (None, None).

def withDefault(default: { default = Option[a] }, o: Option[a]): Option[a]§ Source

Returns o if it is Some(v). Otherwise returns default.

def zip(o1: Option[a], o2: Option[b]): Option[(a, b)]§ Source

Returns Some((v1, v2)) if o1 is Some(v1) and o2 is Some(v2). Otherwise returns None.