--- name: "queue" section: "3erl" platform: "linux" package: "erlang-manpages" version: "1:25.2.3+dfsg-1+deb12u4" release: "Debian 12 (Bookworm)" platforms: ["linux"] url: "https://new.carta.tech/queue/3erl" --- # queue(3erl) Abstract data type for FIFO queues. ## 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. In abstract terms, the representation is a composite type of existing Erlang terms. See note on data types. 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 information, 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" contains 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 equivalent 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*, starting with *AccIn == Acc0*. The queue is traversed in queue order, that is, from front to rear. *Fun/2* must return a new accumulator, 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*. Note that the test will return *true* for a term coinciding with the representation of a queue, even when not constructed by thus module. See also note on data types. ``` 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.