Quick StartTryGuideAPICommunityBlogGitHub

Standard Library

Below is the API for the OCaml standard library. It's directly copied over from the OCaml Manual, formatted to the Reason syntax and styled accordingly. The API docs are work-in-progress; we'll be polishing these gradually!

If you're targeting JavaScript, the API docs for BuckleScript includes all of below, plus JS-specific APIs.

Module Queue

module Queue: sig .. end
First-in first-out queues.

This module implements queues (FIFOs), with in-place modification.

Warning This module is not thread-safe: each Queue.t value must be protected from concurrent access (e.g. with a Mutex.t). Failure to do so can lead to a crash.

type t('a);
The type of queues containing elements of type 'a.
exception Empty;
Raised when Queue.take or Queue.peek is applied to an empty queue.
let create: unit => t('a);
Return a new queue, initially empty.
let add: ('a, t('a)) => unit;
add x q adds the element x at the end of the queue q.
let push: ('a, t('a)) => unit;
push is a synonym for add.
let take: t('a) => 'a;
take q removes and returns the first element in queue q, or raises Empty if the queue is empty.
let pop: t('a) => 'a;
pop is a synonym for take.
let peek: t('a) => 'a;
peek q returns the first element in queue q, without removing it from the queue, or raises Empty if the queue is empty.
let top: t('a) => 'a;
top is a synonym for peek.
let clear: t('a) => unit;
Discard all elements from a queue.
let copy: t('a) => t('a);
Return a copy of the given queue.
let is_empty: t('a) => bool;
Return true if the given queue is empty, false otherwise.
let length: t('a) => int;
Return the number of elements in a queue.
let iter: ('a => unit, t('a)) => unit;
iter f q applies f in turn to all elements of q, from the least recently entered to the most recently entered. The queue itself is unchanged.
let fold: (('b, 'a) => 'b, 'b, t('a)) => 'b;
fold f accu q is equivalent to List.fold_left f accu l, where l is the list of q's elements. The queue remains unchanged.
let transfer: (t('a), t('a)) => unit;
transfer q1 q2 adds all of q1's elements at the end of the queue q2, then clears q1. It is equivalent to the sequence iter (fun x -> add x q2) q1; clear q1, but runs in constant time.