Module Accessor__.Many

type ('a, +'x, 'y) t

An (a, x, y) t is an applicative for defining many accessors. See the documentation of Accessor.many for more information.

A value of type (a, x, y) t can make the following claim: I can give you some number of xes and if you tell me how to replace each of them with a y, I will also give you an a.

module Accessed : Base.Monad.S_indexed with type ('x, 'a, 'y) t := ('a, 'x, 'y) t
val access : 'a -> ('b, 'a, 'b) t

access a "accesses" a and returns the value you are expected replace it with.

val of_nonempty : ('a, 'x, 'y) Accessor.Nonempty.t -> ('a, 'x, 'y) t
module Of_applicative : functor (A : sig ... end) -> sig ... end
module Of_applicative2 : functor (A : sig ... end) -> sig ... end
module Of_applicative3 : functor (A : sig ... end) -> sig ... end
module Open_on_rhs_intf : sig ... end
include Base.Applicative.S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) t
include Base__.Applicative_intf.For_let_syntax3
type ('a, 'd, 'e) t
val return : 'a -> ('a, _, _) t
val map : ('a, 'd, 'e) t -> f:('a -> 'b) -> ('b, 'd, 'e) t
val both : ('a, 'd, 'e) t -> ('b, 'd, 'e) t -> ('a * 'b, 'd, 'e) t
include Base__.Applicative_intf.Applicative_infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t
type ('a, 'd, 'e) t
val (<*>) : ('a -> 'b, 'd, 'e) t -> ('a, 'd, 'e) t -> ('b, 'd, 'e) t
val (<*) : ('a, 'd, 'e) t -> (unit, 'd, 'e) t -> ('a, 'd, 'e) t
val (*>) : (unit, 'd, 'e) t -> ('a, 'd, 'e) t -> ('a, 'd, 'e) t
val (>>|) : ('a, 'd, 'e) t -> ('a -> 'b) -> ('b, 'd, 'e) t
val apply : ('a -> 'b, 'd, 'e) t -> ('a, 'd, 'e) t -> ('b, 'd, 'e) t
val map2 : ('a, 'd, 'e) t -> ('b, 'd, 'e) t -> f:('a -> 'b -> 'c) -> ('c, 'd, 'e) t
val map3 : ('a, 'd, 'e) t -> ('b, 'd, 'e) t -> ('c, 'd, 'e) t -> f:('a -> 'b -> 'c -> 'result) -> ('result, 'd, 'e) t
val all : ('a, 'd, 'e) t list -> ('a list, 'd, 'e) t
val all_unit : (unit, 'd, 'e) t list -> (unit, 'd, 'e) t
module Applicative_infix : Base__.Applicative_intf.Applicative_infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t
include Base.Applicative.Let_syntax3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) t with module Open_on_rhs_intf := Open_on_rhs_intf
type ('a, 'd, 'e) t
module Open_on_rhs_intf : sig ... end
module Let_syntax : sig ... end