Unix/Linux Go Back    


Linux 2.6 - man page for queue (linux section 3erl)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)


queue(3erl)			     Erlang Module Definition			      queue(3erl)

NAME
       queue - Abstract Data Type for FIFO Queues

DESCRIPTION
       This module implements (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, 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 should be regarded as opaque by other
       modules. Any code assuming knowledge of the format is running on thin ice.

       All  operations has an amortized O(1) running time, except len/1 , join/2 , split/2 , fil-
       ter/2 and member/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.

       The module has several 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 also 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" contain alternative functions that build less
       garbage as well as 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. The 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.

ORIGINAL API
EXPORTS
       new() -> Q

	      Types  Q = queue()

	      Returns an empty queue.

       is_queue(Term) -> true | false

	      Types  Term = term()

	      Tests if Q is a queue and returns true if so and false otherwise.

       is_empty(Q) -> true | false

	      Types  Q = queue()

	      Tests if Q is empty and returns true if so and false otherwise.

       len(Q) -> N

	      Types  Q = queue()
		     N = integer()

	      Calculates and returns the length of queue Q .

       in(Item, Q1) -> Q2

	      Types  Item = term()
		     Q1 = Q2 = queue()

	      Inserts Item at the rear of queue Q1 . Returns the resulting queue Q2 .

       in_r(Item, Q1) -> Q2

	      Types  Item = term()
		     Q1 = Q2 = queue()

	      Inserts Item at the front of queue Q1 . Returns the resulting queue Q2 .

       out(Q1) -> Result

	      Types  Result = {{value, Item}, Q2} | {empty, Q1}
		     Q1 = Q2 = queue()

	      Removes the item at the front of queue Q1 . Returns the tuple {{value, Item}, Q2} ,
	      where  Item  is the item removed and Q2 is the resulting queue. If Q1 is empty, the
	      tuple {empty, Q1} is returned.

       out_r(Q1) -> Result

	      Types  Result = {{value, Item}, Q2} | {empty, Q1}
		     Q1 = Q2 = queue()

	      Removes the item at the rear of the queue Q1 . Returns the  tuple  {{value,  Item},
	      Q2}  ,  where Item is the item removed and Q2 is the new queue. If Q1 is empty, the
	      tuple {empty, Q1} is returned.

       from_list(L) -> queue()

	      Types  L = list()

	      Returns a queue containing the items in L in the same order; the head item  of  the
	      list will become the front item of the queue.

       to_list(Q) -> list()

	      Types  Q = queue()

	      Returns  a  list of the items in the queue in the same order; the front item of the
	      queue will become the head of the list.

       reverse(Q1) -> Q2

	      Types  Q1 = Q2 = queue()

	      Returns a queue Q2 that contains the items of Q1 in the reverse order.

       split(N, Q1) -> {Q2,Q3}

	      Types  N = integer()
		     Q1 = Q2 = Q3 = queue()

	      Splits Q1 in two. The N front items are put in Q2 and the rest in Q3

       join(Q1, Q2) -> Q3

	      Types  Q1 = Q2 = Q3 = queue()

	      Returns a queue Q3 that is the result of joining Q1 and Q2 with Q1 in front of Q2 .

       filter(Fun, Q1) -> Q2

	      Types  Fun = fun(Item) -> bool() | list()
		     Q1 = Q2 = queue()

	      Returns a queue Q2 that is the result of calling Fun(Item) on all items in Q1 ,  in
	      order from front to rear.

	      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  return-
	      ing a list builds more garbage than returning an atom.

       member(Item, Q) -> bool()

	      Types  Item = term()
		     Q = queue()

	      Returns true if Item matches some element in Q , otherwise false .

EXTENDED API
EXPORTS
       get(Q) -> Item

	      Types  Item = term()
		     Q = queue()

	      Returns Item at the front of queue Q .

	      Fails with reason empty if Q is empty.

       get_r(Q) -> Item

	      Types  Item = term()
		     Q = queue()

	      Returns Item at the rear of queue Q .

	      Fails with reason empty if Q is empty.

       drop(Q1) -> Q2

	      Types  Item = term()
		     Q1 = Q2 = queue()

	      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) -> Q2

	      Types  Item = term()
		     Q1 = Q2 = queue()

	      Returns a queue Q2 that is the result of removing the rear item from Q1 .

	      Fails with reason empty if Q1 is empty.

       peek(Q) -> {value,Item} | empty

	      Types  Item = term()
		     Q = queue()

	      Returns  the tuple {value, Item} where Item is the front item of Q , or empty if Q1
	      is empty.

       peek_r(Q) -> {value,Item} | empty

	      Types  Item = term()
		     Q = queue()

	      Returns the tuple {value, Item} where Item is the rear item of Q , or empty  if  Q1
	      is empty.

OKASAKI API
EXPORTS
       cons(Item, Q1) -> Q2

	      Types  Item = term()
		     Q1 = Q2 = queue()

	      Inserts Item at the head of queue Q1 . Returns the new queue Q2 .

       head(Q) -> Item

	      Types  Item = term()
		     Q = queue()

	      Returns Item from the head of queue Q .

	      Fails with reason empty if Q is empty.

       tail(Q1) -> Q2

	      Types  Item = term()
		     Q1 = Q2 = queue()

	      Returns a queue Q2 that is the result of removing the head item from Q1 .

	      Fails with reason empty if Q1 is empty.

       snoc(Q1, Item) -> Q2

	      Types  Item = term()
		     Q1 = Q2 = queue()

	      Inserts Item as the tail item of queue Q1 . Returns the new queue Q2 .

       daeh(Q) -> Item
       last(Q) -> Item

	      Types  Item = term()
		     Q = queue()

	      Returns the tail item of queue Q .

	      Fails with reason empty if Q is empty.

       liat(Q1) -> Q2
       init(Q1) -> Q2
       lait(Q1) -> Q2

	      Types  Item = term()
		     Q1 = Q2 = queue()

	      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.

Ericsson AB				  stdlib 1.17.3 			      queue(3erl)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums


All times are GMT -4. The time now is 09:29 PM.