`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 -> ( 'a -> 'b ) -> 'b`

`x |> f`

is the same as `f x`

. A 'pipe' operator.

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

`f @@ x`

is the same as `f x`

, but right-associative.

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

### Monad

Functions with a fixed domain are monads in their codomain.

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