Applicative.ListSourceList defines applications that work across all possible combinations of the items in the respective lists. This is often used to model non-determinism.
E.g., to get all pairs that can be formed by selecting first and second elements from the respective lists:
# let x = List.NonDet.((fun x y -> (x, y)) <@> [1;2] <*> ['a';'b']);;
- : (int * char) list = [(1, 'a'); (1, 'b'); (2, 'a'); (2, 'b')]
include Seed with type 'a t = 'a List.tinclude Functor.S with type 'a t = 'a List.tinclude Functor.Seed with type 'a t = 'a List.tThe principle type.
The type constructor t is the mapping of objects taking every type 'a to a type 'a t.
map ~f maps the function f : 'a -> 'b to a function 'f T : 'a T -> 'b T.
As an example, if T (x : u) : u t then map ~(f:u -> v) (T x) is T (f x) : v t. As a result, map is often thought of as applying f "in" T.
The function map is the mapping of arrows, taking every arrow 'a -> 'b to an arrow 'a t -> 'b t.
map2 ~f x y is return f <*> x <*> y, i.e., f "lifted" in to t and then applied to both x and y.
both (F a) (F b) is F (a, b), i.e., it is the product of a and b in F
Binding operators for use with the OCaml 4.08 extension. See the OCaml docs on binding operators for more information.