nim-stew/stew/keyed_queue.nim

# Nimbus
# Copyright (c) 2018 Status Research & Development GmbH
# Licensed under either of
#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
#    http://www.apache.org/licenses/LICENSE-2.0)
#  * MIT license ([LICENSE-MIT](LICENSE-MIT) or
#    http://opensource.org/licenses/MIT)
# at your option. This file may not be copied, modified, or distributed except
# according to those terms.

## Keyed Queue
## ===========
##
## This module provides a keyed fifo or stack data structure similar to
## `DoublyLinkedList` but with efficient random data access for fetching
## and deletion. The underlying data structure is a hash table with data
## lookup and delete assumed to be O(1) in most cases (so long as the
## underlying hash table does not degrade into one-bucket linear mode, or
## some bucket-adjustment algorithm takes over.)
##
## For consistency with  other data types in Nim the queue has value
## semantics, this means that `=` performs a deep copy of the allocated queue
## which is refered to the deep copy semantics of the underlying table driver.

import
  std/[math, tables],
  ./results

export
  results

{.push raises: [Defect].}

type
  KeyedQueueItem*[K,V] = object ##\
    ## Data value container as stored in the queue.
    ## There is a special requirements for `KeyedQueueItem` terminal nodes:
    ## *prv == nxt* so that there is no dangling link. On the flip side,
    ## this requires some extra consideration when deleting the second node
    ## relative to either end.
    data*: V         ## Some data value, can freely be modified.
    kPrv*, kNxt*: K  ## Queue links, read-only.

  KeyedQueuePair*[K,V] = object ##\
    ## Key-value pair, typically used as return code.
    key: K      ## Sorter key (read-only for consistency with `SLstResult[K,V]`)
    data*: V    ## Some data value, to be modified freely

  KeyedQueueTab*[K,V] = ##\
    ## Internal table type exposed for debugging.
    Table[K,KeyedQueueItem[K,V]]

  KeyedQueue*[K,V] = object ##\
    ## Data queue descriptor
    tab*: KeyedQueueTab[K,V]   ## Data table
    kFirst*, kLast*: K         ## Doubly linked item list queue

  BlindValue = ##\
    ## Type name is syntactic sugar, used for key-only queues
    distinct byte

  KeyedQueueNV*[K] = ##\
    ## Key-only queue, no values
    KeyedQueue[K,BlindValue]

# ------------------------------------------------------------------------------
# Private helpers
# ------------------------------------------------------------------------------

template noKeyError(info: static[string]; code: untyped) =
  try:
    code
  except KeyError as e:
    raiseAssert "Not possible (" & info & "): " & e.msg

# ------------------------------------------------------------------------------
# Private functions
# ------------------------------------------------------------------------------

proc shiftImpl[K,V](rq: var KeyedQueue[K,V]) =
  ## Expects: rq.tab.len != 0

  noKeyError("shiftImpl"):
   # Unqueue first item
   let item = rq.tab[rq.kFirst] # yes, crashes if `rq.tab.len == 0`
   rq.tab.del(rq.kFirst)

   if rq.tab.len == 0:
     rq.kFirst.reset
     rq.kLast.reset
   else:
     rq.kFirst = item.kNxt
     if rq.tab.len == 1:
       rq.tab[rq.kFirst].kNxt = rq.kFirst            # node points to itself
     rq.tab[rq.kFirst].kPrv = rq.tab[rq.kFirst].kNxt # term node has: nxt == prv


proc popImpl[K,V](rq: var KeyedQueue[K,V]) =
  ## Expects: rq.tab.len != 0

  # Pop last item
  noKeyError("popImpl"):
    let item = rq.tab[rq.kLast] # yes, crashes if `rq.tab.len == 0`
    rq.tab.del(rq.kLast)

    if rq.tab.len == 0:
      rq.kFirst.reset
      rq.kLast.reset
    else:
      rq.kLast = item.kPrv
      if rq.tab.len == 1:
        rq.tab[rq.kLast].kPrv = rq.kLast         # single node points to itself
      rq.tab[rq.kLast].kNxt = rq.tab[rq.kLast].kPrv # term node has: nxt == prv


proc deleteImpl[K,V](rq: var KeyedQueue[K,V]; key: K) =
  ## Expects: rq.tab.hesKey(key)

  if rq.kFirst == key:
    rq.shiftImpl

  elif rq.kLast == key:
    rq.popImpl

  else:
    noKeyError("deleteImpl"):
      let item = rq.tab[key] # yes, crashes if `not rq.tab.hasKey(key)`
      rq.tab.del(key)

      # now: 2 < rq.tab.len (otherwise rq.kFirst == key or rq.kLast == key)
      if rq.tab[rq.kFirst].kNxt == key:
        # item was the second one
        rq.tab[rq.kFirst].kPrv = item.kNxt
      if rq.tab[rq.kLast].kPrv == key:
        # item was one before last
        rq.tab[rq.kLast].kNxt = item.kPrv

      rq.tab[item.kPrv].kNxt = item.kNxt
      rq.tab[item.kNxt].kPrv = item.kPrv


proc appendImpl[K,V](rq: var KeyedQueue[K,V]; key: K; val: V) =
  ## Expects: not rq.tab.hasKey(key)

  # Append queue item
  var item = KeyedQueueItem[K,V](data: val)

  noKeyError("appendImpl"):
    if rq.tab.len == 0:
      rq.kFirst = key
      item.kPrv = key
    else:
      if rq.kFirst == rq.kLast:
        rq.tab[rq.kFirst].kPrv = key # first terminal node
      rq.tab[rq.kLast].kNxt = key
      item.kPrv = rq.kLast

    rq.kLast = key
    item.kNxt = item.kPrv # terminal node

    rq.tab[key] = item # yes, makes `verify()` fail if `rq.tab.hasKey(key)`


proc prependImpl[K,V](rq: var KeyedQueue[K,V]; key: K; val: V) =
  ## Expects: not rq.tab.hasKey(key)

  # Prepend queue item
  var item = KeyedQueueItem[K,V](data: val)

  noKeyError("prependImpl"):
    if rq.tab.len == 0:
      rq.kLast = key
      item.kNxt = key
    else:
      if rq.kFirst == rq.kLast:
        rq.tab[rq.kLast].kNxt = key # first terminal node
      rq.tab[rq.kFirst].kPrv = key
      item.kNxt = rq.kFirst

    rq.kFirst = key
    item.kPrv = item.kNxt # terminal node has: nxt == prv

    rq.tab[key] = item # yes, makes `verify()` fail if `rq.tab.hasKey(key)`

# -----------

proc shiftKeyImpl[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
  noKeyError("shiftKeyImpl"):
    if 0 < rq.tab.len:
      let key = rq.kFirst
      rq.shiftImpl
      return ok(key)
  err()

proc popKeyImpl[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
  noKeyError("popKeyImpl"):
    if 0 < rq.tab.len:
      let key = rq.kLast
      rq.popImpl
      return ok(key)
  err()

# -----------

proc firstKeyImpl[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
  if rq.tab.len == 0:
    return err()
  ok(rq.kFirst)

proc secondKeyImpl[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
  if rq.tab.len < 2:
    return err()
  noKeyError("secondKeyImpl"):
    return ok(rq.tab[rq.kFirst].kNxt)

proc beforeLastKeyImpl[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
  if rq.tab.len < 2:
    return err()
  noKeyError("lastKeyImpl"):
    return ok(rq.tab[rq.kLast].kPrv)

proc lastKeyImpl[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
  if rq.tab.len == 0:
    return err()
  ok(rq.kLast)

proc nextKeyImpl[K,V](rq: var KeyedQueue[K,V]; key: K): Result[K,void] =
  if not rq.tab.hasKey(key) or rq.kLast == key:
    return err()
  noKeyError("nextKeyImpl"):
    return ok(rq.tab[key].kNxt)

proc prevKeyImpl[K,V](rq: var KeyedQueue[K,V]; key: K): Result[K,void] =
  if not rq.tab.hasKey(key) or rq.kFirst == key:
    return err()
  noKeyError("prevKeyImpl"):
    return ok(rq.tab[key].kPrv)

# ------------------------------------------------------------------------------
# Public functions, constructor
# ------------------------------------------------------------------------------

proc init*[K,V](rq: var KeyedQueue[K,V]; initSize = 10) =
  ## Optional initaliser for the queue setting the inital size of the
  ## underlying table object.
  rq.tab = initTable[K,KeyedQueueItem[K,V]](initSize.nextPowerOfTwo)

proc init*[K,V](T: type KeyedQueue[K,V]; initSize = 10): T =
  ## Initaliser variant.
  result.init(initSize)

proc init*[K](rq: var KeyedQueueNV[K]; initSize = 10) =
  ## Key-only queue, no explicit values
  rq.tab = initTable[K,KeyedQueueItem[K,BlindValue]](initSize.nextPowerOfTwo)

proc init*[K](T: type KeyedQueueNV[K]; initSize = 10): T =
  ## Initaliser variant.
  result.init(initSize)

# ------------------------------------------------------------------------------
# Public functions, list operations
# ------------------------------------------------------------------------------

proc append*[K,V](rq: var KeyedQueue[K,V]; key: K; val: V): bool =
  ## Append new `key`. The function will succeed returning `true` unless the
  ## `key` argument exists in the queue,  already.
  ##
  ## All the items on the queue different from the one just added are
  ## called *previous* or *left hand* items while the item just added
  ## is the *right-most* item.
  if not rq.tab.hasKey(key):
    rq.appendImpl(key, val)
    return true

template push*[K,V](rq: var KeyedQueue[K,V]; key: K; val: V): bool =
  ## Same as `append()`
  rq.append(key, val)


proc replace*[K,V](rq: var KeyedQueue[K,V]; key: K; val: V): bool =
  ## Replace value for entry associated with the key argument `key`. Returns
  ## `true` on success, and `false` otherwise.
  if rq.tab.hasKey(key):
    noKeyError("replace"):
      rq.tab[key].data = val
    return true

proc `[]=`*[K,V](rq: var KeyedQueue[K,V]; key: K; val: V) =
  ## This function provides a combined append/replace action with table
  ## semantics:
  ## * If the argument `key` is not in the queue yet, append the `(key,val)`
  ##   pair as in `rq.append(key,val)`
  ## * Otherwise replace the value entry of the queue item by the argument
  ##   `val` as in `rq.replace(key,val)`
  if rq.tab.hasKey(key):
    noKeyError("[]="):
      rq.tab[key].data = val
  else:
    rq.appendImpl(key, val)


proc prepend*[K,V](rq: var KeyedQueue[K,V]; key: K; val: V): bool =
  ## Prepend new `key`. The function will succeed returning `true` unless the
  ## `key` argument exists in the queue, already.
  ##
  ## All the items on the queue different from the item just added are
  ## called *following* or *right hand* items while the item just added
  ## is the *left-most* item.
  if not rq.tab.hasKey(key):
    rq.prependImpl(key, val)
    return true

template unshift*[K,V](rq: var KeyedQueue[K,V]; key: K; val: V): bool =
  ## Same as `prepend()`
  rq.prepend(key,val)


proc shift*[K,V](rq: var KeyedQueue[K,V]): Result[KeyedQueuePair[K,V],void] =
  ## Deletes the *first* queue item and returns the key-value item pair just
  ## deleted. For a non-empty queue this function is the same as
  ## `rq.firstKey.value.delele`.
  ##
  ## Using the notation introduced with `rq.append` and `rq.prepend`, the
  ## item returned and deleted is the *left-most* item.
  if 0 < rq.tab.len:
    noKeyError("shift"):
      let kvp = KeyedQueuePair[K,V](
        key: rq.kFirst,
        data: rq.tab[rq.kFirst].data)
      rq.shiftImpl
      return ok(KeyedQueuePair[K,V](kvp))
  err()

proc shiftKey*[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
  ## Similar to `shift()` but with different return value.
  rq.shiftKeyImpl

proc shiftValue*[K,V](rq: var KeyedQueue[K,V]): Result[V,void] =
  ## Similar to `shift()` but with different return value.
  if 0 < rq.tab.len:
    noKeyError("shiftValue"):
      let val = rq.tab[rq.kFirst].data
      rq.shiftImpl
      return ok(val)
  err()


proc pop*[K,V](rq: var KeyedQueue[K,V]): Result[KeyedQueuePair[K,V],void] =
  ## Deletes the *last* queue item and returns the  key-value item pair just
  ## deleted. For a non-empty queue this function is the same as
  ## `rq.lastKey.value.delele`.
  ##
  ## Using the notation introduced with `rq.append` and `rq.prepend`, the
  ## item returned and deleted is the *right-most* item.
  if 0 < rq.tab.len:
    noKeyError("pop"):
      let kvp = KeyedQueuePair[K,V](
        key: rq.kLast,
        data: rq.tab[rq.kLast].data)
      rq.popImpl
      return ok(KeyedQueuePair[K,V](kvp))
  err()

proc popKey*[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
  ## Similar to `pop()` but with different return value.
  rq.popKeyImpl

proc popValue*[K,V](rq: var KeyedQueue[K,V]): Result[V,void] =
  ## Similar to `pop()` but with different return value.
  if 0 < rq.tab.len:
    noKeyError("popValue"):
      let val = rq.tab[rq.kLast].data
      rq.popImpl
      return ok(val)
  err()


proc delete*[K,V](rq: var KeyedQueue[K,V]; key: K):
           Result[KeyedQueuePair[K,V], void] =
  ## Delete the item with key `key` from the queue and returns the key-value
  ## item pair just deleted (if any).
  if rq.tab.hasKey(key):
    noKeyError("delete"):
      let kvp = KeyedQueuePair[K,V](
        key: key,
        data: rq.tab[key].data)
      rq.deleteImpl(key)
      return ok(kvp)
  err()

proc del*[K,V](rq: var KeyedQueue[K,V]; key: K) =
  ## Similar to `delete()` but without return code.
  if rq.tab.hasKey(key):
    rq.deleteImpl(key)

# --------

proc append*[K](rq: var KeyedQueueNV[K]; key: K): bool =
  ## Key-only queue variant
  rq.append(key,BlindValue(0))

template push*[K](rq: var KeyedQueueNV[K]; key: K): bool =
  ## Key-only queue variant
  rq.append(key)


proc prepend*[K](rq: var KeyedQueueNV[K]; key: K): bool =
  ## Key-only queue variant
  rq.prepend(key,BlindValue(0))

template unshift*[K](rq: var KeyedQueueNV[K]; key: K): bool =
  ## Key-only queue variant
  rq.prepend(key)


proc shift*[K](rq: var KeyedQueueNV[K]): Result[K,void] =
  ## Key-only queue variant
  rq.shiftKeyImpl

proc shiftKey*[K](rq: var KeyedQueueNV[K]): Result[K,void]
    {.gcsafe, deprecated: "use shift() for key-only queue".} =
  rq.shiftKeyImpl


proc pop*[K](rq: var KeyedQueueNV[K]): Result[K,void] =
  ## Key-only variant of `pop()` (same as `popKey()`)
  rq.popKeyImpl

proc popKey*[K](rq: var KeyedQueueNV[K]): Result[K,void]
    {.gcsafe, deprecated: "use pop() for key-only queue".} =
  rq.popKeyImpl

# ------------------------------------------------------------------------------
# Public functions, fetch
# ------------------------------------------------------------------------------

proc hasKey*[K,V](rq: var KeyedQueue[K,V]; key: K): bool =
  ## Check whether the argument `key` has been queued, already
  rq.tab.hasKey(key)

proc eq*[K,V](rq: var KeyedQueue[K,V]; key: K): Result[V,void] =
  ## Retrieve the value data stored with the argument `key` from
  ## the queue if there is any.
  if not rq.tab.hasKey(key):
    return err()
  noKeyError("eq"):
    return ok(rq.tab[key].data)

proc `[]`*[K,V](rq: var KeyedQueue[K,V]; key: K): V
    {.gcsafe,raises: [Defect,KeyError].} =
  ## This function provides a simplified version of the `eq()` function with
  ## table semantics. Note that this finction throws a `KeyError` exception
  ## unless the argument `key` exists in the queue.
  rq.tab[key].data

# ------------------------------------------------------------------------------
# Public functions, LRU mode
# ------------------------------------------------------------------------------

proc lruFetch*[K,V](rq: var KeyedQueue[K,V]; key: K): Result[V,void] =
  ## Fetch in *last-recently-used* mode: If the argument `key` exists in the
  ## queue, move the key-value item pair to the *right end* (see `append()`)
  ## of the queue and return the value associated with the key.
  if not rq.tab.hasKey(key):
    return err()

  noKeyError("lruFetch"):
    let item = rq.tab[key]
    if rq.kLast != key:
      # Now, `key` is in the table and does not refer to the last `item`,
      # so the table has at least two entries.

      # unlink item
      if rq.kFirst == key:
        rq.kFirst = item.kNxt
        rq.tab[rq.kFirst].kPrv = rq.tab[rq.kFirst].kNxt # term node: nxt == prv

      else: # Now, there are at least three entries
        if rq.tab[rq.kFirst].kNxt == key:
          rq.tab[rq.kFirst].kPrv = item.kNxt            # item was the 2nd one
        rq.tab[item.kPrv].kNxt = item.kNxt
        rq.tab[item.kNxt].kPrv = item.kPrv

      # Re-append item, i.e. appendImpl() without adding item.
      rq.tab[rq.kLast].kNxt = key
      rq.tab[key].kPrv = rq.kLast
      rq.kLast = key
      rq.tab[key].kNxt = rq.tab[key].kPrv               # term node: nxt == prv

    return ok(item.data)

proc lruAppend*[K,V](rq: var KeyedQueue[K,V]; key: K; val: V; maxItems: int): V =
  ## Append in *last-recently-used* mode: If the queue has at least `maxItems`
  ## item entries, do `shift()` out the *left-most* one. Then `append()` the
  ## key-value argument pair `(key,val)` to the *right end*. Together with
  ## `lruFetch()` this function can be used to build a *LRU cache*:
  ## ::
  ##   const queueMax = 10
  ##
  ##   proc expensiveCalculation(key: int): Result[int,void] =
  ##     ...
  ##
  ##   proc lruCache(q: var KeyedQueue[int,int]; key: int): Result[int,void] =
  ##     block:
  ##       let rc = q.lruFetch(key)
  ##       if rc.isOK:
  ##          return ok(rc.value)
  ##     block:
  ##       let rc = expensiveCalculation(key)
  ##       if rc.isOK:
  ##          return ok(q.lruAppend(key, rc.value, queueMax))
  ##     err()
  ##
  # Limit number of cached items
  try:
    if maxItems <= rq.tab.len:
      rq.shiftImpl
    # Append new value
    rq.appendImpl(key, val)
    return val
  except KeyError:
    raiseAssert "Not possible"

# ------------------------------------------------------------------------------
# Public traversal functions, fetch keys
# ------------------------------------------------------------------------------

proc firstKey*[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
  ## Retrieve first key from the queue unless it is empty.
  ##
  ## Using the notation introduced with `rq.append` and `rq.prepend`, the
  ## key returned is the *left-most* one.
  rq.firstKeyImpl

proc secondKey*[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
  ## Retrieve the key next after the first key from queue unless it is empty.
  ##
  ## Using the notation introduced with `rq.append` and `rq.prepend`, the
  ## key returned is the one ti the right of the *left-most* one.
  rq.secondKeyImpl

proc beforeLastKey*[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
  ## Retrieve the key just before the last one from queue unless it is empty.
  ##
  ## Using the notation introduced with `rq.append` and `rq.prepend`, the
  ## key returned is the one to the left of the *right-most* one.
  rq.beforeLastKeyImpl

proc lastKey*[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
  ## Retrieve last key from queue unless it is empty.
  ##
  ## Using the notation introduced with `rq.append` and `rq.prepend`, the
  ## key returned is the *right-most* one.
  rq.lastKeyImpl

proc nextKey*[K,V](rq: var KeyedQueue[K,V]; key: K): Result[K,void] =
  ## Retrieve the key following the argument `key` from queue if
  ## there is any.
  ##
  ## Using the notation introduced with `rq.append` and `rq.prepend`, the
  ## key returned is the next one to the *right*.
  rq.nextKeyImpl(key)

proc prevKey*[K,V](rq: var KeyedQueue[K,V]; key: K): Result[K,void] =
  ## Retrieve the key preceeding the argument `key` from queue if
  ## there is any.
  ##
  ## Using the notation introduced with `rq.append` and `rq.prepend`, the
  ## key returned is the next one to the *left*.
  rq.prevKeyImpl(key)

# ----------

proc firstKey*[K](rq: var KeyedQueueNV[K]): Result[K,void]
  {.gcsafe, deprecated: "use first() for key-only queue".} =
  rq.firstKeyImpl

proc secondKey*[K](rq: var KeyedQueueNV[K]): Result[K,void]
  {.gcsafe, deprecated: "use second() for key-only queue".} =
  rq.secondKeyImpl

proc beforeLastKey*[K](rq: var KeyedQueueNV[K]): Result[K,void]
  {.gcsafe, deprecated: "use beforeLast() for key-only queue".} =
  rq.beforeLastKeyImpl

proc lastKey*[K](rq: var KeyedQueueNV[K]): Result[K,void]
  {.gcsafe, deprecated: "use last() for key-only queue".} =
  rq.lastKeyImpl

proc nextKey*[K](rq: var KeyedQueueNV[K]; key: K): Result[K,void]
  {.gcsafe, deprecated: "use next() for key-only queue".} =
  rq.nextKeyImpl(key)

proc prevKey*[K](rq: var KeyedQueueNV[K]; key: K): Result[K,void]
  {.gcsafe, deprecated: "use prev() for key-only queue".} =
  rq.nextKeyImpl(key)

# ------------------------------------------------------------------------------
# Public traversal functions, fetch key/value pairs
# ------------------------------------------------------------------------------

proc first*[K,V](rq: var KeyedQueue[K,V]): Result[KeyedQueuePair[K,V],void] =
  ## Similar to `firstKey()` but with key-value item pair return value.
  if rq.tab.len == 0:
    return err()
  noKeyError("first"):
    let key = rq.kFirst
    return ok(KeyedQueuePair[K,V](key: key, data: rq.tab[key].data))

proc second*[K,V](rq: var KeyedQueue[K,V]): Result[KeyedQueuePair[K,V],void] =
  ## Similar to `secondKey()` but with key-value item pair return value.
  if rq.tab.len < 2:
    return err()
  noKeyError("second"):
    let key = rq.tab[rq.kFirst].kNxt
    return ok(KeyedQueuePair[K,V](key: key, data: rq.tab[key].data))

proc beforeLast*[K,V](rq: var KeyedQueue[K,V]):
               Result[KeyedQueuePair[K,V],void] =
  ## Similar to `beforeLastKey()` but with key-value item pair return value.
  if rq.tab.len < 2:
    return err()
  noKeyError("beforeLast"):
    let key = rq.tab[rq.kLast].kPrv
    return ok(KeyedQueuePair[K,V](key: key, data: rq.tab[key].data))

proc last*[K,V](rq: var KeyedQueue[K,V]): Result[KeyedQueuePair[K,V],void] =
  ## Similar to `lastKey()` but with key-value item pair return value.
  if rq.tab.len == 0:
    return err()
  noKeyError("last"):
    let key = rq.kLast
    return ok(KeyedQueuePair[K,V](key: key, data: rq.tab[key].data))

proc next*[K,V](rq: var KeyedQueue[K,V]; key: K):
         Result[KeyedQueuePair[K,V],void] =
  ## Similar to `nextKey()` but with key-value item pair return value.
  if not rq.tab.hasKey(key) or rq.kLast == key:
    return err()
  noKeyError("next"):
    let nKey = rq.tab[key].kNxt
    return ok(KeyedQueuePair[K,V](key: nKey, data: rq.tab[nKey].data))

proc prev*[K,V](rq: var KeyedQueue[K,V]; key: K):
         Result[KeyedQueuePair[K,V],void] =
  ## Similar to `prevKey()` but with key-value item pair return value.
  if not rq.tab.hasKey(key) or rq.kFirst == key:
    return err()
  noKeyError("prev"):
    let pKey = rq.tab[key].kPrv
    return ok(KeyedQueuePair[K,V](key: pKey, data: rq.tab[pKey].data))

# ------------

proc first*[K](rq: var KeyedQueueNV[K]): Result[K,void] =
  ## Key-only queue variant
  rq.firstKeyImpl

proc second*[K](rq: var KeyedQueueNV[K]): Result[K,void] =
  ## Key-only queue variant
  rq.secondKeyImpl

proc beforeLast*[K](rq: var KeyedQueueNV[K]): Result[K,void] =
  ## Key-only queue variant
  rq.beforeLastKeyImpl

proc last*[K](rq: var KeyedQueueNV[K]): Result[K,void] =
  ## Key-only queue variant
  rq.lastKeyImpl

proc next*[K](rq: var KeyedQueueNV[K]; key: K): Result[K,void] =
  ## Key-only queue variant
  rq.nextKeyImpl(key)

proc prev*[K](rq: var KeyedQueueNV[K]; key: K): Result[K,void] =
  ## Key-only queue variant
  rq.nextKeyImpl(key)

# ------------------------------------------------------------------------------
# Public traversal functions, data container items
# ------------------------------------------------------------------------------

proc firstValue*[K,V](rq: var KeyedQueue[K,V]): Result[V,void] =
  ## Retrieve first value item from the queue unless it is empty.
  ##
  ## Using the notation introduced with `rq.append` and `rq.prepend`, the
  ## value item returned is the *left-most* one.
  if rq.tab.len == 0:
    return err()
  noKeyError("firstValue"):
    return ok(rq.tab[rq.kFirst].data)

proc secondValue*[K,V](rq: var KeyedQueue[K,V]): Result[V,void] =
  ## Retrieve the value item next to the first one from the queue unless it
  ## is empty.
  ##
  ## Using the notation introduced with `rq.append` and `rq.prepend`, the
  ## value item returned is the one to the *right* of the *left-most* one.
  if rq.tab.len < 2:
    return err()
  noKeyError("secondValue"):
    return ok(rq.tab[rq.tab[rq.kFirst].kNxt].data)

proc beforeLastValue*[K,V](rq: var KeyedQueue[K,V]): Result[V,void] =
  ## Retrieve the value item just before the last item from the queue
  ## unless it is empty.
  ##
  ## Using the notation introduced with `rq.append` and `rq.prepend`, the
  ## value item returned is the one to the *left* of the *right-most* one.
  if rq.tab.len < 2:
    return err()
  noKeyError("beforeLastValue"):
    return ok(rq.tab[rq.tab[rq.kLast].kPrv].data)

proc lastValue*[K,V](rq: var KeyedQueue[K,V]): Result[V,void] =
  ## Retrieve the last value item from the queue if there is any.
  ##
  ## Using the notation introduced with `rq.append` and `rq.prepend`, the
  ## value item returned is the *right-most* one.
  if rq.tab.len == 0:
    return err()
  noKeyError("lastValue"):
    return ok(rq.tab[rq.kLast].data)

# ------------------------------------------------------------------------------
# Public functions, miscellaneous
# ------------------------------------------------------------------------------

proc `==`*[K,V](a, b: var KeyedQueue[K,V]): bool =
  ## Returns `true` if both argument queues contain the same data. Note that
  ## this is a slow operation as all `(key,data)` pairs will to be compared.
  if a.tab.len == b.tab.len and a.kFirst == b.kFirst and a.kLast == b.kLast:
    for (k,av) in a.tab.pairs:
      if not b.tab.hasKey(k):
        return false
      noKeyError("=="):
        let bv = b.tab[k]
        # bv.data might be a reference, so dive into it explicitely.
        if av.kPrv != bv.kPrv or av.kNxt != bv.kNxt or bv.data != av.data:
          return false
    return true

proc key*[K,V](kqp: KeyedQueuePair[K,V]): K =
  ## Getter
  kqp.key

proc len*[K,V](rq: var KeyedQueue[K,V]): int =
  ## Returns the number of items in the queue
  rq.tab.len

proc clear*[K,V](rq: var KeyedQueue[K,V]) =
  ## Clear the queue
  rq.tab.clear
  rq.kFirst.reset
  rq.kLast.reset

proc toKeyedQueueResult*[K,V](key: K; data: V):
                       Result[KeyedQueuePair[K,V],void] =
  ## Helper, chreate `ok()` result
  ok(KeyedQueuePair[K,V](key: key, data: data))

# ------------------------------------------------------------------------------
# Public iterators
# ------------------------------------------------------------------------------

iterator nextKeys*[K,V](rq: var KeyedQueue[K,V]): K =
  ## Iterate over all keys in the queue starting with the `rq.firstKey.value`
  ## key (if any). Using the notation introduced with `rq.append` and
  ## `rq.prepend`, the iterator processes *left* to *right*.
  ##
  ## :Note:
  ##    When running in a loop it is *ok* to delete the current item and all
  ##    the items already visited. Items not visited yet must not be deleted
  ##    as the loop would become unpredictable.
  if 0 < rq.tab.len:
    var
      key = rq.kFirst
      loopOK = true
    while loopOK:
      let yKey = key
      loopOK = key != rq.kLast
      noKeyError("nextKeys"):
        key = rq.tab[key].kNxt
      yield yKey

iterator nextValues*[K,V](rq: var KeyedQueue[K,V]): V =
  ## Iterate over all values in the queue starting with the
  ## `rq.kFirst.value.value` item value (if any). Using the notation introduced
  ## with `rq.append` and `rq.prepend`, the iterator processes *left* to
  ## *right*.
  ##
  ## See the note at the `nextKeys()` function comment about deleting items.
  if 0 < rq.tab.len:
    var
      key = rq.kFirst
      loopOK = true
    while loopOK:
      var item: KeyedQueueItem[K,V]
      noKeyError("nextValues"):
        item = rq.tab[key]
      loopOK = key != rq.kLast
      key = item.kNxt
      yield item.data

iterator nextPairs*[K,V](rq: var KeyedQueue[K,V]): KeyedQueuePair[K,V] =
  ## Iterate over all (key,value) pairs in the queue starting with the
  ## `(rq.firstKey.value,rq.first.value.value)` key/item pair (if any). Using
  ## the notation introduced with `rq.append` and `rq.prepend`, the iterator
  ## processes *left* to *right*.
  ##
  ## See the note at the `nextKeys()` function comment about deleting items.
  if 0 < rq.tab.len:
    var
      key = rq.kFirst
      loopOK = true
    while loopOK:
      let yKey = key
      var item: KeyedQueueItem[K,V]
      noKeyError("nextPairs"):
        item = rq.tab[key]
      loopOK = key != rq.kLast
      key = item.kNxt
      yield KeyedQueuePair[K,V](key: yKey, data: item.data)

iterator prevKeys*[K,V](rq: var KeyedQueue[K,V]): K =
  ## Reverse iterate over all keys in the queue starting with the
  ## `rq.lastKey.value` key (if any). Using the notation introduced with
  ## `rq.append` and `rq.prepend`, the iterator processes *right* to *left*.
  ##
  ## See the note at the `nextKeys()` function comment about deleting items.
  if 0 < rq.tab.len:
    var
      key = rq.kLast
      loopOK = true
    while loopOK:
      let yKey = key
      loopOK = key != rq.kFirst
      noKeyError("prevKeys"):
        key = rq.tab[key].kPrv
      yield yKey

iterator prevValues*[K,V](rq: var KeyedQueue[K,V]): V =
  ## Reverse iterate over all values in the queue starting with the
  ## `rq.kLast.value.value` item value (if any). Using the notation introduced
  ## with `rq.append` and `rq.prepend`, the iterator processes *right* to
  ## *left*.
  ##
  ## See the note at the `nextKeys()` function comment about deleting items.
  if 0 < rq.tab.len:
    var
      key = rq.kLast
      loopOK = true
    while loopOK:
      var item: KeyedQueueItem[K,V]
      noKeyError("prevValues"):
        item = rq.tab[key]
      loopOK = key != rq.kFirst
      key = item.kPrv
      yield item.data

iterator prevPairs*[K,V](rq: var KeyedQueue[K,V]): KeyedQueuePair[K,V] =
  ## Reverse iterate over all (key,value) pairs in the queue starting with the
  ## `(rq.lastKey.value,rq.last.value.value)` key/item pair (if any). Using
  ## the notation introduced with `rq.append` and `rq.prepend`, the iterator
  ## processes *right* to *left*.
  ##
  ## See the note at the `nextKeys()` function comment about deleting items.
  if 0 < rq.tab.len:
    var
      key = rq.kLast
      loopOK = true
    while loopOK:
      let yKey = key
      var item: KeyedQueueItem[K,V]
      noKeyError("prevPairs"):
        item = rq.tab[key]
      loopOK = key != rq.kFirst
      key = item.kPrv
      yield KeyedQueuePair[K,V](key: yKey, data: item.data)

# ------------------------------------------------------------------------------
# End
# ------------------------------------------------------------------------------