Module CCDeque

`module CCDeque: `sig` .. `end``

Imperative deque

This structure provides fast access to its front and back elements, with O(1) operations

`type `'a` t `
Contains 'a elements, queue in both ways
`exception Empty`
`val create : `unit -> 'a t``
New deque
`val clear : `'a t -> unit``
Remove all elements
Since 0.13
`val is_empty : `'a t -> bool``
Is the deque empty?
`val equal : `?eq:('a -> 'a -> bool) -> 'a t -> 'a t -> bool``
`equal a b` checks whether `a` and `b` contain the same sequence of elements.
Since 0.13
`eq` : comparison function for elements
`val compare : `?cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int``
`compare a b` compares lexicographically `a` and `b`
Since 0.13
`cmp` : comparison function for elements
`val length : `'a t -> int``
Number of elements used to be linear time, now constant time
`val push_front : `'a t -> 'a -> unit``
Push value at the front
`val push_back : `'a t -> 'a -> unit``
Push value at the back
`val peek_front : `'a t -> 'a``
First value, or
Raises `Empty` if empty
`val peek_back : `'a t -> 'a``
Last value, or
Raises `Empty` if empty
`val take_back : `'a t -> 'a``
Take last value, or
Raises `Empty` if empty
`val take_front : `'a t -> 'a``
Take first value, or
Raises `Empty` if empty
`val append_front : `into:'a t -> 'a t -> unit``
`append_front ~into q` adds all elements of `q` at the front of `into` O(length q) in time
Since 0.13
`val append_back : `into:'a t -> 'a t -> unit``
`append_back ~into q` adds all elements of `q` at the back of `into`. O(length q) in time
Since 0.13
`val iter : `('a -> unit) -> 'a t -> unit``
Iterate on elements
`val fold : `('b -> 'a -> 'b) -> 'b -> 'a t -> 'b``
Fold on elements
Since 0.13

Conversions

`type `'a` gen = `unit -> 'a option` `
`type `'a` sequence = `('a -> unit) -> unit` `
`val of_seq : `'a sequence -> 'a t``
Create a deque from the sequence.
Since 0.13 optional argument [deque] disappears, use {!add_seq_back} instead
`val to_seq : `'a t -> 'a sequence``
iterate on the elements
`val of_gen : `'a gen -> 'a t``
`of_gen g` makes a deque containing the elements of `g`
Since 0.13
`val to_gen : `'a t -> 'a gen``
Iterates on elements of the deque
Since 0.13
`val add_seq_front : `'a t -> 'a sequence -> unit``
`add_seq_front q seq` adds elements of `seq` into the front of `q`, in reverse order. O(n) in time, where `n` is the number of elements to add.
Since 0.13
`val add_seq_back : `'a t -> 'a sequence -> unit``
`add_seq_back q seq` adds elements of `seq` into the back of `q`, in order. O(n) in time, where `n` is the number of elements to add.
Since 0.13
`val copy : `'a t -> 'a t``
Fresh copy, O(n) in time
`val of_list : `'a list -> 'a t``
Conversion from list, in order
Since 0.13
`val to_list : `'a t -> 'a list``
List of elements, in order. Less efficient than `CCDeque.to_rev_list`.
Since 0.13
`val to_rev_list : `'a t -> 'a list``
Efficient conversion to list, in reverse order
Since 0.13

print

`type `'a` printer = `Format.formatter -> 'a -> unit` `
`val print : `'a printer -> 'a t printer``
Print the elements
Since 0.13