gleam/bool

A type with two possible values, True and False. Used to indicate whether things are… true or false!

Often is it 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.

Functions

and

</>

pub fn and(a: Bool, b: Bool) -> Bool

Returns 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

> and(True, True)
True

> and(False, True)
False

> False |> and(True)
False

compare

</>

pub fn compare(a: Bool, with b: Bool) -> Order

Compares two bools and returns the first value’s Order to the second.

Examples

> import gleam/order
> compare(True, False)
order.Gt

exclusive_nor

</>

pub fn exclusive_nor(a: Bool, b: Bool) -> Bool

Returns the exclusive nor of two bools.

Examples

> exclusive_nor(False, False)
True

> exclusive_nor(False, True)
False

> exclusive_nor(True, False)
False

> exclusive_nor(True, True)
True

exclusive_or

</>

pub fn exclusive_or(a: Bool, b: Bool) -> Bool

Returns the exclusive or of two bools.

Examples

> exclusive_or(False, False)
False

> exclusive_or(False, True)
True

> exclusive_or(True, False)
True

> exclusive_or(True, True)
False

guard

</>

pub fn guard(
  when requirement: Bool,
  return consequence: a,
  otherwise alternative: fn() -> a,
) -> a

Run 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 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"

lazy_guard

</>

pub fn lazy_guard(
  when requirement: Bool,
  return consequence: fn() -> a,
  otherwise alternative: fn() -> a,
) -> a

Runs 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(1, 99)
> let name = "User " <> int.to_string(number)
> "Welcome, " <> name
"Welcome, User 54"

max

</>

pub fn max(a: Bool, b: Bool) -> Bool

Returns True if either argument’s value is True.

Examples

> max(True, False)
True

> max(False, True)
True

> max(False, False)
False

min

</>

pub fn min(a: Bool, b: Bool) -> Bool

Returns False if either bool value is False.

Examples

> min(True, False)
False

> min(False, True)
False

> min(False, False)
False

nand

</>

pub fn nand(a: Bool, b: Bool) -> Bool

Returns the nand of two bools.

Examples

> nand(False, False)
True

> nand(False, True)
True

> nand(True, False)
True

> nand(True, True)
False

negate

</>

pub fn negate(bool: Bool) -> Bool

Returns the opposite bool value.

This is the same as the ! or not operators in some other languages.

Examples

> negate(True)
False

> negate(False)
True

nor

</>

pub fn nor(a: Bool, b: Bool) -> Bool

Returns the nor of two bools.

Examples

> nor(False, False)
True

> nor(False, True)
False

> nor(True, False)
False

> nor(True, True)
False

or

</>

pub fn or(a: Bool, b: Bool) -> Bool

Returns 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

> or(True, True)
True

> or(False, True)
True

> False |> or(True)
True

to_int

</>

pub fn to_int(bool: Bool) -> Int

Returns a numeric representation of the given bool.

Examples

> to_int(True)
1

> to_int(False)
0

to_string

</>

pub fn to_string(bool: Bool) -> String

Returns a string representation of the given bool.

Examples

> to_string(True)
"True"

> to_string(False)
"False"