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
``````