A priority queue where keys of type k are annotated with values of type a. The queue supports extracting the key-value pair with minimum key.

\(O(1)\). Returns the empty priority queue.

\(O(1)\). Constructs a singleton priority queue.

Amortized \(O(1)\), worst-case \(O(\log n)\). Inserts an element with the specified key into the queue.

\(O(n)\) (an earlier implementation had \(O(1)\) but was buggy). Insert an element with the specified key into the priority queue, putting it behind elements whose key compares equal to the inserted one.

Amortized \(O(\log \min(n_1,n_2))\), worst-case \(O(\log \max(n_1,n_2))\). Returns the union of the two specified queues.

The union of a list of queues: (unions == foldl union empty).

\(O(1)\). Checks if this priority queue is empty.

\(O(1)\). Returns the size of this priority queue.

\(O(1)\). The minimal (key, element) in the queue. Calls error if empty.

\(O(1)\). The minimal (key, element) in the queue, if the queue is nonempty.

\(O(\log n)\). Deletes the minimal (key, element) in the queue. Returns an empty queue if the queue is empty.

\(O(\log n)\). Delete and find the element with the minimum key. Calls error if empty.

\(O(1)\). Alter the value at the minimum key. If the queue is empty, does nothing.

\(O(1)\). Alter the value at the minimum key in an Applicative context. If the queue is empty, does nothing.

Since: 1.4.2

\(O(1)\). Alter the value at the minimum key. If the queue is empty, does nothing.

\(O(1)\) per operation. Alter the value at the minimum key in an Applicative context. If the queue is empty, does nothing.

Since: 1.4.2

\(O(\log n)\). (Actually \(O(1)\) if there's no deletion.) Update the value at the minimum key. If the queue is empty, does nothing.

\(O(\log n)\) per operation. (Actually \(O(1)\) if there's no deletion.) Update the value at the minimum key. If the queue is empty, does nothing.

Since: 1.4.2

\(O(\log n)\). (Actually \(O(1)\) if there's no deletion.) Update the value at the minimum key. If the queue is empty, does nothing.

\(O(\log n)\) per operation. (Actually \(O(1)\) if there's no deletion.) Update the value at the minimum key in an Applicative context. If the queue is empty, does nothing.

Since: 1.4.2

\(O(\log n)\). Retrieves the value associated with the minimal key of the queue, and the queue stripped of that element, or Nothing if passed an empty queue.

\(O(\log n)\). Retrieves the minimal (key, value) pair of the map, and the map stripped of that element, or Nothing if passed an empty map.

\(O(n)\). Map a function over all values in the queue.

\(O(n)\). Map a function over all values in the queue.

\(O(n)\). mapKeys f q is the queue obtained by applying f to each key of q.

\(O(n)\). mapKeysMonotonic f q == mapKeys f q, but only works when f is (weakly) monotonic. The precondition is not checked. This function has better performance than mapKeys.

Note: if the given function returns bottom for any of the keys in the queue, then the portion of the queue which is bottom is unspecified.

\(O(n \log n)\). Fold the keys and values in the map, such that foldrWithKey f z q == foldr (uncurry f) z (toAscList q).

If you do not care about the traversal order, consider using foldrWithKeyU.

\(O(n \log n)\). Fold the keys and values in the map, such that foldlWithKey f z q == foldl (uncurry . f) z (toAscList q).

If you do not care about the traversal order, consider using foldlWithKeyU.

\(O(n \log n)\). Traverses the elements of the queue in ascending order by key. (traverseWithKey f q == fromAscList $ traverse (uncurry f) (toAscList q))

If you do not care about the order of the traversal, consider using traverseWithKeyU.

If you are working in a strict monad, consider using mapMWithKey.

A strictly accumulating version of traverseWithKey. This works well in IO and strict State, and is likely what you want for other "strict" monads, where ⊥ >>= pure () = ⊥.

\(O(k \log n)\)/. Takes the first k (key, value) pairs in the queue, or the first n if k >= n. (take k q == take k (toAscList q))

\(O(k \log n)\)/. Deletes the first k (key, value) pairs in the queue, or returns an empty queue if k >= n.

\(O(k \log n)\)/. Equivalent to (take k q, drop k q).

Takes the longest possible prefix of elements satisfying the predicate. (takeWhile p q == takeWhile (p . snd) (toAscList q))

Takes the longest possible prefix of elements satisfying the predicate. (takeWhile p q == takeWhile (uncurry p) (toAscList q))

Removes the longest possible prefix of elements satisfying the predicate.

Removes the longest possible prefix of elements satisfying the predicate.

Equivalent to (takeWhile p q, dropWhile p q).

Equivalent to (takeWhileWithKey p q, dropWhileWithKey p q).

Equivalent to span (not . p).

Equivalent to spanWithKey ( k a -> not (p k a)) q.

\(O(n)\). Filter all values that satisfy the predicate.

\(O(n)\). Filter all values that satisfy the predicate.

\(O(n)\). Partition the queue according to a predicate. The first queue contains all elements which satisfy the predicate, the second all elements that fail the predicate.

\(O(n)\). Partition the queue according to a predicate. The first queue contains all elements which satisfy the predicate, the second all elements that fail the predicate.

\(O(n)\). Map values and collect the Just results.

\(O(n)\). Map values and collect the Just results.

\(O(n)\). Map values and separate the Left and Right results.

\(O(n)\). Map values and separate the Left and Right results.

\(O(n)\). Constructs a priority queue from an unordered list.

\(O(n)\). Build a priority queue from an ascending list of (key, value) pairs. The precondition is not checked.

\(O(n)\). Build a priority queue from a descending list of (key, value) pairs. The precondition is not checked.

\(O(n \log n)\). Return all keys of the queue in ascending order.

\(O(n \log n)\). Return all elements of the queue in ascending order by key.

\(O(n \log n)\). Equivalent to toAscList.

\(O(n \log n)\). Return all (key, value) pairs in ascending order by key.

\(O(n \log n)\). Return all (key, value) pairs in descending order by key.

\(O(n \log n)\). Equivalent to toAscList.

If the traversal order is irrelevant, consider using toListU.

\(O(n)\). An unordered right fold over the elements of the queue, in no particular order.

\(O(n)\). An unordered monoidal fold over the elements of the queue, in no particular order.

Since: 1.4.2

\(O(n)\). An unordered right fold over the elements of the queue, in no particular order.

\(O(n)\). An unordered left fold over the elements of the queue, in no particular order. This is rarely what you want; foldrU and foldlU' are more likely to perform well.

\(O(n)\). An unordered strict left fold over the elements of the queue, in no particular order.

Since: 1.4.2

\(O(n)\). An unordered left fold over the elements of the queue, in no particular order. This is rarely what you want; foldrWithKeyU and foldlWithKeyU' are more likely to perform well.

\(O(n)\). An unordered strict left fold over the elements of the queue, in no particular order.

Since: 1.4.2

\(O(n)\). An unordered traversal over a priority queue, in no particular order. While there is no guarantee in which order the elements are traversed, the resulting priority queue will be perfectly valid.

\(O(n)\). An unordered traversal over a priority queue, in no particular order. While there is no guarantee in which order the elements are traversed, the resulting priority queue will be perfectly valid.

\(O(n)\). Return all keys of the queue in no particular order.

\(O(n)\). Return all elements of the queue in no particular order.

\(O(n)\). Equivalent to toListU.

\(O(n)\). Returns all (key, value) pairs in the queue in no particular order.

\(O(\log n)\). seqSpine q r forces the spine of q and returns r.

Note: The spine of a MinPQueue is stored somewhat lazily. In earlier versions of this package, some operations could produce chains of thunks along the spine, occasionally necessitating manual forcing. Now, all operations are careful to force enough to avoid this problem.