1queue(3) Erlang Module Definition queue(3)
2
6 queue - Abstract data type for FIFO queues.
7
9 This module provides (double-ended) FIFO queues in an efficient manner.
10 All functions fail with reason badarg if arguments are of wrong type,
12 for example, queue arguments are not queues, indexes are not integers,
13 and list arguments are not lists. Improper lists cause internal
14 crashes. An index out of range for a queue also causes a failure with
15 reason badarg.
16 Some functions, where noted, fail with reason empty for an empty queue.
18 The data representing a queue as used by this module is to be regarded
20 as opaque by other modules. In abstract terms, the representation is a
21 composite type of existing Erlang terms. See note on data types. Any
22 code assuming knowledge of the format is running on thin ice.
23 All operations have an amortized O(1) running time, except all/2,
25 any/2, delete/2, delete_r/2, delete_with/2, delete_with_r/2, filter/2,
26 filtermap/2, fold/3, join/2, len/1, member/2, split/2 that have O(n).
27 To minimize the size of a queue minimizing the amount of garbage built
28 by queue operations, the queues do not contain explicit length informa‐
29 tion, and that is why len/1 is O(n). If better performance for this
30 particular operation is essential, it is easy for the caller to keep
31 track of the length.
32 Queues are double-ended. The mental picture of a queue is a line of
34 people (items) waiting for their turn. The queue front is the end with
35 the item that has waited the longest. The queue rear is the end an item
36 enters when it starts to wait. If instead using the mental picture of a
37 list, the front is called head and the rear is called tail.
38 Entering at the front and exiting at the rear are reverse operations on
40 the queue.
41 This module has three sets of interface functions: the "Original API",
43 the "Extended API", and the "Okasaki API".
44 The "Original API" and the "Extended API" both use the mental picture
46 of a waiting line of items. Both have reverse operations suffixed "_r".
47 The "Original API" item removal functions return compound terms with
49 both the removed item and the resulting queue. The "Extended API" con‐
50 tains alternative functions that build less garbage and functions for
51 just inspecting the queue ends. Also the "Okasaki API" functions build
52 less garbage.
53 The "Okasaki API" is inspired by "Purely Functional Data Structures" by
55 Chris Okasaki. It regards queues as lists. This API is by many regarded
56 as strange and avoidable. For example, many reverse operations have
57 lexically reversed names, some with more readable but perhaps less un‐
58 derstandable aliases.
59
61 queue(Item)
62 As returned by new/0.
64 queue() = queue(term())
66
69 all(Pred, Q :: queue(Item)) -> boolean()
70 Types:
72 Pred = fun((Item) -> boolean())
74 Returns true if Pred(Item) returns true for all items Item in Q,
76 otherwise false.
77 any(Pred, Q :: queue(Item)) -> boolean()
79 Types:
81 Pred = fun((Item) -> boolean())
83 Returns true if Pred(Item) returns true for at least one item
85 Item in Q, otherwise false.
86 delete(Item, Q1) -> Q2
88 Types:
90 Item = T
92 Q1 = Q2 = queue(T)
93 T = term()
94 Returns a copy of Q1 where the first item matching Item is
96 deleted, if there is such an item.
97 delete_r(Item, Q1) -> Q2
99 Types:
101 Item = T
103 Q1 = Q2 = queue(T)
104 T = term()
105 Returns a copy of Q1 where the last item matching Item is
107 deleted, if there is such an item.
108 delete_with(Pred, Q1) -> Q2
110 Types:
112 Pred = fun((Item) -> boolean())
114 Q1 = Q2 = queue(Item)
115 Item = term()
116 Returns a copy of Q1 where the first item for which Pred returns
118 true is deleted, if there is such an item.
119 delete_with_r(Pred, Q1) -> Q2
121 Types:
123 Pred = fun((Item) -> boolean())
125 Q1 = Q2 = queue(Item)
126 Item = term()
127 Returns a copy of Q1 where the last item for which Pred returns
129 true is deleted, if there is such an item.
130 filter(Fun, Q1 :: queue(Item)) -> Q2 :: queue(Item)
132 Types:
134 Fun = fun((Item) -> boolean() | [Item])
136 Returns a queue Q2 that is the result of calling Fun(Item) on
138 all items in Q1.
139 If Fun(Item) returns true, Item is copied to the result queue.
141 If it returns false, Item is not copied. If it returns a list,
142 the list elements are inserted instead of Item in the result
143 queue.
144 So, Fun(Item) returning [Item] is thereby semantically equiva‐
146 lent to returning true, just as returning [] is semantically
147 equivalent to returning false. But returning a list builds more
148 garbage than returning an atom.
149 filtermap(Fun, Q1) -> Q2
151 Types:
153 Fun = fun((Item) -> boolean() | {true, Value})
155 Q1 = queue(Item)
156 Q2 = queue(Item | Value)
157 Item = Value = term()
158 Returns a queue Q2 that is the result of calling Fun(Item) on
160 all items in Q1.
161 If Fun(Item) returns true, Item is copied to the result queue.
163 If it returns false, Item is not copied. If it returns {true,
164 NewItem}, the queue element at this position is replaced with
165 NewItem in the result queue.
166 fold(Fun, Acc0, Q :: queue(Item)) -> Acc1
168 Types:
170 Fun = fun((Item, AccIn) -> AccOut)
172 Acc0 = Acc1 = AccIn = AccOut = term()
173 Calls Fun(Item, AccIn) on successive items Item of Queue, start‐
175 ing with AccIn == Acc0. The queue is traversed in queue order,
176 that is, from front to rear. Fun/2 must return a new accumula‐
177 tor, which is passed to the next call. The function returns the
178 final value of the accumulator. Acc0 is returned if the queue is
179 empty.
180 Example:
182 > queue:fold(fun(X, Sum) -> X + Sum end, 0, queue:from_list([1,2,3,4,5])).
184 15
185 > queue:fold(fun(X, Prod) -> X * Prod end, 1, queue:from_list([1,2,3,4,5])).
186 120
187 from_list(L :: [Item]) -> queue(Item)
189 Returns a queue containing the items in L in the same order; the
191 head item of the list becomes the front item of the queue.
192 in(Item, Q1 :: queue(Item)) -> Q2 :: queue(Item)
194 Inserts Item at the rear of queue Q1. Returns the resulting
196 queue Q2.
197 in_r(Item, Q1 :: queue(Item)) -> Q2 :: queue(Item)
199 Inserts Item at the front of queue Q1. Returns the resulting
201 queue Q2.
202 is_empty(Q :: queue()) -> boolean()
204 Tests if Q is empty and returns true if so, otherwise false.
206 is_queue(Term :: term()) -> boolean()
208 Tests if Term is a queue and returns true if so, otherwise
210 false. Note that the test will return true for a term coinciding
211 with the representation of a queue, even when not constructed by
212 thus module. See also note on data types.
213 join(Q1 :: queue(Item), Q2 :: queue(Item)) -> Q3 :: queue(Item)
215 Returns a queue Q3 that is the result of joining Q1 and Q2 with
217 Q1 in front of Q2.
218 len(Q :: queue()) -> integer() >= 0
220 Calculates and returns the length of queue Q.
222 member(Item, Q :: queue(Item)) -> boolean()
224 Returns true if Item matches some element in Q, otherwise false.
226 new() -> queue()
228 Returns an empty queue.
230 out(Q1 :: queue(Item)) ->
232 {{value, Item}, Q2 :: queue(Item)} |
233 {empty, Q1 :: queue(Item)}
234 Removes the item at the front of queue Q1. Returns tuple
236 {{value, Item}, Q2}, where Item is the item removed and Q2 is
237 the resulting queue. If Q1 is empty, tuple {empty, Q1} is re‐
238 turned.
239 out_r(Q1 :: queue(Item)) ->
241 {{value, Item}, Q2 :: queue(Item)} |
242 {empty, Q1 :: queue(Item)}
243 Removes the item at the rear of queue Q1. Returns tuple {{value,
245 Item}, Q2}, where Item is the item removed and Q2 is the new
246 queue. If Q1 is empty, tuple {empty, Q1} is returned.
247 reverse(Q1 :: queue(Item)) -> Q2 :: queue(Item)
249 Returns a queue Q2 containing the items of Q1 in the reverse or‐
251 der.
252 split(N :: integer() >= 0, Q1 :: queue(Item)) ->
254 {Q2 :: queue(Item), Q3 :: queue(Item)}
255 Splits Q1 in two. The N front items are put in Q2 and the rest
257 in Q3.
258 to_list(Q :: queue(Item)) -> [Item]
260 Returns a list of the items in the queue in the same order; the
262 front item of the queue becomes the head of the list.
263
266 drop(Q1 :: queue(Item)) -> Q2 :: queue(Item)
267 Returns a queue Q2 that is the result of removing the front item
269 from Q1.
270 Fails with reason empty if Q1 is empty.
272 drop_r(Q1 :: queue(Item)) -> Q2 :: queue(Item)
274 Returns a queue Q2 that is the result of removing the rear item
276 from Q1.
277 Fails with reason empty if Q1 is empty.
279 get(Q :: queue(Item)) -> Item
281 Returns Item at the front of queue Q.
283 Fails with reason empty if Q is empty.
285 get_r(Q :: queue(Item)) -> Item
287 Returns Item at the rear of queue Q.
289 Fails with reason empty if Q is empty.
291 peek(Q :: queue(Item)) -> empty | {value, Item}
293 Returns tuple {value, Item}, where Item is the front item of Q,
295 or empty if Q is empty.
296 peek_r(Q :: queue(Item)) -> empty | {value, Item}
298 Returns tuple {value, Item}, where Item is the rear item of Q,
300 or empty if Q is empty.
301
304 cons(Item, Q1 :: queue(Item)) -> Q2 :: queue(Item)
305 Inserts Item at the head of queue Q1. Returns the new queue Q2.
307 daeh(Q :: queue(Item)) -> Item
309 Returns the tail item of queue Q.
311 Fails with reason empty if Q is empty.
313 head(Q :: queue(Item)) -> Item
315 Returns Item from the head of queue Q.
317 Fails with reason empty if Q is empty.
319 init(Q1 :: queue(Item)) -> Q2 :: queue(Item)
321 Returns a queue Q2 that is the result of removing the tail item
323 from Q1.
324 Fails with reason empty if Q1 is empty.
326 lait(Q1 :: queue(Item)) -> Q2 :: queue(Item)
328 Returns a queue Q2 that is the result of removing the tail item
330 from Q1.
331 Fails with reason empty if Q1 is empty.
333 The name lait/1 is a misspelling - do not use it anymore.
335 last(Q :: queue(Item)) -> Item
337 Returns the tail item of queue Q.
339 Fails with reason empty if Q is empty.
341 liat(Q1 :: queue(Item)) -> Q2 :: queue(Item)
343 Returns a queue Q2 that is the result of removing the tail item
345 from Q1.
346 Fails with reason empty if Q1 is empty.
348 snoc(Q1 :: queue(Item), Item) -> Q2 :: queue(Item)
350 Inserts Item as the tail item of queue Q1. Returns the new queue
352 Q2.
353 tail(Q1 :: queue(Item)) -> Q2 :: queue(Item)
355 Returns a queue Q2 that is the result of removing the head item
357 from Q1.
358 Fails with reason empty if Q1 is empty.
360Ericsson AB stdlib 4.2 queue(3)