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 const : 'a ‑> 'b ‑> 'a
Produce a function that just returns its first argument.
const x y = x
for any y
.
val curry : (('a * 'b) ‑> 'c) ‑> 'a ‑> 'b ‑> 'c
Convert a function which accepts a pair of arguments into a function which accepts two arguments.
curry f x y
is f (x,y)
.
val uncurry : ('a ‑> 'b ‑> 'c) ‑> ('a * 'b) ‑> 'c
Convert a function which accepts a two arguments into a function which accepts a pair of arguments.
uncurry f (x,y)
is f x y
.
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 Pervasives.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.
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.
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.
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.
Functions with a fixed domain are monads in their codomain.