MutableQueue

A FIFO (first in first out) queue data structure.

add

RESCRIPT

let add: (t<'a>, 'a) => unit

add(q, x) adds the element x at the end of the queue q.

clear

RESCRIPT

let clear: t<'a> => unit

Discard all elements from the queue.

copy

RESCRIPT

let copy: t<'a> => t<'a>

copy(q) returns a fresh queue.

forEach

RESCRIPT

let forEach: (t<'a>, 'a => unit) => unit

forEach(q, f) appliesfin turn to all elements ofq`, from the least recently entered to the most recently entered. The queue itself is unchanged.

forEachU

Deprecated

Use forEach instead

RESCRIPT

let forEachU: (t<'a>, 'a => unit) => unit

fromArray

RESCRIPT

let fromArray: array<'a> => t<'a>

fromArray a is equivalent to Array.forEach(a, add(q, a));

isEmpty

RESCRIPT

let isEmpty: t<'a> => bool

Returns true if the given queue is empty, false otherwise.

make

RESCRIPT

let make: unit => t<'a>

Returns a new queue, initially empty.

map

RESCRIPT

let map: (t<'a>, 'a => 'b) => t<'b>

mapU

Deprecated

Use map instead

RESCRIPT

let mapU: (t<'a>, 'a => 'b) => t<'b>

peek

RESCRIPT

let peek: t<'a> => option<'a>

peekOpt(q) returns the first element in queue q, without removing it from the queue.

peekExn

RESCRIPT

let peekExn: t<'a> => 'a

peekExn(q) throws an exception if q is empty.

peekOrThrow

RESCRIPT

let peekOrThrow: t<'a> => 'a

peekOrThrow(q) throws an exception if q is empty.

peekUndefined

RESCRIPT

let peekUndefined: t<'a> => Js.undefined<'a>

peekUndefined(q) returns undefined if not found.

pop

RESCRIPT

let pop: t<'a> => option<'a>

pop(q) removes and returns the first element in queue q.

popExn

RESCRIPT

let popExn: t<'a> => 'a

popExn(q) throw an exception if q is empty.

popOrThrow

RESCRIPT

let popOrThrow: t<'a> => 'a

popOrThrow(q) throw an exception if q is empty.

popUndefined

RESCRIPT

let popUndefined: t<'a> => Js.undefined<'a>

popUndefined(q) removes and returns the first element in queue q. it will return undefined if it is already empty.

reduce

RESCRIPT

let reduce: (t<'a>, 'b, ('b, 'a) => 'b) => 'b

reduce(q, accu, f) is equivalent to List.reduce(l, accu, f), where l is the list of q's elements. The queue remains unchanged.

reduceU

Deprecated

Use reduce instead

RESCRIPT

let reduceU: (t<'a>, 'b, ('b, 'a) => 'b) => 'b

size

RESCRIPT

let size: t<'a> => int

Returns the number of elements in a queue.

t

RESCRIPT

type t<'a>

The type of queues containing elements of type('a).

toArray

RESCRIPT

let toArray: t<'a> => array<'a>

First added will be in the beginning of the array.

transfer

RESCRIPT

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 forEach((x) => add(x, q2), q1); clear q1, but runs in constant time.