Applies a function to a value. Useful for point-free style.

Examples

let double = fn(x) { x * 2 }
apply(5, double) // 10

// Useful in higher-order contexts:
[1, 2, 3] |> list.map(apply(_, double)) // [2, 4, 6]

Composes two functions, applying g first, then f. This is mathematical function composition: (f ∘ g)(x) = f(g(x))

Examples

let add_one = fn(x) { x + 1 }
let double = fn(x) { x * 2 }
let add_then_double = compose(double, add_one)
add_then_double(5) // 12 ((5 + 1) * 2)

Creates a constant function that always returns the same value.

Examples

let get_five = constant(5)
get_five(1) // 5
get_five("anything") // 5

Converts a two-argument function into a curried function.

Examples

let add = fn(a, b) { a + b }
let curried_add = curry(add)
let add_five = curried_add(5)
add_five(10) // 15

Flips the order of arguments for a two-argument function.

Examples

let subtract = fn(a, b) { a - b }
let flipped_subtract = flip(subtract)
subtract(10, 3) // 7
flipped_subtract(3, 10) // 7 (same as subtract(10, 3))

The identity function - returns its input unchanged. Useful as a default or placeholder function.

Examples

identity(42) // 42
identity("hello") // "hello"
[1, 2, 3] |> list.map(identity) // [1, 2, 3]

Applies a list of functions sequentially to a value. All functions must have the same input/output type for type safety.

Examples

let add_one = fn(x) { x + 1 }
let double = fn(x) { x * 2 }
let subtract_three = fn(x) { x - 3 }

5
|> pipe([add_one, double, subtract_three])
// Result: 9 (((5 + 1) * 2) - 3)

Applies two functions sequentially with different types. More flexible than pipe for simple two-step transformations.

Examples

5
|> pipe2(fn(x) { x + 1 }, fn(x) { int.to_string(x) })
// Result: "6"

Applies three functions sequentially with different types.

Examples

5
|> pipe3(
  fn(x) { x + 1 },
  fn(x) { x * 2 },
  fn(x) { int.to_string(x) }
)
// Result: "12"

Applies four functions sequentially with different types.

Applies a function to a value and returns the original value. Useful for side effects in a pipeline without changing the value.

Examples

import gleam/io

42
|> tap(fn(x) { io.println("Debug: " <> int.to_string(x)) })
|> fn(x) { x * 2 }
// Prints "Debug: 42" and returns 84

Converts a curried function back into a two-argument function.

Examples

let curried_add = fn(a) { fn(b) { a + b } }
let add = uncurry(curried_add)
add(5, 10) // 15