Provided by: erlang-manpages_25.2.3+dfsg-1_all bug

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.