fe v0.1.4 FE.Maybe View Source

FE.Maybe is an explicit data type for representing values that might or might not exist.

Link to this section Summary

Functions

Passes the value of FE.Maybe to the provided function and returns its return value, that should be of the type FE.Maybe

Works like fold/3, except that the first element of the provided list is removed from it, wrapped in a FE.Maybe and treated as the initial accumulator

Folds over the provided list of elements, where the accumulator and each element in the list are passed to the provided function

Creates an FE.Maybe representing the value passed as an argument

Extracts only the values from a list of Maybe.t()s

Transforms an FE.Maybe value using the provided function. Nothing is done if there is no value

Creates an FE.Maybe from any Elixir term

Creates an FE.Maybe representing the absence of a value

Returns the value stored in an FE.Maybe. Raises an FE.Maybe.Error if a non-value is passed

Returns the value stored in a FE.Maybe or the provided default if there is no value

Passes the value stored in FE.Maybe as input to the first function, or returns the provided default

Link to this section Types

Link to this type t(a) View Source
t(a) :: {:just, a} | :nothing

Link to this section Functions

Link to this function and_then(maybe, f) View Source
and_then(t(a), (a -> t(a))) :: t(a) when a: var

Passes the value of FE.Maybe to the provided function and returns its return value, that should be of the type FE.Maybe.

Useful for chaining together a computation consisting of multiple steps, each of which takes a value as an argument and returns a FE.Maybe.

Examples

iex> FE.Maybe.and_then(FE.Maybe.nothing(), fn s -> FE.Maybe.just(String.length(s)) end)
FE.Maybe.nothing()

iex> FE.Maybe.and_then(FE.Maybe.just("foobar"), fn s -> FE.Maybe.just(String.length(s)) end)
FE.Maybe.just(6)

iex> FE.Maybe.and_then(FE.Maybe.just("foobar"), fn _ -> FE.Maybe.nothing() end)
FE.Maybe.nothing()
Link to this function fold(elems, f) View Source
fold([b], (b, a -> t(a))) :: t(a) when b: var, a: var

Works like fold/3, except that the first element of the provided list is removed from it, wrapped in a FE.Maybe and treated as the initial accumulator.

Then, fold is executed over the remainder of the provided list.

Examples

iex> FE.Maybe.fold([1,2,3], fn elem, acc -> FE.Maybe.just(elem+acc) end)
FE.Maybe.just(6)

iex> FE.Maybe.fold([1], fn elem, acc -> FE.Maybe.just(elem+acc) end)
FE.Maybe.just(1)

iex> FE.Maybe.fold([1], fn _, _ -> FE.Maybe.nothing() end)
FE.Maybe.just(1)

iex> FE.Maybe.fold([1, 2, 3], &(FE.Maybe.just(&1 + &2)))
FE.Maybe.just(6)

iex> FE.Maybe.fold([1, -22, 3], fn
...>   elem, _acc when elem < 0 -> FE.Maybe.nothing()
...>   elem, acc -> FE.Maybe.just(elem+acc)
...> end)
FE.Maybe.nothing()
Link to this function fold(maybe, elems, f) View Source
fold(t(a), [b], (b, a -> t(a))) :: t(a) when b: var, a: var

Folds over the provided list of elements, where the accumulator and each element in the list are passed to the provided function.

The provided function must returns a new accumulator of the FE.Maybe type. The provided FE.Maybe is the initial accumulator.

Returns the last FE.Maybe returned by the function.

Stops and returns nothing() if at any step the function returns nothing.

Examples

iex> FE.Maybe.fold(FE.Maybe.nothing(), [], &FE.Maybe.just(&1))
FE.Maybe.nothing()

iex> FE.Maybe.fold(FE.Maybe.just(5), [], &FE.Maybe.just(&1))
FE.Maybe.just(5)

iex> FE.Maybe.fold(FE.Maybe.nothing(), [1, 2], &FE.Maybe.just(&1 + &2))
FE.Maybe.nothing()

iex> FE.Maybe.fold(FE.Maybe.just(1), [1, 1], &FE.Maybe.just(&1 + &2))
FE.Maybe.just(3)

iex> FE.Maybe.fold(FE.Maybe.just(1), [1, 2, -2, 3], fn
...>   elem, _acc when elem < 0 -> FE.Maybe.nothing()
...>   elem, acc -> FE.Maybe.just(elem+acc)
...> end)
FE.Maybe.nothing()
Link to this function just(value) View Source
just(a) :: t(a) when a: var

Creates an FE.Maybe representing the value passed as an argument.

Link to this function justs(els) View Source
justs([t(a)]) :: [a] when a: var

Extracts only the values from a list of Maybe.t()s

Examples

iex> FE.Maybe.justs([FE.Maybe.just(:good), FE.Maybe.nothing(), FE.Maybe.just(:better)])
[:good, :better]
Link to this function map(maybe, f) View Source
map(t(a), (a -> a)) :: t(a) when a: var

Transforms an FE.Maybe value using the provided function. Nothing is done if there is no value.

Examples

iex> FE.Maybe.map(FE.Maybe.nothing(), &String.length/1)
FE.Maybe.nothing()

iex> FE.Maybe.map(FE.Maybe.just("foo"), &String.length/1)
FE.Maybe.just(3)
Link to this function new(term) View Source
new(a | nil) :: t(a) when a: var

Creates an FE.Maybe from any Elixir term.

It creates a non-value from nil and a value from any other term. Please note that false, 0, the empty list, etc., are valid values.

Examples

iex> FE.Maybe.new(nil)
FE.Maybe.nothing()

iex> FE.Maybe.new(:x)
FE.Maybe.just(:x)

iex> FE.Maybe.new(false)
FE.Maybe.just(false)
Link to this function nothing() View Source
nothing() :: t(any())

Creates an FE.Maybe representing the absence of a value.

Link to this function to_result(maybe, error) View Source
to_result(t(a), b) :: FE.Result.t(a, b) when b: var

Transforms an FE.Maybe to an FE.Result.

An FE.Maybe with a value becomes a successful value of a FE.Result.

A FE.Maybe without a value wrapped becomes an erroneous FE.Result, where the second argument is used as the error’s value.

Examples

iex> FE.Maybe.to_result(FE.Maybe.just(3), "No number found")
FE.Result.ok(3)

iex> FE.Maybe.to_result(FE.Maybe.nothing(), "No number found")
FE.Result.error("No number found")
Link to this function to_review(maybe, issues) View Source
to_review(t(a), [b]) :: FE.Review.t(a, b) when b: var

Transforms an FE.Maybe to an FE.Review.

An FE.Maybe with a value becomes an accepted FE.Review with the same value.

An FE.Maybe without a value wrapped becomes a rejected FE.Review, where the issues are takens from the second argument to the function.

Examples

iex> FE.Maybe.to_review(FE.Maybe.just(3), ["No number found"])
FE.Review.accepted(3)

iex> FE.Maybe.to_review(FE.Maybe.nothing(), ["No number found"])
FE.Review.rejected(["No number found"])
Link to this function unwrap!(maybe) View Source
unwrap!(t(a)) :: a | no_return() when a: var

Returns the value stored in an FE.Maybe. Raises an FE.Maybe.Error if a non-value is passed.

Examples

iex> FE.Maybe.unwrap!(FE.Maybe.just(:value))
:value

iex> try do FE.Maybe.unwrap!(FE.Maybe.nothing()) ; rescue e -> e end
%FE.Maybe.Error{message: "unwrapping Maybe that has no value"}
Link to this function unwrap_or(maybe, default) View Source
unwrap_or(t(a), a) :: a when a: var

Returns the value stored in a FE.Maybe or the provided default if there is no value.

Examples

iex> FE.Maybe.unwrap_or(FE.Maybe.nothing(), 0)
0

iex> FE.Maybe.unwrap_or(FE.Maybe.just(5), 0)
5
Link to this function unwrap_with(maybe, on_just, default) View Source
unwrap_with(t(a), (a -> b), b) :: b when a: var, b: var

Passes the value stored in FE.Maybe as input to the first function, or returns the provided default.

Examples

iex> FE.Maybe.unwrap_with(FE.Maybe.nothing(), fn(x) -> x+1 end, 0)
0

iex> FE.Maybe.unwrap_with(FE.Maybe.just(4), fn(x) -> x+1 end, 0)
5

iex> FE.Maybe.unwrap_with(FE.Maybe.just("a"), fn(x) -> x <> "bc" end, "xyz")
"abc"