# 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``

Takes two functions and chains them together to form one function that takes the input from the first and returns the output of the second.

## constant

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

Takes a single argument and returns a new function that ignores its argument and always returns the input value.

## 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 })
> let doubles = 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.