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"

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"