# Module CCFun

`module CCFun: `sig` .. `end``

# Basic Functions

`val (|>) : `'a -> ('a -> 'b) -> 'b``
Pipeline. `x |> f` is the same as `f x`.
`val compose : `('a -> 'b) -> ('b -> 'c) -> 'a -> 'c``
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]`
Since 0.6
`val (%>) : `('a -> 'b) -> ('b -> 'c) -> 'a -> 'c``
Alias to `compose`
`val (@@) : `('a -> 'b) -> 'a -> 'b``
`f @@ x` is the same as `f x`, but right-associative.
Since 0.5
`val id : `'a -> 'a``
Identity function
`val const : `'a -> 'b -> 'a``
`const x y = x` for any `y`
`val flip : `('a -> 'b -> 'c) -> 'b -> 'a -> 'c``
Flip arguments
`val curry : `('a * 'b -> 'c) -> 'a -> 'b -> 'c``
`val uncurry : `('a -> 'b -> 'c) -> 'a * 'b -> 'c``
`val tap : `('a -> 'b) -> '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 Pervasives.compare
``````

`val (%) : `('b -> 'c) -> ('a -> 'b) -> 'a -> 'c``
Mathematical composition
`val lexicographic : `('a -> 'a -> int) -> ('a -> 'a -> int) -> 'a -> 'a -> int``
Lexicographic combination of comparison functions
`val finally : `h:(unit -> 'b) -> 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.
`val finally1 : `h:(unit -> 'c) -> ('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.
Since 0.16
`val finally2 : `h:(unit -> 'd) -> ('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.
Since 0.16
`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).
Since 0.18

Functions with a fixed domain are monads in their codomain

```module Monad `(``X`` : ``sig`
type t

`end``) `: `sig` .. `end````