Module BatStd

module BatStd: sig .. end

val print_bool : bool -> unit

Print a boolean to stdout.

val prerr_bool : bool -> unit

Print a boolean to stderr.

val input_file : ?bin:bool -> string -> string

returns the data of a given filename.

val output_file : filename:string -> text:string -> unit

creates a filename, write text into it and close it.

val string_of_char : char -> string

creates a string from a char.

val identity : 'a -> 'a

the identity function.

val unique : unit -> int

returns an unique identifier every time it is called.

val dump : 'a -> string

represent a runtime value as a string. Since types are lost at compile time, the representation might not match your type. For example, None will be printed 0 since they share the same runtime representation.

val print : 'a -> unit

print the representation of a runtime value on stdout. See remarks for dump.

val finally : (unit -> unit) -> ('a -> 'b) -> 'a -> 'b

finally fend f x calls f x and then fend() even if f x raised an exception.

val args : unit -> string BatEnum.t

An enumeration of the arguments passed to this program through the command line.

args () is given by the elements of Sys.argv, minus the first element.

val exe : string

The name of the current executable.

exe is given by the first argument of Sys.argv

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

Operators

Function application. x |> f is equivalent to f x.

This operator is commonly used to write a function composition by order of evaluation means rather than by inverse order. For instance, g (f x) means "apply f to x, then apply g to the result." In some circumstances, it may be more understandable to write this as x |> f |> g, or "starting from x, apply f, then apply g."

This operator may also be useful for composing sequences of function calls without too many parenthesis.

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

Function application. f <| x is equivalent to f x.

This operators may be useful for composing sequences of function calls without too many parenthesis.

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

Function composition. f |- g is fun x -> g (f x). This is also equivalent to applying |> twice.

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

Function composition. f -| g is fun x -> f (g x). Mathematically, this is operator o.

val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c

Argument flipping.

flip f x y is f y x. Don't abuse this function, it may shorten considerably your code but it also has the nasty habit of making it harder to read.

val ( *** ) : ('a -> 'b) -> ('c -> 'd) -> 'a * 'c -> 'b * 'd

Function pairing.

f *** g is fun (x,y) -> (f x, g y).

val (&&&) : ('a -> 'b) -> ('a -> 'c) -> 'a -> 'b * 'c

Applying two functions to the same argument.

f &&& g is fun x -> (f x, g x).

val first : ('a -> 'b * 'c) -> 'a -> 'b

Projection of a pair to its first element.

val second : ('a -> 'b * 'c) -> 'a -> 'c

Projection of a pair to its second element.

val curry : ('a * 'b -> 'c) -> 'a -> 'b -> 'c

Turn a function that takes a pair into a function that takes its arguments one at a time.

val uncurry : ('a -> 'b -> 'c) -> 'a * 'b -> 'c

Turn a function that takes its arguments one at a time into a function that takes a pair as argument.

val const : 'a -> 'b -> 'a

Ignore its second argument.

Therefore, const x is the function which always returns x.

val ignore_ok : ('a, exn) result -> unit

ignore_ok (f x) ignores the result of f x if it's ok, but throws the exception contained if Bad is returned.

val ok : ('a, exn) result -> 'a

f x |> ok unwraps the Ok result of f x and returns it, or throws the exception contained if Bad is returned.

val wrap : ('a -> 'b) -> 'a -> ('b, exn) result

wrap f x wraps a function that would normally throw an exception on failure such that it now returns a result with either the Ok return value or the Bad exception.