Up
Module
Make_using_comparator
(
Key
: sig .. end) :
S
with
module
Key
=
Key
with
type
comparator_witness
=
Key.comparator_witness
Parameters
Key
: sig .. end
Signature
module
Key
=
Key
type
comparator_witness =
Key.comparator_witness
type
enumeration_witness
type
'a t = (
Key.t
, 'a,
comparator_witness
,
enumeration_witness
)
t
val
compare : ('a -> 'a -> int) -> 'a
t
-> 'a
t
-> int
val
bin_t : 'a
Bin_prot.Type_class.t
-> 'a
t
Bin_prot.Type_class.t
val
bin_read_t : 'a
Bin_prot.Read.reader
-> 'a
t
Bin_prot.Read.reader
val
__bin_read_t__ : 'a
Bin_prot.Read.reader
-> (int -> 'a
t
)
Bin_prot.Read.reader
val
bin_reader_t : 'a
Bin_prot.Type_class.reader
-> 'a
t
Bin_prot.Type_class.reader
val
bin_size_t : 'a
Bin_prot.Size.sizer
-> 'a
t
Bin_prot.Size.sizer
val
bin_write_t : 'a
Bin_prot.Write.writer
-> 'a
t
Bin_prot.Write.writer
val
bin_writer_t : 'a
Bin_prot.Type_class.writer
-> 'a
t
Bin_prot.Type_class.writer
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
include
Core_kernel.Std_internal.Applicative
with
type
'a
t
:= 'a
t
type
'a t
val
return : 'a -> 'a
t
val
apply : ('a -> 'b)
t
-> 'a
t
-> 'b
t
val
map : 'a
t
-> f:('a -> 'b) -> 'b
t
val
map2 : 'a
t
-> 'b
t
-> f:('a -> 'b -> 'c) -> 'c
t
val
map3 : 'a
t
-> 'b
t
-> 'c
t
-> f:('a -> 'b -> 'c -> 'd) -> 'd
t
val
all : 'a
t
list -> 'a list
t
val
both : 'a
t
-> 'b
t
-> ('a * 'b)
t
module
Applicative_infix
: sig .. end
include
module type of
Applicative_infix
val
(<*>) : ('a -> 'b)
t
-> 'a
t
-> 'b
t
same as
apply
val
(<*) : 'a
t
-> unit
t
-> 'a
t
same as
apply
val
(*>) : unit
t
-> 'a
t
-> 'a
t
val
create : (
Key.t
-> 'a) -> 'a
t