gleam/bool
A type with two possible values, True and False. Used to indicate whether
things are… true or false!
It is often clearer and offers more type safety to define a custom type
than to use Bool. For example, rather than having a is_teacher: Bool
field consider having a role: SchoolRole field where SchoolRole is a custom
type that can be either Student or Teacher.
Values
pub fn and(a: Bool, b: Bool) -> BoolReturns the and of two bools, but it evaluates both arguments.
It’s the function equivalent of the && operator.
This function is useful in higher order functions or pipes.
Examples
assert and(True, True)
assert !and(False, True)
assert !and(False, True)
assert !and(False, False)
pub fn exclusive_nor(a: Bool, b: Bool) -> BoolReturns the exclusive nor of two bools.
Examples
assert exclusive_nor(False, False)
assert !exclusive_nor(False, True)
assert !exclusive_nor(True, False)
assert exclusive_nor(True, True)
pub fn exclusive_or(a: Bool, b: Bool) -> BoolReturns the exclusive or of two bools.
Examples
assert !exclusive_or(False, False)
assert exclusive_or(False, True)
assert exclusive_or(True, False)
assert !exclusive_or(True, True)
pub fn guard(
when requirement: Bool,
return consequence: a,
otherwise alternative: fn() -> a,
) -> aRun a callback function if the given bool is False, otherwise return a
default value.
With a use expression this function can simulate the early-return pattern
found in some other programming languages.
In a procedural language:
if (predicate) return value;
// ...
In Gleam with a use expression:
use <- guard(when: predicate, return: value)
// ...
Like everything in Gleam use is an expression, so it short circuits the
current block, not the entire function. As a result you can assign the value
to a variable:
let x = {
use <- guard(when: predicate, return: value)
// ...
}
Note that unlike in procedural languages the return value is evaluated
even when the predicate is False, so it is advisable not to perform
expensive computation nor side-effects there.
Examples
let name = ""
use <- guard(when: name == "", return: "Welcome!")
"Hello, " <> name
// -> "Welcome!"
let name = "Kamaka"
use <- guard(when: name == "", return: "Welcome!")
"Hello, " <> name
// -> "Hello, Kamaka"
pub fn lazy_guard(
when requirement: Bool,
return consequence: fn() -> a,
otherwise alternative: fn() -> a,
) -> aRuns a callback function if the given bool is True, otherwise runs an
alternative callback function.
Useful when further computation should be delayed regardless of the given bool’s value.
See guard for more info.
Examples
let name = "Kamaka"
let inquiry = fn() { "How may we address you?" }
use <- lazy_guard(when: name == "", return: inquiry)
"Hello, " <> name
// -> "Hello, Kamaka"
import gleam/int
let name = ""
let greeting = fn() { "Hello, " <> name }
use <- lazy_guard(when: name == "", otherwise: greeting)
let number = int.random(99)
let name = "User " <> int.to_string(number)
"Welcome, " <> name
// -> "Welcome, User 54"
pub fn nand(a: Bool, b: Bool) -> BoolReturns the nand of two bools.
Examples
assert nand(False, False)
assert nand(False, True)
assert nand(True, False)
assert !nand(True, True)
pub fn negate(bool: Bool) -> BoolReturns the opposite bool value.
This is the same as the ! or not operators in some other languages.
Examples
assert !negate(True)
assert negate(False)
pub fn nor(a: Bool, b: Bool) -> BoolReturns the nor of two bools.
Examples
assert nor(False, False)
assert !nor(False, True)
assert !nor(True, False)
assert !nor(True, True)
pub fn or(a: Bool, b: Bool) -> BoolReturns the or of two bools, but it evaluates both arguments.
It’s the function equivalent of the || operator.
This function is useful in higher order functions or pipes.
Examples
assert or(True, True)
assert or(False, True)
assert or(True, False)
assert !or(False, False)