gleam_stdlib - v0.37.0

gleam/function

Functions

apply1

</> 
pub fn apply1(fun: fn(a) -> b, arg1: a) -> b

Takes a function with arity one and an argument, calls that function with the argument and returns the function return value.

Useful for concisely calling functions returned as a part of a pipeline.

Example

let doubler = fn() {
  fn(x: Int) { x * 2 }
}

doubler() |> apply1(2)
// -> 4

apply2

</> 
pub fn apply2(fun: fn(a, b) -> c, arg1: a, arg2: b) -> c

Takes a function with arity two and two arguments, calls that function with the arguments and returns the function return value.

See apply1 for more details.

apply3

</> 
pub fn apply3(
  fun: fn(a, b, c) -> d,
  arg1: a,
  arg2: b,
  arg3: c,
) -> d

Takes a function with arity three and three arguments, calls that function with the arguments and returns the function return value.

See apply1 for more details.

compose

</> 
pub fn compose(fun1: fn(a) -> b, fun2: fn(b) -> c) -> fn(a) -> c

Deprecated: Use a fn literal instead, it is easier to understand

constant

</> 
pub fn constant(value: a) -> fn(b) -> a

Deprecated: Use a fn literal instead, it is easier to understand

curry2

</> 
pub fn curry2(fun: fn(a, b) -> c) -> fn(a) -> fn(b) -> c

Takes a function with 2 arguments (an arity of 2), and returns the curried equivalent.

fn(a, b) -> c becomes fn(a) -> fn(b) -> c.

Examples

Currying creates a new function that is identical to the given function except that arguments must now be supplied one by one over several function calls. It thus is the process of taking a function with n arguments and producing a sequence of n single-argument functions. Given:

fn my_fun(i: Int, s: String) -> String { ... }

…calling curry2(my_fun) would return the curried equivalent, like so:

curry2(my_fun)
// fn(Int) -> fn(String) -> String

Currying is useful when you want to partially apply a function with some arguments and then pass it somewhere else, for example:

import gleam/list
let multiply = curry2(fn(x, y) { x * y })
list.map([1, 2, 3], multiply(2))
// -> [2, 4, 6]

curry3

</> 
pub fn curry3(
  fun: fn(a, b, c) -> d,
) -> fn(a) -> fn(b) -> fn(c) -> d

Takes a function with 3 arguments (an arity of 3), and returns the curried equivalent.

fn(a, b, c) -> d becomes fn(a) -> fn(b) -> fn(c) -> d.

See curry2 for a detailed explanation.

curry4

</> 
pub fn curry4(
  fun: fn(a, b, c, d) -> e,
) -> fn(a) -> fn(b) -> fn(c) -> fn(d) -> e

Takes a function with 4 arguments (an arity of 4), and returns the curried equivalent.

fn(a, b, c, d) -> e becomes fn(a) -> fn(b) -> fn(c) -> fn(d) -> e.

See curry2 for a detailed explanation.

curry5

</> 
pub fn curry5(
  fun: fn(a, b, c, d, e) -> f,
) -> fn(a) -> fn(b) -> fn(c) -> fn(d) -> fn(e) -> f

Takes a function with 5 arguments (an arity of 5), and returns the curried equivalent.

fn(a, b, c, d, e) -> f becomes fn(a) -> fn(b) -> fn(c) -> fn(d) -> fn(e) -> f.

See curry2 for a detailed explanation.

curry6

</> 
pub fn curry6(
  fun: fn(a, b, c, d, e, f) -> g,
) -> fn(a) -> fn(b) -> fn(c) -> fn(d) -> fn(e) -> fn(f) -> g

Takes a function with 6 arguments (an arity of 6), and returns the curried equivalent.

fn(a, b, c, d, e, f) -> g becomes fn(a) -> fn(b) -> fn(c) -> fn(d) -> fn(e) -> fn(f) -> g.

See curry2 for a detailed explanation.

flip

</> 
pub fn flip(fun: fn(a, b) -> c) -> fn(b, a) -> c

Takes a function that takes two arguments and returns a new function that takes the same two arguments, but in reverse order.

identity

</> 
pub fn identity(x: a) -> a

Takes a single argument and always returns its input value.

tap

</> 
pub fn tap(arg: a, effect: fn(a) -> b) -> a

Takes an argument and a single function, calls that function with that argument and returns that argument instead of the function return value. Useful for running synchronous side effects in a pipeline.

✨ Search Document