Documentation for gololang.Errors

Useful augmentations, decorators and function to deal with errors in Golo.

Augmentations

java.util.Optional

and(this, other)

Conjunctive chaining.

This is equivalent to :flatMap(|_| -> other), i.e. applicative or monadic sequence with discarding. (Can also be seen as :map(const(^id)): apply(other))

For instance:

Some(1): `and(None()) == None()
None(): `and(Some(1)) == None()
Some(1): `and(Some("2") == Some("2")

Note that this method is eager. If you want laziness, use the flatMap equivalent.

andThen(this, f)

Same as map or flatMap, depending on the type returned by f.

This is a generic version for map and flatMap: if f returns an Optional, it's equivalent to flatMap, otherwise, it's equivalent to map.

This allows code such as:

Some(21): andThen(|x| -> x + 1): andThen(|x| -> Some(2 * x)) == Some(42)

apply(this, arg)

Apply the function contained is this optional to the given optional. If the function has several parameters, an optional containing a partialized version is returned, that can be applyed to subsequent optionals. This makes Optional an “applicative functor”.

For instance:

let f = Some(|x| -> x + 10)
f: apply(Some(32)) # Some(42)
f: apply(None())  # None()

Some(|a, b| -> a + b): apply(Some(21)): apply(Some(21)) # Some(42)

either(this, mapping, default)

Case analysis for the option.

If the result is not empty, apply the first function (similar to flatMap), otherwise invoke the second function (similar to orElseGet). For instance:

Some(21): either(|x| -> x * 2, -> "plop") == 42
None(): either(|x| -> x * 2, -> "plop") == "plop"

This is indeed equivalent to

opt: map(mapping): orElseGet(default)

flattened(this)

Remove one level of optional.

This is actually equivalent to :flatMap(identity) (or :flatMap(f) is equivalent to :map(f): flattened()).

For instance:

Some(Some(42)): flattened() == Some(42)
None(): flattened() == None()
Some(None()): flattened() == None()

isEmpty(this)

Test if this optional is empty.

isNone(this)

Alias for isEmpty

isSome(this, value)

Test if this optional contains a value equals to the provided one.

isSome(this)

Alias for isPresent

iterator(this)

or(this, other)

Disjunctive chaining.

For instance:

Some(1): `or(Some(2)) == Some(1)
None(): `or(Some(1)) == Some(1)
Some(1): `or(None()) == Some(1)
None(): `or(None()) == None()

Note that this method is eager.

Some(1): orElseGet(-> Some(2)) None(): orElseGet(-> Some(2))

reduce(this, init, func)

Reduce this option using func with init as initial value.

For instance:

Some("b"): reduce("a", |x, y| -> x + y) == "ab"
None(): reduce(42, |x, y| -> x + y) == 42

toList(this)

Convert this optional into a list

toResult(this)

toResult(this, param)

Functions

Empty()

Error(msg)

None()

Ok(v)

Option(v)

Result(v)

Some(v)

catching(default)

Allows an unary function to be called with an Optional or a Result value. Similar to flatMap, but using default on the exception if the call failed.

For instance:

let foo = |x| -> x: toUpperCase()

let safeFoo = catching("plop")(foo)

safeFoo(null)         # "plop"
safeFoo(None())       # "plop"
safeFoo(Error("err")) # "plop"
safeFoo(Ok("a"))      # "A"
safeFoo(Some("a"))    # "A"

catching(^gololang.error.Result::error)(foo)(null) # Result.error(NullPointerException())

Can be used as a decorator.

nullify(f)

Transform a function into one that can return null if something went wrong (i.e. None, Error or exception).

Can be used as a decorator.

option(f)

Transform a function raising an exception into a function returning a option. The resulting function returns Option(f(x)) if f(x) succeeds and None if f(x) raises an exception.

Can be used as a decorator.

raising(f)

Transforms a function returning a result or an option into a function returning the associated value or raising an exception.

Can be used as a decorator.

result(f)

Transform a function raising an exception into a function returning a Result. The resulting function returns Result.ok(f(x)) if f(x) succeeds and Result.error(e) if f(x) raises e.

Can be used as a decorator.

trying(f)

Execute the given block and return a Result.

This is similar to result, except that the block take no parameter and is immediately executed. This is not a decorator, but rather a replacement for a try catch block.

For instance:

let res = trying({
  let f = foo()
  let x = bar()
  let z = f(x)
  return z + plop()
})

If any of the operation in the block raises an exception, res will be a Result.error containing the exception, otherwise it will be a Result.ok containing the returned value.