jon.recoil.org

Parameter Compose.Outer

include Base.Applicative.S
type 'a t
val return : 'a 'p 'q. 'a -> 'a Outer.t

Convert a value to a t.

val apply : 'a 'b 'p 'q. ('a -> 'b) Outer.t -> 'a Outer.t -> 'b Outer.t

Applies the functions in one t to the values in another. Well-behaved applicatives satisfy these "laws", using <*> as infix apply:

  • return Fn.id <*> t is equivalent to t
  • return Fn.compose <*> tf <*> tg <*> tx is equivalent to tf <*> (tg <*> tx)
  • return f <*> return x is equivalent to return (f x)
  • tf <*> return x is equivalent to return (fun f -> f x) <*> tf
val both : 'a 'b 'p 'q. 'a Outer.t -> 'b Outer.t -> ('a * 'b) Outer.t

Combines values in two ts as tuples. Using <*> as infix apply, equivalent to return (fun a b -> a, b) <*> ta <*> tb.

val map : 'a 'b 'p 'q. 'a Outer.t -> f:('a -> 'b) -> 'b Outer.t

Transforms the contents of a t. Using <*> as infix apply, equivalent to return f <*> t.

val map2 : 'a 'b 'c 'p 'q. 'a Outer.t -> 'b Outer.t -> f:('a -> 'b -> 'c) -> 'c Outer.t

Combines the contents of two ts. Using <*> as infix apply, equivalent to return f <*> ta <*> tb.

val map3 : 'a 'b 'c 'd 'p 'q. 'a Outer.t -> 'b Outer.t -> 'c Outer.t -> f:('a -> 'b -> 'c -> 'd) -> 'd Outer.t

Combines the contents of three ts. Using <*> as infix apply, equivalent to return f <*> ta <*> tb <*> tc.

val all : 'a 'p 'q. 'a Outer.t list -> 'a list Outer.t

Combines a list of t.

val all_unit : 'p 'q. unit Outer.t list -> unit Outer.t

Combines a list of t whose contents are unimportant.

val (<*>) : 'a 'b 'p 'q. ('a -> 'b) Outer.t -> 'a Outer.t -> 'b Outer.t
val (<*) : 'a 'p 'q. 'a Outer.t -> unit Outer.t -> 'a Outer.t
val (*>) : 'a 'p 'q. unit Outer.t -> 'a Outer.t -> 'a Outer.t
val (>>|) : 'a 'b 'p 'q. 'a Outer.t -> ('a -> 'b) -> 'b Outer.t
module Applicative_infix : sig ... end