base v0.15.0 · OCaml Package

type 'a array = 'a Array.t

val compare_array : 'a. ('a -> 'a -> int) -> 'a array -> 'a array -> int

val equal_array : 'a. ('a -> 'a -> bool) -> 'a array -> 'a array -> bool

val array_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a array

val sexp_of_array : 'a. ('a -> Sexplib0.Sexp.t) -> 'a array -> Sexplib0.Sexp.t

val array_sexp_grammar : 
  'a Sexplib0.Sexp_grammar.t ->
  'a array Sexplib0.Sexp_grammar.t

type bool = Bool.t

val compare_bool : bool -> bool -> int

val equal_bool : bool -> bool -> bool

val hash_fold_bool : Hash.state -> bool -> Hash.state

val hash_bool : bool -> Hash.hash_value

val bool_of_sexp : Sexplib0.Sexp.t -> bool

val sexp_of_bool : bool -> Sexplib0.Sexp.t

val bool_sexp_grammar : bool Sexplib0.Sexp_grammar.t

type char = Char.t

val compare_char : char -> char -> int

val equal_char : char -> char -> bool

val hash_fold_char : Hash.state -> char -> Hash.state

val hash_char : char -> Hash.hash_value

val char_of_sexp : Sexplib0.Sexp.t -> char

val sexp_of_char : char -> Sexplib0.Sexp.t

val char_sexp_grammar : char Sexplib0.Sexp_grammar.t

type exn = Exn.t

val sexp_of_exn : exn -> Sexplib0.Sexp.t

type float = Float.t

val compare_float : float -> float -> int

val equal_float : float -> float -> bool

val hash_fold_float : Hash.state -> float -> Hash.state

val hash_float : float -> Hash.hash_value

val float_of_sexp : Sexplib0.Sexp.t -> float

val sexp_of_float : float -> Sexplib0.Sexp.t

val float_sexp_grammar : float Sexplib0.Sexp_grammar.t

type int = Int.t

val compare_int : int -> int -> int

val equal_int : int -> int -> bool

val hash_fold_int : Hash.state -> int -> Hash.state

val hash_int : int -> Hash.hash_value

val int_of_sexp : Sexplib0.Sexp.t -> int

val sexp_of_int : int -> Sexplib0.Sexp.t

val int_sexp_grammar : int Sexplib0.Sexp_grammar.t

type int32 = Int32.t

val compare_int32 : int32 -> int32 -> int

val equal_int32 : int32 -> int32 -> bool

val hash_fold_int32 : Hash.state -> int32 -> Hash.state

val hash_int32 : int32 -> Hash.hash_value

val int32_of_sexp : Sexplib0.Sexp.t -> int32

val sexp_of_int32 : int32 -> Sexplib0.Sexp.t

val int32_sexp_grammar : int32 Sexplib0.Sexp_grammar.t

type int64 = Int64.t

val compare_int64 : int64 -> int64 -> int

val equal_int64 : int64 -> int64 -> bool

val hash_fold_int64 : Hash.state -> int64 -> Hash.state

val hash_int64 : int64 -> Hash.hash_value

val int64_of_sexp : Sexplib0.Sexp.t -> int64

val sexp_of_int64 : int64 -> Sexplib0.Sexp.t

val int64_sexp_grammar : int64 Sexplib0.Sexp_grammar.t

type 'a list = 'a List.t

val compare_list : 'a. ('a -> 'a -> int) -> 'a list -> 'a list -> int

val equal_list : 'a. ('a -> 'a -> bool) -> 'a list -> 'a list -> bool

val hash_fold_list : 
  'a. (Hash.state -> 'a -> Hash.state) ->
  Hash.state ->
  'a list ->
  Hash.state

val list_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a list

val sexp_of_list : 'a. ('a -> Sexplib0.Sexp.t) -> 'a list -> Sexplib0.Sexp.t

val list_sexp_grammar : 
  'a Sexplib0.Sexp_grammar.t ->
  'a list Sexplib0.Sexp_grammar.t

type nativeint = Nativeint.t

val compare_nativeint : nativeint -> nativeint -> int

val equal_nativeint : nativeint -> nativeint -> bool

val hash_fold_nativeint : Hash.state -> nativeint -> Hash.state

val hash_nativeint : nativeint -> Hash.hash_value

val nativeint_of_sexp : Sexplib0.Sexp.t -> nativeint

val sexp_of_nativeint : nativeint -> Sexplib0.Sexp.t

val nativeint_sexp_grammar : nativeint Sexplib0.Sexp_grammar.t

type 'a option = 'a Option.t

val compare_option : 'a. ('a -> 'a -> int) -> 'a option -> 'a option -> int

val equal_option : 'a. ('a -> 'a -> bool) -> 'a option -> 'a option -> bool

val hash_fold_option : 
  'a. (Hash.state -> 'a -> Hash.state) ->
  Hash.state ->
  'a option ->
  Hash.state

val option_of_sexp : 
  'a. (Sexplib0.Sexp.t -> 'a) ->
  Sexplib0.Sexp.t ->
  'a option

val sexp_of_option : 
  'a. ('a -> Sexplib0.Sexp.t) ->
  'a option ->
  Sexplib0.Sexp.t

val option_sexp_grammar : 
  'a Sexplib0.Sexp_grammar.t ->
  'a option Sexplib0.Sexp_grammar.t

type 'a ref = 'a Ref.t

val compare_ref : 'a. ('a -> 'a -> int) -> 'a ref -> 'a ref -> int

val equal_ref : 'a. ('a -> 'a -> bool) -> 'a ref -> 'a ref -> bool

val ref_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a ref

val sexp_of_ref : 'a. ('a -> Sexplib0.Sexp.t) -> 'a ref -> Sexplib0.Sexp.t

val ref_sexp_grammar : 
  'a Sexplib0.Sexp_grammar.t ->
  'a ref Sexplib0.Sexp_grammar.t

type string = String.t

val compare_string : string -> string -> int

val equal_string : string -> string -> bool

val hash_fold_string : Hash.state -> string -> Hash.state

val hash_string : string -> Hash.hash_value

val string_of_sexp : Sexplib0.Sexp.t -> string

val sexp_of_string : string -> Sexplib0.Sexp.t

val string_sexp_grammar : string Sexplib0.Sexp_grammar.t

type bytes = Bytes.t

val compare_bytes : bytes -> bytes -> int

val equal_bytes : bytes -> bytes -> bool

val bytes_of_sexp : Sexplib0.Sexp.t -> bytes

val sexp_of_bytes : bytes -> Sexplib0.Sexp.t

val bytes_sexp_grammar : bytes Sexplib0.Sexp_grammar.t

type unit = Unit.t

val compare_unit : unit -> unit -> int

val equal_unit : unit -> unit -> bool

val hash_fold_unit : Hash.state -> unit -> Hash.state

val hash_unit : unit -> Hash.hash_value

val unit_of_sexp : Sexplib0.Sexp.t -> unit

val sexp_of_unit : unit -> Sexplib0.Sexp.t

val unit_sexp_grammar : unit Sexplib0.Sexp_grammar.t

Format stuff

type nonrec ('a, 'b, 'c) format = ('a, 'b, 'c) format

type nonrec ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'd) format4

type nonrec ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) format6

List operators

include module type of struct include List.Infix end

val (@) : 'a List.t -> 'a List.t -> 'a List.t

Int operators and comparisons

include module type of struct include Int.O end

val (+) : Int.t -> Int.t -> Int.t

val (-) : Int.t -> Int.t -> Int.t

val (*) : Int.t -> Int.t -> Int.t

val (/) : Int.t -> Int.t -> Int.t

val (~-) : Int.t -> Int.t

val (**) : Int.t -> Int.t -> Int.t

val (land) : Int.t -> Int.t -> Int.t

val (lor) : Int.t -> Int.t -> Int.t

val (lxor) : Int.t -> Int.t -> Int.t

val lnot : Int.t -> Int.t

val abs : Int.t -> Int.t

val neg : Int.t -> Int.t

val zero : Int.t

val (%) : Int.t -> Int.t -> Int.t

val (/%) : Int.t -> Int.t -> Int.t

val (//) : Int.t -> Int.t -> float

val (lsl) : Int.t -> int -> Int.t

val (asr) : Int.t -> int -> Int.t

val (lsr) : Int.t -> int -> Int.t

val (=) : int -> int -> bool

val (<>) : int -> int -> bool

val (<) : int -> int -> bool

val (>) : int -> int -> bool

val (<=) : int -> int -> bool

val (>=) : int -> int -> bool

val compare : int -> int -> int

val equal : int -> int -> bool

val ascending : int -> int -> int

val descending : int -> int -> int

val max : int -> int -> int

val min : int -> int -> int

Float operators

include module type of struct include Float.O_dot end

Similar to O, except that operators are suffixed with a dot, allowing one to have both int and float operators in scope simultaneously.

val (+.) : Float.t -> Float.t -> Float.t

val (-.) : Float.t -> Float.t -> Float.t

val (*.) : Float.t -> Float.t -> Float.t

val (/.) : Float.t -> Float.t -> Float.t

val (%.) : Float.t -> Float.t -> Float.t

val (**.) : Float.t -> Float.t -> Float.t

val (~-.) : Float.t -> Float.t

val (|>) : 'a -> ('a -> 'b) -> 'b

Reverse application operator. x |> g |> f is equivalent to f (g (x)).

val (@@) : ('a -> 'b) -> 'a -> 'b

Application operator. g @@ f @@ x is equivalent to g (f (x)).

Boolean operations

val (&&) : bool -> bool -> bool

val (||) : bool -> bool -> bool

val not : bool -> bool

val ignore : _ -> unit

val (^) : String.t -> String.t -> String.t

Common string operations

Reference operations

val (!) : 'a ref -> 'a

val ref : 'a -> 'a ref

val (:=) : 'a ref -> 'a -> unit

Pair operations

val fst : ('a * 'b) -> 'a

val snd : ('a * 'b) -> 'b

Exceptions stuff

val raise : exn -> _

val failwith : string -> 'a

val invalid_arg : string -> 'a

val raise_s : Sexp.t -> 'a

Misc

val phys_equal : 'a -> 'a -> bool

val force : 'a Lazy.t -> 'a

package base