gleam/option
Types
Option
Option represents a value that may be present or not. Some means the value is present, None means the value is not.
This is Gleam's alternative to having a value that could be Null, as is possible in some other languages.
pub type Option(a) { Some(a) None }
Constructors
-
Some(a)
-
None
Functions
flatten
pub fn flatten(option: Option(Option(a))) -> Option(a)
Merge a nested Option into a single layer.
Examples
> flatten(Some(Some(1)))
Some(1)
> flatten(Some(None))
None
> flatten(None)
None
from_result
pub fn from_result(result: Result(a, b)) -> Option(a)
Converts a Result type to an Option type
Examples
> from_result(Ok(1))
Some(1)
> from_result(Error"some_error"))
None
is_none
pub fn is_none(option: Option(a)) -> Bool
Check whether the option is a None value.
Examples
> is_none(Some(1))
False
> is_none(None)
True
is_some
pub fn is_some(option: Option(a)) -> Bool
Check whether the option is a Some value.
Examples
> is_some(Some(1))
True
> is_some(None)
False
map
pub fn map( over option: Option(a), with fun: fn(a) -> b, ) -> Option(b)
Update a value held within the Some of an Option by calling a given function on it.
If the option is a None rather than Some the function is not called and the option stays the same.
Examples
> map(over: Some(1), with: fn(x) { x + 1 })
Some(2)
> map(over: None, with: fn(x) { x + 1 })
None
or
pub fn or(first: Option(a), second: Option(a)) -> Option(a)
Return the first value if it is Some, otherwise return the second value.
Examples
> or(Some(1), Some(2))
Some(1)
> or(Some(1), None)
Some(1)
> or(None, Some(2))
Some(2)
> or(None, None)
None
then
pub fn then( option: Option(a), apply fun: fn(a) -> Option(b), ) -> Option(b)
Update a value held within the Some of an Option by calling a given function on it, where the given function also returns an Option. The two Options are then merged together into one Option.
If the Option is a None rather than Some the function is not called and the Option stays the same.
This function is the equivalent of calling map
followed by flatten
, and
it is useful for chaining together multiple functions that return Options.
Examples
> then(Some(1), fn(x) { Some(x + 1) })
Some(2)
> then(Some(1), fn(x) { Some(tuple("a", x)) })
Some(tuple("a", 1))
> then(Some(1), fn(x) { None })
None)
> then(None, fn(x) { Some(x + 1) })
None
to_result
pub fn to_result(option: Option(a), e: b) -> Result(a, b)
Converts an Option type to a Result type
Examples
> to_result(Some(1), "some_error")
Ok(1)
> to_result(None, "some_error")
Error("some_error")
unwrap
pub fn unwrap(option: Option(a), or default: a) -> a
Extract the value from an option, returning a default value if there is none.
Examples
> unwrap(Some(1), 0)
1
> unwrap(None, 0)
0