Module Accessor_async

get t at reads a value from at.

geti t at reads a value and its index from at.

get_option t at reads a value from at, if present.

get_optioni t at reads a value and its index from at, if present.

match_ t at is like get_option, but in the failure case it may be able to give you the input data structure with a different type.

An indexed version of match_.

Extract all the values targetted by an accessor in some composite data structure into a list.

An indexed version of to_list.

Extract all the values targetted by an accessor in some composite data structure into an array.

An indexed version of to_array.

Fold across all the values targetted by an accessor with an accumulator.

Indexed version of fold.

Iterate over all the values targetted by an accessor, applying the function argument to each one.

An indexed version of iter.

length t at returns the number of targets in at.

is_empty t at is true iff there are no targets in at.

sum (module Summable) t at ~f returns the sum of f a for all targets a in at.

sumi is the indexed version of sum.

count t at ~f returns the number of targets in at for which f evaluates to true.

counti is the indexed version of count.

exists t at ~f returns true iff there is a target in at for which f returns true. This is a short-circuiting operation.

existsi is the indexed version of exists.

for_all t at ~f returns true iff f returns true for all targets in at. This is a short-circuiting operation.

for_alli is the indexed version of for_all.

find_map returns the first evaluation of f that returns Some.

find_mapi is the indexed version of find_map.

find t at ~f returns the first target in at for which the evaluation of f returns true.

findi is the indexed version of find.

min_elt t at ~compare uses compare to compare each target in at and returns the first target with the smallest value.

min_elt_option t at ~compare uses compare to compare each target in at and returns the first target with the smallest value, if any.

max_elt t at ~compare uses compare to compare each target in at and returns the first target with the largest value.

max_elt_option t at ~compare uses compare to compare each target in at and returns the first target with the largest value, if any.

hd t at returns the first targetted element of at.

An indexed version of hd.

hd_option t at returns the first targetted element of at, if any.

An indexed version of hd_option.

map_reduce t at ~empty ~combine ~f applies f to each targetted value in at and combines the results using combine. The result is empty if there were no values. empty and combine are expected to satisfy the following properties:

• combine empty a = a
• combine a empty = a
• combine (combine a b) c = combine a (combine b c)

An indexed version of map_reduce.

map_reduce_nonempty t at ~combine ~f applies f to each targetted value in at and combines the results using combine. combine is expected to satisfy the property: combine (combine a b) c = combine a (combine b c).

An indexed version of map_reduce_nonempty.

map t at ~f applies f to each targetted value inside at, replacing it with the result.

mapi is the indexed version of map.

folding_map is a version of map that threads an accumulator through calls to f.

folding_mapi is the indexed version of folding_map.

fold_map is a combination of fold and map that threads an accumulator through calls to f.

fold_mapi is the indexed version of fold_map.

set t at ~to_ replaces targetted values inside at with to_.

transform t a ~f applies f everywhere it can inside of a once. It operates from the bottom up in one pass. t is used to find the children at each level, where the children are expected to have the same type as their parent.

rewrite t a ~f applies the rewrite rule f everywhere it can inside of a until it cannot be applied anywhere else. It operates from the bottom up, retrying subtrees each time a rule is applied successfully. t is used to find the children at each level, where the children are expected to have the same type as their parent.

An Identical.t is similar to a Type_equal.t, but it relates two pairs of types with each other instead of merely two types. It is a more natural way of using an equality accessor than Type_equal.t would be, since you only need to match on one constructor.

An equality is more powerful even than an isomorphism. It can be used to prove that the types are equal using the identical function.

construct goes the opposite way to most access patterns. It allows you to construct a composite data structure without reading from one.

field ~get ~set creates a field accessor. A field accesses exactly one value within a composite data structure. For the field to be well behaved, get and set should satisfy the following properties:

• get (set at a) = a
• set at (get at) = at
• set (set at a) b = set at b

field' is the same as field, just with a slightly different interface. field is usually more convenient to use, but field' can be useful to allow get and set to share the computation of finding the location to modify.

A Field.t is sufficient to define a field accessor, but the resulting accessor might not be as polymorphic as it could have been if defined by hand or using @@deriving accessor.

fieldi is the indexed version of field.

fieldi' is the indexed version of field'.

A Field.t is sufficient to define an indexed field accessor, where the index is the name of the field as a string. The resulting accessor might not be as polymorphic as it could have been if defined by hand or using @@deriving accessor.

variant ~match_ ~construct creates a variant accessor. A variant accesses at most one value within a composite data structure, and if it does access a value then that value is representative of the entire data structure. A well behaved variant should satisfy the following properties:

• match_ (construct a) = First a
• if match_ at = First a then construct a = at
• if match_ at = Second bt then at = bt

varianti is the indexed version of variant.

optional ~match_ ~set creates an optional accessor. An optional accesses at most one value within a composite data structure. A well behaved optional should satisfy the following properties:

• match_ (set at a) = Either.First.map (match_ at) ~f:(const a)
• if match_ at = First a then set at a = at
• if match_ at = Second bt then at = bt and set at b = at
• set (set at a) b = set at b

optional' is the same as optional, just with a slightly different interface. optional is usually more convenient to use, but optional' can be useful to allow match_ and set to share the computation of finding the location to modify.

optionali is the indexed version of optional.

optionali' is the indexed version of optional'.

filter_index predicate accesses the entire value if its index satisfies predicate, otherwise it accesses nothing. Compose it with a many accessor to access a subset of values.

filter_map_index f is like filter_index, but it can also modify the indices.

isomorphism ~get ~construct creates an isomorphism accessor. An isomorphism accesses exactly one value which exactly represents the entire data structure. A well behaved isomorphism should satisfy the following properties:

• get (construct b) = b
• construct (get at) = at

isomorphismi is the indexed version of isomorphism.

map_index f applies f to the the indices that pass through it in a chain of composed accessors.

mapper map creates a mapper accessor. A mapper can modify values inside a composite data structure, but cannot read anything out. A well behaved mapper should satisfy the following properties:

• map at ~f:Fn.id = at
• map at ~f:(Fn.compose f g) = map (map at ~f:g) ~f

mapperi is the indexed version of mapper.

many traverse creates a many accessor. A many accesses any number of values within a composite data structure.

To define a many accessor, you must use Accessor.Many.t, which is an applicative. You should traverse the data structure as necessary, and each time you reach a value that should be accessed, apply Accessor.Many.access to it.

Here is an example of using many to define an accessor that reaches all the elements of a list:

Accessor.many (fun at -> Accessor.Many.all (List.map at ~f:Accessor.Many.access))

A well behaved many should satisfy the same properties as a well behaved mapper, but generalized for an applicative setting. The properties themselves are uselessly complicated when written out, but here they are anyway. A and B are assumed to have the of_many function generated by Many.Of_applicative, and Compose is assumed to be some functor behaving like Applicative.Compose that also uses Many.Of_applicative to generate an of_many function.

• A.of_many (traverse at) ~access:A.return = A.return at

• Compose(A)(B).of_many (traverse at) ~access:(fun a -> A.map (g a) ~f)
  = A.map (A.of_many (traverse at) ~access:g) ~f:(fun at ->
    B.of_many (traverse at) ~access:f)

manyi is the indexed version of many.

nonempty traverse creates a nonempty accessor. A nonempty accesses a nonzero number of values within a composite data structure.

To define a nonempty accessor, you must use Accessor.Nonempty.t, which is an applicative lacking return. You should traverse the data structure as necessary, and each time you reach a value that should be accessed, apply Accessor.Nonempty.access to it.

Here is an example of using nonempty to define an accessor that reaches both components of a tuple:

Accessor.nonempty (fun (a, b) ->
  let open Accessor.Nonempty.Let_syntax in
  let%map_open a = access a
  and b = access b in
  a, b)

A well behaved nonempty should satisfy the second property of a well behaved mapper, but generalized for an applicative setting. The property itself is uselessly complicated when written out, but here it is anyway. A and B are assumed to have the of_nonempty function generated by Nonempty.Of_applicative_without_return, and Compose is assumed to be some functor behaving like Applicative_without_return.Compose that also uses Nonempty.Of_applicative_without_return to generate an of_nonempty function.

Compose(A)(B).of_nonempty (traverse at) ~access:(fun a -> A.map (g a) ~f)
= A.map (A.of_nonempty (traverse at) ~access:g) ~f:(fun at ->
  B.of_nonempty (traverse at) ~access:f)

nonemptyi is the indexed version of nonempty.

getter get creates a getter accessor. A getter reads exactly one value from a composite data structure. There are no properties necessary for a getter to be well behaved.

getteri is the indexed version of getter.

optional_getter get creates an optional getter accessor. An optional getter reads at most one value from a composite data structure. There are no properties necessary for an optional getter to be well behaved.

optional_getteri is the indexed version of optional_getter.

many_getter map_reduce creates a many_getter accessor. A many getter reads any number of values from a composite data structure. There are no properties necessary for a many getter to be well behaved.

To define a many_getter, you must use the Many_getter interface. Like Many, it has an access function to designate which values to access. Unlike Many, instead of an applicative interface, it has empty and append (or ( @ )) functions.

Here is an example of defining a getter that reads all the elements of a list:

Accessor.many_getter (fun at ->
  Accessor.Many_getter.of_list (List.map at ~f:Accessor.Many_getter.access))

many_getteri is the indexed version of many_getter.

nonempty_getter map_reduce creates a nonempty getter accessor. A nonempty getter reads at least one value from a composite data structure. There are no properties necessary for a nonempty getter to be well behaved.

To define a nonempty_getter, you must use the Nonempty_getter interface. Like Nonempty, it has an access function to designate which values to access. Unlike Nonempty, instead of an applicative style interface, it has an append (or ( @ )) function.

Here is an example of defining a getter that reads both of the components of a tuple:

Accessor.nonempty_getter (fun (a, b) ->
  Accessor.Nonempty_getter.(access a @ access b))

nonempty_getteri is the indexed version of nonempty_getter.

constructor construct creates a constructor accessor. A constructor creates a composite data structure from an argument. There are no properties necessary for a constructor to be well behaved.

A Variant.t is not sufficient to define a variant accessor, but is at least sufficient to define a constructor accessor.