gleam/queue
Types
Queue
A queue is an order collection of elements. It is similar to a list, but unlike a list elements can be added to or removed from either the front or the back in a performant fashion.
The internal representation may be different for two queues with the same elements in the same order if the queues were constructed in different ways. This is the price paid for a queue's fast access at both the front and the back.
Because of unpredictable internal representation the equality operator ==
may return surprising results, and the is_equal
and is_logically_equal
functions are the recommended way to test queues for equality.
pub opaque type Queue(element)
Functions
from_list
pub fn from_list(list: List(a)) -> Queue(a)
Convert a list of elements into a queue of the same elements in the same order.
This function runs in constant time.
Examples
> [1, 2, 3] |> from_list |> length
3
is_empty
pub fn is_empty(queue: Queue(a)) -> Bool
Determine whether or not the queue is empty.
This function runs in constant time.
Examples
> [] |> from_list |> is_empty
True
> [1] |> from_list |> is_empty
False
> [1, 2] |> from_list |> is_empty
False
is_equal
pub fn is_equal(a: Queue(a), to b: Queue(a)) -> Bool
Check whether two queues have the same elements in the same order.
This function is useful as the internal representation may be different for
two queues with the same elements in the same order depending on how they
were constructed, so the equality operator ==
may return surprising
results.
This function runs in linear time.
is_logically_equal
pub fn is_logically_equal( a: Queue(a), to b: Queue(a), checking element_is_equal: fn(a, a) -> Bool, ) -> Bool
Check whether two queues have equal elements in the same order, where the equality of elements is determined by a given equality checking function.
This function is useful as the internal representation may be different for
two queues with the same elements in the same order depending on how they
were constructed, so the equality operator ==
may return surprising
results.
This function runs in linear time multiplied by the time taken by the element equality checking function.
length
pub fn length(queue: Queue(a)) -> Int
Count the number of elements in a given queue.
This function has to traverse the queue to determine the number of elements, so it runs in linear time.
Examples
> length(from_list([]))
0
> length(from_list([1]))
1
> length(from_list([1, 2]))
2
pop_back
pub fn pop_back( from queue: Queue(a), ) -> Result(tuple(a, Queue(a)), Nil)
Get the first element from the back of the of the queue, returning the element and a new queue without that element.
This function typically runs in constant time, but will occasionally run in linear time.
Examples
> queue.new()
> |> queue.push_front(0)
> |> queue.push_back(1)
> |> queue.pop_back()
Ok(tuple(1, queue.push_front(queue.new(), 0)))
> queue.new()
> |> queue.push_front(0)
> |> queue.pop_back()
Ok(tuple(0, queue.new()))
> queue.new()
> |> queue.pop_back()
Error(Nil)
pop_front
pub fn pop_front( from queue: Queue(a), ) -> Result(tuple(a, Queue(a)), Nil)
Get the first element from the front of the of the queue, returning the element and a new queue without that element.
This function typically runs in constant time, but will occasionally run in linear time.
Examples
> queue.new()
> |> queue.push_front(0)
> |> queue.push_back(1)
> |> queue.pop_front()
Ok(tuple(0, queue.push_back(queue.new(), 1)))
> queue.new()
> |> queue.push_back(0)
> |> queue.pop_front()
Ok(tuple(0, queue.new()))
> queue.new()
> |> queue.pop_back()
Error(Nil)
push_back
pub fn push_back(onto queue: Queue(a), this item: a) -> Queue(a)
Push an element onto the back of the queue.
Examples
> [0, 0] |> from_list |> push_back(1) |> to_list
[0, 0, 1]
push_front
pub fn push_front(onto queue: Queue(a), this item: a) -> Queue(a)
Push an element onto the front of the queue.
Examples
> [0, 0] |> from_list |> push_front(1) |> to_list
[1, 0, 0]
reverse
pub fn reverse(queue: Queue(a)) -> Queue(a)
Create a new queue from a given queue containing the same elements, but in the opposite order.
This function runs in constant time.
Examples
> reverse(from_list([]))
[]
> reverse(from_list([1]))
[1]
> reverse(from_list([1, 2]))
[2, 1]
to_list
pub fn to_list(queue: Queue(a)) -> List(a)
Convert a queue of elements into a list of the same elements in the same order.
This function runs in linear time.
Examples
> new() |> push_back(1) |> push_back(2) |> to_list
[1, 2]