Queue/Definition: Difference between revisions

 

Operations:

 

 

{{Template:See also lists}}

<br><br>

 

=={{header|ACL2}}==

(cons x xs))

 

 

(defun empty (xs)

 

=={{header|Ada}}==

 

The interface specification for a FIFO is described in the package specification.

type Element_Type is private;

package Fifo is

Next : Fifo_Ptr := null;

end record;

The FIFO implementation is described in the package body:

 

package body Fifo is

end Is_Empty;

 

A "main" procedure for this program is:

with Ada.Text_Io; use Ada.Text_Io;

 

Put_Line(Integer'Image(Val));

end loop;

The following implementation produces equivalent functionality by deriving from the standard Ada Container type Doubly_Linked_Lists.

 

This example needs fewer lines of code on the part of the application programmer, but the implementation is less efficient than the previous example. Each element has all the data members needed for a doubly linked list. It also links in all the functionality of a doubly linked list. Most of that functionality is unneeded in a FIFO.

with Ada.Containers.Doubly_Linked_Lists;

generic

Type Fifo_Type is new List with null record;

end Generic_Fifo;

package body Generic_Fifo is

end Pop;

with Ada.Text_Io; use Ada.Text_Io;

 

Put_Line(Integer'Image(Val));

end loop;

The function Is_Empty is inherited from the Lists type.

 

 

If we wish for the reader to read every value written by the writer we must synchronize the tasks. The writer can only write a new value when the buffer contains a stale value. The reader can only read a value when the value is fresh. This synchronization forces the two tasks to run at the same speed.

type Element_Type is private;

package Synchronous_Fifo is

Is_New : Boolean := False;

end Fifo;

 

----------

end Fifo;

 

with Ada.Text_Io; use Ada.Text_Io;

 

Writer.Stop;

Reader.Stop;

Another choice is to cause the two tasks to run independently. The writer can write whenever it is scheduled. The reader reads whenever it is scheduled, after the writer writes the first valid value.

 

 

In a fully asynchronous system the reader only samples the values written by the writer. There is no control over the number of values not sampled by the reader, or over the number of times the reader reads the same value.

type Element_Type is private;

package Asynchronous_Fifo is

Valid : Boolean := False;

end Fifo;

You may notice that the protected type specification is remarkably similar to the synchronous example above. The only important difference is that Push is declared to be an Entry in the synchronous example while it is a procedure in the asynchronous example. Entries only execute when their boundary condition evaluates to TRUE. Procedures execute unconditionally.

 

----------

end Fifo;

 

with Ada.Text_Io; use Ada.Text_Io;

 

Put_Line(Integer'Image(Val));

end select;

end Reader;

begin

Writer.Stop;

Reader.Stop;

=={{header|ALGOL 68}}==

{{works with|ALGOL 68|Revision 1 - one extension to language used - PRAGMA READ - a non standard feature similar to C's #include directive.}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.7 algol68g-2.7].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

CO REQUIRES:

MODE OBJLINK = STRUCT(

self IS obj queue empty;

 

 

=={{header|ALGOL W}}==

% define a Queue type that will hold StringQueueElements %

record StringQueue ( reference(StringQueueElement) front, back );

while not isEmptyStringQueue( q ) do write( popString( q ) )

end

{{out}}

<pre>

barney

</pre>

 

=={{header|AutoHotkey}}==

 

MsgBox % "Len = " len("qu") ; Number of entries

StringReplace %queue%, %queue%, |, |, UseErrorLevel

Return %queue% = "" ? 0 : ErrorLevel+1

=={{header|AWK}}==

 

BEGIN {

return length(q) == 0

}

 

{{out}}

</pre>

 

=={{header|Batch File}}==

 

More complex variations can be written that remove this limitation.

 

@echo off

setlocal enableDelayedExpansion

for %%N in (!%~1.head!) do set %~2=!%~1.%%N!

exit /b 0

 

 

 

=={{header|Bracmat}}==

 

No special provision is implemented to "throw and exception" in case you try to dequeue from and empty queue, because, in Bracmat, evaluation of an expression, besides resulting in an evaluated expression, always also either "succeeds" or "fails". (There is, in fact, a third possibility, "ignore", telling Bracmat to close an eye even though an evaluation didn't succeed.) So in the example below, the last dequeue operation fails and the program continues on the right hand side of the bar (<code>|</code>) operator

= (list=)

(enqueue=.(.!arg) !(its.list):?(its.list))

)

(empty=.!(its.list):)

 

Normally you would seldom use a class as depicted above, because the operations are so simple that you probably use them directly. Bracmat lists allow prepending as well as appending elements, and single elements can be removed from the beginning or from the end of a list.

 

Appending an element to a long list and removing an element from the end of a long list are quite expensive operations, with a cost <i>O</i>(<i>n</i>), where <i>n</i> is the number of elements in the queue.

 

=={{header|C}}==

===Dynamic array===

Dynamic array working as a circular buffer.

#include <stdlib.h>

#include <string.h>

}

return 1;

 

===Doubly linked list===

#include <stdlib.h>

 

return 1;

}

 

'''Test code'''

This main function works with both implementions above.

{

int i, n;

 

return 0;

 

Of the above two programs, for int types the array method is about twice as fast for the test code given. The doubly linked list is marginally faster than the <code>sys/queue.h</code> below.

Using the <tt>sys/queue.h</tt>, which is not POSIX.1-2001 (but it is BSD). The example allows to push/pop int values, but instead of <tt>int</tt> one can use <tt>void *</tt> and push/pop any kind of "object" (of course changes to the commodity functions <tt>m_queue</tt> and <tt>m_dequeue</tt> are needed)

 

#include <stdlib.h>

#include <stdbool.h>

if ( l->tqh_first == NULL ) return true;

return false;

 

=={{header|C++}}==

{{works with|g++|4.1.2 20061115 (prerelease) (Debian 4.1.1-21)}}

C++ already has a class <code>queue</code> in the standard library, however the following is a simple implementation based on a singly linkes list. Note that an empty queue is internally represented by <code>head == 0</code>, therefore it doesn't matter that the <code>tail</code> value is invalid in that case.

{

template<typename T> class queue

return head == 0;

}

 

=={{header|Clojure}}==

 

 

 

 

 

=={{header|CoffeeScript}}==

# Implement a fifo as an array of arrays, to

# greatly amortize dequeue costs, at some expense of

v = q.dequeue()

console.log v

{{out}}

<pre>

This defines a queue structure that stores its items in a list, and maintains a tail pointer (i.e., a pointer to the last cons in the list). Note that dequeuing the last item in the queue does not clear the tail pointer—enqueuing into the resulting empty queue will correctly reset the tail pointer.

 

(items '() :type list)

(tail '() :type list))

(if (queue-empty-p queue)

(error "Cannot dequeue from empty queue.")

 

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE Queue;

TYPE

END Queue.

Interface extracted from implementation

DEFINITION Queue;

 

 

 

 

END Queue.

 

=={{header|D}}==

=={{header|Déjà Vu}}==

This uses a dictionary to have a sort of [[wp:Circular_buffer|circular buffer]] of infinite size.

{ :start 0 :end 0 }

 

 

empty q:

 

=={{header|E}}==

 

Also, according to E design principles, the read and write ends of the queue are separate objects. This has two advantages; first, it implements [http://wiki.erights.org/wiki/POLA POLA] by allowing only the needed end of the queue to be handed out to its users; second, if the reader end is garbage collected the contents of the queue automatically will be as well (rather than accumulating if the writer continues writing).

 

def [var head, var tail] := Ref.promise()

 

return [reader, writer]

 

=={{header|EchoLisp}}==

There is no native queue type in EchoLisp. make-Q implements queues in message passing style, using vector operations. Conversions from-to lists are also provided.

;; put info string in permanent storage for later use

(info 'make-Q

;; save make-Q

(local-put 'make-Q)

=={{header|Elena}}==

{

if (theTale == theTop)

^ item

}

{

}

{{out}}

<pre>

This is a generic Queue component based on bi-directional lists. See how in Elisa these [http://jklunder.home.xs4all.nl/elisa/part01/doc080.html lists] are defined.

 

component GenericQueue ( Queue, Element );

type Queue;

remove(first(queue.list))];

end component GenericQueue;

In the following tests we will also show how the internal structure of the queue can be made visible to support debugging.

use GenericQueue (QueueofPersons, Person);

type Person = text;

Pull (Q)?

***** Exception: Queue Underflow

 

=={{header|Elixir}}==

{{trans|Erlang}}

def new, do: {Queue, [], []}

def empty?({Queue, [], []}), do: true

def empty?({Queue, _, _}), do: false

 

Example:

The standard way to manage fifo in functional programming is to use a pair of list for the fifo queue, one is the input, the other is the output.

When the output is empty just take the input list and reverse it.

-export([new/0, push/2, pop/1, empty/1]).

 

 

empty({fifo, [], []}) -> true;

 

Note that there exists a 'queue' module in the standard library handling this for you in the first place

=={{header|ERRE}}==

With ERRE 3.0 you can use a class to define the task (in C-64 version you can simply use procedures):

 

CLASS QUEUE

END FOR

PRINT("* End *")

{{out}}

<pre>Push 1

Queue is empty!

* End *</pre>

 

=={{header|Fantom}}==

 

class Queue

{

}

}

 

=={{header|Forth}}==

This is a FIFO implemented as a circular buffer, as is often found between communicating processes such the interrupt and user parts of a device driver. In practice, the get/put actions would block instead of aborting if the queue is empty/full.

 

create buffer size cells allot

here constant end

empty? abort" buffer empty"

\ begin empty? while pause repeat

 

=== Linked list version ===

Using Forth-2012 structure words and ALLOCATE/FREE. In spirit quite similar to the Java variant below, with one difference: Here we use addresses of fields (not possible in Java), which often makes things simpler than in Java (fewer special cases at boundaries), but in this case it does not. Where the Java version has a special case on enqueue, this version has a special case on dequeue:

 

0

field: list-next

over init-queue then

nip ;

 

=={{header|Fortran}}==

See [[FIFO (usage)]] for an example of <code>fifo_nodes</code>

 

use fifo_nodes

! fifo_nodes must define the type fifo_node, with the two field

end function fifo_isempty

 

 

=={{header|FreeBASIC}}==

We first use a macro to define a generic Queue type :

 

' queue_rosetta.bi

Return size

End Function

We now use this type to create a Queue of Cat instances :

 

#Include "queue_rosetta.bi"

Print

Print "Press any key to quit"

 

{{out}}

Error: Attempted to remove 'front' element of an empty queue

</pre>

 

=={{header|GAP}}==

Add(v[1], x);

end;

# 6

Dequeue(v);

 

=={{header|Go}}==

Hard coded to be a queue of strings. Implementation is a circular buffer which grows as needed.

package queue

 

return q.head == q.tail

}

 

=={{header|Groovy}}==

Solution:

private List buffer

 

String toString() { "Queue:${buffer}" }

 

Test:

assert q.empty

 

assert q.empty

try { q.pop() } catch (NoSuchElementException e) { println e }

 

{{out}}

When the output is empty just take the input list and reverse it.

 

 

emptyFifo :: Fifo a

isEmpty (F [] []) = True

isEmpty _ = False

 

== Icon and Unicon ==

The following works in both Icon and Unicon:

 

# Use a record to hold a Queue, using a list as the concrete implementation

record Queue(items)

}

end

 

{{out}}

Unicon also provides classes:

 

# Use a class to hold a Queue, with a list as the concrete implementation

class Queue (items)

}

end

 

Produces the same output as above.

Object oriented technique, using mutable state:

 

 

pop_fifo_=: verb define

isEmpty_fifo_=: verb define

0=#queue

 

Function-level technique, with no reliance on mutable state:

 

push =: ( '' ; ,~ )& > /

tell_atom =: >& {.

onto =: [ ; }.@]

 

 

See also [[FIFO (usage)#J]]

{{works with|Java|1.5+}}

This task could be done using a LinkedList from java.util, but here is a user-defined version with generics:

Node<E> head = null, tail = null;

 

return head == null;

}

 

=={{header|JavaScript}}==

 

=== Using built-in Array ===

fifo.push(42); // Enqueue.

fifo.push(43);

var x = fifo.shift(); // Dequeue.

 

=== Custom constructor function ===

this.data = new Array();

 

this.enqueue = this.push;

this.dequeue = this.pop;

=={{header|jq}}==

 

 

 

 

 

 

 

=={{header|Julia}}==

Julia provides a variety of queue-like methods for vectors, making the solution to this task rather straightforward. Define a <tt>Queue</tt> in terms of a one dimensional array, and provide its methods using the appropriate vector operations. To adhere to Julia naming conventions, the queue operations are named "push!", "pop!" and "isempty" rather than "push", "pop" and "empty".

a::Array{T,1}

end

Base.isempty(q::Queue) = isempty(q.a)

 

!isempty(q) || error("queue must be non-empty")

pop!(q.a)

end

 

return q

end

 

return q

end

 

{{out}}

<pre>

julia> q = Queue()

 

julia> isempty(q)

 

julia> push!(q, 1)

 

julia> isempty(q)

 

julia> push!(q, "two")

 

julia> push!(q, 3.0)

 

julia> push!(q, false)

 

julia> pop!(q)

julia> pop!(q)

ERROR: queue must be non-empty

</pre>

 

=={{header|Kotlin}}==

 

import java.util.LinkedList

println(e.message)

}

 

{{out}}

{{VI solution|LabVIEW_Queue_Definition.png}}

 

=={{header|Lasso}}==

Definition:

data store = list

 

public isEmpty => (.`store`->size == 0)

 

Usage:

#q->isEmpty

// => false

// => true

#q->pop

 

=={{header|Lua}}==

 

function Queue.new()

function Queue.empty( queue )

return queue.first > queue.last

 

=={{header|M2000 Interpreter}}==

A Stack object can be used as LIFO or FIFO. Data push to bottom of stack. Read pop a value to a variable from top of stack.

Module Checkit {

a=Stack

}

Checkit

 

SetAttributes[Push, HoldAll]; Push[a_, elem_] := AppendTo[a, elem]

 

=={{header|MATLAB}} / {{header|Octave}}==

 

Here is a simple implementation of a queue, that works in Matlab and Octave.

% push

 

% empty

 

Below is another solution, that encapsulates the fifo within the object-orientated "class" elements supported by Matlab. For this to work it must be saved in a file named "FIFOQueue.m" in a folder named "@FIFOQueue" in your current Matlab directory.

classdef FIFOQueue

end %methods

 

Sample usage:

myQueue =

>> pop(myQueue)

??? Error using ==> FIFOQueue.FIFOQueue>FIFOQueue.pop at 61

 

=={{header|Maxima}}==

 

enqueue(x, q) := (q@in: cons(x, q@in), done)$

dequeue(q); /* 3 */

dequeue(q); /* 4 */

 

=={{header|NetRexx}}==

Unlike [[#REXX|Rexx]], NetRexx does not include built&ndash;in support for queues but the language's ability to access the [[Java]] SDK permits use of any number of Java's &quot;Collection&quot; classes.

The following sample implements a stack via the <code>ArrayDeque</code> double&ndash;ended queue.

options replace format comments java crossref savelog symbols nobinary

 

 

return

 

<pre style="height: 20ex; overflow: scroll;">

 

=={{header|Nim}}==

 

 

 

{{out}}

<pre>Fifo size: 3

Popping: 26

Popping: 99

 

=={{header|OCaml}}==

When the output is empty just take the input list and reverse it.

 

type 'a fifo

val empty: 'a fifo

| [], [] -> failwith "empty fifo"

| input, [] -> pop ([], List.rev input)

 

and a session in the top-level:

 

# let q = empty ;;

val q : '_a FIFO.fifo = <abstr>

val q : int FIFO.fifo = <abstr>

# let v, q = pop q ;;

 

The standard ocaml library also provides a

If queue is empty, null is returned.

 

 

Queue method: initialize ListBuffer new := l ;

Queue method: empty @l isEmpty ;

Queue method: push @l add ;

 

=={{header|OxygenBasic}}==

This buffer pushes any primitive data (auto converted to strings), and pops strings. The buffer can expand or contract according to usage.

'==========

Class Queue

'==========

 

 

int p at (i+strptr buf)

p=ls

i+=sizeof int

end method

method push(string s)

if i+ls+8>le then

end if

i+=ls

end method

end method

if ls<0 then s="" : return ls 'empty buffer

s=mid buf,bg+1,ls

bg+=ls

if bg>1e6 then

end if

end method

method clear()

end method

 

 

'====

'====

string s

'

fifo.push "Sat on a wall"

'

do

er=fifo.pop s

if er then print "(buffer empty)" : exit do

print s

 

=={{header|Oz}}==

The implementation is thread-safe if there is only one reader thread. When multiple reader threads exist, it is possible that a value is popped more than once.

 

fun {NewQueue}

Stream

{Show {Empty Q}}

{Show {Pop Q}}

 

There is also a [http://www.mozart-oz.org/home/doc/mozart-stdlib/adt/queue.html queue datatype] in the Mozart standard library.

This program should be Standard Pascal compliant (i.e. it doesn't make use of the advanced/non-standard features of FreePascal or GNU Pascal).

 

 

type

testFifo;

writeln('Testing finished.')

 

=={{header|Perl}}==

Lists are a central part of Perl. To implement a FIFO using OO will to many Perl programmers seem a bit awkward.

 

 

Example:

 

 

mypush @fifo, 44, 55, 66;

mypop @fifo for 1 .. 6+3;

 

 

 

 

 

 

 

 

 

=={{header|PHP}}==

private $data = array();

public function push($element){

return empty($this->data);

}

 

Example:

 

$foo->push('One');

$foo->enqueue('Two');

echo $foo->pop(); //Prints 'Three'

echo $foo->pop(); //Throws an exception

 

=={{header|PicoLisp}}==

The built-in function 'fifo' maintains a queue in a circular list, with direct

access to the first and the last cell

(fifo 'Queue 1) # Store number '1'

(fifo 'Queue 'abc) # an internal symbol 'abc'

(fifo 'Queue "abc") # a transient symbol "abc"

(fifo 'Queue '(a b c)) # and a list (a b c)

{{out}}

<pre>->((a b c) 1 abc "abc" .)</pre>

 

=={{header|PL/I}}==

/* To push a node onto the end of the queue. */

push: procedure (tail);

return (h = bind(:Node, null:) );

end empty;

 

=={{header|PostScript}}==

{{libheader|initlib}}

% our queue is just [] and empty? is already defined.

/push {exch tadd}.

/pop {uncons exch}.

 

=={{header|PowerShell}}==

{{works with|PowerShell|2}}<br/>

PowerShell can natively use the .Net Queue class.

$Q = New-Object System.Collections.Queue

{ $Q.Dequeue() }

catch [System.InvalidOperationException]

{{out}}

<pre>1

Works with SWI-Prolog.

One can push any data in queue.

unify_with_occurs_check(U, V).

 

 

append_dl(X-Y, Y-Z, X-Z).

 

=={{header|PureBasic}}==

For FIFO function PureBasic normally uses linked lists.

Usage as described above could look like;

 

Procedure Push(n)

Wend

;---- Now an extra Pop(), e.g. one to many ----

 

{{out}}

To encapsulate this behavior into a class and provide the task's specific API we can simply use:

 

def __init__(self, *args):

self.contents = list(args)

f = FIFO(3,2,1)

for i in f:

 

This example does add to a couple of features which are easy in Python and allow this FIFO class to be used in ways that Python programmers might find more natural. Our ''__init__'' accepts and optional list of initial values, we add ''__len__'' and ''extend'' methods which simply wrap the corresponding list methods; we define a ''__call__'' method to show how one can make objects "callable" as functions, and we define ''__iter__'' and ''next()'' methods to facilitate using these FIFO objects with Python's prevalent iteration syntax (the ''for'' loop). The ''empty'' method could be implemented as simply an alias for ''__len__'' --- but we've chosen to have it more strictly conform to the task specification. Implementing the ''__len__'' method allows code using this object to test of emptiness using normal Python idioms for "truth" (any non-empty container is considered to be "true" and any empty container evaluates as "false").

That sort of wrapper looks like:

 

def __init__(self,*args):

self.contents = list(args)

if not self:

raise StopIteration

 

As noted in the contents this must NOT be a new-style class, it must NOT but sub-classed from ''object'' nor any of its descendents. (A new-style implementation using __getattribute__ would be possible)

Python 2.4 and later includes a [http://docs.python.org/lib/deque-objects.html deque class], supporting thread-safe, memory efficient appends and pops from either side of the deque with approximately the same O(1) performance in either direction. For other options see [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/68436 Python Cookbook].

 

fifo = deque()

fifo. appendleft(value) # push

value = fifo.pop()

not fifo # empty

 

=={{header|R}}==

===Simple functional implementation===

This simple implementation provides three functions that act on a variable in the global environment (user workspace) named ''l''. the push and pop functions display the new status of ''l'', but return NULL silently.

push <- function(x)

{

# list()

pop()

 

The problem with this is that the functions aren't related to the FIFO object (the list ''l''), and they require the list to exist in the global environment. (This second problem is possible to get round by passing ''l'' into the function and then returning it, but that is extra work.)

===Message passing===

 

queue <- function() {

v <- list()

# [1] 1

b("pop")

 

===Object oriented implementation===

A better solution is to use the object oriented facility in the proto package. (R does have it's own native object oriented code, though the proto package is often nicer to use.)

 

 

fifo <- proto(expr = {

fifo$pop()

fifo$pop()

 

=={{header|Racket}}==

Here's an explicit implementation:

 

#lang racket

 

(pop! Q) ; -> 'x

(list (pop! Q) (pop! Q) (pop! Q)) ; -> '(0 1 2)

 

And this is an implementation of a functional queue.

#lang racket

;; Invariants:

(push x q)))))

;; => 3

 

=={{header|REBOL}}==

Title: "FIFO"

URL: http://rosettacode.org/wiki/FIFO

while [not q/empty][print [" " q/pop]]

print rejoin ["Queue is " either q/empty [""]["not "] "empty."]

 

{{out}}

 

=={{header|REXX}}==

* &nbsp; '''PUSH''' &nbsp; &nbsp; (lifo)

* &nbsp; '''QUEUE''' &nbsp; (fifo)

it has to do with the number of lines not yet read in an open (for read) file.

-- Gerard Schildberger. -->

call viewQueue

a="Fred"

viewQueue: if queued()==0 then say 'Queue is empty'

else say 'There are' queued() 'elements in the queue'

'''output'''

<pre>

 

=={{header|Ring}}==

# Project : Queue/Definition

 

see "Error: queue is empty" + nl

ok

Output:

<pre>

Error: queue is empty

</pre>

 

=={{header|Ruby}}==

The core class ''Array'' already implements all queue operations, so this class ''FIFO'' delegates everything to methods of ''Array''.

 

 

# A FIFO queue contains elements in first-in, first-out order.

end

alias inspect to_s

 

f.empty? # => true

f.pop # => nil

g.pop(2) # => [:a, :b]

g.pop(2) # => [:c]

 

=={{header|Rust}}==

===Using the standard library===

The standard library has a double-ended queue implementation (<code>VecDeque<T></code>) which will work here.

fn main() {

let mut stack = VecDeque::new();

assert_eq!(Some("Element3"), stack.pop_front());

assert_eq!(None, stack.pop_front());

===A simple implementation===

This shows the implementation of a singly-linked queue with <code>dequeue</code> and <code>enqueue</code>. There are two <code>peek</code> implementations, one returns an immutable reference, the other returns a mutable one. This implementation also shows iteration over the Queue by value (consumes queue), immutable reference, and mutable reference.

 

pub struct Queue<T> {

})

}

 

=={{header|Scala}}==

private[this] class Node[T](val value:T) {

var next:Option[Node[T]]=None

override def toString()=iterator.mkString("Queue(", ", ", ")")

Usage:

println("isEmpty = " + q.isEmpty)

try{q dequeue} catch{case _:java.util.NoSuchElementException => println("dequeue(empty) failed.")}

println("dequeue = " + q.dequeue)

println("dequeue = " + q.dequeue)

{{out}}

<pre>isEmpty = true

in the vector to hold tail pointer to avoid the append call.

 

(make-vector 1 '()))

 

(vector-set! queue 0 (cdr (vector-ref queue 0)))

ret)))

 

=== Message passing ===

(let ((q (cons '() '())))

(lambda (cmd . arg)

; 6

(q 'get)

 

=={{header|Sidef}}==

Implemented as a class:

method pop {

array.is_empty && die "underflow";

array.len == 0;

}

 

=={{header|Slate}}==

Toy code based on Slate's Queue standard library (which is optimized for FIFO access):

 

q@(Queue traits) isEmpty [resend].

q@(Queue traits) pop [q removeFirst].

q@(Queue traits) pushAll: c [q addAllLast: c].

 

=={{header|Smalltalk}}==

An OrderedCollection can be easily used as a FIFO queue.

 

push: obj [ ^(self add: obj) ]

pop [

f pop printNl.

f isEmpty printNl.

 

=={{header|Standard ML}}==

Here is the signature for a basic queue:

signature QUEUE =

sig

val empty: 'a queue -> bool

end;

A very basic implementation of this signature backed by a list is as follows:

structure Queue:> QUEUE =

struct

| empty _ = false

end;

 

=={{header|Stata}}==

See [[Singly-linked list/Element definition#Stata]].

=={{header|Tcl}}==

Here's a simple implementation using a list:

upvar 1 $stackvar stack

lappend stack $value

peek Q ;# ==> foo

pop Q ;# ==> foo

 

{{tcllib|struct::queue}}

struct::queue Q

Q size ;# ==> 0

Q peek ;# ==> b

Q pop 4 ;# ==> b c d e

 

=={{header|UNIX Shell}}==

{{works with|ksh93}}

typeset -n q=$1

shift

typeset -n q=$1

print "${q[0]}"

 

Usage:

 

queue_empty foo && echo foo is empty || echo foo is not empty

print "peek: $(queue_peek foo)"; queue_pop foo

print "peek: $(queue_peek foo)"; queue_pop foo

 

{{out}}

peek:

queue foo is empty</pre>

 

=={{header|V}}==

V doesn't have mutable data. Below is an function interface for a fifo.

 

[fifo_push swap cons].

[fifo_pop [[*rest a] : [*rest] a] view].

 

Using it

=[5 4 3]

|fifo_empty? puts

=3 4 5

|fifo_empty? puts