Caml (core.Core.Caml)

include Core_kernel.Caml

module Arg = Arg

module Array = Array

module ArrayLabels = ArrayLabels

module Buffer = Buffer

module Bytes = Bytes

module BytesLabels = BytesLabels

module Callback = Callback

module CamlinternalFormat = CamlinternalFormat

module CamlinternalFormatBasics = CamlinternalFormatBasics

module CamlinternalLazy = CamlinternalLazy

module CamlinternalMod = CamlinternalMod

module CamlinternalOO = CamlinternalOO

module Char = Char

module Complex = Complex

module Digest = Digest

module Ephemeron = Ephemeron

module Filename = Filename

module Format = Format

module Gc = Gc

module Genlex = Genlex

module Hashtbl = Hashtbl

module Int32 = Int32

module Int64 = Int64

module Lazy = Lazy

module Lexing = Lexing

module List = List

module ListLabels = ListLabels

module Map = Map

module Marshal = Marshal

module MoreLabels = MoreLabels

module Nativeint = Nativeint

module Obj = Obj

module Oo = Oo

module Parsing = Parsing

module Pervasives = Pervasives

module Printexc = Printexc

module Printf = Printf

module Queue = Queue

module Random = Random

module Scanf = Scanf

module Set = Set

module Sort = Sort

module Spacetime = Spacetime

module Stack = Stack

module StdLabels = StdLabels

module Stream = Stream

module String = String

module StringLabels = StringLabels

module Sys = Sys

module Uchar = Uchar

module Weak = Weak

include Pervasives

external raise : exn ‑> 'a =

external raise_notrace : exn ‑> 'a =

val invalid_arg : string ‑> 'a

val failwith : string ‑> 'a

exception Exit

external (=) : 'a ‑> 'a ‑> bool =

external (<>) : 'a ‑> 'a ‑> bool =

external (<) : 'a ‑> 'a ‑> bool =

external (>) : 'a ‑> 'a ‑> bool =

external (<=) : 'a ‑> 'a ‑> bool =

external (>=) : 'a ‑> 'a ‑> bool =

external compare : 'a ‑> 'a ‑> int =

val min : 'a ‑> 'a ‑> 'a

val max : 'a ‑> 'a ‑> 'a

external (==) : 'a ‑> 'a ‑> bool =

external (!=) : 'a ‑> 'a ‑> bool =

external not : bool ‑> bool =

external (&&) : bool ‑> bool ‑> bool =

external (&) : bool ‑> bool ‑> bool =

external (||) : bool ‑> bool ‑> bool =

external or : bool ‑> bool ‑> bool =

external __LOC__ : string =

external __FILE__ : string =

external __LINE__ : int =

external __MODULE__ : string =

external __POS__ : string * int * int * int =

external __LOC_OF__ : 'a ‑> string * 'a =

external __LINE_OF__ : 'a ‑> int * 'a =

external __POS_OF__ : 'a ‑> (string * int * int * int) * 'a =

external (|>) : 'a ‑> ('a ‑> 'b) ‑> 'b =

external (@@) : ('a ‑> 'b) ‑> 'a ‑> 'b =

external (~-) : int ‑> int =

external (~+) : int ‑> int =

external succ : int ‑> int =

external pred : int ‑> int =

external (+) : int ‑> int ‑> int =

external (-) : int ‑> int ‑> int =

external (*) : int ‑> int ‑> int =

external (/) : int ‑> int ‑> int =

external (mod) : int ‑> int ‑> int =

val abs : int ‑> int

val max_int : int

val min_int : int

external (land) : int ‑> int ‑> int =

external (lor) : int ‑> int ‑> int =

external (lxor) : int ‑> int ‑> int =

val (lnot) : int ‑> int

external (lsl) : int ‑> int ‑> int =

external (lsr) : int ‑> int ‑> int =

external (asr) : int ‑> int ‑> int =

external (~-.) : float ‑> float =

external (~+.) : float ‑> float =

external (+.) : float ‑> float ‑> float =

external (-.) : float ‑> float ‑> float =

external (*.) : float ‑> float ‑> float =

external (/.) : float ‑> float ‑> float =

external (**) : float ‑> float ‑> float =

external sqrt : float ‑> float =

external exp : float ‑> float =

external log : float ‑> float =

external log10 : float ‑> float =

external expm1 : float ‑> float =

external log1p : float ‑> float =

external cos : float ‑> float =

external sin : float ‑> float =

external tan : float ‑> float =

external acos : float ‑> float =

external asin : float ‑> float =

external atan : float ‑> float =

external atan2 : float ‑> float ‑> float =

external hypot : float ‑> float ‑> float =

external cosh : float ‑> float =

external sinh : float ‑> float =

external tanh : float ‑> float =

external ceil : float ‑> float =

external floor : float ‑> float =

external abs_float : float ‑> float =

external copysign : float ‑> float ‑> float =

external mod_float : float ‑> float ‑> float =

external frexp : float ‑> float * int =

external ldexp : float ‑> int ‑> float =

external modf : float ‑> float * float =

external float : int ‑> float =

external float_of_int : int ‑> float =

external truncate : float ‑> int =

external int_of_float : float ‑> int =

val infinity : float

val neg_infinity : float

val nan : float

val max_float : float

val min_float : float

val epsilon_float : float

type fpclass = Pervasives.fpclass =

| FP_normal

| FP_subnormal

| FP_zero

| FP_infinite

| FP_nan

external classify_float : float ‑> fpclass =

val (^) : string ‑> string ‑> string

external int_of_char : char ‑> int =

val char_of_int : int ‑> char

external ignore : 'a ‑> unit =

val string_of_bool : bool ‑> string

val bool_of_string : string ‑> bool

val bool_of_string_opt : string ‑> bool option

val string_of_int : int ‑> string

external int_of_string : string ‑> int =

val int_of_string_opt : string ‑> int option

val string_of_float : float ‑> string

external float_of_string : string ‑> float =

val float_of_string_opt : string ‑> float option

external fst : ('a * 'b) ‑> 'a =

external snd : ('a * 'b) ‑> 'b =

val (@) : 'a list ‑> 'a list ‑> 'a list

type in_channel = Pervasives.in_channel

type out_channel = Pervasives.out_channel

val stdin : in_channel

val stdout : out_channel

val stderr : out_channel

val print_char : char ‑> unit

val print_string : string ‑> unit

val print_bytes : bytes ‑> unit

val print_int : int ‑> unit

val print_float : float ‑> unit

val print_endline : string ‑> unit

val print_newline : unit ‑> unit

val prerr_char : char ‑> unit

val prerr_string : string ‑> unit

val prerr_bytes : bytes ‑> unit

val prerr_int : int ‑> unit

val prerr_float : float ‑> unit

val prerr_endline : string ‑> unit

val prerr_newline : unit ‑> unit

val read_line : unit ‑> string

val read_int : unit ‑> int

val read_int_opt : unit ‑> int option

val read_float : unit ‑> float

val read_float_opt : unit ‑> float option

type open_flag = Pervasives.open_flag =

| Open_rdonly

| Open_wronly

| Open_append

| Open_creat

| Open_trunc

| Open_excl

| Open_binary

| Open_text

| Open_nonblock

val open_out : string ‑> out_channel

val open_out_bin : string ‑> out_channel

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

val flush : out_channel ‑> unit

val flush_all : unit ‑> unit

val output_char : out_channel ‑> char ‑> unit

val output_string : out_channel ‑> string ‑> unit

val output_bytes : out_channel ‑> bytes ‑> unit

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

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

val output_byte : out_channel ‑> int ‑> unit

val output_binary_int : out_channel ‑> int ‑> unit

val output_value : out_channel ‑> 'a ‑> unit

val seek_out : out_channel ‑> int ‑> unit

val pos_out : out_channel ‑> int

val out_channel_length : out_channel ‑> int

val close_out : out_channel ‑> unit

val close_out_noerr : out_channel ‑> unit

val set_binary_mode_out : out_channel ‑> bool ‑> unit

val open_in : string ‑> in_channel

val open_in_bin : string ‑> in_channel

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

val input_char : in_channel ‑> char

val input_line : in_channel ‑> string

val input : in_channel ‑> bytes ‑> int ‑> int ‑> int

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

val really_input_string : in_channel ‑> int ‑> string

val input_byte : in_channel ‑> int

val input_binary_int : in_channel ‑> int

val input_value : in_channel ‑> 'a

val seek_in : in_channel ‑> int ‑> unit

val pos_in : in_channel ‑> int

val in_channel_length : in_channel ‑> int

val close_in : in_channel ‑> unit

val close_in_noerr : in_channel ‑> unit

val set_binary_mode_in : in_channel ‑> bool ‑> unit

module LargeFile = Pervasives.LargeFile

type 'a ref = 'a Pervasives.ref = {

mutable contents : 'a;

}

external ref : 'a ‑> 'a ref =

external (!) : 'a ref ‑> 'a =

external (:=) : 'a ref ‑> 'a ‑> unit =

external incr : int ref ‑> unit =

external decr : int ref ‑> unit =

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

| Ok of 'a

| Error of 'b

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

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

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

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

external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 ‑> ('a, 'b, 'c, 'd, 'e, 'f) format6 =

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

val exit : int ‑> 'a

val at_exit : (unit ‑> unit) ‑> unit

val valid_float_lexem : string ‑> string

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

val do_at_exit : unit ‑> unit