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 equality checks use toList.

Queue.toList firstQueue == Queue.toList secondQueue

empty : Queue a

Construct empty Queue

singleton : a -> Queue a

Construct Queue containing single value

Queue.toList (Queue.singleton 1) == [ 1 ]

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 Queue.empty == 0


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

enqueue : a -> Queue a -> Queue a

Add item to Queue

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


Queue.size (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.size (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 ]

updateFront : (Maybe a -> Maybe a) -> Queue a -> Queue a

Update value at the front of the queue

Queue.toList (Queue.updateFront (Maybe.map (\x -> x + 1)) (Queue.singleton 3)) == [ 4 ]


Queue.toList (Queue.updateFront (Maybe.map (\_ -> Just 42)) Queue.empty) == [ 42 ]


Queue.toList (Queue.updateFront (Maybe.map (\_ -> Nothing)) (Queue.singleton 3)) == []

Modules

Queue