# Module Core_list.Assoc

    module Assoc: sig .. end

Interpret a list of (key, value) pairs as a map in which only the first occurrence of a key affects the semantics, i.e.:

    List.Assoc.xxx alist ...args...

is always the same as (or at least sort of isomorphic to):

     Map.xxx (alist |! Map.of_alist_multi |! Map.map ~f:List.hd) ...args...

    type ('a, 'b) t = ('a * 'b) list

    val add : ('a, 'b) t ->
           ?equal:('a -> 'a -> bool) -> 'a -> 'b -> ('a, 'b) t

    val find : ('a, 'b) t -> ?equal:('a -> 'a -> bool) -> 'a -> 'b option

    val find_exn : ('a, 'b) t -> ?equal:('a -> 'a -> bool) -> 'a -> 'b

    val mem : ('a, 'b) t -> ?equal:('a -> 'a -> bool) -> 'a -> bool

    val remove : ('a, 'b) t ->
           ?equal:('a -> 'a -> bool) -> 'a -> ('a, 'b) t

    val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t

Bijectivity is not guaranteed because we allow a key to appear more than once.

    val inverse : ('a, 'b) t -> ('b, 'a) t

    val compare : ('a -> 'a -> int) ->
           ('b -> 'b -> int) ->
           ('a, 'b) t -> ('a, 'b) t -> int

    val t_of_sexp : (Sexplib.Sexp.t -> 'a) ->
           (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) t

    val sexp_of_t : ('a -> Sexplib.Sexp.t) ->
           ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t

    val bin_t : 'a Bin_prot.Type_class.t ->
           'b Bin_prot.Type_class.t -> ('a, 'b) t Bin_prot.Type_class.t

    val bin_read_t : 'a Bin_prot.Read.reader ->
           'b Bin_prot.Read.reader -> ('a, 'b) t Bin_prot.Read.reader

    val __bin_read_t__ : 'a Bin_prot.Read.reader ->
           'b Bin_prot.Read.reader ->
           (int -> ('a, 'b) t) Bin_prot.Read.reader

    val bin_reader_t : 'a Bin_prot.Type_class.reader ->
           'b Bin_prot.Type_class.reader ->
           ('a, 'b) t Bin_prot.Type_class.reader

    val bin_size_t : 'a Bin_prot.Size.sizer ->
           'b Bin_prot.Size.sizer -> ('a, 'b) t Bin_prot.Size.sizer

    val bin_write_t : 'a Bin_prot.Write.writer ->
           'b Bin_prot.Write.writer -> ('a, 'b) t Bin_prot.Write.writer

    val bin_writer_t : 'a Bin_prot.Type_class.writer ->
           'b Bin_prot.Type_class.writer ->
           ('a, 'b) t Bin_prot.Type_class.writer

Bijectivity is not guaranteed because we allow a key to appear more than once.