ocamlformat
  1. Overview
  2. Docs
package ocamlformat
Legend:
Library
Module
Module type
Parameter
Class
Class type
include module type of Base
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 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 Identifiable = Base.Identifiable
module Indexed_container = Base.Indexed_container
module Info = Base.Info
module Int = Base.Int
module Int_conversions = Base.Int_conversions
module Int32 = Base.Int32
module Int63 = Base.Int63
module Int64 = Base.Int64
module Intable = Base.Intable
module Int_math = Base.Int_math
module Invariant = Base.Invariant
module Lazy = Base.Lazy
module Map = Base.Map
module Maybe_bound = Base.Maybe_bound
module Monad = Base.Monad
module Nativeint = Base.Nativeint
module Nothing = Base.Nothing
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
module Polymorphic_compare = Poly
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 Sign_or_nan = Base.Sign_or_nan
module Source_code_position = Base.Source_code_position
module Stack = Base.Stack
module Staged = Base.Staged
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 Variant = Base.Variant
module With_return = Base.With_return
module Word_size = Base.Word_size
include module type of struct include T end
module type T = T.T
module type T1 = T.T1
module type T2 = T.T2
module type T3 = T.T3
module Sexp : sig ... end
module Export : sig ... end
include module type of struct include Export end
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 : Base.Hash.state -> bool -> Base.Hash.state
val hash_bool : bool -> Base.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 : Base.Hash.state -> char -> Base.Hash.state
val hash_char : char -> Base.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 : Base.Hash.state -> float -> Base.Hash.state
val hash_float : float -> Base.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 : Base.Hash.state -> int -> Base.Hash.state
val hash_int : int -> Base.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 : Base.Hash.state -> int32 -> Base.Hash.state
val hash_int32 : int32 -> Base.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 : Base.Hash.state -> int64 -> Base.Hash.state
val hash_int64 : int64 -> Base.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 Base.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. (Base.Hash.state -> 'a -> Base.Hash.state) -> Base.Hash.state -> 'a list -> Base.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 : Base.Hash.state -> nativeint -> Base.Hash.state
val hash_nativeint : nativeint -> Base.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. (Base.Hash.state -> 'a -> Base.Hash.state) -> Base.Hash.state -> 'a option -> Base.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 = Base.String.t
val compare_string : string -> string -> int
val equal_string : string -> string -> bool
val hash_fold_string : Base.Hash.state -> string -> Base.Hash.state
val hash_string : string -> Base.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 : Base.Hash.state -> unit -> Base.Hash.state
val hash_unit : unit -> Base.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 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 Int.O end
val (~-) : Base.Int.t -> Base.Int.t
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 abs : Base.Int.t -> Base.Int.t
val neg : Base.Int.t -> Base.Int.t
val zero : Base.Int.t
val (//) : Base.Int.t -> Base.Int.t -> float
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 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.

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
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

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 : Base.Sexp.t -> 'a

Misc

val phys_equal : 'a -> 'a -> bool
val force : 'a Lazy.t -> 'a
module Continue_or_stop = Container.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
include module type of Stdio
module In_channel = Stdio.In_channel
module Out_channel = Stdio.Out_channel
val stdin : In_channel.t

Same as In_channel.stdin

val stdout : Out_channel.t

Same as Out_channel.stdout

val stderr : Out_channel.t

Same as Out_channel.stderr

val printf : ('a, Out_channel.t, Base.unit) Base.format -> 'a

Same as Out_channel.printf

val print_s : ?mach:Base.unit -> Base.Sexp.t -> Base.unit

Same as Out_channel.print_s

val eprint_s : ?mach:Base.unit -> Base.Sexp.t -> Base.unit

Same as Out_channel.eprint_s

val eprintf : ('a, Out_channel.t, Base.unit) Base.format -> 'a

Same as Out_channel.eprintf

val print_string : Base.string -> Base.unit

Same as Out_channel.print_string

val print_endline : Base.string -> Base.unit

Same as Out_channel.print_endline

val prerr_endline : Base.string -> Base.unit

Same as Out_channel.prerr_endline

module Cmdliner : sig ... end

Extension of Cmdliner supporting lighter-weight option definition

module Fpath : sig ... end
module List : sig ... end
module String : sig ... end
module Warning : sig ... end
module Format = Caml.Format
module Filename = Caml.Filename
val (>>) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c

Composition of functions: (f >> g) x is exactly equivalent to g (f (x)). Left associative.

val impossible : string -> _

Indicate why the call is expected to be impossible.

val check : ('a -> _) -> 'a -> 'a

Asserting identity: check f x asserts that f x does not raise and returns x.