package ppx_expect

You can search for identifiers within the package.

in-package search v0.2.0

ppx_expect.collector
- Expect_test_collector
  - Current_file
  - Make
    
    Config
    
    IO
    
    Instance
  - Test_outcome
ppx_expect.common
- Expect_test_common
  - Expectation
    
    Body
    
    Raw
  - File
    
    Digest
    
    Location
    
    Name
  - Std
ppx_expect.config
- Expect_test_config
  - IO
  - S
    
    IO
ppx_expect.evaluator
- Ppx_expect_evaluator
ppx_expect.matcher
- Expect_test_matcher
  - Choose_tag
  - Cst
    
    Line
  - Fmt
  - Import
  - Lexer
  - Matcher
    
    Test_correction
    
    Test_outcome
  - Reconcile
    
    Result
  - Std
ppx_expect.payload
- Ppx_expect_payload

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Base end

include module type of struct include Shadow_stdlib end
  with module Array := Caml.Array
  with module Buffer := Caml.Buffer
  with module Char := Caml.Char
  with module Hashtbl := Caml.Hashtbl
  with module Int32 := Caml.Int32
  with module Int64 := Caml.Int64
  with module Lazy := Caml.Lazy
  with module List := Caml.List
  with module Map := Caml.Map
  with module Nativeint := Caml.Nativeint
  with module Printf := Caml.Printf
  with module Random := Caml.Random
  with module Set := Caml.Set
  with module String := Caml.String
  with module Sys := Caml.Sys
  with module Uchar := Caml.Uchar
  with module Lexing := Caml.Lexing
  with type ('a, 'b, 'c) format := ('a, 'b, 'c) Pervasives.format
  with type ('a, 'b, 'c, 'd) format4 := ('a, 'b, 'c, 'd) Pervasives.format4
  with type ('a, 'b, 'c, 'd, 'e, 'f) format6 :=
         ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6
  with type 'a ref := 'a Pervasives.ref

module Arg = Base.Arg

module ArrayLabels = Base.ArrayLabels

module Bytes = Base.Bytes

module BytesLabels = Base.BytesLabels

module Callback = Base.Callback

module Complex = Base.Complex

module Digest = Base.Digest

module Ephemeron = Base.Ephemeron

module Filename = Base.Filename

module Format = Base.Format

module Gc = Base.Gc

module Genlex = Base.Genlex

module ListLabels = Base.ListLabels

module Marshal = Base.Marshal

module MoreLabels = Base.MoreLabels

module Obj = Base.Obj

module Oo = Base.Oo

module Parsing = Base.Parsing

module Pervasives = Base.Pervasives

module Printexc = Base.Printexc

module Queue = Base.Queue

module Scanf = Base.Scanf

module Sort = Base.Sort

module Spacetime = Base.Spacetime

module Stack = Base.Stack

module StdLabels = Base.StdLabels

module Stream = Base.Stream

module StringLabels = Base.StringLabels

module Weak = Base.Weak

val raise_notrace : exn -> 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.raise_notrace] instead

exception Exit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Refering to the stdlib directly is discouraged by Base. You should either use the equivalent functionality offered by Base, or if you really want to refer to the stdlib, use Caml.Exit instead

val (==) : 'a -> 'a -> bool

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [phys_equal] instead.

val (!=) : 'a -> 'a -> bool

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [not (phys_equal ...)] instead.

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

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( & )] instead

val or : bool -> bool -> bool

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( or )] instead

val __LOC__ : string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__LOC__] instead

val __FILE__ : string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__FILE__] instead

val __LINE__ : int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__LINE__] instead

val __MODULE__ : string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__MODULE__] instead

val __POS__ : string * int * int * int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__POS__] instead

val __LOC_OF__ : 'a -> string * 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__LOC_OF__] instead

val __LINE_OF__ : 'a -> int * 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__LINE_OF__] instead

val __POS_OF__ : 'a -> (string * int * int * int) * 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.__POS_OF__] instead

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

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( @@ )] instead

val (~+) : int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( ~+ )] instead

val succ : int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.succ] instead

val pred : int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.pred] instead

val (mod) : int -> int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( mod )] instead

val max_int : int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.max_int] instead

val min_int : int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.min_int] instead

val (~-.) : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( ~-. )] instead

val (~+.) : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( ~+. )] instead

val (+.) : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( +. )] instead

val (-.) : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( -. )] instead

val (*.) : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( *. )] instead

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

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( /. )] instead

val (**) : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( ** )] instead

val sqrt : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.sqrt] instead

val exp : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.exp] instead

val log : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.log] instead

val log10 : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.log10] instead

val expm1 : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.expm1] instead

val log1p : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.log1p] instead

val cos : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.cos] instead

val sin : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.sin] instead

val tan : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.tan] instead

val acos : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.acos] instead

val asin : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.asin] instead

val atan : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.atan] instead

val atan2 : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.atan2] instead

val hypot : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.hypot] instead

val cosh : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.cosh] instead

val sinh : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.sinh] instead

val tanh : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.tanh] instead

val ceil : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.ceil] instead

val floor : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.floor] instead

val abs_float : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.abs_float] instead

val copysign : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.copysign] instead

val mod_float : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.mod_float] instead

val frexp : float -> float * int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.frexp] instead

val ldexp : float -> int -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.ldexp] instead

val modf : float -> float * float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.modf] instead

val float : int -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.float] instead

val float_of_int : int -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.float_of_int] instead

val truncate : float -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.truncate] instead

val int_of_float : float -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.int_of_float] instead

val infinity : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.infinity] instead

val neg_infinity : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.neg_infinity] instead

val nan : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.nan] instead

val max_float : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.max_float] instead

val min_float : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.min_float] instead

val epsilon_float : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.epsilon_float] instead

type nonrec fpclass = Pervasives.fpclass =

| FP_normal
| FP_subnormal
| FP_zero
| FP_infinite
| FP_nan

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Refering to the stdlib directly is discouraged by Base. You should either use the equivalent functionality offered by Base, or if you really want to refer to the stdlib, use Caml.fpclass instead

val classify_float : float -> fpclass

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.classify_float] instead

val int_of_char : char -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.int_of_char] instead

val char_of_int : int -> char

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.char_of_int] instead

val string_of_bool : bool -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.string_of_bool] instead

val bool_of_string : string -> bool

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.bool_of_string] instead

val string_of_int : int -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.string_of_int] instead

val int_of_string : string -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.int_of_string] instead

val string_of_float : float -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.string_of_float] instead

val float_of_string : string -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.float_of_string] instead

type nonrec in_channel = Pervasives.in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.t] instead.

type nonrec out_channel = Pervasives.out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.t] instead.

val stdin : in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.stdin] instead.

val stdout : out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.stdout] instead.

val stderr : out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.stderr] instead.

val print_char : char -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_char Stdio.stdout] instead.

val print_string : string -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_string Stdio.stdout] instead.

val print_bytes : bytes -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.print_bytes] instead

val print_int : int -> unit

deprecated

val print_float : float -> unit

deprecated

val print_endline : string -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.print_endline] instead.

val print_newline : unit -> unit

deprecated

val prerr_char : char -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_char Stdio.stderr] instead.

val prerr_string : string -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_string Stdio.stderr] instead.

val prerr_bytes : bytes -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.prerr_bytes] instead

val prerr_int : int -> unit

deprecated

val prerr_float : float -> unit

deprecated

val prerr_endline : string -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.prerr_endline] instead.

val prerr_newline : unit -> unit

deprecated

val read_line : unit -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_line] instead.

val read_int : unit -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.read_int] instead

val read_float : unit -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.read_float] instead

type nonrec open_flag = Pervasives.open_flag =

| Open_rdonly
| Open_wronly
| Open_append
| Open_creat
| Open_trunc
| Open_excl
| Open_binary
| Open_text
| Open_nonblock

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Refering to the stdlib directly is discouraged by Base. You should either use the equivalent functionality offered by Base, or if you really want to refer to the stdlib, use Caml.open_flag instead

val open_out : string -> out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.create] instead.

val open_out_bin : string -> out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.create] instead.

val open_out_gen : open_flag list -> int -> string -> out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.open_out_gen] instead

val flush : out_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.flush] instead.

val flush_all : unit -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.flush_all] instead

val output_char : out_channel -> char -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_char] instead.

val output_string : out_channel -> string -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_string] instead.

val output_bytes : out_channel -> bytes -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.output_bytes] instead

val output : out_channel -> bytes -> int -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output] instead.

val output_substring : out_channel -> string -> int -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output] instead.

val output_byte : out_channel -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_byte] instead.

val output_binary_int : out_channel -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_binary_int] instead.

val output_value : out_channel -> 'a -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_value] instead.

val seek_out : out_channel -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.seek] instead.

val pos_out : out_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.pos] instead.

val out_channel_length : out_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.length] instead.

val close_out : out_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.close] instead.

val close_out_noerr : out_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.close] instead.

val set_binary_mode_out : out_channel -> bool -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.set_binary_mode] instead.

val open_in : string -> in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.create] instead.

val open_in_bin : string -> in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.create] instead.

val open_in_gen : open_flag list -> int -> string -> in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.open_in_gen] instead

val input_char : in_channel -> char

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_char] instead.

val input_line : in_channel -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_line] instead.

val input : in_channel -> bytes -> int -> int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input] instead.

val really_input : in_channel -> bytes -> int -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.really_input] instead.

val really_input_string : in_channel -> int -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is no equivalent functionality in Base or Stdio but you can use [Stdio.Out_channel] instead. Alternatively, if you really want to refer the stdlib function you can use [Caml.really_input_string].

val input_byte : in_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_byte] instead.

val input_binary_int : in_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_binary_int] instead.

val input_value : in_channel -> 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.unsafe_input_value] instead.

val seek_in : in_channel -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.seek] instead.

val pos_in : in_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.pos] instead.

val in_channel_length : in_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.length] instead.

val close_in : in_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.close] instead.

val close_in_noerr : in_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.close] instead.

val set_binary_mode_in : in_channel -> bool -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.set_binary_mode] instead.

module LargeFile = Base.LargeFile

val incr : int Pervasives.ref -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.incr] instead

val decr : int Pervasives.ref -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.decr] instead

type nonrec ('a, 'b) result = ('a, 'b) Pervasives.result =

| Ok of 'a
| Error of 'b

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Refering to the stdlib directly is discouraged by Base. You should either use the equivalent functionality offered by Base, or if you really want to refer to the stdlib, use Caml.result instead

val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6 -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.string_of_format] instead

val format_of_string : 
  ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6 ->
  ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.format_of_string] instead

val (^^) : 
  ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6 ->
  ('f, 'b, 'c, 'e, 'g, 'h) Pervasives.format6 ->
  ('a, 'b, 'c, 'd, 'g, 'h) Pervasives.format6

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.( ^^ )] instead

val exit : int -> 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.exit] instead

val at_exit : (unit -> unit) -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.at_exit] instead

val valid_float_lexem : string -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.valid_float_lexem] instead

val unsafe_really_input : in_channel -> bytes -> int -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.unsafe_really_input] instead

val do_at_exit : unit -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Caml.do_at_exit] instead

module Applicative = Base.Applicative

module Applicative_intf = Base.Applicative_intf

module Array = Base.Array

module Avltree = Base.Avltree

module Backtrace = Base.Backtrace

module Binary_search = Base.Binary_search

module Binary_searchable = Base.Binary_searchable

module Binary_searchable_intf = Base.Binary_searchable_intf

module Blit = Base.Blit

module Blit_intf = Base.Blit_intf

module Bool = Base.Bool

module Buffer = Base.Buffer

module Char = Base.Char

module Commutative_group = Base.Commutative_group

module Comparable = Base.Comparable

module Comparable_intf = Base.Comparable_intf

module Comparator = Base.Comparator

module Container = Base.Container

module Container_intf = Base.Container_intf

module Either = Base.Either

module Either_intf = Base.Either_intf

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 Hash = Base.Hash

module Hash_intf = Base.Hash_intf

module Hash_set = Base.Hash_set

module Hash_set_intf = Base.Hash_set_intf

module Hasher = Base.Hasher

module Hashtbl = Base.Hashtbl

module Hashtbl_intf = Base.Hashtbl_intf

module Heap_block = Base.Heap_block

module Identifiable = Base.Identifiable

module Indexed_container = Base.Indexed_container

module Info = Base.Info

module Info_intf = Base.Info_intf

module Int = Base.Int

module Int32 = Base.Int32

module Int63 = Base.Int63

module Int64 = Base.Int64

module Int_intf = Base.Int_intf

module Intable = Base.Intable

module Invariant = Base.Invariant

module Lazy = Base.Lazy

module List = Base.List

module Map = Base.Map

module Map_intf = Base.Map_intf

module Maybe_bound = Base.Maybe_bound

module Monad = Base.Monad

module Nativeint = Base.Nativeint

module Option = Base.Option

module Or_error = Base.Or_error

module Ordered_collection_common = Base.Ordered_collection_common

module Ordering = Base.Ordering

module Poly = Base.Poly

module Polymorphic_compare = Base.Polymorphic_compare

module Polymorphic_compare_intf = Base.Polymorphic_compare_intf

module Popcount = Base.Popcount

module Pretty_printer = Base.Pretty_printer

module Printf = Base.Printf

module Linked_queue = Base.Linked_queue

module Queue_intf = Base.Queue_intf

module Random = Base.Random

module Ref = Base.Ref

module Result = Base.Result

module Sequence = Base.Sequence

module Set = Base.Set

module Set_intf = Base.Set_intf

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 String_dict = Base.String_dict

module Sys = Base.Sys

module T = Base.T

module Type_equal = Base.Type_equal

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

module Sexp = Base.Sexp

module Export = Base.Export

include module type of struct include Export end

type 'a array = 'a Base.Array.t

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

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

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

type bool = Base.Bool.t

val bool_of_sexp : Base.Sexp.t -> bool

val sexp_of_bool : bool -> Base.Sexp.t

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

val hash_bool : bool -> Base.Hash.hash_value

val compare_bool : bool -> bool -> int

type char = Base.Char.t

val char_of_sexp : Base.Sexp.t -> char

val sexp_of_char : char -> Base.Sexp.t

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

val hash_char : char -> Base.Hash.hash_value

val compare_char : char -> char -> int

type exn = Base.Exn.t

val sexp_of_exn : exn -> Base.Sexp.t

type float = Base.Float.t

val float_of_sexp : Base.Sexp.t -> float

val sexp_of_float : float -> Base.Sexp.t

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

val hash_float : float -> Base.Hash.hash_value

val compare_float : float -> float -> int

type int = Base.Int.t

val int_of_sexp : Base.Sexp.t -> int

val sexp_of_int : int -> Base.Sexp.t

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

val hash_int : int -> Base.Hash.hash_value

val compare_int : int -> int -> int

type int32 = Base.Int32.t

val int32_of_sexp : Base.Sexp.t -> int32

val sexp_of_int32 : int32 -> Base.Sexp.t

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

val hash_int32 : int32 -> Base.Hash.hash_value

val compare_int32 : int32 -> int32 -> int

type int64 = Base.Int64.t

val int64_of_sexp : Base.Sexp.t -> int64

val sexp_of_int64 : int64 -> Base.Sexp.t

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

val hash_int64 : int64 -> Base.Hash.hash_value

val compare_int64 : int64 -> int64 -> int

type 'a list = 'a Base.List.t

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

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

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

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

type nativeint = Base.Nativeint.t

val nativeint_of_sexp : Base.Sexp.t -> nativeint

val sexp_of_nativeint : nativeint -> Base.Sexp.t

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

val hash_nativeint : nativeint -> Base.Hash.hash_value

val compare_nativeint : nativeint -> nativeint -> int

type 'a option = 'a Base.Option.t

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

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

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

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

type 'a ref = 'a Base.Ref.t

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

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

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

type string = Base.String.t

val string_of_sexp : Base.Sexp.t -> string

val sexp_of_string : string -> Base.Sexp.t

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

val hash_string : string -> Base.Hash.hash_value

val compare_string : string -> string -> int

type unit = Base.Unit.t

val unit_of_sexp : Base.Sexp.t -> unit

val sexp_of_unit : unit -> Base.Sexp.t

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

val hash_unit : unit -> Base.Hash.hash_value

val compare_unit : unit -> unit -> int

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

Format stuff

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

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

List operators

include module type of struct include Base.List.Infix end

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

Int operators and comparisons

include module type of struct include Base.Int.O end

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

include Base.Int_intf.Operators_unbounded with type t := Base.Int.t

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

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

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

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

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

include Base.Polymorphic_compare_intf.Infix with type t := Base.Int.t

val abs : Base.Int.t -> Base.Int.t

val neg : Base.Int.t -> Base.Int.t

val zero : Base.Int.t

val of_int_exn : int -> Base.Int.t

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

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

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

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

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

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

val lnot : Base.Int.t -> Base.Int.t

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

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

val (lsr) : Base.Int.t -> int -> Base.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 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

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

Composition operator

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

Boolean operations

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

val not : bool -> bool

val ignore : _ -> unit

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

Common string operations

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

Reference operations

val ref : 'a -> 'a ref

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

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

Pair operations

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

val failwith : string -> 'a

Exceptions stuff

val invalid_arg : string -> 'a

val raise : exn -> 'a

val raise_s : Base.Sexp.t -> 'a

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

Misc

module Not_exposed_properly = Base.Not_exposed_properly