Creates a FIFO queue.
@eryx/queue Module
Queue data structures.
This module provides three small queue-shaped containers:
Queuefor ordinary FIFO usageDequefor pushing/popping at both endsPriorityQueuefor heap-backed min/max priority scheduling
PriorityQueue is implemented as a proper class-style heap queue rather
than as raw heap-list helpers. Linear-time heapify constructors are
provided for priorities, plain items with a priority extractor, and
explicit (item, priority) entries.
Summary
Functions
Queue:dequeue<T>() → T
Queue:peek<T>() → T
Queue:clear<T>() → ()
Queue:toArray<T>() → { T }
Deque:popFront<T>() → T
Deque:popBack<T>() → T
Deque:peekFront<T>() → T
Deque:peekBack<T>() → T
Deque:clear<T>() → ()
Deque:toArray<T>() → { T }
PriorityQueue.fromPriorities<P>(priorities: { P }, options: PriorityQueueOptions<P, P>?) → PriorityQueue<P, P>
PriorityQueue.from<T, P>(items: { T }, priority: ((item: T) → P), options: PriorityQueueOptions<T, P>?) → PriorityQueue<T, P>
PriorityQueue.fromEntries<T, P>(entries: { PriorityQueueEntry<T, P> }, options: PriorityQueueOptions<T, P>?) → PriorityQueue<T, P>
PriorityQueue:pop<T, P>() → T
PriorityQueue:peek<T, P>() → T
PriorityQueue:pushPop<T, P>(item: T, priority: P?) → T
PriorityQueue:replace<T, P>(item: T, priority: P?) → T
PriorityQueue:clear<T, P>() → ()
PriorityQueue:toHeapArray<T, P>() → { T }
PriorityQueue:toSortedArray<T, P>() → { T }
API Reference
Functions
Queue.new
Parameters
items: { T }?
Optional initial values in dequeue order.
Returns
Queue
Queue.from
Builds a FIFO queue from an array.
Parameters
items: { T }
Initial values in dequeue order.
Returns
Queue
Queue:enqueue
Parameters
item: T
Value to append at the back.
Returns
Queue
Queue:dequeue
Removes and returns the front item.
Errors when the queue is empty.
Queue:dequeue<T>() → T
Returns
T
T The removed item.
Queue:peek
Returns the front item without removing it.
Errors when the queue is empty.
Queue:peek<T>() → T
Returns
T
T The next item.
Queue:isEmpty
Returns
boolean true when the queue has no items.
Queue:clear
Removes all items from the queue.
Queue:clear<T>() → ()
Queue:toArray
Queue:toArray<T>() → { T }
Returns
{ T }
{ T } A shallow array snapshot in dequeue order.
Queue.__iter
Returns the generalized-iteration triple for front-to-back traversal.
Returns
ArrayIterator<T>
generator, state, index Triple consumed by Luau's for ... in protocol.
Deque.new
Creates a double-ended queue.
Parameters
items: { T }?
Optional initial values from front to back.
Returns
Deque
Deque.from
Builds a deque from an array.
Parameters
items: { T }
Initial values from front to back.
Returns
Deque
Deque:pushFront
Parameters
item: T
Value to prepend at the front.
Returns
Deque
Deque:pushBack
Parameters
item: T
Value to append at the back.
Returns
Deque
Deque:popFront
Removes and returns the front item.
Errors when the deque is empty.
Deque:popFront<T>() → T
Returns
T
T The removed item.
Deque:popBack
Removes and returns the back item.
Errors when the deque is empty.
Deque:popBack<T>() → T
Returns
T
T The removed item.
Deque:peekFront
Returns the front item without removing it.
Errors when the deque is empty.
Deque:peekFront<T>() → T
Returns
T
T The next front item.
Deque:peekBack
Returns the back item without removing it.
Errors when the deque is empty.
Deque:peekBack<T>() → T
Returns
T
T The next back item.
Deque:isEmpty
Returns
boolean true when the deque has no items.
Deque:clear
Removes all items from the deque.
Deque:clear<T>() → ()
Deque:toArray
Deque:toArray<T>() → { T }
Returns
{ T }
{ T } A shallow array snapshot from front to back.
Deque.__iter
Returns the generalized-iteration triple for front-to-back traversal.
Returns
ArrayIterator<T>
generator, state, index Triple consumed by Luau's for ... in protocol.
PriorityQueue.new
Creates a heap-backed priority queue.
By default this behaves as a min-priority queue. Callers may either:
- push
(item, priority)pairs directly, or - configure a default priority extractor for future
push(item)calls
Parameters
Optional ordering, comparison, stability, and default priority extraction.
Returns
PriorityQueue<T, P> A new empty priority queue.
PriorityQueue.fromPriorities
Builds a priority queue from an array of raw priority values in linear time.
PriorityQueue.fromPriorities<P>(priorities: { P }, options: PriorityQueueOptions<P, P>?) → PriorityQueue<P, P>
Parameters
priorities: { P }
Initial priorities to heapify.
Optional ordering, comparison, and stability hooks.
Returns
PriorityQueue<P, P> A heapified queue.
PriorityQueue.from
Builds a priority queue from an array of items in linear time.
PriorityQueue.from<T, P>(items: { T }, priority: ((item: T) → P), options: PriorityQueueOptions<T, P>?) → PriorityQueue<T, P>
Parameters
items: { T }
Initial items to heapify.
priority: ((item: T) → P)
Extracts a priority from each item.
Optional ordering, comparison, and stability hooks.
Returns
PriorityQueue<T, P> A heapified queue.
PriorityQueue.fromEntries
Builds a priority queue from explicit (item, priority) entries in
linear time.
PriorityQueue.fromEntries<T, P>(entries: { PriorityQueueEntry<T, P> }, options: PriorityQueueOptions<T, P>?) → PriorityQueue<T, P>
Parameters
Initial entries to heapify.
Optional ordering, comparison, and stability hooks.
Returns
PriorityQueue<T, P> A heapified queue.
PriorityQueue:push
Parameters
item: T
Value to enqueue.
priority: P?
Optional explicit priority override for this item.
Returns
PriorityQueue<T, P> Enables chaining.
PriorityQueue:pop
Removes and returns the next item by priority.
Errors when the queue is empty.
PriorityQueue:pop<T, P>() → T
Returns
T
T The removed item.
PriorityQueue:popEntry
Removes and returns the next (item, priority) entry.
Errors when the queue is empty.
Returns
PriorityQueueEntry<T, P> The removed entry.
PriorityQueue:peek
Returns the next item by priority without removing it.
Errors when the queue is empty.
PriorityQueue:peek<T, P>() → T
Returns
T
T The next item.
PriorityQueue:peekEntry
Returns the next (item, priority) entry without removing it.
Errors when the queue is empty.
Returns
PriorityQueueEntry<T, P> The next entry.
PriorityQueue:pushPop
Pushes a new item, then pops and returns the next item by priority.
When the queue is empty, this returns the pushed item.
PriorityQueue:pushPop<T, P>(item: T, priority: P?) → T
Parameters
item: T
Value to enqueue.
priority: P?
Optional explicit priority override for this item.
Returns
T
T The item that was removed.
PriorityQueue:replace
Pops the current next item by priority, then inserts the replacement.
This is the queue-shaped equivalent of Python's heapreplace.
Errors when the queue is empty.
PriorityQueue:replace<T, P>(item: T, priority: P?) → T
Parameters
item: T
Replacement value to enqueue.
priority: P?
Optional explicit priority override for the replacement.
Returns
T
T The item that was removed.
PriorityQueue:isEmpty
Returns
boolean true when the priority queue has no items.
PriorityQueue:clear
Removes all items from the priority queue.
PriorityQueue:clear<T, P>() → ()
PriorityQueue:toHeapArray
Returns a shallow snapshot of items in internal heap layout.
This result is not priority-sorted; it reflects heap structure only.
PriorityQueue:toHeapArray<T, P>() → { T }
Returns
{ T }
{ T } A shallow item snapshot in heap order.
PriorityQueue:toHeapEntries
Returns a shallow snapshot of entries in internal heap layout.
This result is not priority-sorted; it reflects heap structure only. Hidden stability bookkeeping such as insertion sequence is not exposed.
Returns
{ PriorityQueueEntry<T, P> } A shallow entry snapshot in heap order.
PriorityQueue:toSortedArray
Returns items in pop order without mutating the original queue.
PriorityQueue:toSortedArray<T, P>() → { T }
Returns
{ T }
{ T } A shallow item snapshot in priority-sorted order.
PriorityQueue:toSortedEntries
Returns entries in pop order without mutating the original queue.
Hidden stability bookkeeping such as insertion sequence is not exposed.
Returns
{ PriorityQueueEntry<T, P> } A shallow entry snapshot in priority-sorted order.
PriorityQueue:clone
Returns a shallow copy of this priority queue.
When stability is enabled, cloned queues preserve insertion-order tiebreak behavior.
Returns
PriorityQueue<T, P> A shallow copy of this priority queue.
Types
Queue<T>
Implements: QueueMethods
_items: { T }
Deque<T>
Implements: DequeMethods
_items: { T }
PriorityQueueOrder
PriorityQueueEntry<T, P>
item: T
priority: P
PriorityQueueOptions<T, P>
type PriorityQueueOptions<T, P> = {
order: PriorityQueueOrder?,
less: (((a: P, b: P) → boolean))?,
stable: boolean?
}
PriorityQueueNewOptions<T, P>
type PriorityQueueNewOptions<T, P> = {
order: PriorityQueueOrder?,
less: (((a: P, b: P) → boolean))?,
stable: boolean?,
priority: (((item: T) → P))?
}
priority: (((item: T) → P))?
PriorityQueue<T, P>
type PriorityQueue<T, P> = PriorityQueueMethods<T, P> & {
_heap: { PriorityQueueHeapEntry<T, P> },
_order: PriorityQueueOrder,
_priority: (((item: T) → P))?,
_less: (((a: P, b: P) → boolean))?,
_stable: boolean,
_sequence: number,
size: number
}
Implements: PriorityQueueMethods
_heap: { PriorityQueueHeapEntry<T, P> }
_priority: (((item: T) → P))?