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