Module Read_write

module Read_write: sig .. end

module Key: sig .. end

type ('a, 'z) any = private {

module Immutable: sig .. end

module Read_only: sig .. end

module Mutable: sig .. end

type 'a t = 'a Immutable.t 

val create : read:'a -> write:'a -> ('a, 'b) any

val createi : (Key.t -> 'a) -> ('a, 'b) any

val create_both : 'a -> ('a, 'b) any

val create_fn : (unit -> 'a) -> ('a, 'b) any

val create_with : Key.t -> 'a -> zero:'a -> ('a, 'b) any

val copy : ('a, 'b) any -> ('a, 'c) any

val exists : ('a, 'b) any -> f:('a -> bool) -> bool

val for_all : ('a, 'b) any -> f:('a -> bool) -> bool

val iteri : ('a, 'b) any -> f:(Key.t -> 'a -> unit) -> unit

val iter : ('a, 'b) any -> f:('a -> unit) -> unit

val mapi : ('a, 'c) any ->
       f:(Key.t -> 'a -> 'b) -> ('b, 'd) any

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

val foldi : ('a, 'c) any -> 'b -> f:('b -> Key.t * 'a -> 'b) -> 'b

val fold : ('a, 'c) any -> 'b -> f:('b -> 'a -> 'b) -> 'b

val get : ('a, 'b) any -> Key.t -> 'a

val replace : 'a Mutable.t -> Key.t -> f:('a -> 'a) -> unit

val replace_all : 'a Mutable.t -> f:(Key.t -> 'a -> 'a) -> unit

val set : 'a Mutable.t -> Key.t -> 'a -> unit

module Export: sig .. end

val any_of_sexp : (Sexplib.Sexp.t -> 'a) ->
       (Sexplib.Sexp.t -> 'z) -> Sexplib.Sexp.t -> ('a, 'z) any

val sexp_of_any : ('a -> Sexplib.Sexp.t) ->
       ('z -> Sexplib.Sexp.t) -> ('a, 'z) any -> Sexplib.Sexp.t

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

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