janestreet / async_smtp Goto Github PK
View Code? Open in Web Editor NEWSMTP client and server
License: MIT License
async_smtp's Issues
Any plan to update this version to opam repo?
I'm using the newest opam version:
$ opam info async_smtp
package: async_smtp
version: v0.9.0
repository: default
upstream-url: https://ocaml.janestreet.com/ocaml-core/v0.9/files/async_smtp-v0.9.0.tar.gz
upstream-kind: http
upstream-checksum: 4e415ae1117206cc89a0e1b7aff7d486
homepage: https://github.com/janestreet/async_smtp
bug-reports: https://github.com/janestreet/async_smtp/issues
dev-repo: https://github.com/janestreet/async_smtp.git
But there's no credentials on that version.
Doesn't build anymore
I suspect this is a versioning issue. After fixing Async_bus to be Async_extra.Bus and removing the dependency on async_extra.async_bus I got this
dune build
File "src/rpc_impl.ml", line 55, characters 14-59:
Error: Unbound value Resource_cache.Address_config.Stable.V1.of_v2
File "src/spool_config.ml", line 12, characters 32-77:
Error: Unbound value Resource_cache.Address_config.Stable.V1.of_v2
File "src/spool.ml", line 278, characters 36-81:
Error: Unbound value Resource_cache.Address_config.Stable.V1.to_v2
File "command/spool.ml", line 63, characters 28-38:
Error: Unbound constructor Default_to
File "src/client_cache.ml", line 150, characters 10-40:
Error: This module is not a functor; it has type
sig
module Status :
sig
module Key :
sig
type t = Address_and_route.t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator : (t, comparator_witness) Comparator.t
val validate_lbound :
min:t Base.Maybe_bound.t -> t Validate.check
val validate_ubound :
max:t Base.Maybe_bound.t -> t Validate.check
val validate_bound :
min:t Base.Maybe_bound.t ->
max:t Base.Maybe_bound.t -> t Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = Address_and_route.t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Comparator.t
end
module Tree :
Core_kernel__.Map_intf.Make_S_plain_tree(Key).S
type 'a t = (Key.t, 'a, comparator_witness) Map.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val sexp_of_t :
('a -> Ppx_sexp_conv_lib.Sexp.t) ->
'a t -> Ppx_sexp_conv_lib.Sexp.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_increasing_sequence :
(Key.t * 'a) Base.Sequence.t -> 'a t Base__.Or_error.t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn : (Key.t, 'a) Hashtbl.t -> 'a t
val quickcheck_generator :
Key.t Base_quickcheck.Generator.t ->
'a Base_quickcheck.Generator.t ->
'a t Base_quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add :
'a t ->
key:Key.t ->
data:'a -> 'a t Core_kernel.Map_intf.Or_duplicate.t
val add_exn : 'a t -> key:Key.t -> data:'a -> 'a t
val set : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val find_multi : 'a list t -> Key.t -> 'a list
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Validate.check -> 'a t Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a) Base__Map_intf.Symmetric_diff_element.t
Base.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base.Maybe_bound.t ->
upper_bound:Key.t Base.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base.Sequence.t
val quickcheck_observer :
Key.t Base_quickcheck.Observer.t ->
'v Base_quickcheck.Observer.t ->
'v t Base_quickcheck.Observer.t
val quickcheck_shrinker :
Key.t Base_quickcheck.Shrinker.t ->
'v Base_quickcheck.Shrinker.t ->
'v t Base_quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp :
Ppx_sexp_conv_lib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t :
Key.t Bin_prot.Write.writer
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> Key.t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t :
Key.t Bin_prot.Type_class.writer0
val bin_reader_t :
Key.t Bin_prot.Type_class.reader0
val bin_t : Key.t Bin_prot.Type_class.t0
end) ->
sig
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
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Hash.state -> Key.t -> Hash.state
end) ->
sig
val hash_fold_t :
(Hash.state -> 'a -> Hash.state) ->
Hash.state -> 'a t -> Hash.state
end
end
module Set :
sig
module Elt :
sig
type t = Address_and_route.t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness) Comparator.t
end
module Tree :
Core_kernel__.Set_intf.Make_S_plain_tree(Elt).S
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> int
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
type named =
(Elt.t, comparator_witness)
Core_kernel.Set_intf.Named.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) result) ->
('accum, 'e) result
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Container_intf.Summable with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(Elt.t, Elt.t) Core_kernel._either Base.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
module Named :
sig
val is_subset :
named -> of_:named -> unit Base__.Or_error.t
val equal : named -> named -> unit Base__.Or_error.t
end
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> ('b, 'final) Continue_or_stop.t) ->
finish:('b -> 'final) -> 'final
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t) Base.Set.Merge_to_sequence_element.t
Base.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness) Core_kernel.Map.t
val quickcheck_observer :
Elt.t Base_quickcheck.Observer.t ->
t Base_quickcheck.Observer.t
val quickcheck_shrinker :
Elt.t Base_quickcheck.Shrinker.t ->
t Base_quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Hash_set.t -> t
val of_hashtbl_keys : (Elt.t, 'a) Hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness) Core_kernel.Map.t -> t
val quickcheck_generator :
Elt.t Base_quickcheck.Generator.t ->
t Base_quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Ppx_sexp_conv_lib.Sexp.t -> Elt.t
end) ->
sig
val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
end
module Provide_bin_io :
functor
(Elt : sig
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t :
Elt.t Bin_prot.Write.writer
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> Elt.t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer0
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader0
val bin_t : Elt.t Bin_prot.Type_class.t0
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer0
val bin_reader_t : t Bin_prot.Type_class.reader0
val bin_t : t Bin_prot.Type_class.t0
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Hash.state -> Elt.t -> Hash.state
end) ->
sig
val hash_fold_t : Hash.state -> t -> Hash.state
val hash : t -> int
end
end
val compare : t -> t -> int
val hash_fold_t : Hash.state -> t -> Hash.state
val hash : t -> int
val hashable : t Base.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) 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
val invariant :
'a Base__Invariant_intf.t ->
'a t Base__Invariant_intf.t
val create :
(key, 'b, unit -> 'b t)
Hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Hashtbl_intf.create_options_without_hashable
val sexp_of_key :
'a t -> key -> Ppx_sexp_conv_lib.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val findi_or_add :
'b t -> key -> default:(key -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val findi_and_call :
'b t ->
key ->
if_found:(key:key -> data:'b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Validate.check -> 'b t Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val find_multi : 'b list t -> key -> 'b list
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp :
Ppx_sexp_conv_lib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(int -> key) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t :
key Bin_prot.Type_class.writer0
val bin_reader_t :
key Bin_prot.Type_class.reader0
val bin_t : key Bin_prot.Type_class.t0
end) ->
sig
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
end
end
module Hash_set :
sig
type elt = t
type t = elt Hash_set.t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Base.Hash_set.create_options_without_first_class_module
val of_list :
('a, elt list -> t)
Base.Hash_set.create_options_without_first_class_module
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp :
Ppx_sexp_conv_lib.Sexp.t -> elt
end) ->
sig
val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
end
module Provide_bin_io :
functor
(X : sig
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(int -> elt) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t :
elt Bin_prot.Type_class.writer0
val bin_reader_t :
elt Bin_prot.Type_class.reader0
val bin_t : elt Bin_prot.Type_class.t0
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer0
val bin_reader_t : t Bin_prot.Type_class.reader0
val bin_t : t Bin_prot.Type_class.t0
end
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val compare : t -> t -> int
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Ppx_sexp_conv_lib.Sexp.t) ->
'a t -> Ppx_sexp_conv_lib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) result) ->
('accum, 'e) result
val fold_until :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'final) Continue_or_stop.t) ->
finish:('accum -> 'final) -> 'final
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Container_intf.Summable with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> compare:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> compare:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Base.unit
val create :
?growth_allowed:sexp_bool ->
?size:int -> Base.unit -> 'a t
val clear : 'a t -> Base.unit
val mem : 'a t -> Key.t -> sexp_bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t ->
[ `back | `front ] ->
Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> [ `back | `front ] -> Key.t -> 'a -> Base.unit
val enqueue_back :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_back_exn : 'a t -> Key.t -> 'a -> Base.unit
val enqueue_front :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_front_exn : 'a t -> Key.t -> 'a -> Base.unit
val lookup_and_move_to_back : 'a t -> Key.t -> 'a option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val lookup_and_move_to_front :
'a t -> Key.t -> 'a option
val lookup_and_move_to_front_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a option
val first_with_key : 'a t -> (Key.t * 'a) option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> [ `back | `front ] -> 'a option
val dequeue_exn : 'a t -> [ `back | `front ] -> 'a
val dequeue_back : 'a t -> 'a option
val dequeue_back_exn : 'a t -> 'a
val dequeue_front : 'a t -> 'a option
val dequeue_front_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> [ `back | `front ] -> (Key.t * 'a) option
val dequeue_with_key_exn :
'a t -> [ `back | `front ] -> Key.t * 'a
val dequeue_back_with_key : 'a t -> (Key.t * 'a) option
val dequeue_back_with_key_exn : 'a t -> Key.t * 'a
val dequeue_front_with_key : 'a t -> (Key.t * 'a) option
val dequeue_front_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t -> f:('a -> Base.unit) -> Base.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Base.unit
val replace :
'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> Base.unit
val drop :
?n:int -> 'a t -> [ `back | `front ] -> Base.unit
val drop_front : ?n:int -> 'a t -> Base.unit
val drop_back : ?n:int -> 'a t -> Base.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Base.unit) -> Base.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Resource :
sig
type state = [ `Busy | `Closing | `Idle ]
val sexp_of_state : state -> Ppx_sexp_conv_lib.Sexp.t
val compare_state : state -> state -> int
type t = {
state : state;
since : Core_kernel.Time_ns.Span.t;
}
val since : t -> Core_kernel.Time_ns.Span.t
val state : t -> state
module Fields :
sig
val names : string list
val since :
(t, Core_kernel.Time_ns.Span.t) Fieldslib.Field.t
val state : (t, state) Fieldslib.Field.t
val fold :
init:'acc__0 ->
state:('acc__0 ->
(t, state) Fieldslib.Field.t -> 'acc__1) ->
since:('acc__1 ->
(t, Core_kernel.Time_ns.Span.t)
Fieldslib.Field.t -> 'acc__2) ->
'acc__2
val make_creator :
state:((t, state) Fieldslib.Field.t ->
'acc__0 -> ('input__ -> state) * 'acc__1) ->
since:((t, Core_kernel.Time_ns.Span.t)
Fieldslib.Field.t ->
'acc__1 ->
('input__ -> Core_kernel.Time_ns.Span.t) *
'acc__2) ->
'acc__0 -> ('input__ -> t) * 'acc__2
val create :
state:state -> since:Core_kernel.Time_ns.Span.t -> t
val map :
state:((t, state) Fieldslib.Field.t -> state) ->
since:((t, Core_kernel.Time_ns.Span.t)
Fieldslib.Field.t -> Core_kernel.Time_ns.Span.t) ->
t
val iter :
state:((t, state) Fieldslib.Field.t -> unit) ->
since:((t, Core_kernel.Time_ns.Span.t)
Fieldslib.Field.t -> unit) ->
unit
val for_all :
state:((t, state) Fieldslib.Field.t -> bool) ->
since:((t, Core_kernel.Time_ns.Span.t)
Fieldslib.Field.t -> bool) ->
bool
val exists :
state:((t, state) Fieldslib.Field.t -> bool) ->
since:((t, Core_kernel.Time_ns.Span.t)
Fieldslib.Field.t -> bool) ->
bool
val to_list :
state:((t, state) Fieldslib.Field.t -> 'elem__) ->
since:((t, Core_kernel.Time_ns.Span.t)
Fieldslib.Field.t -> 'elem__) ->
'elem__ list
val map_poly :
([< `Read | `Set_and_create ], t, 'x0) Field.user ->
'x0 list
module Direct :
sig
val iter :
t ->
state:((t, state) Fieldslib.Field.t ->
t -> state -> unit) ->
since:((t, Core_kernel.Time_ns.Span.t)
Fieldslib.Field.t ->
t -> Core_kernel.Time_ns.Span.t -> unit) ->
unit
val fold :
t ->
init:'acc__0 ->
state:('acc__0 ->
(t, state) Fieldslib.Field.t ->
t -> state -> 'acc__1) ->
since:('acc__1 ->
(t, Core_kernel.Time_ns.Span.t)
Fieldslib.Field.t ->
t -> Core_kernel.Time_ns.Span.t -> 'acc__2) ->
'acc__2
val for_all :
t ->
state:((t, state) Fieldslib.Field.t ->
t -> state -> bool) ->
since:((t, Core_kernel.Time_ns.Span.t)
Fieldslib.Field.t ->
t -> Core_kernel.Time_ns.Span.t -> bool) ->
bool
val exists :
t ->
state:((t, state) Fieldslib.Field.t ->
t -> state -> bool) ->
since:((t, Core_kernel.Time_ns.Span.t)
Fieldslib.Field.t ->
t -> Core_kernel.Time_ns.Span.t -> bool) ->
bool
val to_list :
t ->
state:((t, state) Fieldslib.Field.t ->
t -> state -> 'elem__) ->
since:((t, Core_kernel.Time_ns.Span.t)
Fieldslib.Field.t ->
t -> Core_kernel.Time_ns.Span.t -> 'elem__) ->
'elem__ list
val map :
t ->
state:((t, state) Fieldslib.Field.t ->
t -> state -> state) ->
since:((t, Core_kernel.Time_ns.Span.t)
Fieldslib.Field.t ->
t ->
Core_kernel.Time_ns.Span.t ->
Core_kernel.Time_ns.Span.t) ->
t
val set_all_mutable_fields : t -> unit
end
end
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
val compare : t -> t -> int
end
module Resource_list :
sig
type t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
val compare : t -> t -> int
val key : t -> Key.t
val resources : t -> Resource.t list
val queue_length : t -> int
val max_time_on_queue :
t -> Core_kernel.Time_ns.Span.t option
end
type t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
val compare : t -> t -> int
val resource_lists : t -> Resource_list.t list
val num_jobs_in_cache : t -> int
module Make_stable :
sig
module V1 :
functor
(Key : sig
type t = Key.t
val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t :
t Bin_prot.Type_class.writer0
val bin_reader_t :
t Bin_prot.Type_class.reader0
val bin_t : t Bin_prot.Type_class.t0
end) ->
sig
type nonrec t = t
val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer0
val bin_reader_t : t Bin_prot.Type_class.reader0
val bin_t : t Bin_prot.Type_class.t0
end
end
end
type t
val init :
config:Resource_cache.Config.t ->
log_error:(string -> unit) -> Resource.Common_args.t -> t
val status : t -> Status.t
val config : t -> Resource_cache.Config.t
val with_ :
?open_timeout:Core_kernel.Time_ns.Span.t ->
?give_up:unit Deferred.t ->
t ->
Address_and_route.t ->
f:(Resource.t -> 'a Deferred.t) ->
'a Async_kernel.Deferred.Or_error.t
val with_' :
?open_timeout:Core_kernel.Time_ns.Span.t ->
?give_up:unit Deferred.t ->
t ->
Address_and_route.t ->
f:(Resource.t -> 'a Deferred.t) ->
[ `Cache_is_closed
| `Error_opening_resource of Error.t
| `Gave_up_waiting_for_resource
| `Ok of 'a ] Deferred.t
val with_any :
?open_timeout:Core_kernel.Time_ns.Span.t ->
?give_up:unit Deferred.t ->
t ->
Address_and_route.t list ->
f:(Resource.t -> 'a Deferred.t) ->
(Address_and_route.t * 'a) Async_kernel.Deferred.Or_error.t
val with_any' :
?open_timeout:Core_kernel.Time_ns.Span.t ->
?give_up:unit Deferred.t ->
t ->
Address_and_route.t list ->
f:(Resource.t -> 'a Deferred.t) ->
[ `Cache_is_closed
| `Error_opening_resource of Address_and_route.t * Error.t
| `Gave_up_waiting_for_resource
| `Ok of Address_and_route.t * 'a ] Deferred.t
val with_any_loop :
?open_timeout:Core_kernel.Time_ns.Span.t ->
?give_up:unit Deferred.t ->
t ->
Address_and_route.t list ->
f:(Resource.t -> 'a Deferred.t) ->
[ `Cache_is_closed
| `Error_opening_all_resources of
(Address_and_route.t * Error.t) list
| `Gave_up_waiting_for_resource
| `Ok of Address_and_route.t * 'a ] Deferred.t
val close_started : t -> bool
val close_finished : t -> unit Deferred.t
val close_and_flush : t -> unit Deferred.t
end
make: *** [default] Error 1
Anyone knows what's going on there?
Recommend Projects
-
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
-
Vue.js
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
-
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
-
TensorFlow
An Open Source Machine Learning Framework for Everyone
-
Django
The Web framework for perfectionists with deadlines.
-
Laravel
A PHP framework for web artisans
-
D3
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
-
Recommend Topics
-
javascript
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
-
web
Some thing interesting about web. New door for the world.
-
server
A server is a program made to process requests and deliver data to clients.
-
Machine learning
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
-
Visualization
Some thing interesting about visualization, use data art
-
Game
Some thing interesting about game, make everyone happy.
Recommend Org
-
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
-
Microsoft
Open source projects and samples from Microsoft.
-
Google
Google ❤️ Open Source for everyone.
-
Alibaba
Alibaba Open Source for everyone
-
D3
Data-Driven Documents codes.
-
Tencent
China tencent open source team.