Packages
gleam_stdlib
0.14.0
1.0.3
1.0.2
1.0.1
1.0.0
0.71.0
0.70.0
0.69.0
0.68.1
0.68.0
0.67.1
0.67.0
0.65.0
0.64.0
0.63.2
0.63.1
0.63.0
0.62.1
0.62.0
0.61.0
0.60.0
0.59.0
0.58.0
0.57.0
0.56.0
0.55.0
0.54.0
0.53.0
0.52.0
0.51.0
0.50.0
0.49.0
0.48.0
0.47.0
0.46.0
0.45.0
0.44.0
0.43.0
0.42.0
0.41.0
0.40.0
0.39.0
0.38.0
0.37.0
0.36.0
0.35.1
0.35.0
0.34.0
0.33.1
0.33.0
0.32.1
0.32.0
0.31.0
0.30.2
0.30.1
0.30.0
0.29.2
0.29.1
0.29.0
0.28.2
0.28.1
0.28.0
0.27.0
0.26.1
0.26.0
0.25.0
0.24.0
0.23.0
0.22.3
0.22.2
0.22.1
0.22.0
0.21.0
0.20.0
0.19.3
0.19.2
0.19.1
0.19.0
0.18.1
0.18.0
0.18.0-rc1
0.17.1
0.17.0
0.16.0
0.15.0
0.14.0
0.13.0
0.12.0
0.11.0
0.10.1
0.10.0
0.9.0
0.8.0
0.7.0
0.6.0
0.5.0
0.4.0
0.4.0-rc1
0.3.1
0.3.0
0.2.0
retired
A standard library for the Gleam programming language
Current section
Files
Jump to
Current section
Files
src/gleam/option.gleam
/// 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
}
/// Checks whether the option is a Some value.
///
/// ## Examples
///
/// > is_some(Some(1))
/// True
///
/// > is_some(None)
/// False
///
pub fn is_some(option: Option(a)) -> Bool {
option != None
}
/// Checks whether the option is a None value.
///
/// ## Examples
///
/// > is_none(Some(1))
/// False
///
/// > is_none(None)
/// True
///
pub fn is_none(option: Option(a)) -> Bool {
option == None
}
/// 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")
///
pub fn to_result(option: Option(a), e) -> Result(a, e) {
case option {
Some(a) -> Ok(a)
_ -> Error(e)
}
}
/// Converts a Result type to an Option type
///
/// ## Examples
///
/// > from_result(Ok(1))
/// Some(1)
/// > from_result(Error"some_error"))
/// None
///
pub fn from_result(result: Result(a, e)) -> Option(a) {
case result {
Ok(a) -> Some(a)
_ -> None
}
}
/// Extracts the value from an option, returning a default value if there is none.
///
/// ## Examples
///
/// > unwrap(Some(1), 0)
/// 1
///
/// > unwrap(None, 0)
/// 0
///
pub fn unwrap(option: Option(a), or default: a) -> a {
case option {
Some(x) -> x
None -> default
}
}
/// Updates 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
///
pub fn map(over option: Option(a), with fun: fn(a) -> b) -> Option(b) {
case option {
Some(x) -> Some(fun(x))
None -> None
}
}
/// Merges a nested Option into a single layer.
///
/// ## Examples
///
/// > flatten(Some(Some(1)))
/// Some(1)
///
/// > flatten(Some(None))
/// None
///
/// > flatten(None)
/// None
///
pub fn flatten(option: Option(Option(a))) -> Option(a) {
case option {
Some(x) -> x
None -> None
}
}
/// Updates 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
///
pub fn then(option: Option(a), apply fun: fn(a) -> Option(b)) -> Option(b) {
case option {
Some(x) -> fun(x)
None -> None
}
}
/// Returns 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
///
pub fn or(first: Option(a), second: Option(a)) -> Option(a) {
case first {
Some(_) -> first
None -> second
}
}