Queue/Usage: Difference between revisions

 

=={{header|11l}}==

 

my_queue.append(‘foo’)

print(my_queue.pop_left())

print(my_queue.pop_left())

 

{{out}}

bar

baz

</pre>

 

=={{header|8th}}==

10 q:new \ create a new queue 10 deep

123 q:push

q:pop . cr \ displays 341

q:len . cr \ displays 0

 

=={{header|Ada}}==

with Ada.Text_Io; use Ada.Text_Io;

Pop (Queue, Value);

Put_Line ("Is_Empty " & Boolean'Image (Is_Empty (Queue)));

Sample output:

<pre>Is_Empty TRUE</pre>

'''File: prelude/link.a68''' c.f. [[Queue/Definition#ALGOL 68|Queue/Definition]]<br>

'''File: prelude/queue_base.a68''' c.f. [[Queue/Definition#ALGOL 68|Queue/Definition]]<br>

MODE DIETITEM = STRUCT(

STRING food, annual quantity, units, REAL cost

("Wheat Flour", "370","lb.", 13.33),

("Total Annual Cost", "","", 39.93)

# -*- coding: utf-8 -*- #

 

# OR example queue ISNT obj queue empty #

printf((diet item fmt, obj queue get(example queue), $l$))

<pre>

Get remaining values from queue:

 

=={{header|AppleScript}}==

set StackRef's contents to {value} & StackRef's contents

return StackRef

pop(a reference to theStack)

log result

(*2, 1*)

(*3, 2, 1*)

=={{header|Arturo}}==

 

 

 

 

 

 

 

 

 

 

{{out}}

 

 

=={{header|Astro}}==

 

my_queue.push!('foo')

print my_queue.pop!() # 'foo'

print my_queue.pop!() # 'bar'

 

=={{header|AutoHotkey}}==

 

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

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

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

 

{{works with|BBC BASIC for Windows}}

FOR n = 3 TO 5

= (rptr% = wptr%)

ENDCASE

'''Output:'''

<pre>

 

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

| out$"Attempt to dequeue failed"

)

Output:

<pre>1

=={{header|C}}==

See [[FIFO]] for the needed code.

#include <stdlib.h>

#include <stdbool.h>

 

exit(0);

 

=={{header|C sharp}}==

In C# we can use the Queue<T> class in the .NET 2.0 framework.

using System.Collections.Generic;

 

}

}

 

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

Note that with C++'s standard queue, accessing the first element of the queue and removing it are two separate operations, <tt>front()</tt> and <tt>pop()</tt>.

#include <cassert> // for run time assertions

 

q.pop();

assert( q.empty() );

 

Note that the container used to store the queue elements can be specified explicitly; to use a linked linst instead of a deque (the latter is the default), just replace the definition of <tt>q</tt> to

 

(and add <tt>#include <list></tt>, of course). Also note that the containers can be used directly; in that case <tt>push</tt> and <tt>pop</tt> have to be replaced by <tt>push_back</tt> and <tt>pop_front</tt>.

=={{header|Clojure}}==

Using the implementation from [[FIFO]]:

 

(enqueue q 1)

(dequeue q) ; 3

 

Or use a java implementation:

 

(.add q 1)

(.remove q) ; 3

 

 

=={{header|CoffeeScript}}==

# We build a Queue on top of an ordinary JS array, which supports push

# and shift. For simple queues, it might make sense to just use arrays

catch e

console.log "#{e}"

output

> coffee queue.coffee

1

100000

Error: queue is empty

 

=={{header|Common Lisp}}==

Using the implementation from [[FIFO]].

 

(enqueue 38 queue)

(assert (not (queue-empty-p queue)))

(assert (eql 38 (dequeue queue)))

(assert (eql 23 (dequeue queue)))

 

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

BlackBox Component Builder

MODULE UseQueue;

IMPORT

END Do;

END UseQueue.

Execute: ^Q UseQueue.Do<br/>

Output:

in a file named <code>queue.coh</code>.

 

 

typedef QueueData is uint8; # the queue will contain bytes

 

# free the queue

 

{{out}}

 

=={{header|D}}==

private static struct Node {

T data;

assert(q.pop() == 30);

assert(q.empty());

 

===Faster Version===

This versions creates a circular queue able to grow. Define "queue_usage2_main" to run the main and its tests.

 

import std.traits: hasIndirections;

}

}

 

=={{header|Delphi}}==

Generics were added in Delphi2009.

 

 

{$APPTYPE CONSOLE}

lStringQueue.Free;

end

 

Output:

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

This uses the definition from [[Queue/Definition#Déjà Vu]]

!. empty Q

enqueue Q "HELLO"

!. dequeue Q

!. empty Q

{{out}}

<pre>true

queue.deja:28

queue.deja:10 in dequeue</pre>

 

=={{header|E}}==

Using the implementation from [[FIFO]].

 

require(escape empty { reader.dequeue(empty); false } catch _ { true })

writer.enqueue(1)

require(reader.dequeue(throw) == 2)

require(reader.dequeue(throw) == 3)

 

E also has queues in the standard library such as <code>&lt;import:org.erights.e.examples.concurrency.makeQueue></code>, but they are designed for concurrency purposes and do not report emptiness but rather return a promise for the next element.

 

=={{header|Elena}}==

import extensions;

var queue := new Queue();

// "Pop" items from the queue in FIFO order

// If we try to pop from an empty queue, an exception

// is thrown.

 

=={{header|Elisa}}==

=={{header|Elixir}}==

Here a list is used as Queue.

defmodule Queue do

def empty?([]), do: true

def front([h|_]), do: h

end

Example:

iex(2)> q = [1,2,3,4,5]

[1, 2, 3, 4, 5]

iex(8)> Queue.empty?(l)

true

 

=={{header|Erlang}}==

All functions, from the shell:

{fifo,[],[]}

2> fifo:empty(Q).

8> fifo:pop(fifo:new()).

** exception error: 'empty fifo'

 

Crashing is the normal expected behavior in Erlang: let it crash, a supervisor will take responsibility of restarting processes, or the caller will take care of it. Only program for the successful cases.

=={{header|Factor}}==

For this task, we'll use Factor's <code>deque</code> vocabulary (short for double-ended queue). The <code>deque</code> class is a mixin, one of whose instances is <code>dlist</code> (double-linked list). Hence, the deque protocol works with double-linked lists. When using a deque as a queue, the convention is to queue elements with <code>push-front</code> and deque them with <code>pop-back</code>.

IN: rosetta-code.queue-usage

 

[ pop-back drop ] ! pop 3 (and discard)

[ deque-empty? . ] ! t

Alternatively, batch operations can be used.

[ [ { 1 2 3 } ] dip push-all-front ] ! push all from sequence

[ . ] ! DL{ 3 2 1 }

[ [ drop ] slurp-deque ] ! pop and discard all

[ deque-empty? . ] ! t

 

=={{header|Fantom}}==

Using definition of Queue in: [[Queue/Definition]] task.

 

class Main

{

}

}

 

Output:

And a Forth version using some new features of Forth 2012, dynamic memory allocation and a linked list can be seen here:<BR> http://rosettacode.org/wiki/Queue/Definition#Linked_list_version

 

create \ compile time: build the data structure in memory

dup

r@ ->cnt 1+! \ incr. the counter

r@ head++

 

Create 2 Queues and test the operators at the Forth console interactively

=== Version for the [[FIFO#Linked_list_version|Linked List implementation]] ===

 

make-queue constant q1

make-queue constant q2

q2 dequeue .

q2 empty? .

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

 

type fifo_node

integer :: datum

end do

 

 

=={{header|FreeBASIC}}==

As FreeBASIC does not have a built-in Queue type, I am reusing the type I wrote for the [[Queue/Definition]] task:

 

#Include "queue_rosetta.bi" '' include macro-based generic Queue type used in earlier task

Print

Print "Press any key to quit"

 

{{out}}

===With Queue/Definition code===

Solution using [[Queue/Definition#Go|package]] from the [[Queue/Definition]] task:

 

import (

}

}

Output:

<pre>

===With channels===

Go buffered channels are FIFO, and better, are concurrency-safe (if you have an application for that.) Code below is same as code above only with Go channels rather than the home made queue implementation. Note that you don't have to start concurrent goroutines to use channels, they are useful all on their own. Other differences worth noting: Buffered channels are not dynamically resizable. This is a good thing, as queues that can grow without limit allow ugly bugs that consume memory and grind to a halt. Also blocking operations (as seen here with push) are probably a bad idea with a single goroutine. Much safer to use non-blocking operations that handle success and failure (the way pop is done here.)

 

import "fmt"

}

}

===With linked lists===

 

import (

}

}

 

=={{header|Groovy}}==

 

Solution:

 

Test:

println q

// "push" adds to end of "queue" list

println q

assert q.empty

 

Output:

Running the code from [[Queue/Definition#Haskell]] through GHC's interpreter.

 

Prelude> :l fifo.hs

[1 of 1] Compiling Main ( fifo.hs, interpreted )

*Main> v''''

Nothing

 

=={{header|Icon}} and {{header|Unicon}}==

Icon and Unicon provide built-in queue and stack functions.

queue := []

write("Usage:\nqueue x x x - x - - - - -\n\t- pops elements\n\teverything else pushes")

procedure empty(X) #: fail if X is not empty

if *X = 0 then return

 

Sample output: <pre>queue - 1 3 4 5 6 - - - - - - - -

This is an interactive J session:

 

isEmpty__queue ''

1

7

isEmpty__queue ''

 

Using function-level FIFO queue implementation from [[FIFO#J|FIFO]]

 

This is an interactive J session:

1

first_named_state =: push 9 onto make_empty _

7

is_empty pop pop pop this_state

 

=={{header|Java}}==

{{works with|Java|1.5+}}

LinkedList can always be used as a queue or stack, but not in conjunction with the Stack object provided by Java. To use a LinkedList as a stack, use the <tt>push</tt> and <tt>pop</tt> methods. A LinkedList can also be used as a double-ended queue (deque); LinkedList has implemented the Deque interface since Java 1.6+.

import java.util.Queue;

...

System.out.println(queue.remove()); // 1

System.out.println(queue); // [2, 3]

 

You can also use "offer" and "poll" methods instead of "add" and "remove", respectively. They indicate errors with the return value instead of throwing an exception.

 

{{works with|Java|1.4}}

...

LinkedList queue = new LinkedList();

System.out.println(queue.removeFirst()); // 1

System.out.println(queue); // [2, 3]

 

=={{header|JavaScript}}==

JavaScript arrays can be used as FIFOs.

print(f.length);

f.push(1,2); // can take multiple arguments

print(f.shift())

print(f.length == 0);

 

outputs:

{{works with|Julia|0.6}}

 

 

queue = Queue(String)

@show enqueue!(queue, "bar")

@show dequeue!(queue) # -> foo

 

=={{header|Kotlin}}==

The related [[Queue/Definition]] task, where we wrote our own Queue class, intimated that we should use the language's built-in queue for this task so that's what I'm going to do here, using Java collection types as Kotlin doesn't have a Queue type in its standard library:

 

import java.util.*

println("Can't remove elements from an empty queue")

}

 

{{out}}

Can't remove elements from an empty queue

</pre>

 

=={{header|Lasso}}==

</pre>

Example:

local(queue) = queue

#queue->size

#queue->size == 0

// => true

 

=={{header|Logo}}==

UCB Logo comes with a protocol for treating lists as queues.

 

print empty? :fifo ; true

queue "fifo 1

print dequeue "fifo ; 1

show :fifo ; [2 3]

 

=={{header|Lua}}==

Uses the queue-definition given at [[Queue/Definition#Lua]]

Queue.push( q, 5 )

Queue.push( q, "abc" )

while not Queue.empty( q ) do

print( Queue.pop( q ) )

 

One can also just use a regular Lua table (shown here in interactive mode):

 

> q = {}

> -- push:

> -- empty?

> =#q == 0

 

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

 

 

a=stack

Stack a {

Print StackType$(a, 1)="String", StackType$(a,2)="Number"

}

 

=={{header|Maple}}==

There are more builtin operations like reverse(), length(),etc.

queue[enqueue](q,1);

queue[enqueue](q,2);

>>>3

queue[empty](q);

 

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

SetAttributes[Pop, HoldAllComplete]; Pop[a_] := If[EmptyQ[a], False, b = First[a]; Set[a, Most[a]]; b]

->1

Pop[Queue]

 

=={{header|Nemerle}}==

The <tt>Nemerle.Collections</tt> namespace contains an implementation of a Queue.

def empty = q.IsEmpty(); // true at this point

q.Push(empty); // or Enqueue(), or Add()

 

=={{header|NetRexx}}==

 

The demonstration employs an in-line deployment of a queue object having as it's underlying implementation a <code>java.util.Deque</code> interface instanciated as a <code>java.util.ArrayDeque</code>. Typically this queue implementation would reside outside of the demonstration program and be imported at run-time rather than within the body of this source.

options replace format comments java crossref savelog symbols nobinary

 

method isFalse public constant binary returns boolean

return \isTrue

;Output

<pre>

 

=={{header|Nim}}==

 

 

{{out}}

 

=={{header|Objeck}}==

class Test {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|OCaml}}==

val q : '_a Queue.t = <abstr>

# Queue.is_empty q;;

- : int = 4

# Queue.is_empty q;;

 

=={{header|Oforth}}==

Using FIFO implementation :

 

| q i |

Queue new ->q

20 loop: i [ i q push ]

 

=={{header|ooRexx}}==

ooRexx includes a built-in queue class.

q = .queue~new -- create an instance

q~queue(3) -- adds to the end, but this is at the front

q~queue(2) -- add to the end

say q~pull q~pull q~pull q~isempty -- should display all and be empty

Output:

<pre>

 

=={{header|Oz}}==

[Queue] = {Link ['x-oz://system/adt/Queue.ozf']}

MyQueue = {Queue.new}

{Show {MyQueue.get}} %% foo

{Show {MyQueue.get}} %% bar

 

=={{header|Perl}}==

Perl has built-in support to these operations:

 

push @queue, (1..5); # enqueue numbers from 1 to 5

print $n while($n = shift @queue); # dequeue all

print "\n";

Output:

2345

 

=={{header|Phix}}==

Using the implementation from [[Queue/Definition#Phix|Queue/Definition]]

 

=={{header|PHP}}==

{{works with|PHP|5.3+}}

$queue = new SplQueue;

echo $queue->isEmpty() ? 'true' : 'false', "\n"; // empty test - returns true

echo $queue->dequeue(), "\n"; // returns 1

echo $queue->isEmpty() ? 'true' : 'false', "\n"; // returns false

 

=={{header|PicoLisp}}==

Using the implementation from [[FIFO]]:

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

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

(println (fifo 'Queue)) # and a list (abc)

Output:

<pre>1

 

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

test: proc options (main);

 

end;

end test;

The output:

1

3

17

19

 

=={{header|PostScript}}==

{{libheader|initlib}}

[1 2 3 4 5] 6 exch tadd

= [1 2 3 4 5 6]

[] empty?

=true

 

=={{header|PowerShell}}==

{{works with|PowerShell|4.0}}

 

[System.Collections.ArrayList]$queue = @()

# isEmpty?

}

"the queue contains : $queue"

<b>Output:</b>

<pre>

===PowerShell using the .NET Queue Class===

Declare a new queue:

$queue = New-Object -TypeName System.Collections.Queue

#or

$queue = [System.Collections.Queue] @()

Show the methods and properties of the queue object:

Get-Member -InputObject $queue

{{Out}}

<pre>

</pre>

Put some stuff in the queue:

1,2,3 | ForEach-Object {$queue.Enqueue($_)}

Take a peek at the head of the queue:

$queue.Peek()

{{Out}}

<pre>

</pre>

Pop the head of the queue:

$queue.Dequeue()

{{Out}}

<pre>

</pre>

Clear the queue:

$queue.Clear()

Test if queue is empty:

if (-not $queue.Count) {"Queue is empty"}

{{Out}}

<pre>

Works with SWI-Prolog.

 

%% definitions of queue

empty(U-V) :-

write('Pop the queue : '),

pop(Q4, _V, _Q5).

Output :

<pre>?- queue.

 

=={{header|PureBasic}}==

 

Procedure Push(n)

Debug Pop()

Wend

 

'''Outputs

 

=={{header|Python}}==

my_queue = Queue.Queue()

my_queue.put("foo")

print my_queue.get() # foo

print my_queue.get() # bar

 

=={{header|Quackery}}==

 

[ nested join ] is push ( q x --> q )

[ behead ] is pop ( q --> q x )

 

'''Demonstrating operations in Quackery shell:'''

<pre>/O> queue

 

=={{header|Racket}}==

 

(require data/queue)

(dequeue! queue) ; 'green

 

 

=={{header|Raku}}==

 

Raku maintains the same list operators of Perl 5, for this task, the operations are:

pop (aka dequeue) -- @list.shift

but there's also @list.pop which removes a item from the end,

and @list.unshift which add a item on the start of the list.<br/>

Example:

 

@queue.push('b', 'c'); # [ a, b, c ]

 

@queue.unshift('A'); # [ A, b ]

 

=={{header|REBOL}}==

See [[FIFO#REBOL]] for implementation. Example repeated here for completeness.

 

 

q: make fifo []

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

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

 

Output:

 

The entries in the stack may be anything, including "nulls".

say '══════════════════════════════════ Pushing five values to the stack.'

do j=1 for 4 /*a DO loop to PUSH four values. */

push: queue arg(1); return /*(The REXX QUEUE is FIFO.) */

pop: procedure; parse pull x; return x /*REXX PULL removes a stack item. */

{{out|output|text=:}}

<pre>

 

=={{header|Ruby}}==

 

=={{header|Rust}}==

 

fn main() {

}

}

 

=={{header|Scala}}==

println("isEmpty = " + q.isEmpty)

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

println("dequeue = " + q.dequeue)

println("dequeue = " + q.dequeue)

Output:

<pre>isEmpty = true

=={{header|Sidef}}==

Using the class defined at [[FIFO#Sidef]]

say f.empty; # true

f.push('foo');

var g = FIFO('xxx', 'yyy');

say g.pop; # xxx

 

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

{{works with|SML/NJ}}

; Functional interface

opening Fifo

datatype 'a fifo = ...

val v''' = 4 : int

- isEmpty q'''''';

 

{{works with|SML/NJ}}

; Imperative interface

opening Queue

type 'a queue

val it = 4 : int

- isEmpty q;

 

=={{header|Stata}}==

=={{header|Tcl}}==

See [[FIFO#Tcl|FIFO]] for operation implementations:

empty Q ;# ==> 1 (true)

push Q foo

peek Q ;# ==> foo

pop Q ;# ==> foo

 

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

{{works with|ksh93}}

See [[Queue/Definition#UNIX_Shell|Queue/Definition]] for implementation:

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

 

Output:

See [[Queue/Definition#VBA]] for implementation.

The FiFo queue has been implemented with Collection. queue.count will return number of items in the queue. queue(i) will return the i-th item in the queue.

push "One"

push "Two"

push "Three"

Debug.Print pop, pop, pop, empty_

<pre>One Two Three True</pre>

 

=={{header|Wren}}==

{{libheader|Wren-queue}}

 

var q = Queue.new()

q.clear()

System.print("Queue cleared")

 

{{out}}

 

=={{header|XPL0}}==

def Size=8;

int Fifo(Size);

ChOut(0, ChIn(8)); CrLf(0); \pop

ChOut(0, ChIn(8)); CrLf(0); \pop

 

Output:

 

=={{header|Yabasic}}==

queue$ = queue$ + x$ + "#"

end sub

wend

 

 

{{out}}