package travesty

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type

Miscellaneous function combinators.

Fn contains various higher-order functions in the style of Base's Fn module.

Constant predicates

These are convenience shorthands for Base.Fn.const.

val always : 'a -> bool

always x is true.

val never : 'a -> bool

never x is false.

Pointwise liftings of operators

These complement Base.Fn.non.

val conj : ('a -> bool) -> ('a -> bool) -> 'a -> bool

conj f g lifts && over predicates f and g. It is short-circuiting: g is never called if f returns false.

Examples:

let is_zero = Int.(conj is_non_negative is_non_positive) 
(* Short-circuiting: *)
conj always (fun () -> failwith "oops") () ;
(* --> exception *)
conj never (fun () -> failwith "oops") ()

(* --> false *)
val disj : ('a -> bool) -> ('a -> bool) -> 'a -> bool

disj f g lifts || over predicates f and g. It is short-circuiting: g is never called if f returns true.

Examples:

let is_not_zero = Int.(disj is_negative is_positive) 
(* Short-circuiting: *)
disj never (fun () -> failwith "oops") () ;
(* --> exception *)
disj always (fun () -> failwith "oops") ()

(* --> false *)
val (&&&) : ('a -> bool) -> ('a -> bool) -> 'a -> bool

f &&& g is conj f g.

val (|||) : ('a -> bool) -> ('a -> bool) -> 'a -> bool

f ||| g is disj f g.

Miscellaneous combinators

val on : ('a -> 'b) -> 'a -> 'a -> f:('b -> 'b -> 'r) -> 'r

on lift x y ~f lifts a binary function f using the lifter lift. It does the same thing as the `on` function from Haskell, but with arguments flipped to make sense without infixing.

Effectively, it's Base.Comparable.lift, but with a slightly different signature.

Example:

let ints = on fst ~f:Int.equal (42, "banana") (42, "apple") in
let strs = on snd ~f:String.equal (42, "banana") (42, "apple") in
(ints, strs)

(* --> true, false *)

F# style function composition operator

This is in a separate module to reduce the ambiguity caused by its use.

module Compose_syntax : sig ... end