Module Expect_test_matcher.Import

include Base

This module is the toplevel of the Base library; it's what you get when you write open Base.

The recommended way to use Base is to build with -open Base. Files compiled this way will have the environment described in this file as their initial environment.

Base extends some modules and data structures from the standard library, like Array, Buffer, Bytes, Char, Hashtbl, Int32, Int64, Lazy, List, Map, Nativeint, Printf, Random, Set, String, Sys, and Uchar. One key difference is that Base doesn't use exceptions as much as the standard library and instead makes heavy use of the Result type, as in:

type ('a,'b) result = Ok of 'a | Error of 'b

Base also adds entirely new modules, most notably:

Broadly the goal of Base is both to be a more complete standard library, with richer APIs, and to be more consistent in its design. For instance, in the standard library some things have modules and others don't; in Base, everything is a module.

module Applicative = Base.Applicative
module Array = Base.Array
module Avltree = Base.Avltree
module Backtrace = Base.Backtrace
module Binary_searchable = Base.Binary_searchable
module Blit = Base.Blit
module Bool = Base.Bool
module Buffer = Base.Buffer
module Bytes = Base.Bytes
module Char = Base.Char
module Commutative_group = Base.Commutative_group
module Comparable = Base.Comparable
module Comparator = Base.Comparator
module Comparisons = Base.Comparisons
module Container = Base.Container
module Either = Base.Either
module Equal = Base.Equal
module Error = Base.Error
module Exn = Base.Exn
module Field = Base.Field
module Float = Base.Float
module Floatable = Base.Floatable
module Fn = Base.Fn
module Formatter = Base.Formatter
module Hash = Base.Hash
module Hash_set = Base.Hash_set
module Hashable = Base.Hashable
module Hasher = Base.Hasher
module Hashtbl = Base.Hashtbl
module Heap_block = Base.Heap_block
module Identifiable = Base.Identifiable
module Indexed_container = Base.Indexed_container
module Info = Base.Info
module Int = Base.Int
module Int32 = Base.Int32
module Int63 = Base.Int63
module Int64 = Base.Int64
module Intable = Base.Intable
module Invariant = Base.Invariant
module Lazy = Base.Lazy
module List = Base.List
module Map = Base.Map
module Maybe_bound = Base.Maybe_bound
module Monad = Base.Monad
module Nativeint = Base.Nativeint
module Option = Base.Option
module Option_array = Base.Option_array
module Or_error = Base.Or_error
module Ordered_collection_common = Base.Ordered_collection_common
module Ordering = Base.Ordering
module Poly = Base.Poly

Poly is a convenient shorthand for Polymorphic_compare in the common case that one wants to use a polymorphic comparator directly in an expression, e.g., Poly.equal a b.

module Polymorphic_compare = Base.Polymorphic_compare
module Popcount = Base.Popcount
module Pretty_printer = Base.Pretty_printer
module Printf = Base.Printf
module Linked_queue = Base.Linked_queue
module Queue = Base.Queue
module Random = Base.Random
module Ref = Base.Ref
module Result = Base.Result
module Sequence = Base.Sequence
module Set = Base.Set
module Sexpable = Base.Sexpable
module Sign = Base.Sign
module Source_code_position = Base.Source_code_position
module Staged = Base.Staged
module String = Base.String
module Stringable = Base.Stringable
module Sys = Base.Sys
module T = Base.T
module Type_equal = Base.Type_equal
module Uniform_array = Base.Uniform_array
module Unit = Base.Unit
module Uchar = Base.Uchar
module Validate = Base.Validate
module Variant = Base.Variant
module With_return = Base.With_return
module Word_size = Base.Word_size
include T

This module defines various abstract interfaces that are convenient when one needs a module that matches a bare signature with just a type. This sometimes occurs in functor arguments and in interfaces.

module type T : sig ... end
module type T1 : sig ... end
module type T2 : sig ... end
module type T3 : sig ... end
module Sexp = Base.Sexp
module Export = Base.Export
include Export
type 'a array = 'a Array.t
val compare_array : a. ('a ‑> 'a ‑> int) ‑> 'a array ‑> 'a array ‑> int
val array_of_sexp : a. (Sexp.t ‑> 'a) ‑> Sexp.t ‑> 'a array
val sexp_of_array : a. ('a ‑> Sexp.t) ‑> 'a array ‑> Sexp.t
type bool = Bool.t
val compare_bool : bool ‑> bool ‑> int
val hash_fold_bool : Hash.state ‑> bool ‑> Hash.state
val hash_bool : bool ‑> Hash.hash_value
val bool_of_sexp : Sexp.t ‑> bool
val sexp_of_bool : bool ‑> Sexp.t
type char = Char.t
val compare_char : char ‑> char ‑> int
val hash_fold_char : Hash.state ‑> char ‑> Hash.state
val hash_char : char ‑> Hash.hash_value
val char_of_sexp : Sexp.t ‑> char
val sexp_of_char : char ‑> Sexp.t
type exn = Exn.t
val sexp_of_exn : exn ‑> Sexp.t
type float = Float.t
val compare_float : float ‑> float ‑> int
val hash_fold_float : Hash.state ‑> float ‑> Hash.state
val hash_float : float ‑> Hash.hash_value
val float_of_sexp : Sexp.t ‑> float
val sexp_of_float : float ‑> Sexp.t
type int = Int.t
val compare_int : int ‑> int ‑> int
val hash_fold_int : Hash.state ‑> int ‑> Hash.state
val hash_int : int ‑> Hash.hash_value
val int_of_sexp : Sexp.t ‑> int
val sexp_of_int : int ‑> Sexp.t
type int32 = Int32.t
val compare_int32 : int32 ‑> int32 ‑> int
val hash_fold_int32 : Hash.state ‑> int32 ‑> Hash.state
val hash_int32 : int32 ‑> Hash.hash_value
val int32_of_sexp : Sexp.t ‑> int32
val sexp_of_int32 : int32 ‑> Sexp.t
type int64 = Int64.t
val compare_int64 : int64 ‑> int64 ‑> int
val hash_fold_int64 : Hash.state ‑> int64 ‑> Hash.state
val hash_int64 : int64 ‑> Hash.hash_value
val int64_of_sexp : Sexp.t ‑> int64
val sexp_of_int64 : int64 ‑> Sexp.t
type 'a list = 'a List.t
val compare_list : a. ('a ‑> 'a ‑> int) ‑> 'a list ‑> 'a list ‑> int
val hash_fold_list : a. (Hash.state ‑> 'a ‑> Hash.state) ‑> Hash.state ‑> 'a list ‑> Hash.state
val list_of_sexp : a. (Sexp.t ‑> 'a) ‑> Sexp.t ‑> 'a list
val sexp_of_list : a. ('a ‑> Sexp.t) ‑> 'a list ‑> Sexp.t
type nativeint = Nativeint.t
val compare_nativeint : nativeint ‑> nativeint ‑> int
val hash_fold_nativeint : Hash.state ‑> nativeint ‑> Hash.state
val hash_nativeint : nativeint ‑> Hash.hash_value
val nativeint_of_sexp : Sexp.t ‑> nativeint
val sexp_of_nativeint : nativeint ‑> Sexp.t
type 'a option = 'a Option.t
val compare_option : a. ('a ‑> 'a ‑> int) ‑> 'a option ‑> 'a option ‑> int
val hash_fold_option : a. (Hash.state ‑> 'a ‑> Hash.state) ‑> Hash.state ‑> 'a option ‑> Hash.state
val option_of_sexp : a. (Sexp.t ‑> 'a) ‑> Sexp.t ‑> 'a option
val sexp_of_option : a. ('a ‑> Sexp.t) ‑> 'a option ‑> Sexp.t
type 'a ref = 'a Ref.t
val compare_ref : a. ('a ‑> 'a ‑> int) ‑> 'a ref ‑> 'a ref ‑> int
val ref_of_sexp : a. (Sexp.t ‑> 'a) ‑> Sexp.t ‑> 'a ref
val sexp_of_ref : a. ('a ‑> Sexp.t) ‑> 'a ref ‑> Sexp.t
type string = String.t
val compare_string : string ‑> string ‑> int
val hash_fold_string : Hash.state ‑> string ‑> Hash.state
val hash_string : string ‑> Hash.hash_value
val string_of_sexp : Sexp.t ‑> string
val sexp_of_string : string ‑> Sexp.t
type bytes = Bytes.t
val compare_bytes : bytes ‑> bytes ‑> int
val bytes_of_sexp : Sexp.t ‑> bytes
val sexp_of_bytes : bytes ‑> Sexp.t
type unit = Unit.t
val compare_unit : unit ‑> unit ‑> int
val hash_fold_unit : Hash.state ‑> unit ‑> Hash.state
val hash_unit : unit ‑> Hash.hash_value
val unit_of_sexp : Sexp.t ‑> unit
val sexp_of_unit : unit ‑> Sexp.t

Format stuff

type ('a, 'b, 'c) format = ('a, 'b, 'c) Pervasives.format
type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'd) Pervasives.format4
type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6

Sexp

Exporting the ad-hoc types that are recognized by ppx_sexp_* converters. sexp_array, sexp_list, and sexp_option allow a record field to be absent when converting from a sexp, and if absent, the field will take a default value of the appropriate type:

        sexp_array   [||]
        sexp_bool    false
        sexp_list    []
        sexp_option  None

sexp_opaque causes the conversion to sexp to produce the atom <opaque>.

For more documentation, see sexplib/README.md.

type 'a sexp_array = 'a array
type 'a sexp_list = 'a list
type 'a sexp_opaque = 'a
type 'a sexp_option = 'a option

List operators

include List.Infix
val (@) : 'a Base__List.t ‑> 'a Base__List.t ‑> 'a Base__List.t

Int operators and comparisons

include Int.O

A sub-module designed to be opened to make working with ints more convenient.

include Base__.Int_intf.Operators_unbounded
type t
val (+) : t ‑> t ‑> t
val (-) : t ‑> t ‑> t
val (*) : t ‑> t ‑> t
val (/) : t ‑> t ‑> t
val (~-) : t ‑> t
val (**) : t ‑> t ‑> t
include Base.Comparisons.Infix with type t := t
type 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 abs : t ‑> t
val neg : t ‑> t
val zero : t
val (%) : t ‑> t ‑> t
val (/%) : t ‑> t ‑> t
val (//) : t ‑> t ‑> float
val (land) : t ‑> t ‑> t
val (lor) : t ‑> t ‑> t
val (lxor) : t ‑> t ‑> t
val (lnot) : t ‑> t
val (lsl) : t ‑> int ‑> t
val (asr) : t ‑> int ‑> t
val (lsr) : t ‑> int ‑> t
include Base__.Import.Int_replace_polymorphic_compare
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 ascending : int ‑> int ‑> int
val descending : int ‑> int ‑> int
val compare : int ‑> int ‑> int
val equal : int ‑> int ‑> bool
val max : int ‑> int ‑> int
val min : int ‑> int ‑> int

Float operators

include Float.O_dot

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

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

val (**.) : Base.Float.t ‑> Base.Float.t ‑> Base.Float.t
val (~-.) : Base.Float.t ‑> Base.Float.t
external (|>) : 'a ‑> ('a ‑> 'b) ‑> 'b = "%revapply"

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

external (@@) : ('a ‑> 'b) ‑> 'a ‑> 'b = "%apply"

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

Boolean operations

external (&&) : bool ‑> bool ‑> bool = "%sequand"
external (||) : bool ‑> bool ‑> bool = "%sequor"
external not : bool ‑> bool = "%boolnot"
external ignore : _ ‑> unit = "%ignore"
val (^) : String.t ‑> String.t ‑> String.t

Common string operations

Reference operations

external (!) : 'a ref ‑> 'a = "%field0"
external ref : 'a ‑> 'a ref = "%makemutable"
external (:=) : 'a ref ‑> 'a ‑> unit = "%setfield0"

Pair operations

val fst : ('a * 'b) ‑> 'a
val snd : ('a * 'b) ‑> 'b

Exceptions stuff

val failwith : string ‑> 'a
val invalid_arg : string ‑> 'a
val raise : exn ‑> 'a
val raise_s : Sexp.t ‑> 'a

Misc

val phys_equal : 'a ‑> 'a ‑> bool
external force : 'a Lazy.t ‑> 'a = "%lazy_force"
module Continue_or_stop = Base__.Container_intf.Export.Continue_or_stop

Continue_or_stop.t is used by the f argument to fold_until in order to indicate whether folding should continue, or stop early.

exception Not_found_s of Sexplib0.Sexp.t
module Not_exposed_properly = Base.Not_exposed_properly