module Stack: sig .. endLast-in first-out stacks.
This module implements stacks (LIFOs), with in-place modification.
type t('a);
The type of stacks containing elements of type 'a.
exception Empty;
let create: unit => t('a);
Return a new stack, initially empty.
let push: ('a, t('a)) => unit;
push x s adds the element x at the top of stack s.
let pop: t('a) => 'a;
pop s removes and returns the topmost element in stack s,
or raises Stack.Empty if the stack is empty.
let pop_opt: t('a) => option('a);
pop_opt s removes and returns the topmost element in stack s,
or returns None if the stack is empty.
let top: t('a) => 'a;
top s returns the topmost element in stack s,
or raises Stack.Empty if the stack is empty.
let top_opt: t('a) => option('a);
top_opt s returns the topmost element in stack s,
or None if the stack is empty.
let clear: t('a) => unit;
Discard all elements from a stack.
let copy: t('a) => t('a);
Return a copy of the given stack.
let is_empty: t('a) => bool;
Return true if the given stack is empty, false otherwise.
let length: t('a) => int;
Return the number of elements in a stack. Time complexity O(1)
let iter: ('a => unit, t('a)) => 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.
let fold: (('b, 'a) => 'b, 'b, t('a)) => 'b;
fold f accu s is (f (... (f (f accu x1) x2) ...) xn)
where x1 is the top of the stack, x2 the second element,
and xn the bottom element. The stack is unchanged.
let to_seq: t('a) => Seq.t('a);
Iterate on the stack, top to bottom. It is safe to modify the stack during iteration.
let add_seq: (t('a), Seq.t('a)) => unit;
Add the elements from the iterator on the top of the stack.
let of_seq: Seq.t('a) => t('a);
Create a stack from the iterator