Queue

Queue is simple FIFO (first in, first out) datastructure.

Type

Equality checks (==) on Queue are unreliable due to dynamic distribution of elements.

If you need need qeuality checks use toList.

Queue.toList firstQueue == Queue.toList secondQueue

empty : Queue a

Construct empty Queue

Query

isEmpty : Queue a -> Bool

Determine if Queue is empty

Queue.isEmpty Queue.empty == True


Queue.isEmpty (Queue.fromList [ 1, 2 ]) == False

size : Queue a -> Int

Get size of Queue

Queue.size empty == 0
Queue.size (Queue.fromList [ 1, 2 ]) = 2

enqueue : a -> Queue a -> Queue a

Add item to Queue

Queue.length (Queue.enqueue 1 Queue.empty) == 1


Queue.length (Queue.enqueue 1 (Queue.fromList [ 1, 2 ])) == 3

dequeue : Queue a -> ( Maybe a, Queue a )

Take item from Queue

Queue.dequeue Queue.empty == ( Nothing, Queue.empty )


Queue.dequeue (Queue.fromList [ 1 ]) == ( Just 1, Queue.empty )

front : Queue a -> Maybe a

Ask for front item without removing it from Queue

Queue.front Queue.empty == Nothing


Queue.front (Queue.fromList [ 1, 2 ]) == Just 1

Lists

fromList : List a -> Queue a

Build Queue from List

Queue.fromList [] == Queue.empty
Queue.length (Queue.fromList [ 1, 2, 3 ])) == 3

toList : Queue a -> List a

Convert Queue to List

Queue.toList (Queue.fromList []) == []


Queue.toList (Queue.fromList [ 1, 2, 3 ]) == [ 1, 2, 3 ]

Transformations

map : (a -> b) -> Queue a -> Queue b

Map function over Queue

Queue.toList (Queue.map identity (Queue.fromList [ 1, 2 ])) == [ 1, 2 ]


Queue.toList (Queue.map ((+) 1) (Queue.fromList [ 1, 2 ])) == [ 2, 3 ]

filter : (a -> Bool) -> Queue a -> Queue a

Filter items items in Queue

Queue.toList (Queue.filter identity (Queue.fromList [ True, False ])) == [ True ]


Queue.toList (Queue.filter ((<) 1) (Queue.fromList [ 1, 2 ])) == [ 2 ]

Modules

Queue