`val const : 'a -> 'b -> 'a`

`val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c`

`val negate : ('a -> bool) -> 'a -> bool`

`val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a`

`exception Finally_raised of exn`

`val compose : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c`

`compose f g x`

is `g (f x)`

. Composition.

`val compose_binop : ('a -> 'b) -> ('b -> 'b -> 'c) -> 'a -> 'a -> 'c`

`compose_binop f g`

is `fun x y -> g (f x) (f y)`

. Example (partial order): `List.sort (compose_binop fst CCInt.compare) [1, true; 2, false; 1, false]`

.

`val curry : (('a * 'b) -> 'c) -> 'a -> 'b -> 'c`

`curry f x y`

is `f (x,y)`

. Convert a function which accepts a pair of arguments into a function which accepts two arguments.

`val uncurry : ('a -> 'b -> 'c) -> ('a * 'b) -> 'c`

`uncurry f (x,y)`

is `f x y`

. Convert a function which accepts a two arguments into a function which accepts a pair of arguments.

`val tap : ('a -> _) -> 'a -> 'a`

`tap f x`

evaluates `f x`

, discards it, then returns `x`

. Useful in a pipeline, for instance:

```
CCArray.(1 -- 10)
|> tap CCArray.shuffle
|> tap @@ CCArray.sort Stdlib.compare
```

`val lexicographic : ('a -> 'a -> int) -> ('a -> 'a -> int) -> 'a -> 'a -> int`

Lexicographic combination of comparison functions.

`val finally : h:(unit -> _) -> f:(unit -> 'a) -> 'a`

`finally ~h f`

calls `f ()`

and returns its result. If it raises, the same exception is raised; in **any** case, `h ()`

is called after `f ()`

terminates. If `h ()`

raises an exception, then this exception will be passed on and any exception that may have been raised by `f ()`

is lost.

`val finally1 : h:(unit -> _) -> ('a -> 'b) -> 'a -> 'b`

`finally1 ~h f x`

is the same as `f x`

, but after the computation, `h ()`

is called whether `f x`

rose an exception or not. If `h ()`

raises an exception, then this exception will be passed on and any exception that may have been raised by `f ()`

is lost.

`val finally2 : h:(unit -> _) -> ('a -> 'b -> 'c) -> 'a -> 'b -> 'c`

`finally2 ~h f x y`

is the same as `f x y`

, but after the computation, `h ()`

is called whether `f x y`

rose an exception or not. If `h ()`

raises an exception, then this exception will be passed on and any exception that may have been raised by `f ()`

is lost.

`val opaque_identity : 'a -> 'a`

`opaque_identity x`

is like `x`

, but prevents Flambda from using `x`

's definition for optimizing it. (flambda is an optimization/inlining pass in OCaml >= 4.03).

`val iterate : int -> ('a -> 'a) -> 'a -> 'a`

`iterate n f`

is `f`

iterated `n`

times. That is to say, `iterate 0 f x`

is `x`

, `iterate 1 f x`

is `f x`

, `iterate 2 f x`

is `f (f x)`

, etc.

### Infix

Infix operators.

`module Infix : sig ... end`

`include module type of Infix`

`val (%>) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c`

`(f %> g) x`

or `(%>) f g x`

is `g (f x)`

. Alias to `compose`

.

`val (%) : ('b -> 'c) -> ('a -> 'b) -> 'a -> 'c`

`(f % g) x`

or `(%) f g x`

is `f (g x)`

. Mathematical composition.

`val let@ : ('a -> 'b) -> 'a -> 'b`

`let@ x = foo in bar`

is the equivalent of `foo @@ fun x -> bar`

. It can be very useful for resource management, alongside with `protect`

.

### Monad

Functions with a fixed domain are monads in their codomain.

`module Monad (X : sig ... end) : sig ... end`