# Module Std_kernel.Total_map

    module Total_map: Total_map

    type ('key, 'a, 'cmp) t = private ('key, 'a, 'cmp) Std_internal.Map.t

    val to_map : ('key, 'a, 'cmp) t -> ('key, 'a, 'cmp) Std_internal.Map.t

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 map : ('key, 'a, 'cmp) t -> f:('a -> 'b) -> ('key, 'b, 'cmp) t

    val mapi : ('key, 'a, 'cmp) t ->
           f:(key:'key -> data:'a -> 'b) -> ('key, 'b, 'cmp) t

    val map2 : ('key, 'a, 'cmp) t ->
           ('key, 'b, 'cmp) t ->
           f:('a -> 'b -> 'c) -> ('key, 'c, 'cmp) t

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

    val iter2 : ('key, 'a, 'cmp) t ->
           ('key, 'b, 'cmp) t -> f:(key:'key -> 'a -> 'b -> unit) -> unit

    val set : ('key, 'a, 'cmp) t -> 'key -> 'a -> ('key, 'a, 'cmp) t

    val to_alist : ('key, 'a, 'b) t -> ('key * 'a) list

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

    val change : ('key, 'a, 'cmp) t ->
           'key -> ('a -> 'a) -> ('key, 'a, 'cmp) t

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

    module Make: functor (Key : Key) -> S  with module Key = Key