queue - Abstract data type for FIFO queues.
Please see following description for synopsis
queue(3) Erlang Module Definition queue(3)
NAME
queue - Abstract data type for FIFO queues.
DESCRIPTION
This module provides (double-ended) FIFO queues in an efficient manner.
All functions fail with reason badarg if arguments are of wrong type,
for example, queue arguments are not queues, indexes are not integers,
and list arguments are not lists. Improper lists cause internal
crashes. An index out of range for a queue also causes a failure with
reason badarg.
Some functions, where noted, fail with reason empty for an empty queue.
The data representing a queue as used by this module is to be regarded
as opaque by other modules. Any code assuming knowledge of the format
is running on thin ice.
All operations have an amortized O(1) running time, except all/2,
any/2, delete/2, delete_r/2, delete_with/2, delete_with_r/2, filter/2,
filtermap/2, fold/3, join/2, len/1, member/2, split/2 that have O(n).
To minimize the size of a queue minimizing the amount of garbage built
by queue operations, the queues do not contain explicit length informa-
tion, and that is why len/1 is O(n). If better performance for this
particular operation is essential, it is easy for the caller to keep
track of the length.
Queues are double-ended. The mental picture of a queue is a line of
people (items) waiting for their turn. The queue front is the end with
the item that has waited the longest. The queue rear is the end an item
enters when it starts to wait. If instead using the mental picture of a
list, the front is called head and the rear is called tail.
Entering at the front and exiting at the rear are reverse operations on
the queue.
This module has three sets of interface functions: the "Original API",
the "Extended API", and the "Okasaki API".
The "Original API" and the "Extended API" both use the mental picture
of a waiting line of items. Both have reverse operations suffixed "_r".
The "Original API" item removal functions return compound terms with
both the removed item and the resulting queue. The "Extended API" con-
tains alternative functions that build less garbage and functions for
just inspecting the queue ends. Also the "Okasaki API" functions build
less garbage.
The "Okasaki API" is inspired by "Purely Functional Data Structures" by
Chris Okasaki. It regards queues as lists. This API is by many regarded
as strange and avoidable. For example, many reverse operations have
lexically reversed names, some with more readable but perhaps less
understandable aliases.
DATA TYPES
queue(Item)
As returned by new/0.
queue() = queue(term())
ORIGINAL API
EXPORTS
all(Pred, Q :: queue(Item)) -> boolean()
Types:
Pred = fun((Item) -> boolean())
Returns true if Pred(Item) returns true for all items Item in Q,
otherwise false.
any(Pred, Q :: queue(Item)) -> boolean()
Types:
Pred = fun((Item) -> boolean())
Returns true if Pred(Item) returns true for at least one item
Item in Q, otherwise false.
delete(Item, Q1) -> Q2
Types:
Item = T
Q1 = Q2 = queue(T)
T = term()
Returns a copy of Q1 where the first item matching Item is
deleted, if there is such an item.
delete_r(Item, Q1) -> Q2
Types:
Item = T
Q1 = Q2 = queue(T)
T = term()
Returns a copy of Q1 where the last item matching Item is
deleted, if there is such an item.
delete_with(Pred, Q1) -> Q2
Types:
Pred = fun((Item) -> boolean())
Q1 = Q2 = queue(Item)
Item = term()
Returns a copy of Q1 where the first item for which Pred returns
true is deleted, if there is such an item.
delete_with_r(Pred, Q1) -> Q2
Types:
Pred = fun((Item) -> boolean())
Q1 = Q2 = queue(Item)
Item = term()
Returns a copy of Q1 where the last item for which Pred returns
true is deleted, if there is such an item.
filter(Fun, Q1 :: queue(Item)) -> Q2 :: queue(Item)
Types:
Fun = fun((Item) -> boolean() | [Item])
Returns a queue Q2 that is the result of calling Fun(Item) on
all items in Q1.
If Fun(Item) returns true, Item is copied to the result queue.
If it returns false, Item is not copied. If it returns a list,
the list elements are inserted instead of Item in the result
queue.
So, Fun(Item) returning [Item] is thereby semantically equiva-
lent to returning true, just as returning [] is semantically
equivalent to returning false. But returning a list builds more
garbage than returning an atom.
filtermap(Fun, Q1) -> Q2
Types:
Fun = fun((Item) -> boolean() | {true, Value})
Q1 = queue(Item)
Q2 = queue(Item | Value)
Item = Value = term()
Returns a queue Q2 that is the result of calling Fun(Item) on
all items in Q1.
If Fun(Item) returns true, Item is copied to the result queue.
If it returns false, Item is not copied. If it returns {true,
NewItem}, the queue element at this position is replaced with
NewItem in the result queue.
fold(Fun, Acc0, Q :: queue(Item)) -> Acc1
Types:
Fun = fun((Item, AccIn) -> AccOut)
Acc0 = Acc1 = AccIn = AccOut = term()
Calls Fun(Item, AccIn) on successive items Item of Queue, start-
ing with AccIn == Acc0. The queue is traversed in queue order,
that is, from front to rear. Fun/2 must return a new accumula-
tor, which is passed to the next call. The function returns the
final value of the accumulator. Acc0 is returned if the queue is
empty.
Example:
> queue:fold(fun(X, Sum) -> X + Sum end, 0, queue:from_list([1,2,3,4,5])).
15
> queue:fold(fun(X, Prod) -> X * Prod end, 1, queue:from_list([1,2,3,4,5])).
120
from_list(L :: [Item]) -> queue(Item)
Returns a queue containing the items in L in the same order; the
head item of the list becomes the front item of the queue.
in(Item, Q1 :: queue(Item)) -> Q2 :: queue(Item)
Inserts Item at the rear of queue Q1. Returns the resulting
queue Q2.
in_r(Item, Q1 :: queue(Item)) -> Q2 :: queue(Item)
Inserts Item at the front of queue Q1. Returns the resulting
queue Q2.
is_empty(Q :: queue()) -> boolean()
Tests if Q is empty and returns true if so, otherwise false.
is_queue(Term :: term()) -> boolean()
Tests if Term is a queue and returns true if so, otherwise
false.
join(Q1 :: queue(Item), Q2 :: queue(Item)) -> Q3 :: queue(Item)
Returns a queue Q3 that is the result of joining Q1 and Q2 with
Q1 in front of Q2.
len(Q :: queue()) -> integer() >= 0
Calculates and returns the length of queue Q.
member(Item, Q :: queue(Item)) -> boolean()
Returns true if Item matches some element in Q, otherwise false.
new() -> queue()
Returns an empty queue.
out(Q1 :: queue(Item)) ->
{{value, Item}, Q2 :: queue(Item)} |
{empty, Q1 :: queue(Item)}
Removes the item at the front of queue Q1. Returns tuple
{{value, Item}, Q2}, where Item is the item removed and Q2 is
the resulting queue. If Q1 is empty, tuple {empty, Q1} is
returned.
out_r(Q1 :: queue(Item)) ->
{{value, Item}, Q2 :: queue(Item)} |
{empty, Q1 :: queue(Item)}
Removes the item at the rear of queue Q1. Returns tuple {{value,
Item}, Q2}, where Item is the item removed and Q2 is the new
queue. If Q1 is empty, tuple {empty, Q1} is returned.
reverse(Q1 :: queue(Item)) -> Q2 :: queue(Item)
Returns a queue Q2 containing the items of Q1 in the reverse
order.
split(N :: integer() >= 0, Q1 :: queue(Item)) ->
{Q2 :: queue(Item), Q3 :: queue(Item)}
Splits Q1 in two. The N front items are put in Q2 and the rest
in Q3.
to_list(Q :: queue(Item)) -> [Item]
Returns a list of the items in the queue in the same order; the
front item of the queue becomes the head of the list.
EXTENDED API
EXPORTS
drop(Q1 :: queue(Item)) -> Q2 :: queue(Item)
Returns a queue Q2 that is the result of removing the front item
from Q1.
Fails with reason empty if Q1 is empty.
drop_r(Q1 :: queue(Item)) -> Q2 :: queue(Item)
Returns a queue Q2 that is the result of removing the rear item
from Q1.
Fails with reason empty if Q1 is empty.
get(Q :: queue(Item)) -> Item
Returns Item at the front of queue Q.
Fails with reason empty if Q is empty.
get_r(Q :: queue(Item)) -> Item
Returns Item at the rear of queue Q.
Fails with reason empty if Q is empty.
peek(Q :: queue(Item)) -> empty | {value, Item}
Returns tuple {value, Item}, where Item is the front item of Q,
or empty if Q is empty.
peek_r(Q :: queue(Item)) -> empty | {value, Item}
Returns tuple {value, Item}, where Item is the rear item of Q,
or empty if Q is empty.
OKASAKI API
EXPORTS
cons(Item, Q1 :: queue(Item)) -> Q2 :: queue(Item)
Inserts Item at the head of queue Q1. Returns the new queue Q2.
daeh(Q :: queue(Item)) -> Item
Returns the tail item of queue Q.
Fails with reason empty if Q is empty.
head(Q :: queue(Item)) -> Item
Returns Item from the head of queue Q.
Fails with reason empty if Q is empty.
init(Q1 :: queue(Item)) -> Q2 :: queue(Item)
Returns a queue Q2 that is the result of removing the tail item
from Q1.
Fails with reason empty if Q1 is empty.
lait(Q1 :: queue(Item)) -> Q2 :: queue(Item)
Returns a queue Q2 that is the result of removing the tail item
from Q1.
Fails with reason empty if Q1 is empty.
The name lait/1 is a misspelling - do not use it anymore.
last(Q :: queue(Item)) -> Item
Returns the tail item of queue Q.
Fails with reason empty if Q is empty.
liat(Q1 :: queue(Item)) -> Q2 :: queue(Item)
Returns a queue Q2 that is the result of removing the tail item
from Q1.
Fails with reason empty if Q1 is empty.
snoc(Q1 :: queue(Item), Item) -> Q2 :: queue(Item)
Inserts Item as the tail item of queue Q1. Returns the new queue
Q2.
tail(Q1 :: queue(Item)) -> Q2 :: queue(Item)
Returns a queue Q2 that is the result of removing the head item
from Q1.
Fails with reason empty if Q1 is empty.
Ericsson AB stdlib 3.17 queue(3)