A function that can never be called. It is polymorphic in the return type.

Given a function f that takes an argument of type A and returns a B, and another function g that takes a B and returns a C, you can compose them by passing the result of f to g.

(∘) :: (b -> c) -> (a -> b) -> (a -> c)
(g ∘ f) x = g (f x)

Properties of composition:

• Associativity h ∘ (g ∘ f) == (h ∘ g) ∘ f == h ∘ g ∘ f
• Identity see id for more info

Examples

let f = fn(x: Int) { int.to_string(x) }
let g = fn(s: String) { s == "28" }
let h = compose(g, f)
// -> h takes an int, transforms it into a string, then compares it to "28" and returns a bool

const function.

Examples

constant(1)(2)
// -> 1

Produces the factorizing function from a candidate c with two injections i and j to the best coproduct (either).
Property: i and j can be reconstructed from the canonical coproduct e
With m = coproduct_factorizer(i, j), we have:

• i(x) = m(Left(x))
• j(x) = m(Right(x))

Examples

// Given the candidate #(Int, Bool) with two injections from Int and Bool
let i = fn(x: Int) {#(x, True)}
let j = fn(x: Bool) {#(9, x)}
// We show that Either(Int, Bool) is a better coproduct by finding the mapping m:
let m = coproduct_factorizer(i, j)
m(Left(2))
// -> #(2, True)  
m(Right(False))
// -> #(9, False)  

Transforms a function that takes 2 arguments into a function that takes one argument and returns a partial function.

Examples

let map_123 = [1, 2, 3] |> curry(list.map)
map_123(fn(x) { x + 1 })
// -> [2, 3, 4]
map_123(fn(x) { x * 2 })
// -> [2, 4, 6]

Composition for the embellished functions that return the Writer type.

(>=>) :: (a -> Writer b) -> (b -> Writer c) -> (a -> Writer c)
m1 >=> m2 = \x -> 
  let (y, s1) = m1 x
      (z, s2) = m2 y
  in (z, s1 ++ s2)

Examples

let up_case = fn(s: String) { Writer(string.uppercase(s), "upCase ") }
let to_words = fn(s: String) { Writer(string.split(s, " "), "toWords ") }
let process = fish(up_case, to_words)
process("Anna has apples")
// -> Writer(["ANNA", "HAS", "APPLES"], "upCase toWords ")

flip function.

Examples

let f = fn(x: Int, y: Bool) { int.to_string(x) <> " " <> bool.to_string(y) }
flip(f)(True, 23)
// -> "23 True"

The identity function is a unit of composition.

id :: a -> a
id a = a

It follows the identity conditions:

• f ∘ id == f
• id ∘ f == f

Examples

id(3)
// -> 3
id("abc")
// -> "abc"

Composition for the Maybe type

Examples

let safe_reciprocal = fn(x) {
  case x != 0.0 {
    True -> Just(1.0 /. x)
    False -> Nothing
  }
}
let safe_root = fn(x) {
  case x >=. 0.0 {
    True -> Just(x |> float.square_root() |> result.unwrap(0.0))
    False -> Nothing
  }
}
let safe_reciprocal_root = maybe_compose(safe_reciprocal, safe_root)
// -> a function that calculates sqrt(1/x)
safe_reciprocal_root(0.25)
// -> Just(2.0)
safe_reciprocal_root(0.0)
// -> Nothing
safe_reciprocal_root(-2.0)
// -> Nothing

The idenitity morphism for the Maybe type.

Examples

maybe_id(25)
// -> Just(25)
maybe_id(Nothing)
// -> Just(Nothing)

Converts from Maybe to gleam Option.

Examples

maybe_to_option(Nothing)
// -> None
maybe_to_option(Just(2))
// -> Some(2)

Converts from gleam Option to Maybe.

Examples

option_to_maybe(None)
// -> Nothing
option_to_maybe(Some(2))
// -> Just(2)

Converts from Pair to gleam Tuple.

Examples

pair_to_tuple(Pair(2, True))
// -> #(2, True)

Produces the factorizing function from a candidate c with two projections p and q to the best product (tuple / pair).
Property: p and q can be reconstructed from the canonical product
With m = product_factorizer(p, q), we have:

• p(x) = m(x).fst
• q(x) = m(x).snd

Examples

// Given the candidate Int with two projections to Int and Bool
let p = fn(x: Int) {x}
let q = fn(_: Int) {True}
// We show that Pair(Int, Bool) is a better product by finding the mapping m:
let m = product_factorizer(p, q)
m(7)
// -> Pair(7, True)  

Converts from gleam Tuple to Pair.

Examples

tuple_to_pair(#(2, True))
// -> Pair(2, True)

Transforms a function that takes one argument and returns a partial function into a function that takes `2 arguments.

Examples

let add_partial = fn(x) { fn(y) { x + y } }
let add = uncurry(add_partial)
add(2, 5)
// -> 7
add(1, 1)
// -> 2

A function from any type to a unit (Nil in gleam).

unit :: a -> ()
unit _ = ()

Examples

unit(42)
// -> Nil
unit(True)
// -> Nil