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. This
function is not thread-safe. Use

`BatPervasives.unique`

instead.`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 with_dispose : ``dispose:('a -> unit) -> ('a -> 'b) -> 'a -> 'b`

`with_dispose dispose f x`

invokes `f`

on `x`

, calling `dispose x`

when `f`

terminates (either with a return value or an
exception).`val forever : ``('a -> 'b) -> 'a -> unit`

`forever f x`

invokes `f`

on `x`

repeatedly (until an exception occurs).`val ignore_exceptions : ``('a -> 'b) -> 'a -> unit`

`ignore_exceptions f x`

invokes `f`

on `x`

, ignoring both the returned value
and the exceptions that may be raised.`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`

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 tap : ``('a -> unit) -> 'a -> 'a`

`type ``('a, 'b)`

result =

`|` |
`Ok of ` |
|||

`|` |
`Bad of ` |
`(*` | The result of a computation - either an `Ok` with the normal
result or a `Bad` with some value (often an exception) containing
failure information | `*)` |

`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.
Unless you are attempting to adapt Batteries Included to a new model of
concurrency, you probably won't need this.

`val lock : ``BatConcurrent.lock Pervasives.ref`

A lock used to synchronize internal operations.

By default, this is `BatConcurrent.nolock`

. However, if you're
using a version of Batteries compiled in threaded mode, this uses
`BatMutex`

. If you're attempting to use Batteries with another
concurrency model, set the lock appropriately.