always x is true.

never x is false.

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 *)

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 *)

f &&& g is conj f g.

f ||| g is disj f g.

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 *)