`include module type of struct include BatStack end`
`type 'a t = 'a Stdlib.Stack.t`

The type of stacks containing elements of type `'a`.

`exception Empty`

Raised when `Stack.pop` or `Stack.top` is applied to an empty stack.

`val create : unit -> 'a t`

Return a new stack, initially empty.

`val push : 'a -> 'a t -> unit`

`push x s` adds the element `x` at the top of stack `s`.

`val clear : 'a t -> unit`

Discard all elements from a stack.

`val copy : 'a t -> 'a t`

Return a copy of the given stack.

`val is_empty : 'a t -> bool`

Return `true` if the given stack is empty, `false` otherwise.

`val length : 'a t -> int`

Return the number of elements in a stack.

`val iter : ('a -> unit) -> 'a t -> unit`

`iter f s` applies `f` in turn to all elements of `s`, from the element at the top of the stack to the element at the bottom of the stack. The stack itself is unchanged.

`include BatEnum.Enumerable with type 'a enumerable = 'a t`
`type 'a enumerable = 'a t`

The data structure, e.g. `'a List.t`

`val enum : 'a t -> 'a BatEnum.t`

`enum s` returns an enumeration of the elements of stack `s`, from the most recently entered to the least recently entered. This enumeration is made on a copy of the input stack, and reading from it will not affect `s`.

`val enum_destruct : 'a t -> 'a BatEnum.t`

`enum_destruct s` returns a destructive enumeration of the elements of stack `s`, from the most recently entered to the least recently entered. Reading the enumeration will progressively empty `s`.

`val of_enum : 'a BatEnum.t -> 'a t`

`of_enum e` returns a new stack containing all the elements of `e`. This is equivalent to calling `push` with the first element of the enumeration, then with the second, etc.

Note: if `s` is a stack, `s <> of_enum (enum s)`, as `of_enum` reverses the input order.

## Boilerplate code

### Printing

`val print : ?first:string -> ?last:string -> ?sep:string -> ('a BatInnerIO.output -> 'b -> unit) -> 'a BatInnerIO.output -> 'b t -> unit`
`val compare : 'a BatOrd.comp -> 'a t BatOrd.comp`
`val equal : 'a BatOrd.eq -> 'a t BatOrd.eq`
`module Exceptionless = BatStack.Exceptionless`
`include module type of struct include BatStack.Exceptionless end`
`val top : 'a BatStack.t -> 'a option`
`val pop : 'a BatStack.t -> 'a option`