package async_unix

You can search for identifiers within the package.

in-package search v0.2.0

async_unix
- Async_unix
  - Async_config
  - Clock
    
    Event
    
    Status
  - Dump_core_on_job_delay
    
    How_to_dump
  - Fd
    
    Close
    
    Kind
  - In_thread
    
    Helper_thread
    
    Priority
  - Io_stats
  - LargeFile
  - Log
    
    Blocking
    
    Output
    
    Global
    
    Global_intf
    
    Level
    
    Stable
    
    V1
    
    Make_global
    
    Message
    
    Stable
    
    V0
    
    V2
    
    Output
    
    Format
    
    Stable
    
    V1
    
    Reader
    
    Expert
    
    Rotation
    
    Id_intf
  - Overwrite_
  - Print
  - Printf
  - Process
    
    Output
    
    Stable
    
    V1
  - Reader
    
    Id
    
    Hash_queue
    
    Key
    
    Hash_set
    
    Provide_bin_io
    
    X
    
    Provide_of_sexp
    
    X
    
    Map
    
    Key
    
    Provide_bin_io
    
    Key
    
    Provide_hash
    
    Key
    
    Provide_of_sexp
    
    Key
    
    Tree
    
    Provide_of_sexp
    
    K
    
    Replace_polymorphic_compare
    
    Set
    
    Elt
    
    Named
    
    Provide_bin_io
    
    Elt
    
    Provide_hash
    
    Elt
    
    Provide_of_sexp
    
    Elt
    
    Tree
    
    Named
    
    Provide_of_sexp
    
    Elt
    
    Table
    
    Provide_bin_io
    
    Key
    
    Provide_of_sexp
    
    Key
    
    Macro_loader
    
    Read_result
    
    Let_syntax
    
    Let_syntax
    
    Open_on_rhs
    
    Monad_infix
  - Require_explicit_time_source
    
    Clock
    
    Event
    
    Status
    
    Scheduler
    
    Time
    
    Time_ns
  - Scheduler
    
    Expert
  - Sexp
  - Shutdown
  - Signal
  - Socket
    
    Address
    
    Blocking_sexp
    
    Inet
    
    Blocking_sexp
    
    Show_port_in_test
    
    Unix
    
    Family
    
    Opt
    
    Type
  - Sys
  - Thread_safe
  - Thread_safe_pipe
    
    If_closed
    
    Written_or_closed
  - Unix
    
    Addr_info
    
    Blocking_sexp
    
    File_kind
    
    Map
    
    Key
    
    Provide_bin_io
    
    Key
    
    Provide_hash
    
    Key
    
    Provide_of_sexp
    
    Key
    
    Tree
    
    Provide_of_sexp
    
    K
    
    Replace_polymorphic_compare
    
    Set
    
    Elt
    
    Named
    
    Provide_bin_io
    
    Elt
    
    Provide_hash
    
    Elt
    
    Provide_of_sexp
    
    Elt
    
    Tree
    
    Named
    
    Provide_of_sexp
    
    Elt
    
    Group
    
    Fields
    
    Direct
    
    Host
    
    Inet_addr
    
    Name_info
    
    Passwd
    
    Fields
    
    Direct
    
    Protocol_family
    
    Socket
    
    Address
    
    Blocking_sexp
    
    Inet
    
    Blocking_sexp
    
    Show_port_in_test
    
    Unix
    
    Family
    
    Opt
    
    Type
    
    Stats
    
    Fields
    
    Direct
    
    Terminal_io
  - Writer
    
    Id
    
    Hash_queue
    
    Key
    
    Hash_set
    
    Provide_bin_io
    
    X
    
    Provide_of_sexp
    
    X
    
    Map
    
    Key
    
    Provide_bin_io
    
    Key
    
    Provide_hash
    
    Key
    
    Provide_of_sexp
    
    Key
    
    Tree
    
    Provide_of_sexp
    
    K
    
    Replace_polymorphic_compare
    
    Set
    
    Elt
    
    Named
    
    Provide_bin_io
    
    Elt
    
    Provide_hash
    
    Elt
    
    Provide_of_sexp
    
    Elt
    
    Tree
    
    Named
    
    Provide_of_sexp
    
    Elt
    
    Table
    
    Provide_bin_io
    
    Key
    
    Provide_of_sexp
    
    Key
    
    Line_ending
    
    Terminate_with

Legend:
Library
Module
Module type
Parameter
Class
Class type

include Core_kernel.Hashtbl_intf.S
  with type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashtbl.t
  with type key = t

include Core_kernel.Hashtbl_intf.S_plain
  with type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashtbl.t
  with type key = t

type key = t

type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashtbl.t

type 'b t = (key, 'b) hashtbl

val sexp_of_t : 
  ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
  'b t ->
  Ppx_sexp_conv_lib.Sexp.t

type ('a, 'b) t_ = 'b t

type 'a key_ = key

val hashable : key Base.Hashable.t

include Base.Invariant.S1 with type 'b t := 'b t

val invariant : ('a -> unit) -> 'a t -> unit

val create : 
  ('a key_, 'b, unit -> ('a, 'b) t_)
    Core_kernel.Hashtbl_intf.create_options_without_hashable

val of_alist : 
  ('a key_,
    'b,
    ('a key_ * 'b) list ->
    [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
    Core_kernel.Hashtbl_intf.create_options_without_hashable

val of_alist_report_all_dups : 
  ('a key_,
    'b,
    ('a key_ * 'b) list ->
    [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
    Core_kernel.Hashtbl_intf.create_options_without_hashable

val of_alist_or_error : 
  ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Base.Or_error.t)
    Core_kernel.Hashtbl_intf.create_options_without_hashable

val of_alist_exn : 
  ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
    Core_kernel.Hashtbl_intf.create_options_without_hashable

val of_alist_multi : 
  ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
    Core_kernel.Hashtbl_intf.create_options_without_hashable

val create_mapped : 
  ('a key_,
    'b,
    get_key:('r -> 'a key_) ->
    get_data:('r -> 'b) ->
    'r list ->
    [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
    Core_kernel.Hashtbl_intf.create_options_without_hashable

val create_with_key : 
  ('a key_,
    'r,
    get_key:('r -> 'a key_) ->
    'r list ->
    [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
    Core_kernel.Hashtbl_intf.create_options_without_hashable

val create_with_key_or_error : 
  ('a key_,
    'r,
    get_key:('r -> 'a key_) ->
    'r list ->
    ('a, 'r) t_ Base.Or_error.t)
    Core_kernel.Hashtbl_intf.create_options_without_hashable

val create_with_key_exn : 
  ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
    Core_kernel.Hashtbl_intf.create_options_without_hashable

val group : 
  ('a key_,
    'b,
    get_key:('r -> 'a key_) ->
    get_data:('r -> 'b) ->
    combine:('b -> 'b -> 'b) ->
    'r list ->
    ('a, 'b) t_)
    Core_kernel.Hashtbl_intf.create_options_without_hashable

include Core_kernel.Hashtbl_intf.Accessors
  with type ('a, 'b) t := ('a, 'b) t_
  with type 'a key := 'a key_

val sexp_of_key : ('a, _) t_ -> 'a key_ -> Base.Sexp.t

val clear : (_, _) t_ -> unit

val copy : ('a, 'b) t_ -> ('a, 'b) t_

val fold : 
  ('a, 'b) t_ ->
  init:'c ->
  f:(key:'a key_ -> data:'b -> 'c -> 'c) ->
  'c

Attempting to modify (set, remove, etc.) the hashtable during iteration (fold, iter, iter_keys, iteri) will raise an exception.

val iter_keys : ('a, _) t_ -> f:('a key_ -> unit) -> unit

val iter : (_, 'b) t_ -> f:('b -> unit) -> unit

val iteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit

val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool

val exists : (_, 'b) t_ -> f:('b -> bool) -> bool

val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool

val for_all : (_, 'b) t_ -> f:('b -> bool) -> bool

val counti : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> int

val count : (_, 'b) t_ -> f:('b -> bool) -> int

val length : (_, _) t_ -> int

val is_empty : (_, _) t_ -> bool

val mem : ('a, _) t_ -> 'a key_ -> bool

val remove : ('a, _) t_ -> 'a key_ -> unit

val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit

val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Ok | `Duplicate ]

add and add_exn leave the table unchanged if the key was already present.

val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit

val change : ('a, 'b) t_ -> 'a key_ -> f:('b option -> 'b option) -> unit

change t key ~f changes t's value for key to be f (find t key).

val update : ('a, 'b) t_ -> 'a key_ -> f:('b option -> 'b) -> unit

update t key ~f is change t key ~f:(fun o -> Some (f o)).

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

map t f returns new table with bound values replaced by f applied to the bound values

val mapi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_

like map, but function takes both key and data as arguments

val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_

returns new table with bound values filtered by f applied to the bound values

val filter_mapi : 
  ('a, 'b) t_ ->
  f:(key:'a key_ -> data:'b -> 'c option) ->
  ('a, 'c) t_

like filter_map, but function takes both key and data as arguments

val filter_keys : ('a, 'b) t_ -> f:('a key_ -> bool) -> ('a, 'b) t_

val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_

val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_

val partition_map : 
  ('a, 'b) t_ ->
  f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
  ('a, 'c) t_ * ('a, 'd) t_

returns new tables with bound values partitioned by f applied to the bound values

val partition_mapi : 
  ('a, 'b) t_ ->
  f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
  ('a, 'c) t_ * ('a, 'd) t_

like partition_map, but function takes both key and data as arguments

val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_

returns a pair of tables (t1, t2), where t1 contains all the elements of the initial table which satisfy the predicate f, and t2 contains all the elements which do not satisfy f.

val partitioni_tf : 
  ('a, 'b) t_ ->
  f:(key:'a key_ -> data:'b -> bool) ->
  ('a, 'b) t_ * ('a, 'b) t_

like partition_tf, but function takes both key and data as arguments

val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b

find_or_add t k ~default returns the data associated with key k if it is in the table t, otherwise it lets d = default() and adds it to the table.

val findi_or_add : ('a, 'b) t_ -> 'a key_ -> default:('a key_ -> 'b) -> 'b

like find_or_add but default takes the key as an argument.

val find : ('a, 'b) t_ -> 'a key_ -> 'b option

find t k returns Some (the current binding) of k in t, or None if no such binding exists

val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b

find_exn t k returns the current binding of k in t, or raises Caml.Not_found or Not_found_s if no such binding exists.

val find_and_call : 
  ('a, 'b) t_ ->
  'a key_ ->
  if_found:('b -> 'c) ->
  if_not_found:('a key_ -> 'c) ->
  'c

find_and_call t k ~if_found ~if_not_found

is equivalent to:

match find t k with Some v -> if_found v | None -> if_not_found k

except that it doesn't allocate the option.

val findi_and_call : 
  ('a, 'b) t_ ->
  'a key_ ->
  if_found:(key:'a key_ -> data:'b -> 'c) ->
  if_not_found:('a key_ -> 'c) ->
  'c

val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option

find_and_remove t k returns Some (the current binding) of k in t and removes it, or None is no such binding exists

val merge : 
  ('k, 'a) t_ ->
  ('k, 'b) t_ ->
  f:
    (key:'k key_ ->
      [ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] ->
      'c option) ->
  ('k, 'c) t_

Merge two hashtables.

The result of merge f h1 h2 has as keys the set of all k in the union of the sets of keys of h1 and h2 for which d(k) is not None, where:

d(k) =

f ~key:k (Some d1) None if k in h1 is to d1, and h2 does not map k;

f ~key:k None (Some d2) if k in h2 is to d2, and h1 does not map k;

f ~key:k (Some d1) (Some d2) otherwise, where k in h1 is to d1 and k in h2 is to d2.

Each key k is mapped to a single piece of data x, where d(k) = Some x.

type 'a merge_into_action =

| Remove
| Set_to of 'a

Every key in src will be removed or set in dst according to the return value of f.

val merge_into : 
  src:('k, 'a) t_ ->
  dst:('k, 'b) t_ ->
  f:(key:'k key_ -> 'a -> 'b option -> 'b merge_into_action) ->
  unit

val keys : ('a, _) t_ -> 'a key_ list

Returns the list of all keys for given hashtable.

val data : (_, 'b) t_ -> 'b list

Returns the list of all data for given hashtable.

val filter_keys_inplace : ('a, _) t_ -> f:('a key_ -> bool) -> unit

filter_inplace t ~f removes all the elements from t that don't satisfy f.

val filter_inplace : (_, 'b) t_ -> f:('b -> bool) -> unit

val filteri_inplace : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> unit

val map_inplace : (_, 'b) t_ -> f:('b -> 'b) -> unit

map_inplace t ~f applies f to all elements in t, transforming them in place

val mapi_inplace : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'b) -> unit

val filter_map_inplace : (_, 'b) t_ -> f:('b -> 'b option) -> unit

filter_map_inplace combines the effects of map_inplace and filter_inplace

val filter_mapi_inplace : 
  ('a, 'b) t_ ->
  f:(key:'a key_ -> data:'b -> 'b option) ->
  unit

val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool

equal t1 t2 f and similar t1 t2 f both return true iff t1 and t2 have the same keys and for all keys k, f (find_exn t1 k) (find_exn t2 k). equal and similar only differ in their types.

val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool

val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list

Returns the list of all (key,data) pairs for given hashtable.

val validate : 
  name:('a key_ -> string) ->
  'b Base.Validate.check ->
  ('a, 'b) t_ Base.Validate.check

val incr : ?by:int -> ?remove_if_zero:bool -> ('a, int) t_ -> 'a key_ -> unit

remove_if_zero's default is false.

val decr : ?by:int -> ?remove_if_zero:bool -> ('a, int) t_ -> 'a key_ -> unit

include Core_kernel.Hashtbl_intf.Multi
  with type ('a, 'b) t := ('a, 'b) t_
  with type 'a key := 'a key_

val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit

add_multi t ~key ~data if key is present in the table then cons data on the list, otherwise add key with a single element list.

val remove_multi : ('a, _ list) t_ -> 'a key_ -> unit

remove_multi t key updates the table, removing the head of the list bound to key. If the list has only one element (or is empty) then the binding is removed.

val find_multi : ('a, 'b list) t_ -> 'a key_ -> 'b list

find_multi t key returns the empty list if key is not present in the table, returns t's values for key otherwise

module Provide_of_sexp (Key : sig ... end) : sig ... end

module Provide_bin_io (Key : sig ... end) : sig ... end

include sig ... end

val t_of_sexp : 
  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
  Ppx_sexp_conv_lib.Sexp.t ->
  'v_x__002_ t

include Core_kernel.Hashtbl_intf.Binable.S1 with type 'v t := 'v t

val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t

val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1

val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1

val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1

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

val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer

val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader

val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t