Up
# Module Total_map

### Signature

Sequence a total map of computations in order of their keys resulting in computation
of the total map of results.
module
Make_using_comparator
(Key : sig .. end) : S with module Key = Key with type
comparator_witness = Key.comparator_witness

A `('key, 'value, cmp) Map.t`

where every value of type `'key`

is present.

This is intended to be used on `'key`

types where there is a full enumeration of the
type. In the common use case, `'key`

will be a simple variant type with ```
[@@deriving
compare, enumerate]
```

. For example:

```
module Arrow_key = struct
module T = struct
type t =
| Up
| Down
| Left
| Right
[@@deriving sexp, bin_io, compare, enumerate]
end
include T
module Total_map = Total_map.Make (T)
end
```

In such a case, a `t`

is semantically equivalent to a pure function from `'key`

to
`'value`

. The differences are that it is serializable and that mapping or changing a
`t`

will produce a `t`

using the same amount of space as the original.

However, in theory you could also modify the comparison function and enumeration, so long as the enumeration contains at least one representative of each equivalence class determined by the comparison function.

Many of the functions below have types reflecting the fact that the maps are total
(e.g., `find`

does not return an option). The fact that they won't raise exceptions
relies on the enumeration passed to `Make`

being complete.

val
iter : ('key, 'a, _, _) t -> f:(key:'key -> data:'a -> unit) -> unit

val
iteri : ('key, 'a, _, _) t -> f:(key:'key -> data:'a -> unit) -> unit

val
find : ('key, 'a, _, _) t -> 'key -> 'a

The only reason that the Applicative interface isn't included here is that we don't
have an `Applicative.S3`

.

module type
Key
= sig .. end

module type
S
= sig .. end