package goblint

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type
module All : sig ... end
include module type of struct include All end
include module type of Batteries with module Format := Batteries.Format
module Legacy = All.Legacy
module Array = All.Array
module Buffer = All.Buffer
module Bytes = All.Bytes
type bytes = Bytes.t
module Char = All.Char
module Complex = All.Complex
module Digest = All.Digest
module Either = All.Either
module Gc = All.Gc
module Genlex = All.Genlex
module Hashtbl = All.Hashtbl
module Int32 = All.Int32
module Int64 = All.Int64
module Lexing = All.Lexing
module List = All.List
module Map = All.Map
module Marshal = All.Marshal
module Nativeint = All.Nativeint
module Printexc = All.Printexc
module Printf = All.Printf
module Queue = All.Queue
module Random = All.Random
module Scanf = All.Scanf
module Set = All.Set
module Stack = All.Stack
module Stream = All.Stream
module String = All.String
module Sys = All.Sys
module Unix = All.Unix
module Big_int = All.Big_int
module Num = All.Num
module Bigarray = All.Bigarray
module Base64 = All.Base64
module BitSet = All.BitSet
module Bit_set = All.Bit_set
module Dllist = All.Dllist
module DynArray = All.DynArray
module Enum = All.Enum
module File = All.File
module Global = All.Global
module IO = All.IO
module LazyList = All.LazyList
module MultiPMap = All.MultiPMap
module Option = All.Option
module RefList = All.RefList
module Ref = All.Ref
module Cache = All.Cache
module CharParser = All.CharParser
module Deque = All.Deque
module Hashcons = All.Hashcons
module Heap = All.Heap
module FingerTree = All.FingerTree
module Logger = All.Logger
module MultiMap = All.MultiMap
module ParserCo = All.ParserCo
module Result = All.Result
module Return = All.Return
module Seq = All.Seq
module Substring = All.Substring
module Tuple = All.Tuple
module Tuple2 = All.Tuple2
module Tuple3 = All.Tuple3
module Tuple4 = All.Tuple4
module Tuple5 = All.Tuple5
module Vect = All.Vect
module ISet = All.ISet
module IMap = All.IMap
module Splay = All.Splay
module Uref = All.Uref
module UChar = All.UChar
module UTF8 = All.UTF8
module Text = All.Text
module Concurrent = All.Concurrent
module Interfaces = All.Interfaces
module Number = All.Number
module Float = All.Float
module Int = All.Int
module Bool = All.Bool
module Unit = All.Unit
module Filename = All.Filename
module Incubator = All.Incubator
val raise : exn -> 'a
val raise_notrace : exn -> 'a
val invalid_arg : string -> 'a
val failwith : string -> 'a
exception Exit
val (=) : 'a -> 'a -> bool
val (<>) : 'a -> 'a -> bool
val (<) : 'a -> 'a -> bool
val (>) : 'a -> 'a -> bool
val (<=) : 'a -> 'a -> bool
val (>=) : 'a -> 'a -> bool
val compare : 'a -> 'a -> int
val min : 'a -> 'a -> 'a
val max : 'a -> 'a -> 'a
val (==) : 'a -> 'a -> bool
val (!=) : 'a -> 'a -> bool
val not : bool -> bool
val (&&) : bool -> bool -> bool
val (&) : bool -> bool -> bool
  • deprecated Use (&&) instead.
val (||) : bool -> bool -> bool
val or : bool -> bool -> bool
  • deprecated Use (||) instead.
val __LOC__ : string
val __FILE__ : string
val __LINE__ : int
val __MODULE__ : string
val __POS__ : string * int * int * int
val __LOC_OF__ : 'a -> string * 'a
val __LINE_OF__ : 'a -> int * 'a
val __POS_OF__ : 'a -> (string * int * int * int) * 'a
val (~-) : int -> int
val (~+) : int -> int
val succ : int -> int
val pred : int -> int
val (+) : int -> int -> int
val (-) : int -> int -> int
val (*) : int -> int -> int
val (/) : int -> int -> int
val (mod) : int -> int -> int
val abs : int -> int
val max_int : int
val min_int : int
val (land) : int -> int -> int
val (lor) : int -> int -> int
val (lxor) : int -> int -> int
val lnot : int -> int
val (lsl) : int -> int -> int
val (lsr) : int -> int -> int
val (asr) : int -> int -> int
val (~-.) : float -> float
val (~+.) : float -> float
val (+.) : float -> float -> float
val (-.) : float -> float -> float
val (*.) : float -> float -> float
val (/.) : float -> float -> float
val (**) : float -> float -> float
val sqrt : float -> float
val exp : float -> float
val log : float -> float
val log10 : float -> float
val expm1 : float -> float
val log1p : float -> float
val cos : float -> float
val sin : float -> float
val tan : float -> float
val acos : float -> float
val asin : float -> float
val atan : float -> float
val atan2 : float -> float -> float
val hypot : float -> float -> float
val cosh : float -> float
val sinh : float -> float
val tanh : float -> float
val ceil : float -> float
val floor : float -> float
val abs_float : float -> float
val copysign : float -> float -> float
val mod_float : float -> float -> float
val frexp : float -> float * int
val ldexp : float -> int -> float
val modf : float -> float * float
val float : int -> float
val float_of_int : int -> float
val truncate : float -> int
val 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 nonrec fpclass = Stdlib.Pervasives.fpclass =
  1. | FP_normal
  2. | FP_subnormal
  3. | FP_zero
  4. | FP_infinite
  5. | FP_nan
val classify_float : float -> fpclass
val (^) : string -> string -> string
val int_of_char : char -> int
val char_of_int : int -> char
val 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
val int_of_string : string -> int
val int_of_string_opt : string -> int option
val string_of_float : float -> string
val float_of_string : string -> float
val float_of_string_opt : string -> float option
val fst : ('a * 'b) -> 'a
val snd : ('a * 'b) -> 'b
type nonrec in_channel = Stdlib.Pervasives.in_channel
type nonrec out_channel = Stdlib.Pervasives.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 nonrec open_flag = Stdlib.Pervasives.open_flag =
  1. | Open_rdonly
  2. | Open_wronly
  3. | Open_append
  4. | Open_creat
  5. | Open_trunc
  6. | Open_excl
  7. | Open_binary
  8. | Open_text
  9. | Open_nonblock
val output_bytes : Stdlib.out_channel -> bytes -> unit
val seek_out : Stdlib.out_channel -> int -> unit
val pos_out : Stdlib.out_channel -> int
val out_channel_length : Stdlib.out_channel -> int
val set_binary_mode_out : Stdlib.out_channel -> bool -> unit
val really_input_string : Stdlib.in_channel -> int -> string
val seek_in : Stdlib.in_channel -> int -> unit
val pos_in : Stdlib.in_channel -> int
val in_channel_length : Stdlib.in_channel -> int
val set_binary_mode_in : Stdlib.in_channel -> bool -> unit
module LargeFile = All.LargeFile
type nonrec !'a ref = 'a Stdlib.Pervasives.ref = {
  1. mutable contents : 'a;
}
val ref : 'a -> 'a ref
val (!) : 'a ref -> 'a
val (:=) : 'a ref -> 'a -> unit
val incr : int ref -> unit
val decr : int ref -> unit
type (!'a, !'b, !'c, !'d, !'e, !'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.Pervasives.format6
type (!'a, !'b, !'c, !'d) format4 = ('a, 'b, 'c, 'd) Stdlib.Pervasives.format4
type (!'a, !'b, !'c) format = ('a, 'b, 'c) Stdlib.Pervasives.format
val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> string
val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6
val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('f, 'b, 'c, 'e, 'g, 'h) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'g, 'h) Stdlib.format6
val exit : int -> 'a
val at_exit : (unit -> unit) -> unit
val valid_float_lexem : string -> string
val do_at_exit : unit -> unit
val input_lines : Stdlib.Pervasives.in_channel -> string BatEnum.t
val input_chars : Stdlib.Pervasives.in_channel -> char BatEnum.t
val input_list : Stdlib.Pervasives.in_channel -> string list
val input_all : Stdlib.Pervasives.in_channel -> string
val dump : 'a -> string
val print_any : 'b BatIO.output -> 'a -> unit
val (@) : 'a list -> 'a list -> 'a list
val stdin : BatIO.input
val stdout : unit BatIO.output
val stderr : unit BatIO.output
val stdnull : unit BatIO.output
val flush_all : unit -> unit
val print_bool : bool -> unit
val print_guess : 'a BatIO.output -> 'b -> unit
val print_all : BatIO.input -> unit
val prerr_bool : bool -> unit
val prerr_guess : 'a -> unit
val prerr_all : BatIO.input -> unit
val output_file : filename:string -> text:string -> unit
val open_out : ?mode:BatFile.open_out_flag list -> ?perm:BatFile.permission -> string -> unit BatIO.output
val open_out_bin : string -> unit BatIO.output
val open_out_gen : Stdlib.open_flag list -> int -> string -> unit BatIO.output
val flush : unit BatIO.output -> unit
val output_char : unit BatIO.output -> char -> unit
val output_string : unit BatIO.output -> string -> unit
val output : unit BatIO.output -> Stdlib.Bytes.t -> int -> int -> unit
val output_substring : unit BatIO.output -> string -> int -> int -> unit
val output_byte : unit BatIO.output -> int -> unit
val output_binary_int : unit BatIO.output -> int -> unit
val output_binary_float : unit BatIO.output -> float -> unit
val output_value : unit BatIO.output -> 'a -> unit
val close_out : unit BatIO.output -> unit
val close_out_noerr : unit BatIO.output -> unit
val input_file : ?bin:bool -> string -> string
val open_in : ?mode:BatFile.open_in_flag list -> ?perm:BatFile.permission -> string -> BatIO.input
val open_in_bin : string -> BatIO.input
val open_in_gen : Stdlib.open_flag list -> int -> string -> BatIO.input
val input_char : BatIO.input -> char
val input_line : BatIO.input -> string
val input : BatIO.input -> Stdlib.Bytes.t -> int -> int -> int
val really_input : BatIO.input -> Stdlib.Bytes.t -> int -> int -> unit
val input_byte : BatIO.input -> int
val input_binary_int : BatIO.input -> int
val input_binary_float : BatIO.input -> float
val input_value : BatIO.input -> 'a
val close_in : BatIO.input -> unit
val close_in_noerr : BatIO.input -> unit
val identity : 'a -> 'a
val undefined : ?message:string -> 'a -> 'b
val (@@) : ('a -> 'b) -> 'a -> 'b
val (%) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b
val (|>) : 'a -> ('a -> 'b) -> 'b
val (%>) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c
val (|?) : 'a option -> 'a -> 'a
val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c
val curry : (('a * 'b) -> 'c) -> 'a -> 'b -> 'c
val uncurry : ('a -> 'b -> 'c) -> ('a * 'b) -> 'c
val neg : ('a -> bool) -> 'a -> bool
val neg2 : ('a -> 'b -> bool) -> 'a -> 'b -> bool
val const : 'a -> 'b -> 'a
val unique : unit -> int
val tap : ('a -> unit) -> 'a -> 'a
val finally : (unit -> unit) -> ('a -> 'b) -> 'a -> 'b
val with_dispose : dispose:('a -> unit) -> ('a -> 'b) -> 'a -> 'b
val forever : ('a -> 'b) -> 'a -> unit
val ignore_exceptions : ('a -> 'b) -> 'a -> unit
val verify_arg : bool -> string -> unit
val args : unit -> string BatEnum.t
val invisible_args : int Stdlib.ref
val exe : string
val foreach : 'a BatEnum.t -> ('a -> unit) -> unit
val iter : ('a -> unit) -> 'a BatEnum.t -> unit
val map : ('a -> 'b) -> 'a BatEnum.t -> 'b BatEnum.t
val filter_map : ('a -> 'b option) -> 'a BatEnum.t -> 'b BatEnum.t
val reduce : ('a -> 'a -> 'a) -> 'a BatEnum.t -> 'a
val fold : ('b -> 'a -> 'b) -> 'b -> 'a BatEnum.t -> 'b
val scanl : ('b -> 'a -> 'b) -> 'b -> 'a BatEnum.t -> 'b BatEnum.t
val (/@) : 'a BatEnum.t -> ('a -> 'b) -> 'b BatEnum.t
val (@/) : ('a -> 'b) -> 'a BatEnum.t -> 'b BatEnum.t
val (//@) : 'a BatEnum.t -> ('a -> 'b option) -> 'b BatEnum.t
val (@//) : ('a -> 'b option) -> 'a BatEnum.t -> 'b BatEnum.t
val exists : ('a -> bool) -> 'a BatEnum.t -> bool
val for_all : ('a -> bool) -> 'a BatEnum.t -> bool
val find : ('a -> bool) -> 'a BatEnum.t -> 'a
val peek : 'a BatEnum.t -> 'a option
val get : 'a BatEnum.t -> 'a option
val push : 'a BatEnum.t -> 'a -> unit
val junk : 'a BatEnum.t -> unit
val filter : ('a -> bool) -> 'a BatEnum.t -> 'a BatEnum.t
val (//) : 'a BatEnum.t -> ('a -> bool) -> 'a BatEnum.t
val concat : 'a BatEnum.t BatEnum.t -> 'a BatEnum.t
val (--) : int -> int -> int BatEnum.t
val (--^) : int -> int -> int BatEnum.t
val (--.) : (float * float) -> float -> float BatEnum.t
val (---) : int -> int -> int BatEnum.t
val (--~) : char -> char -> char BatEnum.t
val print : ?first:string -> ?last:string -> ?sep:string -> ('a BatInnerIO.output -> 'b -> unit) -> 'a BatInnerIO.output -> 'b BatEnum.t -> unit
type (!'a, !'e) result = ('a, 'e) BatInnerPervasives.result =
  1. | Ok of 'a
  2. | Error of 'e
val ignore_ok : ('a, exn) result -> unit
val ok : ('a, exn) result -> 'a
val wrap : ('a -> 'b) -> 'a -> ('b, exn) result
val lock : BatConcurrent.lock Stdlib.ref
module Format = All.Format
val comp2 : ('a -> 'a -> 'b) -> ('c -> 'a) -> 'c -> 'c -> 'b
val compareBy : ?cmp:('a -> 'a -> int) -> ('b -> 'a) -> 'b -> 'b -> int
val str_remove : string -> string -> string
val split_time : unit -> int * int * int * int
val string_of_time : unit -> string
val localtime : unit -> string
module Ana : sig ... end
OCaml

Innovation. Community. Security.