9 files changed, 429 insertions, 424 deletions

diff --git a/lib/pure/collections/LockFreeHash.nim b/lib/pure/collections/LockFreeHash.nim
index b94b542ff..5640838b1 100644
--- a/lib/pure/collections/LockFreeHash.nim
+++ b/lib/pure/collections/LockFreeHash.nim
@@ -1,8 +1,40 @@
-#nimrod c -t:-march=i686 --cpu:amd64 --threads:on -d:release lockfreehash.nim
+#nim c -t:-march=i686 --cpu:amd64 --threads:on -d:release lockfreehash.nim
 
-import baseutils, unsigned, math, hashes
+import unsigned, math, hashes
 
+#------------------------------------------------------------------------------
+## Memory Utility Functions
+
+proc newHeap*[T](): ptr T =
+  result = cast[ptr T](alloc0(sizeof(T))) 
+
+proc copyNew*[T](x: var T): ptr T =
+  var 
+    size = sizeof(T)    
+    mem = alloc(size)  
+  copyMem(mem, x.addr, size)  
+  return cast[ptr T](mem)
+
+proc copyTo*[T](val: var T, dest: int) = 
+  copyMem(pointer(dest), val.addr, sizeof(T))    
+
+proc allocType*[T](): pointer = alloc(sizeof(T)) 
+
+proc newShared*[T](): ptr T =
+  result = cast[ptr T](allocShared0(sizeof(T))) 
+
+proc copyShared*[T](x: var T): ptr T =
+  var 
+    size = sizeof(T)    
+    mem = allocShared(size)  
+  copyMem(mem, x.addr, size)  
+  return cast[ptr T](mem)
 
+#------------------------------------------------------------------------------
+## Pointer arithmetic 
+
+proc `+`*(p: pointer, i: int): pointer {.inline.} =
+  cast[pointer](cast[int](p) + i)
 
 const
   minTableSize = 8
@@ -194,7 +226,7 @@ proc copySlot[K,V](idx: int, oldTbl: var PConcTable[K,V], newTbl: var PConcTable
   #Prevent new values from appearing in the old table by priming 
   oldVal = atomic_load_n(oldTbl[idx].value.addr, ATOMIC_RELAXED)
   while not isPrime(oldVal):
-    var box = if oldVal == NULL or isTomb(oldVal) : oldVal.setTomb.setPrime 
+    var box = if oldVal == 0 or isTomb(oldVal) : oldVal.setTomb.setPrime 
       else: oldVal.setPrime 
     if atomic_compare_exchange_n(oldTbl[idx].value.addr, oldVal.addr, 
       box, false, ATOMIC_RELAXED, ATOMIC_RELAXED):
@@ -209,8 +241,8 @@ proc copySlot[K,V](idx: int, oldTbl: var PConcTable[K,V], newTbl: var PConcTable
     return false
   if isTomb(oldVal): 
     echo("oldVal is Tomb!!!, should not happen")
-  if pop(oldVal) != NULL:  
-    result = setVal(newTbl, pop(oldKey), pop(oldVal), NULL, true) == NULL
+  if pop(oldVal) != 0:  
+    result = setVal(newTbl, pop(oldKey), pop(oldVal), 0, true) == 0
   if result: 
     #echo("Copied a Slot! idx= " & $idx & " key= " & $oldKey & " val= " & $oldVal)    
   else: 
@@ -323,7 +355,7 @@ proc setVal[K,V](table: var PConcTable[K,V], key: int, val: int,
     idx = idx and (table.len - 1) 
     #echo("try set idx = " & $idx & "for" & $key)
     var
-      probedKey = NULL     
+      probedKey = 0     
       openKey = atomic_compare_exchange_n(table[idx].key.addr, probedKey.addr, 
         key, false, ATOMIC_RELAXED, ATOMIC_RELAXED) 
     if openKey:
@@ -339,7 +371,7 @@ proc setVal[K,V](table: var PConcTable[K,V], key: int, val: int,
     if keyEQ[K](probedKey, key):
       #echo("we found the matching slot")    
       break # We found a matching slot      
-    if (not(expVal != NULL and match)) and (probes >= reProbeLimit or key.isTomb):
+    if (not(expVal != 0 and match)) and (probes >= reProbeLimit or key.isTomb):
       if key.isTomb: echo("Key is Tombstone")
       #if probes >= reProbeLimit: echo("Too much probing " & $probes)
       #echo("try to resize")
@@ -361,7 +393,7 @@ proc setVal[K,V](table: var PConcTable[K,V], key: int, val: int,
     return oldVal
   nextTable = atomic_load_n(table.next.addr, ATOMIC_SEQ_CST)  
   if nextTable == nil and 
-    ((oldVal == NULL and 
+    ((oldVal == 0 and 
     (probes >= reProbeLimit or table.used / table.len > 0.8)) or
     (isPrime(oldVal))):
     if table.used / table.len > 0.8: echo("resize because usage ratio = " &
@@ -380,12 +412,12 @@ proc setVal[K,V](table: var PConcTable[K,V], key: int, val: int,
     if atomic_compare_exchange_n(table[idx].value.addr, oldVal.addr, 
         val, false, ATOMIC_RELEASE, ATOMIC_RELAXED):
       #echo("val set at table " & $cast[int](table))
-      if expVal != NULL:
-        if (oldVal == NULL or isTomb(oldVal)) and not isTomb(val):
+      if expVal != 0:
+        if (oldVal == 0 or isTomb(oldVal)) and not isTomb(val):
           discard atomic_add_fetch(table.active.addr, 1, ATOMIC_RELAXED)
-        elif not (oldVal == NULL or isTomb(oldVal)) and isTomb(val):
+        elif not (oldVal == 0 or isTomb(oldVal)) and isTomb(val):
           discard atomic_add_fetch(table.active.addr, -1, ATOMIC_RELAXED)
-      if oldVal == NULL and expVal != NULL:
+      if oldVal == 0 and expVal != 0:
         return setTomb(oldVal)
       else: return oldVal
     if isPrime(oldVal):
@@ -415,7 +447,7 @@ proc getVal[K,V](table: var PConcTable[K,V], key: int): int =
       if not isPrime(val):
         if isTomb(val):
           #echo("val was tomb but not prime") 
-          return NULL
+          return 0
         else:
           #echo("-GotIt- idx = ", idx, " key = ", key, " val ", val ) 
           return val
@@ -427,7 +459,7 @@ proc getVal[K,V](table: var PConcTable[K,V], key: int): int =
       if probes >= reProbeLimit*4 or key.isTomb:
         if newTable == nil:
           #echo("too many probes and no new table ", key, "  ", idx )
-          return NULL
+          return 0
         else: 
           newTable = helpCopy(table)
           return getVal(newTable, key)
@@ -437,10 +469,10 @@ proc getVal[K,V](table: var PConcTable[K,V], key: int): int =
 #------------------------------------------------------------------------------
    
 #proc set*(table: var PConcTable[TRaw,TRaw], key: TRaw, val: TRaw) =
-#  discard setVal(table, pack(key), pack(key), NULL, false)
+#  discard setVal(table, pack(key), pack(key), 0, false)
 
 #proc set*[V](table: var PConcTable[TRaw,V], key: TRaw, val: ptr V) =
-#  discard setVal(table, pack(key), cast[int](val), NULL, false)
+#  discard setVal(table, pack(key), cast[int](val), 0, false)
 
 proc set*[K,V](table: var PConcTable[K,V], key: var K, val: var V) =
   when not (K is TRaw): 
@@ -451,10 +483,10 @@ proc set*[K,V](table: var PConcTable[K,V], key: var K, val: var V) =
     var newVal = cast[int](copyShared(val))
   else: 
     var newVal = pack(val)
-  var oldPtr = pop(setVal(table, newKey, newVal, NULL, false))
+  var oldPtr = pop(setVal(table, newKey, newVal, 0, false))
     #echo("oldPtr = ", cast[int](oldPtr), " newPtr = ", cast[int](newPtr))
   when not (V is TRaw): 
-    if newVal != oldPtr and oldPtr != NULL: 
+    if newVal != oldPtr and oldPtr != 0: 
       deallocShared(cast[ptr V](oldPtr))
   
  
@@ -573,10 +605,3 @@ when isMainModule:
   #  echo(i, " = ", hashInt(i) and 8191)
 
   deleteConcTable(table)
-
-
-
-
-
-
-
diff --git a/lib/pure/collections/baseutils.nim b/lib/pure/collections/baseutils.nim
deleted file mode 100644
index 565a89ccb..000000000
--- a/lib/pure/collections/baseutils.nim
+++ /dev/null
@@ -1,41 +0,0 @@
-
-
-
-#------------------------------------------------------------------------------
-## Useful Constants
-const NULL* = 0
-
-
-#------------------------------------------------------------------------------
-## Memory Utility Functions
-
-proc newHeap*[T](): ptr T =
-  result = cast[ptr T](alloc0(sizeof(T))) 
-
-proc copyNew*[T](x: var T): ptr T =
-  var 
-    size = sizeof(T)    
-    mem = alloc(size)  
-  copyMem(mem, x.addr, size)  
-  return cast[ptr T](mem)
-
-proc copyTo*[T](val: var T, dest: int) = 
-  copyMem(pointer(dest), val.addr, sizeof(T))    
-
-proc allocType*[T](): pointer = alloc(sizeof(T)) 
-
-proc newShared*[T](): ptr T =
-  result = cast[ptr T](allocShared0(sizeof(T))) 
-
-proc copyShared*[T](x: var T): ptr T =
-  var 
-    size = sizeof(T)    
-    mem = allocShared(size)  
-  copyMem(mem, x.addr, size)  
-  return cast[ptr T](mem)
-
-#------------------------------------------------------------------------------
-## Pointer arithmetic 
-
-proc `+`*(p: pointer, i: int): pointer {.inline.} =
-  cast[pointer](cast[int](p) + i)
\ No newline at end of file
diff --git a/lib/pure/collections/critbits.nim b/lib/pure/collections/critbits.nim
index 1fde1f419..8f506409b 100644
--- a/lib/pure/collections/critbits.nim
+++ b/lib/pure/collections/critbits.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2012 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
@@ -12,30 +12,32 @@
 ## by Adam Langley.
 
 type
-  TNode[T] = object {.pure, final, acyclic.}
+  NodeObj[T] = object {.pure, final, acyclic.}
     byte: int ## byte index of the difference
     otherbits: char
     case isLeaf: bool
-    of false: child: array[0..1, ref TNode[T]]
+    of false: child: array[0..1, ref NodeObj[T]]
     of true: 
       key: string
       when T isnot void:
         val: T
     
-  PNode[T] = ref TNode[T]
-  TCritBitTree*[T] = object {.
+  Node[T] = ref NodeObj[T]
+  CritBitTree*[T] = object {.
       pure, final.} ## The crit bit tree can either be used
                     ## as a mapping from strings to
                     ## some type ``T`` or as a set of
                     ## strings if ``T`` is void.
-    root: PNode[T]
+    root: Node[T]
     count: int
-    
-proc len*[T](c: TCritBitTree[T]): int =
+
+{.deprecated: [TCritBitTree: CritBitTree].}
+
+proc len*[T](c: CritBitTree[T]): int =
   ## returns the number of elements in `c` in O(1).
   result = c.count
 
-proc rawGet[T](c: TCritBitTree[T], key: string): PNode[T] =
+proc rawGet[T](c: CritBitTree[T], key: string): Node[T] =
   var it = c.root
   while it != nil:
     if not it.isLeaf:
@@ -45,15 +47,15 @@ proc rawGet[T](c: TCritBitTree[T], key: string): PNode[T] =
     else:
       return if it.key == key: it else: nil
 
-proc contains*[T](c: TCritBitTree[T], key: string): bool {.inline.} =
+proc contains*[T](c: CritBitTree[T], key: string): bool {.inline.} =
   ## returns true iff `c` contains the given `key`.
   result = rawGet(c, key) != nil
 
-proc hasKey*[T](c: TCritBitTree[T], key: string): bool {.inline.} =
+proc hasKey*[T](c: CritBitTree[T], key: string): bool {.inline.} =
   ## alias for `contains`.
   result = rawGet(c, key) != nil
 
-proc rawInsert[T](c: var TCritBitTree[T], key: string): PNode[T] =
+proc rawInsert[T](c: var CritBitTree[T], key: string): Node[T] =
   if c.root == nil:
     new c.root
     c.root.isleaf = true
@@ -84,7 +86,7 @@ proc rawInsert[T](c: var TCritBitTree[T], key: string): PNode[T] =
     let ch = it.key[newByte]
     let dir = (1 + (ord(ch) or newOtherBits)) shr 8
     
-    var inner: PNode[T]
+    var inner: Node[T]
     new inner
     new result
     result.isLeaf = true
@@ -106,7 +108,7 @@ proc rawInsert[T](c: var TCritBitTree[T], key: string): PNode[T] =
     wherep[] = inner
   inc c.count
 
-proc containsOrIncl*[T](c: var TCritBitTree[T], key: string, val: T): bool =
+proc containsOrIncl*[T](c: var CritBitTree[T], key: string, val: T): bool =
   ## returns true iff `c` contains the given `key`. If the key does not exist
   ## ``c[key] = val`` is performed.
   let oldCount = c.count
@@ -115,23 +117,23 @@ proc containsOrIncl*[T](c: var TCritBitTree[T], key: string, val: T): bool =
   when T isnot void:
     if not result: n.val = val
 
-proc containsOrIncl*(c: var TCritBitTree[void], key: string): bool =
+proc containsOrIncl*(c: var CritBitTree[void], key: string): bool =
   ## returns true iff `c` contains the given `key`. If the key does not exist
   ## it is inserted into `c`.
   let oldCount = c.count
   var n = rawInsert(c, key)
   result = c.count == oldCount
 
-proc incl*(c: var TCritBitTree[void], key: string) =
+proc incl*(c: var CritBitTree[void], key: string) =
   ## includes `key` in `c`.
   discard rawInsert(c, key)
 
-proc `[]=`*[T](c: var TCritBitTree[T], key: string, val: T) =
+proc `[]=`*[T](c: var CritBitTree[T], key: string, val: T) =
   ## puts a (key, value)-pair into `t`.
   var n = rawInsert(c, key)
   n.val = val
 
-proc `[]`*[T](c: TCritBitTree[T], key: string): T {.inline.} =
+proc `[]`*[T](c: CritBitTree[T], key: string): T {.inline.} =
   ## retrieves the value at ``c[key]``. If `key` is not in `t`,
   ## default empty value for the type `B` is returned
   ## and no exception is raised. One can check with ``hasKey`` whether the key
@@ -139,22 +141,22 @@ proc `[]`*[T](c: TCritBitTree[T], key: string): T {.inline.} =
   let n = rawGet(c, key)
   if n != nil: result = n.val
 
-proc mget*[T](c: var TCritBitTree[T], key: string): var T {.inline.} =
+proc mget*[T](c: var CritBitTree[T], key: string): var T {.inline.} =
   ## retrieves the value at ``c[key]``. The value can be modified.
-  ## If `key` is not in `t`, the ``EInvalidKey`` exception is raised.
+  ## If `key` is not in `t`, the ``KeyError`` exception is raised.
   let n = rawGet(c, key)
   if n != nil: result = n.val
-  else: raise newException(EInvalidKey, "key not found: " & $key)
+  else: raise newException(KeyError, "key not found: " & $key)
 
-proc excl*[T](c: var TCritBitTree[T], key: string) =
+proc excl*[T](c: var CritBitTree[T], key: string) =
   ## removes `key` (and its associated value) from the set `c`.
   ## If the `key` does not exist, nothing happens.
   var p = c.root
   var wherep = addr(c.root)
-  var whereq: ptr PNode = nil
+  var whereq: ptr Node[T] = nil
   if p == nil: return
   var dir = 0
-  var q: PNode
+  var q: Node[T]
   while not p.isLeaf:
     whereq = wherep
     q = p
@@ -170,7 +172,7 @@ proc excl*[T](c: var TCritBitTree[T], key: string) =
       whereq[] = q.child[1 - dir]
     dec c.count
 
-iterator leaves[T](n: PNode[T]): PNode[T] =
+iterator leaves[T](n: Node[T]): Node[T] =
   if n != nil:
     # XXX actually we could compute the necessary stack size in advance:
     # it's rougly log2(c.count).
@@ -183,33 +185,33 @@ iterator leaves[T](n: PNode[T]): PNode[T] =
         assert(it != nil)
       yield it
 
-iterator keys*[T](c: TCritBitTree[T]): string =
+iterator keys*[T](c: CritBitTree[T]): string =
   ## yields all keys in lexicographical order.
   for x in leaves(c.root): yield x.key
 
-iterator values*[T](c: TCritBitTree[T]): T =
+iterator values*[T](c: CritBitTree[T]): T =
   ## yields all values of `c` in the lexicographical order of the
   ## corresponding keys.
   for x in leaves(c.root): yield x.val
 
-iterator mvalues*[T](c: var TCritBitTree[T]): var T =
+iterator mvalues*[T](c: var CritBitTree[T]): var T =
   ## yields all values of `c` in the lexicographical order of the
   ## corresponding keys. The values can be modified.
   for x in leaves(c.root): yield x.val
 
-iterator items*[T](c: TCritBitTree[T]): string =
+iterator items*[T](c: CritBitTree[T]): string =
   ## yields all keys in lexicographical order.
   for x in leaves(c.root): yield x.key
 
-iterator pairs*[T](c: TCritBitTree[T]): tuple[key: string, val: T] =
+iterator pairs*[T](c: CritBitTree[T]): tuple[key: string, val: T] =
   ## yields all (key, value)-pairs of `c`.
   for x in leaves(c.root): yield (x.key, x.val)
   
-iterator mpairs*[T](c: var TCritBitTree[T]): tuple[key: string, val: var T] =
+iterator mpairs*[T](c: var CritBitTree[T]): tuple[key: string, val: var T] =
   ## yields all (key, value)-pairs of `c`. The yielded values can be modified.
   for x in leaves(c.root): yield (x.key, x.val)
 
-proc allprefixedAux[T](c: TCritBitTree[T], key: string): PNode[T] =
+proc allprefixedAux[T](c: CritBitTree[T], key: string): Node[T] =
   var p = c.root
   var top = p
   if p != nil:
@@ -223,42 +225,42 @@ proc allprefixedAux[T](c: TCritBitTree[T], key: string): PNode[T] =
       if p.key[i] != key[i]: return
     result = top
 
-iterator itemsWithPrefix*[T](c: TCritBitTree[T], prefix: string): string =
+iterator itemsWithPrefix*[T](c: CritBitTree[T], prefix: string): string =
   ## yields all keys starting with `prefix`.
   let top = allprefixedAux(c, prefix)
   for x in leaves(top): yield x.key
 
-iterator keysWithPrefix*[T](c: TCritBitTree[T], prefix: string): string =
+iterator keysWithPrefix*[T](c: CritBitTree[T], prefix: string): string =
   ## yields all keys starting with `prefix`.
   let top = allprefixedAux(c, prefix)
   for x in leaves(top): yield x.key
 
-iterator valuesWithPrefix*[T](c: TCritBitTree[T], prefix: string): T =
+iterator valuesWithPrefix*[T](c: CritBitTree[T], prefix: string): T =
   ## yields all values of `c` starting with `prefix` of the
   ## corresponding keys.
   let top = allprefixedAux(c, prefix)
   for x in leaves(top): yield x.val
 
-iterator mvaluesWithPrefix*[T](c: var TCritBitTree[T], prefix: string): var T =
+iterator mvaluesWithPrefix*[T](c: var CritBitTree[T], prefix: string): var T =
   ## yields all values of `c` starting with `prefix` of the
   ## corresponding keys. The values can be modified.
   let top = allprefixedAux(c, prefix)
   for x in leaves(top): yield x.val
 
-iterator pairsWithPrefix*[T](c: TCritBitTree[T],
+iterator pairsWithPrefix*[T](c: CritBitTree[T],
                              prefix: string): tuple[key: string, val: T] =
   ## yields all (key, value)-pairs of `c` starting with `prefix`.
   let top = allprefixedAux(c, prefix)
   for x in leaves(top): yield (x.key, x.val)
   
-iterator mpairsWithPrefix*[T](c: var TCritBitTree[T],
+iterator mpairsWithPrefix*[T](c: var CritBitTree[T],
                               prefix: string): tuple[key: string, val: var T] =
   ## yields all (key, value)-pairs of `c` starting with `prefix`.
   ## The yielded values can be modified.
   let top = allprefixedAux(c, prefix)
   for x in leaves(top): yield (x.key, x.val)
 
-proc `$`*[T](c: TCritBitTree[T]): string =
+proc `$`*[T](c: CritBitTree[T]): string =
   ## turns `c` into a string representation. Example outputs:
   ## ``{keyA: value, keyB: value}``, ``{:}``
   ## If `T` is void the outputs look like:
@@ -285,7 +287,7 @@ proc `$`*[T](c: TCritBitTree[T]): string =
     result.add("}")
 
 when isMainModule:
-  var r: TCritBitTree[void]
+  var r: CritBitTree[void]
   r.incl "abc"
   r.incl "xyz"
   r.incl "def"
diff --git a/lib/pure/collections/intsets.nim b/lib/pure/collections/intsets.nim
index f1e67fc0e..5d9c3f445 100644
--- a/lib/pure/collections/intsets.nim
+++ b/lib/pure/collections/intsets.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2012 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
@@ -9,7 +9,7 @@
 
 ## The ``intsets`` module implements an efficient int set implemented as a
 ## sparse bit set.
-## **Note**: Since Nimrod currently does not allow the assignment operator to
+## **Note**: Since Nim currently does not allow the assignment operator to
 ## be overloaded, ``=`` for int sets performs some rather meaningless shallow
 ## copy; use ``assign`` to get a deep copy.
 
@@ -17,7 +17,7 @@ import
   os, hashes, math
 
 type
-  TBitScalar = int
+  BitScalar = int
 
 const 
   InitIntSetSize = 8         # must be a power of two!
@@ -25,8 +25,8 @@ const
   BitsPerTrunk = 1 shl TrunkShift # needs to be a power of 2 and
                                   # divisible by 64
   TrunkMask = BitsPerTrunk - 1
-  IntsPerTrunk = BitsPerTrunk div (sizeof(TBitScalar) * 8)
-  IntShift = 5 + ord(sizeof(TBitScalar) == 8) # 5 or 6, depending on int width
+  IntsPerTrunk = BitsPerTrunk div (sizeof(BitScalar) * 8)
+  IntShift = 5 + ord(sizeof(BitScalar) == 8) # 5 or 6, depending on int width
   IntMask = 1 shl IntShift - 1
 
 type
@@ -34,15 +34,16 @@ type
   TTrunk {.final.} = object 
     next: PTrunk             # all nodes are connected with this pointer
     key: int                 # start address at bit 0
-    bits: array[0..IntsPerTrunk - 1, TBitScalar] # a bit vector
+    bits: array[0..IntsPerTrunk - 1, BitScalar] # a bit vector
   
   TTrunkSeq = seq[PTrunk]
-  TIntSet* {.final.} = object ## an efficient set of 'int' implemented as a
-                              ## sparse bit set
+  IntSet* = object ## an efficient set of 'int' implemented as a sparse bit set
     counter, max: int
     head: PTrunk
     data: TTrunkSeq
 
+{.deprecated: [TIntSet: IntSet].}
+
 proc mustRehash(length, counter: int): bool {.inline.} = 
   assert(length > counter)
   result = (length * 2 < counter * 3) or (length - counter < 4)
@@ -50,7 +51,7 @@ proc mustRehash(length, counter: int): bool {.inline.} =
 proc nextTry(h, maxHash: THash): THash {.inline.} = 
   result = ((5 * h) + 1) and maxHash 
 
-proc intSetGet(t: TIntSet, key: int): PTrunk = 
+proc intSetGet(t: IntSet, key: int): PTrunk = 
   var h = key and t.max
   while t.data[h] != nil: 
     if t.data[h].key == key: 
@@ -58,7 +59,7 @@ proc intSetGet(t: TIntSet, key: int): PTrunk =
     h = nextTry(h, t.max)
   result = nil
 
-proc intSetRawInsert(t: TIntSet, data: var TTrunkSeq, desc: PTrunk) = 
+proc intSetRawInsert(t: IntSet, data: var TTrunkSeq, desc: PTrunk) = 
   var h = desc.key and t.max
   while data[h] != nil: 
     assert(data[h] != desc)
@@ -66,7 +67,7 @@ proc intSetRawInsert(t: TIntSet, data: var TTrunkSeq, desc: PTrunk) =
   assert(data[h] == nil)
   data[h] = desc
 
-proc intSetEnlarge(t: var TIntSet) = 
+proc intSetEnlarge(t: var IntSet) = 
   var n: TTrunkSeq
   var oldMax = t.max
   t.max = ((t.max + 1) * 2) - 1
@@ -75,7 +76,7 @@ proc intSetEnlarge(t: var TIntSet) =
     if t.data[i] != nil: intSetRawInsert(t, n, t.data[i])
   swap(t.data, n)
 
-proc intSetPut(t: var TIntSet, key: int): PTrunk = 
+proc intSetPut(t: var IntSet, key: int): PTrunk = 
   var h = key and t.max
   while t.data[h] != nil: 
     if t.data[h].key == key: 
@@ -92,7 +93,7 @@ proc intSetPut(t: var TIntSet, key: int): PTrunk =
   t.head = result
   t.data[h] = result
 
-proc contains*(s: TIntSet, key: int): bool =
+proc contains*(s: IntSet, key: int): bool =
   ## returns true iff `key` is in `s`.  
   var t = intSetGet(s, `shr`(key, TrunkShift))
   if t != nil: 
@@ -101,14 +102,14 @@ proc contains*(s: TIntSet, key: int): bool =
   else: 
     result = false
   
-proc incl*(s: var TIntSet, key: int) = 
+proc incl*(s: var IntSet, key: int) = 
   ## includes an element `key` in `s`.
   var t = intSetPut(s, `shr`(key, TrunkShift))
   var u = key and TrunkMask
   t.bits[`shr`(u, IntShift)] = t.bits[`shr`(u, IntShift)] or
       `shl`(1, u and IntMask)
 
-proc excl*(s: var TIntSet, key: int) = 
+proc excl*(s: var IntSet, key: int) = 
   ## excludes `key` from the set `s`.
   var t = intSetGet(s, `shr`(key, TrunkShift))
   if t != nil: 
@@ -116,7 +117,7 @@ proc excl*(s: var TIntSet, key: int) =
     t.bits[`shr`(u, IntShift)] = t.bits[`shr`(u, IntShift)] and
         not `shl`(1, u and IntMask)
 
-proc containsOrIncl*(s: var TIntSet, key: int): bool = 
+proc containsOrIncl*(s: var IntSet, key: int): bool = 
   ## returns true if `s` contains `key`, otherwise `key` is included in `s`
   ## and false is returned.
   var t = intSetGet(s, `shr`(key, TrunkShift))
@@ -130,14 +131,14 @@ proc containsOrIncl*(s: var TIntSet, key: int): bool =
     incl(s, key)
     result = false
     
-proc initIntSet*: TIntSet =
+proc initIntSet*: IntSet =
   ## creates a new int set that is empty.
   newSeq(result.data, InitIntSetSize)
   result.max = InitIntSetSize-1
   result.counter = 0
   result.head = nil
 
-proc assign*(dest: var TIntSet, src: TIntSet) =
+proc assign*(dest: var IntSet, src: IntSet) =
   ## copies `src` to `dest`. `dest` does not need to be initialized by
   ## `initIntSet`. 
   dest.counter = src.counter
@@ -161,7 +162,7 @@ proc assign*(dest: var TIntSet, src: TIntSet) =
 
     it = it.next
 
-iterator items*(s: TIntSet): int {.inline.} =
+iterator items*(s: IntSet): int {.inline.} =
   ## iterates over any included element of `s`.
   var r = s.head
   while r != nil:
@@ -186,11 +187,11 @@ template dollarImpl(): stmt =
     result.add($key)
   result.add("}")
 
-proc `$`*(s: TIntSet): string =
+proc `$`*(s: IntSet): string =
   ## The `$` operator for int sets.
   dollarImpl()
 
-proc empty*(s: TIntSet): bool {.inline.} =
+proc empty*(s: IntSet): bool {.inline.} =
   ## returns true if `s` is empty. This is safe to call even before
   ## the set has been initialized with `initIntSet`.
   result = s.counter == 0
diff --git a/lib/pure/collections/lists.nim b/lib/pure/collections/lists.nim
index b8f8d20b5..929de5973 100644
--- a/lib/pure/collections/lists.nim
+++ b/lib/pure/collections/lists.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2012 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
@@ -15,52 +15,59 @@ when not defined(nimhygiene):
   {.pragma: dirty.}
 
 type
-  TDoublyLinkedNode* {.pure, 
-      final.}[T] = object ## a node a doubly linked list consists of
-    next*, prev*: ref TDoublyLinkedNode[T]
+  DoublyLinkedNodeObj*[T] = object ## a node a doubly linked list consists of
+    next*, prev*: ref DoublyLinkedNodeObj[T]
     value*: T
-  PDoublyLinkedNode*[T] = ref TDoublyLinkedNode[T]
+  DoublyLinkedNode*[T] = ref DoublyLinkedNodeObj[T]
 
-  TSinglyLinkedNode* {.pure, 
-      final.}[T] = object ## a node a singly linked list consists of
-    next*: ref TSinglyLinkedNode[T]
+  SinglyLinkedNodeObj*[T] = object ## a node a singly linked list consists of
+    next*: ref SinglyLinkedNodeObj[T]
     value*: T
-  PSinglyLinkedNode*[T] = ref TSinglyLinkedNode[T]
+  SinglyLinkedNode*[T] = ref SinglyLinkedNodeObj[T]
 
-  TSinglyLinkedList* {.pure, final.}[T] = object ## a singly linked list
-    head*, tail*: PSinglyLinkedNode[T]
+  SinglyLinkedList*[T] = object ## a singly linked list
+    head*, tail*: SinglyLinkedNode[T]
   
-  TDoublyLinkedList* {.pure, final.}[T] = object ## a doubly linked list
-    head*, tail*: PDoublyLinkedNode[T]
+  DoublyLinkedList*[T] = object ## a doubly linked list
+    head*, tail*: DoublyLinkedNode[T]
 
-  TSinglyLinkedRing* {.pure, final.}[T] = object ## a singly linked ring
-    head*: PSinglyLinkedNode[T]
+  SinglyLinkedRing*[T] = object ## a singly linked ring
+    head*: SinglyLinkedNode[T]
   
-  TDoublyLinkedRing* {.pure, final.}[T] = object ## a doubly linked ring
-    head*: PDoublyLinkedNode[T]
-
-proc initSinglyLinkedList*[T](): TSinglyLinkedList[T] =
+  DoublyLinkedRing*[T] = object ## a doubly linked ring
+    head*: DoublyLinkedNode[T]
+
+{.deprecated: [TDoublyLinkedNode: DoublyLinkedNodeObj,
+    PDoublyLinkedNode: DoublyLinkedNode, 
+    TSinglyLinkedNode: SinglyLinkedNodeObj,
+    PSinglyLinkedNode: SinglyLinkedNode,
+    TDoublyLinkedList: DoublyLinkedList,
+    TSinglyLinkedRing: SinglyLinkedRing,
+    TDoublyLinkedRing: DoublyLinkedRing,
+    TSinglyLinkedList: SinglyLinkedList].}
+
+proc initSinglyLinkedList*[T](): SinglyLinkedList[T] =
   ## creates a new singly linked list that is empty.
   discard
 
-proc initDoublyLinkedList*[T](): TDoublyLinkedList[T] =
+proc initDoublyLinkedList*[T](): DoublyLinkedList[T] =
   ## creates a new doubly linked list that is empty.
   discard
 
-proc initSinglyLinkedRing*[T](): TSinglyLinkedRing[T] =
+proc initSinglyLinkedRing*[T](): SinglyLinkedRing[T] =
   ## creates a new singly linked ring that is empty.
   discard
 
-proc initDoublyLinkedRing*[T](): TDoublyLinkedRing[T] =
+proc initDoublyLinkedRing*[T](): DoublyLinkedRing[T] =
   ## creates a new doubly linked ring that is empty.
   discard
 
-proc newDoublyLinkedNode*[T](value: T): PDoublyLinkedNode[T] =
+proc newDoublyLinkedNode*[T](value: T): DoublyLinkedNode[T] =
   ## creates a new doubly linked node with the given `value`.
   new(result)
   result.value = value
 
-proc newSinglyLinkedNode*[T](value: T): PSinglyLinkedNode[T] =
+proc newSinglyLinkedNode*[T](value: T): SinglyLinkedNode[T] =
   ## creates a new singly linked node with the given `value`.
   new(result)
   result.value = value
@@ -99,38 +106,38 @@ template findImpl() {.dirty.} =
   for x in nodes(L):
     if x.value == value: return x
 
-iterator items*[T](L: TDoublyLinkedList[T]): T = 
+iterator items*[T](L: DoublyLinkedList[T]): T = 
   ## yields every value of `L`.
   itemsListImpl()
 
-iterator items*[T](L: TSinglyLinkedList[T]): T = 
+iterator items*[T](L: SinglyLinkedList[T]): T = 
   ## yields every value of `L`.
   itemsListImpl()
 
-iterator items*[T](L: TSinglyLinkedRing[T]): T = 
+iterator items*[T](L: SinglyLinkedRing[T]): T = 
   ## yields every value of `L`.
   itemsRingImpl()
 
-iterator items*[T](L: TDoublyLinkedRing[T]): T = 
+iterator items*[T](L: DoublyLinkedRing[T]): T = 
   ## yields every value of `L`.
   itemsRingImpl()
 
-iterator nodes*[T](L: TSinglyLinkedList[T]): PSinglyLinkedNode[T] = 
+iterator nodes*[T](L: SinglyLinkedList[T]): SinglyLinkedNode[T] = 
   ## iterates over every node of `x`. Removing the current node from the
   ## list during traversal is supported.
   nodesListImpl()
 
-iterator nodes*[T](L: TDoublyLinkedList[T]): PDoublyLinkedNode[T] = 
+iterator nodes*[T](L: DoublyLinkedList[T]): DoublyLinkedNode[T] = 
   ## iterates over every node of `x`. Removing the current node from the
   ## list during traversal is supported.
   nodesListImpl()
 
-iterator nodes*[T](L: TSinglyLinkedRing[T]): PSinglyLinkedNode[T] = 
+iterator nodes*[T](L: SinglyLinkedRing[T]): SinglyLinkedNode[T] = 
   ## iterates over every node of `x`. Removing the current node from the
   ## list during traversal is supported.
   nodesRingImpl()
 
-iterator nodes*[T](L: TDoublyLinkedRing[T]): PDoublyLinkedNode[T] = 
+iterator nodes*[T](L: DoublyLinkedRing[T]): DoublyLinkedNode[T] = 
   ## iterates over every node of `x`. Removing the current node from the
   ## list during traversal is supported.
   nodesRingImpl()
@@ -142,73 +149,73 @@ template dollarImpl() {.dirty.} =
     result.add($x.value)
   result.add("]")
 
-proc `$`*[T](L: TSinglyLinkedList[T]): string = 
+proc `$`*[T](L: SinglyLinkedList[T]): string = 
   ## turns a list into its string representation.
   dollarImpl()
 
-proc `$`*[T](L: TDoublyLinkedList[T]): string = 
+proc `$`*[T](L: DoublyLinkedList[T]): string = 
   ## turns a list into its string representation.
   dollarImpl()
 
-proc `$`*[T](L: TSinglyLinkedRing[T]): string = 
+proc `$`*[T](L: SinglyLinkedRing[T]): string = 
   ## turns a list into its string representation.
   dollarImpl()
 
-proc `$`*[T](L: TDoublyLinkedRing[T]): string = 
+proc `$`*[T](L: DoublyLinkedRing[T]): string = 
   ## turns a list into its string representation.
   dollarImpl()
 
-proc find*[T](L: TSinglyLinkedList[T], value: T): PSinglyLinkedNode[T] = 
+proc find*[T](L: SinglyLinkedList[T], value: T): SinglyLinkedNode[T] = 
   ## searches in the list for a value. Returns nil if the value does not
   ## exist.
   findImpl()
 
-proc find*[T](L: TDoublyLinkedList[T], value: T): PDoublyLinkedNode[T] = 
+proc find*[T](L: DoublyLinkedList[T], value: T): DoublyLinkedNode[T] = 
   ## searches in the list for a value. Returns nil if the value does not
   ## exist.
   findImpl()
 
-proc find*[T](L: TSinglyLinkedRing[T], value: T): PSinglyLinkedNode[T] = 
+proc find*[T](L: SinglyLinkedRing[T], value: T): SinglyLinkedNode[T] = 
   ## searches in the list for a value. Returns nil if the value does not
   ## exist.
   findImpl()
 
-proc find*[T](L: TDoublyLinkedRing[T], value: T): PDoublyLinkedNode[T] = 
+proc find*[T](L: DoublyLinkedRing[T], value: T): DoublyLinkedNode[T] = 
   ## searches in the list for a value. Returns nil if the value does not
   ## exist.
   findImpl()
 
-proc contains*[T](L: TSinglyLinkedList[T], value: T): bool {.inline.} = 
+proc contains*[T](L: SinglyLinkedList[T], value: T): bool {.inline.} = 
   ## searches in the list for a value. Returns false if the value does not
   ## exist, true otherwise.
   result = find(L, value) != nil
 
-proc contains*[T](L: TDoublyLinkedList[T], value: T): bool {.inline.} = 
+proc contains*[T](L: DoublyLinkedList[T], value: T): bool {.inline.} = 
   ## searches in the list for a value. Returns false if the value does not
   ## exist, true otherwise.
   result = find(L, value) != nil
 
-proc contains*[T](L: TSinglyLinkedRing[T], value: T): bool {.inline.} = 
+proc contains*[T](L: SinglyLinkedRing[T], value: T): bool {.inline.} = 
   ## searches in the list for a value. Returns false if the value does not
   ## exist, true otherwise.
   result = find(L, value) != nil
 
-proc contains*[T](L: TDoublyLinkedRing[T], value: T): bool {.inline.} = 
+proc contains*[T](L: DoublyLinkedRing[T], value: T): bool {.inline.} = 
   ## searches in the list for a value. Returns false if the value does not
   ## exist, true otherwise.
   result = find(L, value) != nil
 
-proc prepend*[T](L: var TSinglyLinkedList[T], 
-                 n: PSinglyLinkedNode[T]) {.inline.} = 
+proc prepend*[T](L: var SinglyLinkedList[T], 
+                 n: SinglyLinkedNode[T]) {.inline.} = 
   ## prepends a node to `L`. Efficiency: O(1).
   n.next = L.head
   L.head = n
 
-proc prepend*[T](L: var TSinglyLinkedList[T], value: T) {.inline.} = 
+proc prepend*[T](L: var SinglyLinkedList[T], value: T) {.inline.} = 
   ## prepends a node to `L`. Efficiency: O(1).
   prepend(L, newSinglyLinkedNode(value))
   
-proc append*[T](L: var TDoublyLinkedList[T], n: PDoublyLinkedNode[T]) = 
+proc append*[T](L: var DoublyLinkedList[T], n: DoublyLinkedNode[T]) = 
   ## appends a node `n` to `L`. Efficiency: O(1).
   n.next = nil
   n.prev = L.tail
@@ -218,11 +225,11 @@ proc append*[T](L: var TDoublyLinkedList[T], n: PDoublyLinkedNode[T]) =
   L.tail = n
   if L.head == nil: L.head = n
 
-proc append*[T](L: var TDoublyLinkedList[T], value: T) = 
+proc append*[T](L: var DoublyLinkedList[T], value: T) = 
   ## appends a value to `L`. Efficiency: O(1).
   append(L, newDoublyLinkedNode(value))
 
-proc prepend*[T](L: var TDoublyLinkedList[T], n: PDoublyLinkedNode[T]) = 
+proc prepend*[T](L: var DoublyLinkedList[T], n: DoublyLinkedNode[T]) = 
   ## prepends a node `n` to `L`. Efficiency: O(1).
   n.prev = nil
   n.next = L.head
@@ -232,11 +239,11 @@ proc prepend*[T](L: var TDoublyLinkedList[T], n: PDoublyLinkedNode[T]) =
   L.head = n
   if L.tail == nil: L.tail = n
 
-proc prepend*[T](L: var TDoublyLinkedList[T], value: T) = 
+proc prepend*[T](L: var DoublyLinkedList[T], value: T) = 
   ## prepends a value to `L`. Efficiency: O(1).
   prepend(L, newDoublyLinkedNode(value))
   
-proc remove*[T](L: var TDoublyLinkedList[T], n: PDoublyLinkedNode[T]) = 
+proc remove*[T](L: var DoublyLinkedList[T], n: DoublyLinkedNode[T]) = 
   ## removes `n` from `L`. Efficiency: O(1).
   if n == L.tail: L.tail = n.prev
   if n == L.head: L.head = n.next
@@ -244,7 +251,7 @@ proc remove*[T](L: var TDoublyLinkedList[T], n: PDoublyLinkedNode[T]) =
   if n.prev != nil: n.prev.next = n.next
 
 
-proc prepend*[T](L: var TSinglyLinkedRing[T], n: PSinglyLinkedNode[T]) = 
+proc prepend*[T](L: var SinglyLinkedRing[T], n: SinglyLinkedNode[T]) = 
   ## prepends a node `n` to `L`. Efficiency: O(1).
   if L.head != nil: 
     n.next = L.head    
@@ -253,11 +260,11 @@ proc prepend*[T](L: var TSinglyLinkedRing[T], n: PSinglyLinkedNode[T]) =
     n.next = n
   L.head = n
 
-proc prepend*[T](L: var TSinglyLinkedRing[T], value: T) = 
+proc prepend*[T](L: var SinglyLinkedRing[T], value: T) = 
   ## prepends a value to `L`. Efficiency: O(1).
   prepend(L, newSinglyLinkedNode(value))
 
-proc append*[T](L: var TDoublyLinkedRing[T], n: PDoublyLinkedNode[T]) = 
+proc append*[T](L: var DoublyLinkedRing[T], n: DoublyLinkedNode[T]) = 
   ## appends a node `n` to `L`. Efficiency: O(1).
   if L.head != nil:
     n.next = L.head
@@ -269,11 +276,11 @@ proc append*[T](L: var TDoublyLinkedRing[T], n: PDoublyLinkedNode[T]) =
     n.next = n
     L.head = n
 
-proc append*[T](L: var TDoublyLinkedRing[T], value: T) = 
+proc append*[T](L: var DoublyLinkedRing[T], value: T) = 
   ## appends a value to `L`. Efficiency: O(1).
   append(L, newDoublyLinkedNode(value))
 
-proc prepend*[T](L: var TDoublyLinkedRing[T], n: PDoublyLinkedNode[T]) = 
+proc prepend*[T](L: var DoublyLinkedRing[T], n: DoublyLinkedNode[T]) = 
   ## prepends a node `n` to `L`. Efficiency: O(1).
   if L.head != nil: 
     n.next = L.head
@@ -285,11 +292,11 @@ proc prepend*[T](L: var TDoublyLinkedRing[T], n: PDoublyLinkedNode[T]) =
     n.next = n
   L.head = n
 
-proc prepend*[T](L: var TDoublyLinkedRing[T], value: T) = 
+proc prepend*[T](L: var DoublyLinkedRing[T], value: T) = 
   ## prepends a value to `L`. Efficiency: O(1).
   prepend(L, newDoublyLinkedNode(value))
   
-proc remove*[T](L: var TDoublyLinkedRing[T], n: PDoublyLinkedNode[T]) = 
+proc remove*[T](L: var DoublyLinkedRing[T], n: DoublyLinkedNode[T]) = 
   ## removes `n` from `L`. Efficiency: O(1).
   n.next.prev = n.prev
   n.prev.next = n.next
@@ -300,5 +307,3 @@ proc remove*[T](L: var TDoublyLinkedRing[T], n: PDoublyLinkedNode[T]) =
       L.head = nil
     else:
       L.head = L.head.prev
-
-
diff --git a/lib/pure/collections/queues.nim b/lib/pure/collections/queues.nim
index 5481272f0..d1c94868a 100644
--- a/lib/pure/collections/queues.nim
+++ b/lib/pure/collections/queues.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2012 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
@@ -12,13 +12,15 @@
 import math
 
 type
-  TQueue* {.pure, final.}[T] = object ## a queue
+  Queue*[T] = object ## a queue
     data: seq[T]
     rd, wr, count, mask: int
-    
+
+{.deprecated: [TQueue: Queue].}
+
 proc initQueue*[T](initialSize=4): TQueue[T] =
   ## creates a new queue. `initialSize` needs to be a power of 2.
-  assert IsPowerOfTwo(initialSize)
+  assert isPowerOfTwo(initialSize)
   result.mask = initialSize-1
   newSeq(result.data, initialSize)
 
diff --git a/lib/pure/collections/sequtils.nim b/lib/pure/collections/sequtils.nim
index 2629e9f40..b824210a5 100644
--- a/lib/pure/collections/sequtils.nim
+++ b/lib/pure/collections/sequtils.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2011 Alex Mitchell
 #
 #    See the file "copying.txt", included in this
@@ -31,7 +31,7 @@ proc concat*[T](seqs: varargs[seq[T]]): seq[T] =
   ##
   ## Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   let
   ##     s1 = @[1, 2, 3]
   ##     s2 = @[4, 5]
@@ -50,7 +50,7 @@ proc concat*[T](seqs: varargs[seq[T]]): seq[T] =
 proc deduplicate*[T](seq1: seq[T]): seq[T] =
   ## Returns a new sequence without duplicates.
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   let
   ##     dup1 = @[1, 1, 3, 4, 2, 2, 8, 1, 4]
   ##     dup2 = @["a", "a", "c", "d", "d"]
@@ -61,6 +61,8 @@ proc deduplicate*[T](seq1: seq[T]): seq[T] =
   result = @[]
   for itm in items(seq1):
     if not result.contains(itm): result.add(itm)
+
+{.deprecated: [distnct: deduplicate].}
     
 proc zip*[S, T](seq1: seq[S], seq2: seq[T]): seq[tuple[a: S, b: T]] =
   ## Returns a new sequence with a combination of the two input sequences.
@@ -69,7 +71,7 @@ proc zip*[S, T](seq1: seq[S], seq2: seq[T]): seq[tuple[a: S, b: T]] =
   ## fields `a` and `b`. If one sequence is shorter, the remaining items in the
   ## longer sequence are discarded. Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   let
   ##     short = @[1, 2, 3]
   ##     long = @[6, 5, 4, 3, 2, 1]
@@ -104,7 +106,7 @@ proc distribute*[T](s: seq[T], num: int, spread = true): seq[seq[T]] =
   ##
   ## Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   let numbers = @[1, 2, 3, 4, 5, 6, 7]
   ##   assert numbers.distribute(3) == @[@[1, 2, 3], @[4, 5], @[6, 7]]
   ##   assert numbers.distribute(3, false)  == @[@[1, 2, 3], @[4, 5, 6], @[7]]
@@ -155,7 +157,7 @@ iterator filter*[T](seq1: seq[T], pred: proc(item: T): bool {.closure.}): T =
   ##
   ## Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   let numbers = @[1, 4, 5, 8, 9, 7, 4]
   ##   for n in filter(numbers, proc (x: int): bool = x mod 2 == 0):
   ##     echo($n)
@@ -169,7 +171,7 @@ proc filter*[T](seq1: seq[T], pred: proc(item: T): bool {.closure.}): seq[T] =
   ##
   ## Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   let
   ##     colors = @["red", "yellow", "black"]
   ##     f1 = filter(colors, proc(x: string): bool = x.len < 6)
@@ -184,7 +186,7 @@ proc keepIf*[T](seq1: var seq[T], pred: proc(item: T): bool {.closure.}) =
   ##
   ## Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   var floats = @[13.0, 12.5, 5.8, 2.0, 6.1, 9.9, 10.1]
   ##   keepIf(floats, proc(x: float): bool = x > 10)
   ##   assert floats == @[13.0, 12.5, 10.1]
@@ -202,7 +204,7 @@ proc delete*[T](s: var seq[T], first=0, last=0) =
   ##
   ## Example:
   ##
-  ##.. code-block:: nimrod
+  ##.. code-block::
   ##   let outcome = @[1,1,1,1,1,1,1,1]
   ##   var dest = @[1,1,1,2,2,2,2,2,2,1,1,1,1,1]
   ##   dest.delete(3, 8)
@@ -223,7 +225,7 @@ proc insert*[T](dest: var seq[T], src: openArray[T], pos=0) =
   ##
   ## Example:
   ##
-  ##.. code-block:: nimrod
+  ##.. code-block::
   ##   var dest = @[1,1,1,1,1,1,1,1]
   ##   let 
   ##     src = @[2,2,2,2,2,2]
@@ -254,7 +256,7 @@ template filterIt*(seq1, pred: expr): expr {.immediate.} =
   ## the ``it`` variable for testing, like: ``filterIt("abcxyz", it == 'x')``.
   ## Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##    let
   ##      temperatures = @[-272.15, -2.0, 24.5, 44.31, 99.9, -113.44]
   ##      acceptable = filterIt(temperatures, it < 50 and it > -10)
@@ -273,7 +275,7 @@ template keepItIf*(varSeq, pred: expr) =
   ## the ``it`` variable for testing, like: ``keepItIf("abcxyz", it == 'x')``.
   ## Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   var candidates = @["foo", "bar", "baz", "foobar"]
   ##   keepItIf(candidates, it.len == 3 and it[0] == 'b')
   ##   assert candidates == @["bar", "baz"]
@@ -292,7 +294,7 @@ template toSeq*(iter: expr): expr {.immediate.} =
   ##
   ## Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   let
   ##     numeric = @[1, 2, 3, 4, 5, 6, 7, 8, 9]
   ##     odd_numbers = toSeq(filter(numeric) do (x: int) -> bool:
@@ -318,18 +320,18 @@ template foldl*(sequence, operation: expr): expr =
   ## the sequence of numbers 1, 2 and 3 will be parenthesized as (((1) - 2) -
   ## 3).  Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   let
   ##     numbers = @[5, 9, 11]
   ##     addition = foldl(numbers, a + b)
   ##     substraction = foldl(numbers, a - b)
   ##     multiplication = foldl(numbers, a * b)
-  ##     words = @["nim", "rod", "is", "cool"]
+  ##     words = @["nim", "is", "cool"]
   ##     concatenation = foldl(words, a & b)
   ##   assert addition == 25, "Addition is (((5)+9)+11)"
   ##   assert substraction == -15, "Substraction is (((5)-9)-11)"
   ##   assert multiplication == 495, "Multiplication is (((5)*9)*11)"
-  ##   assert concatenation == "nimrodiscool"
+  ##   assert concatenation == "nimiscool"
   assert sequence.len > 0, "Can't fold empty sequences"
   var result {.gensym.}: type(sequence[0])
   result = sequence[0]
@@ -354,18 +356,18 @@ template foldr*(sequence, operation: expr): expr =
   ## the sequence of numbers 1, 2 and 3 will be parenthesized as (1 - (2 -
   ## (3))). Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   let
   ##     numbers = @[5, 9, 11]
   ##     addition = foldr(numbers, a + b)
   ##     substraction = foldr(numbers, a - b)
   ##     multiplication = foldr(numbers, a * b)
-  ##     words = @["nim", "rod", "is", "cool"]
+  ##     words = @["nim", "is", "cool"]
   ##     concatenation = foldr(words, a & b)
   ##   assert addition == 25, "Addition is (5+(9+(11)))"
   ##   assert substraction == 7, "Substraction is (5-(9-(11)))"
   ##   assert multiplication == 495, "Multiplication is (5*(9*(11)))"
-  ##   assert concatenation == "nimrodiscool"
+  ##   assert concatenation == "nimiscool"
   assert sequence.len > 0, "Can't fold empty sequences"
   var result {.gensym.}: type(sequence[0])
   result = sequence[sequence.len - 1]
@@ -384,7 +386,7 @@ template mapIt*(seq1, typ, pred: expr): expr =
   ## since the new returned sequence can have a different type than the
   ## original.  Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   let
   ##     nums = @[1, 2, 3, 4]
   ##     strings = nums.mapIt(string, $(4 * it))
@@ -401,7 +403,7 @@ template mapIt*(varSeq, pred: expr) =
   ## expression. The expression has to return the same type as the sequence you
   ## are mutating. Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   var nums = @[1, 2, 3, 4]
   ##   nums.mapIt(it * 3)
   ##   assert nums[0] + nums[3] == 15
@@ -412,7 +414,7 @@ template mapIt*(varSeq, pred: expr) =
 template newSeqWith*(len: int, init: expr): expr =
   ## creates a new sequence, calling `init` to initialize each value. Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block::
   ##   var seq2D = newSeqWith(20, newSeq[bool](10))
   ##   seq2D[0][0] = true
   ##   seq2D[1][0] = true
@@ -503,12 +505,12 @@ when isMainModule:
       addition = foldl(numbers, a + b)
       substraction = foldl(numbers, a - b)
       multiplication = foldl(numbers, a * b)
-      words = @["nim", "rod", "is", "cool"]
+      words = @["nim", "is", "cool"]
       concatenation = foldl(words, a & b)
     assert addition == 25, "Addition is (((5)+9)+11)"
     assert substraction == -15, "Substraction is (((5)-9)-11)"
     assert multiplication == 495, "Multiplication is (((5)*9)*11)"
-    assert concatenation == "nimrodiscool"
+    assert concatenation == "nimiscool"
 
   block: # foldr tests
     let
@@ -516,12 +518,12 @@ when isMainModule:
       addition = foldr(numbers, a + b)
       substraction = foldr(numbers, a - b)
       multiplication = foldr(numbers, a * b)
-      words = @["nim", "rod", "is", "cool"]
+      words = @["nim", "is", "cool"]
       concatenation = foldr(words, a & b)
     assert addition == 25, "Addition is (5+(9+(11)))"
     assert substraction == 7, "Substraction is (5-(9-(11)))"
     assert multiplication == 495, "Multiplication is (5*(9*(11)))"
-    assert concatenation == "nimrodiscool"
+    assert concatenation == "nimiscool"
 
   block: # delete tests
     let outcome = @[1,1,1,1,1,1,1,1]
diff --git a/lib/pure/collections/sets.nim b/lib/pure/collections/sets.nim
index ce901963e..92ef3152d 100644
--- a/lib/pure/collections/sets.nim
+++ b/lib/pure/collections/sets.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2012 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
@@ -24,18 +24,20 @@ when not defined(nimhygiene):
   {.pragma: dirty.}
 
 type
-  TSlotEnum = enum seEmpty, seFilled, seDeleted
-  TKeyValuePair[A] = tuple[slot: TSlotEnum, key: A]
-  TKeyValuePairSeq[A] = seq[TKeyValuePair[A]]
-  TSet* {.final, myShallow.}[A] = object ## \
+  SlotEnum = enum seEmpty, seFilled, seDeleted
+  KeyValuePair[A] = tuple[slot: SlotEnum, key: A]
+  KeyValuePairSeq[A] = seq[KeyValuePair[A]]
+  HashSet* {.myShallow.}[A] = object ## \
     ## A generic hash set.
     ##
-    ## Use `init() <#init,TSet[A],int>`_ or `initSet[type]() <#initSet>`_
+    ## Use `init() <#init,HashSet[A],int>`_ or `initSet[type]() <#initSet>`_
     ## before calling other procs on it.
-    data: TKeyValuePairSeq[A]
+    data: KeyValuePairSeq[A]
     counter: int
 
-proc isValid*[A](s: TSet[A]): bool =
+{.deprecated: [TSet: HashSet].}
+
+proc isValid*[A](s: HashSet[A]): bool =
   ## Returns `true` if the set has been initialized with `initSet <#initSet>`_.
   ##
   ## Most operations over an uninitialized set will crash at runtime and
@@ -43,13 +45,13 @@ proc isValid*[A](s: TSet[A]): bool =
   ## your own procs to verify that sets passed to your procs are correctly
   ## initialized. Example:
   ##
-  ## .. code-block :: nimrod
+  ## .. code-block ::
   ##   proc savePreferences(options: TSet[string]) =
   ##     assert options.isValid, "Pass an initialized set!"
   ##     # Do stuff here, may crash in release builds!
   result = not s.data.isNil
 
-proc len*[A](s: TSet[A]): int =
+proc len*[A](s: HashSet[A]): int =
   ## Returns the number of keys in `s`.
   ##
   ## Due to an implementation detail you can call this proc on variables which
@@ -63,14 +65,14 @@ proc len*[A](s: TSet[A]): int =
   ##   assert values.len == 0
   result = s.counter
 
-proc card*[A](s: TSet[A]): int =
+proc card*[A](s: HashSet[A]): int =
   ## Alias for `len() <#len,TSet[A]>`_.
   ##
   ## Card stands for the `cardinality
   ## <http://en.wikipedia.org/wiki/Cardinality>`_ of a set.
   result = s.counter
 
-iterator items*[A](s: TSet[A]): A =
+iterator items*[A](s: HashSet[A]): A =
   ## Iterates over keys in the set `s`.
   ##
   ## If you need a sequence with the keys you can use `sequtils.toSeq()
@@ -118,10 +120,10 @@ template rawInsertImpl() {.dirty.} =
   data[h].key = key
   data[h].slot = seFilled
 
-proc rawGet[A](s: TSet[A], key: A): int =
+proc rawGet[A](s: HashSet[A], key: A): int =
   rawGetImpl()
 
-proc mget*[A](s: var TSet[A], key: A): var A =
+proc mget*[A](s: var HashSet[A], key: A): var A =
   ## returns the element that is actually stored in 's' which has the same
   ## value as 'key' or raises the ``EInvalidKey`` exception. This is useful
   ## when one overloaded 'hash' and '==' but still needs reference semantics
@@ -129,9 +131,9 @@ proc mget*[A](s: var TSet[A], key: A): var A =
   assert s.isValid, "The set needs to be initialized."
   var index = rawGet(s, key)
   if index >= 0: result = s.data[index].key
-  else: raise newException(EInvalidKey, "key not found: " & $key)
+  else: raise newException(KeyError, "key not found: " & $key)
 
-proc contains*[A](s: TSet[A], key: A): bool =
+proc contains*[A](s: HashSet[A], key: A): bool =
   ## Returns true iff `key` is in `s`.
   ##
   ## Example:
@@ -147,11 +149,11 @@ proc contains*[A](s: TSet[A], key: A): bool =
   var index = rawGet(s, key)
   result = index >= 0
 
-proc rawInsert[A](s: var TSet[A], data: var TKeyValuePairSeq[A], key: A) =
+proc rawInsert[A](s: var HashSet[A], data: var KeyValuePairSeq[A], key: A) =
   rawInsertImpl()
 
-proc enlarge[A](s: var TSet[A]) =
-  var n: TKeyValuePairSeq[A]
+proc enlarge[A](s: var HashSet[A]) =
+  var n: KeyValuePairSeq[A]
   newSeq(n, len(s.data) * growthFactor)
   for i in countup(0, high(s.data)):
     if s.data[i].slot == seFilled: rawInsert(s, n, s.data[i].key)
@@ -173,7 +175,7 @@ template containsOrInclImpl() {.dirty.} =
     rawInsert(s, s.data, key)
     inc(s.counter)
 
-proc incl*[A](s: var TSet[A], key: A) =
+proc incl*[A](s: var HashSet[A], key: A) =
   ## Includes an element `key` in `s`.
   ##
   ## This doesn't do anything if `key` is already in `s`. Example:
@@ -186,7 +188,7 @@ proc incl*[A](s: var TSet[A], key: A) =
   assert s.isValid, "The set needs to be initialized."
   inclImpl()
 
-proc incl*[A](s: var TSet[A], other: TSet[A]) =
+proc incl*[A](s: var HashSet[A], other: HashSet[A]) =
   ## Includes all elements from `other` into `s`.
   ##
   ## Example:
@@ -201,7 +203,7 @@ proc incl*[A](s: var TSet[A], other: TSet[A]) =
   assert other.isValid, "The set `other` needs to be initialized."
   for item in other: incl(s, item)
 
-proc excl*[A](s: var TSet[A], key: A) =
+proc excl*[A](s: var HashSet[A], key: A) =
   ## Excludes `key` from the set `s`.
   ##
   ## This doesn't do anything if `key` is not found in `s`. Example:
@@ -217,7 +219,7 @@ proc excl*[A](s: var TSet[A], key: A) =
     s.data[index].slot = seDeleted
     dec(s.counter)
 
-proc excl*[A](s: var TSet[A], other: TSet[A]) =
+proc excl*[A](s: var HashSet[A], other: HashSet[A]) =
   ## Excludes everything in `other` from `s`.
   ##
   ## Example:
@@ -233,7 +235,7 @@ proc excl*[A](s: var TSet[A], other: TSet[A]) =
   assert other.isValid, "The set `other` needs to be initialized."
   for item in other: excl(s, item)
 
-proc containsOrIncl*[A](s: var TSet[A], key: A): bool =
+proc containsOrIncl*[A](s: var HashSet[A], key: A): bool =
   ## Includes `key` in the set `s` and tells if `key` was added to `s`.
   ##
   ## The difference with regards to the `incl() <#incl,TSet[A],A>`_ proc is
@@ -248,7 +250,7 @@ proc containsOrIncl*[A](s: var TSet[A], key: A): bool =
   assert s.isValid, "The set needs to be initialized."
   containsOrInclImpl()
 
-proc init*[A](s: var TSet[A], initialSize=64) =
+proc init*[A](s: var HashSet[A], initialSize=64) =
   ## Initializes a hash set.
   ##
   ## The `initialSize` parameter needs to be a power of too. You can use
@@ -271,7 +273,7 @@ proc init*[A](s: var TSet[A], initialSize=64) =
   s.counter = 0
   newSeq(s.data, initialSize)
 
-proc initSet*[A](initialSize=64): TSet[A] =
+proc initSet*[A](initialSize=64): HashSet[A] =
   ## Wrapper around `init() <#init,TSet[A],int>`_ for initialization of hash
   ## sets.
   ##
@@ -283,7 +285,7 @@ proc initSet*[A](initialSize=64): TSet[A] =
   ##   a.incl(2)
   result.init(initialSize)
 
-proc toSet*[A](keys: openArray[A]): TSet[A] =
+proc toSet*[A](keys: openArray[A]): HashSet[A] =
   ## Creates a new hash set that contains the given `keys`.
   ##
   ## Example:
@@ -302,7 +304,7 @@ template dollarImpl(): stmt {.dirty.} =
     result.add($key)
   result.add("}")
 
-proc `$`*[A](s: TSet[A]): string =
+proc `$`*[A](s: HashSet[A]): string =
   ## Converts the set `s` to a string, mostly for logging purposes.
   ##
   ## Don't use this proc for serialization, the representation may change at
@@ -318,7 +320,7 @@ proc `$`*[A](s: TSet[A]): string =
   assert s.isValid, "The set needs to be initialized."
   dollarImpl()
 
-proc union*[A](s1, s2: TSet[A]): TSet[A] =
+proc union*[A](s1, s2: HashSet[A]): HashSet[A] =
   ## Returns the union of the sets `s1` and `s2`.
   ##
   ## The union of two sets is represented mathematically as *A ∪ B* and is the
@@ -335,7 +337,7 @@ proc union*[A](s1, s2: TSet[A]): TSet[A] =
   result = s1
   incl(result, s2)
 
-proc intersection*[A](s1, s2: TSet[A]): TSet[A] =
+proc intersection*[A](s1, s2: HashSet[A]): HashSet[A] =
   ## Returns the intersection of the sets `s1` and `s2`.
   ##
   ## The intersection of two sets is represented mathematically as *A ∩ B* and
@@ -354,7 +356,7 @@ proc intersection*[A](s1, s2: TSet[A]): TSet[A] =
   for item in s1:
     if item in s2: incl(result, item)
 
-proc difference*[A](s1, s2: TSet[A]): TSet[A] =
+proc difference*[A](s1, s2: HashSet[A]): HashSet[A] =
   ## Returns the difference of the sets `s1` and `s2`.
   ##
   ## The difference of two sets is represented mathematically as *A \ B* and is
@@ -374,7 +376,7 @@ proc difference*[A](s1, s2: TSet[A]): TSet[A] =
     if not contains(s2, item):
       incl(result, item)
 
-proc symmetricDifference*[A](s1, s2: TSet[A]): TSet[A] =
+proc symmetricDifference*[A](s1, s2: HashSet[A]): HashSet[A] =
   ## Returns the symmetric difference of the sets `s1` and `s2`.
   ##
   ## The symmetric difference of two sets is represented mathematically as *A △
@@ -393,23 +395,23 @@ proc symmetricDifference*[A](s1, s2: TSet[A]): TSet[A] =
   for item in s2:
     if containsOrIncl(result, item): excl(result, item)
 
-proc `+`*[A](s1, s2: TSet[A]): TSet[A] {.inline.} =
+proc `+`*[A](s1, s2: HashSet[A]): HashSet[A] {.inline.} =
   ## Alias for `union(s1, s2) <#union>`_.
   result = union(s1, s2)
 
-proc `*`*[A](s1, s2: TSet[A]): TSet[A] {.inline.} =
+proc `*`*[A](s1, s2: HashSet[A]): HashSet[A] {.inline.} =
   ## Alias for `intersection(s1, s2) <#intersection>`_.
   result = intersection(s1, s2)
 
-proc `-`*[A](s1, s2: TSet[A]): TSet[A] {.inline.} =
+proc `-`*[A](s1, s2: HashSet[A]): HashSet[A] {.inline.} =
   ## Alias for `difference(s1, s2) <#difference>`_.
   result = difference(s1, s2)
 
-proc `-+-`*[A](s1, s2: TSet[A]): TSet[A] {.inline.} =
+proc `-+-`*[A](s1, s2: HashSet[A]): HashSet[A] {.inline.} =
   ## Alias for `symmetricDifference(s1, s2) <#symmetricDifference>`_.
   result = symmetricDifference(s1, s2)
 
-proc disjoint*[A](s1, s2: TSet[A]): bool =
+proc disjoint*[A](s1, s2: HashSet[A]): bool =
   ## Returns true iff the sets `s1` and `s2` have no items in common.
   ##
   ## Example:
@@ -426,7 +428,7 @@ proc disjoint*[A](s1, s2: TSet[A]): bool =
     if item in s2: return false
   return true
 
-proc `<`*[A](s, t: TSet[A]): bool =
+proc `<`*[A](s, t: HashSet[A]): bool =
   ## Returns true if `s` is a strict or proper subset of `t`.
   ##
   ## A strict or proper subset `s` has all of its members in `t` but `t` has
@@ -441,7 +443,7 @@ proc `<`*[A](s, t: TSet[A]): bool =
   ##   assert((a < a) == false)
   s.counter != t.counter and s <= t
 
-proc `<=`*[A](s, t: TSet[A]): bool =
+proc `<=`*[A](s, t: HashSet[A]): bool =
   ## Returns true if `s` is subset of `t`.
   ##
   ## A subset `s` has all of its members in `t` and `t` doesn't necessarily
@@ -462,7 +464,7 @@ proc `<=`*[A](s, t: TSet[A]): bool =
       result = false
       return
 
-proc `==`*[A](s, t: TSet[A]): bool =
+proc `==`*[A](s, t: HashSet[A]): bool =
   ## Returns true if both `s` and `t` have the same members and set size.
   ##
   ## Example:
@@ -475,7 +477,7 @@ proc `==`*[A](s, t: TSet[A]): bool =
   ##   assert a == b
   s.counter == t.counter and s <= t
 
-proc map*[A, B](data: TSet[A], op: proc (x: A): B {.closure.}): TSet[B] =
+proc map*[A, B](data: HashSet[A], op: proc (x: A): B {.closure.}): HashSet[B] =
   ## Returns a new set after applying `op` on each of the elements of `data`.
   ##
   ## You can use this proc to transform the elements from a set. Example:
@@ -490,19 +492,20 @@ proc map*[A, B](data: TSet[A], op: proc (x: A): B {.closure.}): TSet[B] =
 # ------------------------------ ordered set ------------------------------
 
 type
-  TOrderedKeyValuePair[A] = tuple[
-    slot: TSlotEnum, next: int, key: A]
-  TOrderedKeyValuePairSeq[A] = seq[TOrderedKeyValuePair[A]]
-  TOrderedSet* {.
-      final, myShallow.}[A] = object ## \
+  OrderedKeyValuePair[A] = tuple[
+    slot: SlotEnum, next: int, key: A]
+  OrderedKeyValuePairSeq[A] = seq[OrderedKeyValuePair[A]]
+  OrderedSet* {.myShallow.}[A] = object ## \
     ## A generic hash set that remembers insertion order.
     ##
-    ## Use `init() <#init,TOrderedSet[A],int>`_ or `initOrderedSet[type]()
+    ## Use `init() <#init,OrderedSet[A],int>`_ or `initOrderedSet[type]()
     ## <#initOrderedSet>`_ before calling other procs on it.
-    data: TOrderedKeyValuePairSeq[A]
+    data: OrderedKeyValuePairSeq[A]
     counter, first, last: int
 
-proc isValid*[A](s: TOrderedSet[A]): bool =
+{.deprecated: [TOrderedSet: OrderedSet].}
+
+proc isValid*[A](s: OrderedSet[A]): bool =
   ## Returns `true` if the ordered set has been initialized with `initSet
   ## <#initOrderedSet>`_.
   ##
@@ -511,13 +514,13 @@ proc isValid*[A](s: TOrderedSet[A]): bool =
   ## in your own procs to verify that ordered sets passed to your procs are
   ## correctly initialized. Example:
   ##
-  ## .. code-block :: nimrod
+  ## .. code-block::
   ##   proc saveTarotCards(cards: TOrderedSet[int]) =
   ##     assert cards.isValid, "Pass an initialized set!"
   ##     # Do stuff here, may crash in release builds!
   result = not s.data.isNil
 
-proc len*[A](s: TOrderedSet[A]): int {.inline.} =
+proc len*[A](s: OrderedSet[A]): int {.inline.} =
   ## Returns the number of keys in `s`.
   ##
   ## Due to an implementation detail you can call this proc on variables which
@@ -531,7 +534,7 @@ proc len*[A](s: TOrderedSet[A]): int {.inline.} =
   ##   assert values.len == 0
   result = s.counter
 
-proc card*[A](s: TOrderedSet[A]): int {.inline.} =
+proc card*[A](s: OrderedSet[A]): int {.inline.} =
   ## Alias for `len() <#len,TOrderedSet[A]>`_.
   ##
   ## Card stands for the `cardinality
@@ -545,7 +548,7 @@ template forAllOrderedPairs(yieldStmt: stmt) {.dirty, immediate.} =
     if s.data[h].slot == seFilled: yieldStmt
     h = nxt
 
-iterator items*[A](s: TOrderedSet[A]): A =
+iterator items*[A](s: OrderedSet[A]): A =
   ## Iterates over keys in the ordered set `s` in insertion order.
   ##
   ## If you need a sequence with the keys you can use `sequtils.toSeq()
@@ -567,10 +570,10 @@ iterator items*[A](s: TOrderedSet[A]): A =
   forAllOrderedPairs:
     yield s.data[h].key
 
-proc rawGet[A](s: TOrderedSet[A], key: A): int =
+proc rawGet[A](s: OrderedSet[A], key: A): int =
   rawGetImpl()
 
-proc contains*[A](s: TOrderedSet[A], key: A): bool =
+proc contains*[A](s: OrderedSet[A], key: A): bool =
   ## Returns true iff `key` is in `s`.
   ##
   ## Example:
@@ -584,16 +587,16 @@ proc contains*[A](s: TOrderedSet[A], key: A): bool =
   var index = rawGet(s, key)
   result = index >= 0
 
-proc rawInsert[A](s: var TOrderedSet[A], 
-                  data: var TOrderedKeyValuePairSeq[A], key: A) =
+proc rawInsert[A](s: var OrderedSet[A], 
+                  data: var OrderedKeyValuePairSeq[A], key: A) =
   rawInsertImpl()
   data[h].next = -1
   if s.first < 0: s.first = h
   if s.last >= 0: data[s.last].next = h
   s.last = h
 
-proc enlarge[A](s: var TOrderedSet[A]) =
-  var n: TOrderedKeyValuePairSeq[A]
+proc enlarge[A](s: var OrderedSet[A]) =
+  var n: OrderedKeyValuePairSeq[A]
   newSeq(n, len(s.data) * growthFactor)
   var h = s.first
   s.first = -1
@@ -605,7 +608,7 @@ proc enlarge[A](s: var TOrderedSet[A]) =
     h = nxt
   swap(s.data, n)
 
-proc incl*[A](s: var TOrderedSet[A], key: A) =
+proc incl*[A](s: var OrderedSet[A], key: A) =
   ## Includes an element `key` in `s`.
   ##
   ## This doesn't do anything if `key` is already in `s`. Example:
@@ -618,7 +621,7 @@ proc incl*[A](s: var TOrderedSet[A], key: A) =
   assert s.isValid, "The set needs to be initialized."
   inclImpl()
 
-proc incl*[A](s: var TSet[A], other: TOrderedSet[A]) =
+proc incl*[A](s: var HashSet[A], other: OrderedSet[A]) =
   ## Includes all elements from `other` into `s`.
   ##
   ## Example:
@@ -633,7 +636,7 @@ proc incl*[A](s: var TSet[A], other: TOrderedSet[A]) =
   assert other.isValid, "The set `other` needs to be initialized."
   for item in other: incl(s, item)
 
-proc containsOrIncl*[A](s: var TOrderedSet[A], key: A): bool =
+proc containsOrIncl*[A](s: var OrderedSet[A], key: A): bool =
   ## Includes `key` in the set `s` and tells if `key` was added to `s`.
   ##
   ## The difference with regards to the `incl() <#incl,TOrderedSet[A],A>`_ proc
@@ -648,7 +651,7 @@ proc containsOrIncl*[A](s: var TOrderedSet[A], key: A): bool =
   assert s.isValid, "The set needs to be initialized."
   containsOrInclImpl()
 
-proc init*[A](s: var TOrderedSet[A], initialSize=64) =
+proc init*[A](s: var OrderedSet[A], initialSize=64) =
   ## Initializes an ordered hash set.
   ##
   ## The `initialSize` parameter needs to be a power of too. You can use
@@ -673,7 +676,7 @@ proc init*[A](s: var TOrderedSet[A], initialSize=64) =
   s.last = -1
   newSeq(s.data, initialSize)
 
-proc initOrderedSet*[A](initialSize=64): TOrderedSet[A] =
+proc initOrderedSet*[A](initialSize=64): OrderedSet[A] =
   ## Wrapper around `init() <#init,TOrderedSet[A],int>`_ for initialization of
   ## ordered hash sets.
   ##
@@ -685,7 +688,7 @@ proc initOrderedSet*[A](initialSize=64): TOrderedSet[A] =
   ##   a.incl(2)
   result.init(initialSize)
 
-proc toOrderedSet*[A](keys: openArray[A]): TOrderedSet[A] =
+proc toOrderedSet*[A](keys: openArray[A]): OrderedSet[A] =
   ## Creates a new ordered hash set that contains the given `keys`.
   ##
   ## Example:
@@ -697,7 +700,7 @@ proc toOrderedSet*[A](keys: openArray[A]): TOrderedSet[A] =
   result = initOrderedSet[A](nextPowerOfTwo(keys.len+10))
   for key in items(keys): result.incl(key)
 
-proc `$`*[A](s: TOrderedSet[A]): string =
+proc `$`*[A](s: OrderedSet[A]): string =
   ## Converts the ordered hash set `s` to a string, mostly for logging purposes.
   ##
   ## Don't use this proc for serialization, the representation may change at
@@ -713,7 +716,7 @@ proc `$`*[A](s: TOrderedSet[A]): string =
   assert s.isValid, "The set needs to be initialized."
   dollarImpl()
 
-proc `==`*[A](s, t: TOrderedSet[A]): bool =
+proc `==`*[A](s, t: OrderedSet[A]): bool =
   ## Equality for ordered sets.
   if s.counter != t.counter: return false
   var h = s.first
@@ -734,14 +737,14 @@ proc `==`*[A](s, t: TOrderedSet[A]): bool =
 proc testModule() =
   ## Internal micro test to validate docstrings and such.
   block isValidTest:
-    var options: TSet[string]
-    proc savePreferences(options: TSet[string]) =
+    var options: HashSet[string]
+    proc savePreferences(options: HashSet[string]) =
       assert options.isValid, "Pass an initialized set!"
     options = initSet[string]()
     options.savePreferences
 
   block lenTest:
-    var values: TSet[int]
+    var values: HashSet[int]
     assert(not values.isValid)
     assert values.len == 0
     assert values.card == 0
@@ -835,14 +838,14 @@ proc testModule() =
     assert b == toSet(["1", "2", "3"])
 
   block isValidTest:
-    var cards: TOrderedSet[string]
-    proc saveTarotCards(cards: TOrderedSet[string]) =
+    var cards: OrderedSet[string]
+    proc saveTarotCards(cards: OrderedSet[string]) =
       assert cards.isValid, "Pass an initialized set!"
     cards = initOrderedSet[string]()
     cards.saveTarotCards
 
   block lenTest:
-    var values: TOrderedSet[int]
+    var values: OrderedSet[int]
     assert(not values.isValid)
     assert values.len == 0
     assert values.card == 0
@@ -879,7 +882,7 @@ proc testModule() =
     assert(a == b) # https://github.com/Araq/Nimrod/issues/1413
 
   block initBlocks:
-    var a: TOrderedSet[int]
+    var a: OrderedSet[int]
     a.init(4)
     a.incl(2)
     a.init
@@ -888,7 +891,7 @@ proc testModule() =
     a.incl(2)
     assert a.len == 1
 
-    var b: TSet[int]
+    var b: HashSet[int]
     b.init(4)
     b.incl(2)
     b.init
diff --git a/lib/pure/collections/tables.nim b/lib/pure/collections/tables.nim
index dcf2ab481..41dfdaca6 100644
--- a/lib/pure/collections/tables.nim
+++ b/lib/pure/collections/tables.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2013 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
@@ -28,7 +28,7 @@
 ## you add such a proc for your custom type everything will work. See this
 ## example:
 ##
-## .. code-block:: nimrod
+## .. code-block::
 ##   type
 ##     Person = object
 ##       firstName, lastName: string
@@ -61,43 +61,45 @@ import
 {.pragma: myShallow.}
 
 type
-  TSlotEnum = enum seEmpty, seFilled, seDeleted
-  TKeyValuePair[A, B] = tuple[slot: TSlotEnum, key: A, val: B]
-  TKeyValuePairSeq[A, B] = seq[TKeyValuePair[A, B]]
-  TTable* {.final, myShallow.}[A, B] = object ## generic hash table
-    data: TKeyValuePairSeq[A, B]
+  SlotEnum = enum seEmpty, seFilled, seDeleted
+  KeyValuePair[A, B] = tuple[slot: SlotEnum, key: A, val: B]
+  KeyValuePairSeq[A, B] = seq[KeyValuePair[A, B]]
+  Table* {.myShallow.}[A, B] = object ## generic hash table
+    data: KeyValuePairSeq[A, B]
     counter: int
-  PTable*[A,B] = ref TTable[A, B]
+  TableRef*[A,B] = ref Table[A, B]
+
+{.deprecated: [TTable: Table, PTable: TableRef].}
 
 when not defined(nimhygiene):
   {.pragma: dirty.}
 
-proc len*[A, B](t: TTable[A, B]): int =
+proc len*[A, B](t: Table[A, B]): int =
   ## returns the number of keys in `t`.
   result = t.counter
 
-iterator pairs*[A, B](t: TTable[A, B]): tuple[key: A, val: B] =
+iterator pairs*[A, B](t: Table[A, B]): tuple[key: A, val: B] =
   ## iterates over any (key, value) pair in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].slot == seFilled: yield (t.data[h].key, t.data[h].val)
 
-iterator mpairs*[A, B](t: var TTable[A, B]): tuple[key: A, val: var B] =
+iterator mpairs*[A, B](t: var Table[A, B]): tuple[key: A, val: var B] =
   ## iterates over any (key, value) pair in the table `t`. The values
   ## can be modified.
   for h in 0..high(t.data):
     if t.data[h].slot == seFilled: yield (t.data[h].key, t.data[h].val)
 
-iterator keys*[A, B](t: TTable[A, B]): A =
+iterator keys*[A, B](t: Table[A, B]): A =
   ## iterates over any key in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].slot == seFilled: yield t.data[h].key
 
-iterator values*[A, B](t: TTable[A, B]): B =
+iterator values*[A, B](t: Table[A, B]): B =
   ## iterates over any value in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].slot == seFilled: yield t.data[h].val
 
-iterator mvalues*[A, B](t: var TTable[A, B]): var B =
+iterator mvalues*[A, B](t: var Table[A, B]): var B =
   ## iterates over any value in the table `t`. The values can be modified.
   for h in 0..high(t.data):
     if t.data[h].slot == seFilled: yield t.data[h].val
@@ -128,10 +130,10 @@ template rawInsertImpl() {.dirty.} =
   data[h].val = val
   data[h].slot = seFilled
 
-proc rawGet[A, B](t: TTable[A, B], key: A): int =
+proc rawGet[A, B](t: Table[A, B], key: A): int =
   rawGetImpl()
 
-proc `[]`*[A, B](t: TTable[A, B], key: A): B =
+proc `[]`*[A, B](t: Table[A, B], key: A): B =
   ## retrieves the value at ``t[key]``. If `key` is not in `t`,
   ## default empty value for the type `B` is returned
   ## and no exception is raised. One can check with ``hasKey`` whether the key
@@ -139,14 +141,14 @@ proc `[]`*[A, B](t: TTable[A, B], key: A): B =
   var index = rawGet(t, key)
   if index >= 0: result = t.data[index].val
 
-proc mget*[A, B](t: var TTable[A, B], key: A): var B =
+proc mget*[A, B](t: var Table[A, B], key: A): var B =
   ## retrieves the value at ``t[key]``. The value can be modified.
   ## If `key` is not in `t`, the ``EInvalidKey`` exception is raised.
   var index = rawGet(t, key)
   if index >= 0: result = t.data[index].val
-  else: raise newException(EInvalidKey, "key not found: " & $key)
+  else: raise newException(KeyError, "key not found: " & $key)
 
-iterator allValues*[A, B](t: TTable[A, B]; key: A): B =
+iterator allValues*[A, B](t: Table[A, B]; key: A): B =
   ## iterates over any value in the table `t` that belongs to the given `key`.
   var h: THash = hash(key) and high(t.data)
   while t.data[h].slot != seEmpty:
@@ -154,16 +156,16 @@ iterator allValues*[A, B](t: TTable[A, B]; key: A): B =
       yield t.data[h].val
     h = nextTry(h, high(t.data))
 
-proc hasKey*[A, B](t: TTable[A, B], key: A): bool =
+proc hasKey*[A, B](t: Table[A, B], key: A): bool =
   ## returns true iff `key` is in the table `t`.
   result = rawGet(t, key) >= 0
 
-proc rawInsert[A, B](t: var TTable[A, B], data: var TKeyValuePairSeq[A, B],
+proc rawInsert[A, B](t: var Table[A, B], data: var KeyValuePairSeq[A, B],
                      key: A, val: B) =
   rawInsertImpl()
 
-proc enlarge[A, B](t: var TTable[A, B]) =
-  var n: TKeyValuePairSeq[A, B]
+proc enlarge[A, B](t: var Table[A, B]) =
+  var n: KeyValuePairSeq[A, B]
   newSeq(n, len(t.data) * growthFactor)
   for i in countup(0, high(t.data)):
     if t.data[i].slot == seFilled: rawInsert(t, n, t.data[i].key, t.data[i].val)
@@ -194,22 +196,22 @@ when false:
       inc(t.counter)
       result = false
 
-proc `[]=`*[A, B](t: var TTable[A, B], key: A, val: B) =
+proc `[]=`*[A, B](t: var Table[A, B], key: A, val: B) =
   ## puts a (key, value)-pair into `t`.
   putImpl()
 
-proc add*[A, B](t: var TTable[A, B], key: A, val: B) =
+proc add*[A, B](t: var Table[A, B], key: A, val: B) =
   ## puts a new (key, value)-pair into `t` even if ``t[key]`` already exists.
   addImpl()
   
-proc del*[A, B](t: var TTable[A, B], key: A) =
+proc del*[A, B](t: var Table[A, B], key: A) =
   ## deletes `key` from hash table `t`.
   let index = rawGet(t, key)
   if index >= 0:
     t.data[index].slot = seDeleted
     dec(t.counter)
 
-proc initTable*[A, B](initialSize=64): TTable[A, B] =
+proc initTable*[A, B](initialSize=64): Table[A, B] =
   ## creates a new hash table that is empty.
   ##
   ## `initialSize` needs to be a power of two. If you need to accept runtime
@@ -220,7 +222,7 @@ proc initTable*[A, B](initialSize=64): TTable[A, B] =
   newSeq(result.data, initialSize)
 
 proc toTable*[A, B](pairs: openArray[tuple[key: A, 
-                    val: B]]): TTable[A, B] =
+                    val: B]]): Table[A, B] =
   ## creates a new hash table that contains the given `pairs`.
   result = initTable[A, B](nextPowerOfTwo(pairs.len+10))
   for key, val in items(pairs): result[key] = val
@@ -237,7 +239,7 @@ template dollarImpl(): stmt {.dirty.} =
       result.add($val)
     result.add("}")
 
-proc `$`*[A, B](t: TTable[A, B]): string =
+proc `$`*[A, B](t: Table[A, B]): string =
   ## The `$` operator for hash tables.
   dollarImpl()
   
@@ -251,93 +253,93 @@ template equalsImpl() =
       if t[key] != val: return false
     return true
   
-proc `==`*[A, B](s, t: TTable[A, B]): bool =
+proc `==`*[A, B](s, t: Table[A, B]): bool =
   equalsImpl()
   
-proc indexBy*[A, B, C](collection: A, index: proc(x: B): C): TTable[C, B] =
+proc indexBy*[A, B, C](collection: A, index: proc(x: B): C): Table[C, B] =
   ## Index the collection with the proc provided.
   # TODO: As soon as supported, change collection: A to collection: A[B]
   result = initTable[C, B]()
   for item in collection:
     result[index(item)] = item
 
-proc len*[A, B](t: PTable[A, B]): int =
+proc len*[A, B](t: TableRef[A, B]): int =
   ## returns the number of keys in `t`.
   result = t.counter
 
-iterator pairs*[A, B](t: PTable[A, B]): tuple[key: A, val: B] =
+iterator pairs*[A, B](t: TableRef[A, B]): tuple[key: A, val: B] =
   ## iterates over any (key, value) pair in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].slot == seFilled: yield (t.data[h].key, t.data[h].val)
 
-iterator mpairs*[A, B](t: PTable[A, B]): tuple[key: A, val: var B] =
+iterator mpairs*[A, B](t: TableRef[A, B]): tuple[key: A, val: var B] =
   ## iterates over any (key, value) pair in the table `t`. The values
   ## can be modified.
   for h in 0..high(t.data):
     if t.data[h].slot == seFilled: yield (t.data[h].key, t.data[h].val)
 
-iterator keys*[A, B](t: PTable[A, B]): A =
+iterator keys*[A, B](t: TableRef[A, B]): A =
   ## iterates over any key in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].slot == seFilled: yield t.data[h].key
 
-iterator values*[A, B](t: PTable[A, B]): B =
+iterator values*[A, B](t: TableRef[A, B]): B =
   ## iterates over any value in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].slot == seFilled: yield t.data[h].val
 
-iterator mvalues*[A, B](t: PTable[A, B]): var B =
+iterator mvalues*[A, B](t: TableRef[A, B]): var B =
   ## iterates over any value in the table `t`. The values can be modified.
   for h in 0..high(t.data):
     if t.data[h].slot == seFilled: yield t.data[h].val
 
-proc `[]`*[A, B](t: PTable[A, B], key: A): B =
+proc `[]`*[A, B](t: TableRef[A, B], key: A): B =
   ## retrieves the value at ``t[key]``. If `key` is not in `t`,
   ## default empty value for the type `B` is returned
   ## and no exception is raised. One can check with ``hasKey`` whether the key
   ## exists.
   result = t[][key]
 
-proc mget*[A, B](t: PTable[A, B], key: A): var B =
+proc mget*[A, B](t: TableRef[A, B], key: A): var B =
   ## retrieves the value at ``t[key]``. The value can be modified.
   ## If `key` is not in `t`, the ``EInvalidKey`` exception is raised.
   t[].mget(key)
 
-proc hasKey*[A, B](t: PTable[A, B], key: A): bool =
+proc hasKey*[A, B](t: TableRef[A, B], key: A): bool =
   ## returns true iff `key` is in the table `t`.
   result = t[].hasKey(key)
 
-proc `[]=`*[A, B](t: PTable[A, B], key: A, val: B) =
+proc `[]=`*[A, B](t: TableRef[A, B], key: A, val: B) =
   ## puts a (key, value)-pair into `t`.
   t[][key] = val
 
-proc add*[A, B](t: PTable[A, B], key: A, val: B) =
+proc add*[A, B](t: TableRef[A, B], key: A, val: B) =
   ## puts a new (key, value)-pair into `t` even if ``t[key]`` already exists.
   t[].add(key, val)
   
-proc del*[A, B](t: PTable[A, B], key: A) =
+proc del*[A, B](t: TableRef[A, B], key: A) =
   ## deletes `key` from hash table `t`.
   t[].del(key)
 
-proc newTable*[A, B](initialSize=64): PTable[A, B] =
+proc newTable*[A, B](initialSize=64): TableRef[A, B] =
   new(result)
   result[] = initTable[A, B](initialSize)
 
-proc newTable*[A, B](pairs: openArray[tuple[key: A, val: B]]): PTable[A, B] =
+proc newTable*[A, B](pairs: openArray[tuple[key: A, val: B]]): TableRef[A, B] =
   ## creates a new hash table that contains the given `pairs`.
   new(result)
   result[] = toTable[A, B](pairs)
 
-proc `$`*[A, B](t: PTable[A, B]): string =
+proc `$`*[A, B](t: TableRef[A, B]): string =
   ## The `$` operator for hash tables.
   dollarImpl()
 
-proc `==`*[A, B](s, t: PTable[A, B]): bool =
+proc `==`*[A, B](s, t: TableRef[A, B]): bool =
   if isNil(s): result = isNil(t)
   elif isNil(t): result = false
   else: result = equalsImpl()
 
-proc newTableFrom*[A, B, C](collection: A, index: proc(x: B): C): PTable[C, B] =
+proc newTableFrom*[A, B, C](collection: A, index: proc(x: B): C): TableRef[C, B] =
   ## Index the collection with the proc provided.
   # TODO: As soon as supported, change collection: A to collection: A[B]
   result = newTable[C, B]()
@@ -347,16 +349,18 @@ proc newTableFrom*[A, B, C](collection: A, index: proc(x: B): C): PTable[C, B] =
 # ------------------------------ ordered table ------------------------------
 
 type
-  TOrderedKeyValuePair[A, B] = tuple[
-    slot: TSlotEnum, next: int, key: A, val: B]
-  TOrderedKeyValuePairSeq[A, B] = seq[TOrderedKeyValuePair[A, B]]
-  TOrderedTable* {.
-      final, myShallow.}[A, B] = object ## table that remembers insertion order
-    data: TOrderedKeyValuePairSeq[A, B]
+  OrderedKeyValuePair[A, B] = tuple[
+    slot: SlotEnum, next: int, key: A, val: B]
+  OrderedKeyValuePairSeq[A, B] = seq[OrderedKeyValuePair[A, B]]
+  OrderedTable* {.
+      myShallow.}[A, B] = object ## table that remembers insertion order
+    data: OrderedKeyValuePairSeq[A, B]
     counter, first, last: int
-  POrderedTable*[A, B] = ref TOrderedTable[A, B]
+  OrderedTableRef*[A, B] = ref OrderedTable[A, B]
+
+{.deprecated: [TOrderedTable: OrderedTable, POrderedTable: OrderedTableRef].}
 
-proc len*[A, B](t: TOrderedTable[A, B]): int {.inline.} =
+proc len*[A, B](t: OrderedTable[A, B]): int {.inline.} =
   ## returns the number of keys in `t`.
   result = t.counter
 
@@ -367,38 +371,38 @@ template forAllOrderedPairs(yieldStmt: stmt) {.dirty, immediate.} =
     if t.data[h].slot == seFilled: yieldStmt
     h = nxt
 
-iterator pairs*[A, B](t: TOrderedTable[A, B]): tuple[key: A, val: B] =
+iterator pairs*[A, B](t: OrderedTable[A, B]): tuple[key: A, val: B] =
   ## iterates over any (key, value) pair in the table `t` in insertion
   ## order.
   forAllOrderedPairs:
     yield (t.data[h].key, t.data[h].val)
 
-iterator mpairs*[A, B](t: var TOrderedTable[A, B]): tuple[key: A, val: var B] =
+iterator mpairs*[A, B](t: var OrderedTable[A, B]): tuple[key: A, val: var B] =
   ## iterates over any (key, value) pair in the table `t` in insertion
   ## order. The values can be modified.
   forAllOrderedPairs:
     yield (t.data[h].key, t.data[h].val)
 
-iterator keys*[A, B](t: TOrderedTable[A, B]): A =
+iterator keys*[A, B](t: OrderedTable[A, B]): A =
   ## iterates over any key in the table `t` in insertion order.
   forAllOrderedPairs:
     yield t.data[h].key
 
-iterator values*[A, B](t: TOrderedTable[A, B]): B =
+iterator values*[A, B](t: OrderedTable[A, B]): B =
   ## iterates over any value in the table `t` in insertion order.
   forAllOrderedPairs:
     yield t.data[h].val
 
-iterator mvalues*[A, B](t: var TOrderedTable[A, B]): var B =
+iterator mvalues*[A, B](t: var OrderedTable[A, B]): var B =
   ## iterates over any value in the table `t` in insertion order. The values
   ## can be modified.
   forAllOrderedPairs:
     yield t.data[h].val
 
-proc rawGet[A, B](t: TOrderedTable[A, B], key: A): int =
+proc rawGet[A, B](t: OrderedTable[A, B], key: A): int =
   rawGetImpl()
 
-proc `[]`*[A, B](t: TOrderedTable[A, B], key: A): B =
+proc `[]`*[A, B](t: OrderedTable[A, B], key: A): B =
   ## retrieves the value at ``t[key]``. If `key` is not in `t`,
   ## default empty value for the type `B` is returned
   ## and no exception is raised. One can check with ``hasKey`` whether the key
@@ -406,19 +410,19 @@ proc `[]`*[A, B](t: TOrderedTable[A, B], key: A): B =
   var index = rawGet(t, key)
   if index >= 0: result = t.data[index].val
 
-proc mget*[A, B](t: var TOrderedTable[A, B], key: A): var B =
+proc mget*[A, B](t: var OrderedTable[A, B], key: A): var B =
   ## retrieves the value at ``t[key]``. The value can be modified.
   ## If `key` is not in `t`, the ``EInvalidKey`` exception is raised.
   var index = rawGet(t, key)
   if index >= 0: result = t.data[index].val
-  else: raise newException(EInvalidKey, "key not found: " & $key)
+  else: raise newException(KeyError, "key not found: " & $key)
 
-proc hasKey*[A, B](t: TOrderedTable[A, B], key: A): bool =
+proc hasKey*[A, B](t: OrderedTable[A, B], key: A): bool =
   ## returns true iff `key` is in the table `t`.
   result = rawGet(t, key) >= 0
 
-proc rawInsert[A, B](t: var TOrderedTable[A, B], 
-                     data: var TOrderedKeyValuePairSeq[A, B],
+proc rawInsert[A, B](t: var OrderedTable[A, B], 
+                     data: var OrderedKeyValuePairSeq[A, B],
                      key: A, val: B) =
   rawInsertImpl()
   data[h].next = -1
@@ -426,8 +430,8 @@ proc rawInsert[A, B](t: var TOrderedTable[A, B],
   if t.last >= 0: data[t.last].next = h
   t.last = h
 
-proc enlarge[A, B](t: var TOrderedTable[A, B]) =
-  var n: TOrderedKeyValuePairSeq[A, B]
+proc enlarge[A, B](t: var OrderedTable[A, B]) =
+  var n: OrderedKeyValuePairSeq[A, B]
   newSeq(n, len(t.data) * growthFactor)
   var h = t.first
   t.first = -1
@@ -439,15 +443,15 @@ proc enlarge[A, B](t: var TOrderedTable[A, B]) =
     h = nxt
   swap(t.data, n)
 
-proc `[]=`*[A, B](t: var TOrderedTable[A, B], key: A, val: B) =
+proc `[]=`*[A, B](t: var OrderedTable[A, B], key: A, val: B) =
   ## puts a (key, value)-pair into `t`.
   putImpl()
 
-proc add*[A, B](t: var TOrderedTable[A, B], key: A, val: B) =
+proc add*[A, B](t: var OrderedTable[A, B], key: A, val: B) =
   ## puts a new (key, value)-pair into `t` even if ``t[key]`` already exists.
   addImpl()
 
-proc initOrderedTable*[A, B](initialSize=64): TOrderedTable[A, B] =
+proc initOrderedTable*[A, B](initialSize=64): OrderedTable[A, B] =
   ## creates a new ordered hash table that is empty.
   ##
   ## `initialSize` needs to be a power of two. If you need to accept runtime
@@ -460,16 +464,16 @@ proc initOrderedTable*[A, B](initialSize=64): TOrderedTable[A, B] =
   newSeq(result.data, initialSize)
 
 proc toOrderedTable*[A, B](pairs: openArray[tuple[key: A, 
-                           val: B]]): TOrderedTable[A, B] =
+                           val: B]]): OrderedTable[A, B] =
   ## creates a new ordered hash table that contains the given `pairs`.
   result = initOrderedTable[A, B](nextPowerOfTwo(pairs.len+10))
   for key, val in items(pairs): result[key] = val
 
-proc `$`*[A, B](t: TOrderedTable[A, B]): string =
+proc `$`*[A, B](t: OrderedTable[A, B]): string =
   ## The `$` operator for ordered hash tables.
   dollarImpl()
 
-proc sort*[A, B](t: var TOrderedTable[A, B], 
+proc sort*[A, B](t: var OrderedTable[A, B], 
                  cmp: proc (x,y: tuple[key: A, val: B]): int) =
   ## sorts `t` according to `cmp`. This modifies the internal list
   ## that kept the insertion order, so insertion order is lost after this
@@ -515,7 +519,7 @@ proc sort*[A, B](t: var TOrderedTable[A, B],
   t.first = list
   t.last = tail
 
-proc len*[A, B](t: POrderedTable[A, B]): int {.inline.} =
+proc len*[A, B](t: OrderedTableRef[A, B]): int {.inline.} =
   ## returns the number of keys in `t`.
   result = t.counter
 
@@ -526,59 +530,59 @@ template forAllOrderedPairs(yieldStmt: stmt) {.dirty, immediate.} =
     if t.data[h].slot == seFilled: yieldStmt
     h = nxt
 
-iterator pairs*[A, B](t: POrderedTable[A, B]): tuple[key: A, val: B] =
+iterator pairs*[A, B](t: OrderedTableRef[A, B]): tuple[key: A, val: B] =
   ## iterates over any (key, value) pair in the table `t` in insertion
   ## order.
   forAllOrderedPairs:
     yield (t.data[h].key, t.data[h].val)
 
-iterator mpairs*[A, B](t: POrderedTable[A, B]): tuple[key: A, val: var B] =
+iterator mpairs*[A, B](t: OrderedTableRef[A, B]): tuple[key: A, val: var B] =
   ## iterates over any (key, value) pair in the table `t` in insertion
   ## order. The values can be modified.
   forAllOrderedPairs:
     yield (t.data[h].key, t.data[h].val)
 
-iterator keys*[A, B](t: POrderedTable[A, B]): A =
+iterator keys*[A, B](t: OrderedTableRef[A, B]): A =
   ## iterates over any key in the table `t` in insertion order.
   forAllOrderedPairs:
     yield t.data[h].key
 
-iterator values*[A, B](t: POrderedTable[A, B]): B =
+iterator values*[A, B](t: OrderedTableRef[A, B]): B =
   ## iterates over any value in the table `t` in insertion order.
   forAllOrderedPairs:
     yield t.data[h].val
 
-iterator mvalues*[A, B](t: POrderedTable[A, B]): var B =
+iterator mvalues*[A, B](t: OrderedTableRef[A, B]): var B =
   ## iterates over any value in the table `t` in insertion order. The values
   ## can be modified.
   forAllOrderedPairs:
     yield t.data[h].val
 
-proc `[]`*[A, B](t: POrderedTable[A, B], key: A): B =
+proc `[]`*[A, B](t: OrderedTableRef[A, B], key: A): B =
   ## retrieves the value at ``t[key]``. If `key` is not in `t`,
   ## default empty value for the type `B` is returned
   ## and no exception is raised. One can check with ``hasKey`` whether the key
   ## exists.
   result = t[][key]
 
-proc mget*[A, B](t: POrderedTable[A, B], key: A): var B =
+proc mget*[A, B](t: OrderedTableRef[A, B], key: A): var B =
   ## retrieves the value at ``t[key]``. The value can be modified.
   ## If `key` is not in `t`, the ``EInvalidKey`` exception is raised.
   result = t[].mget(key)
 
-proc hasKey*[A, B](t: POrderedTable[A, B], key: A): bool =
+proc hasKey*[A, B](t: OrderedTableRef[A, B], key: A): bool =
   ## returns true iff `key` is in the table `t`.
   result = t[].hasKey(key)
 
-proc `[]=`*[A, B](t: POrderedTable[A, B], key: A, val: B) =
+proc `[]=`*[A, B](t: OrderedTableRef[A, B], key: A, val: B) =
   ## puts a (key, value)-pair into `t`.
   t[][key] = val
 
-proc add*[A, B](t: POrderedTable[A, B], key: A, val: B) =
+proc add*[A, B](t: OrderedTableRef[A, B], key: A, val: B) =
   ## puts a new (key, value)-pair into `t` even if ``t[key]`` already exists.
   t[].add(key, val)
 
-proc newOrderedTable*[A, B](initialSize=64): POrderedTable[A, B] =
+proc newOrderedTable*[A, B](initialSize=64): OrderedTableRef[A, B] =
   ## creates a new ordered hash table that is empty.
   ##
   ## `initialSize` needs to be a power of two. If you need to accept runtime
@@ -588,16 +592,16 @@ proc newOrderedTable*[A, B](initialSize=64): POrderedTable[A, B] =
   result[] = initOrderedTable[A, B]()
 
 proc newOrderedTable*[A, B](pairs: openArray[tuple[key: A, 
-                           val: B]]): POrderedTable[A, B] =
+                           val: B]]): OrderedTableRef[A, B] =
   ## creates a new ordered hash table that contains the given `pairs`.
   result = newOrderedTable[A, B](nextPowerOfTwo(pairs.len+10))
   for key, val in items(pairs): result[key] = val
 
-proc `$`*[A, B](t: POrderedTable[A, B]): string =
+proc `$`*[A, B](t: OrderedTableRef[A, B]): string =
   ## The `$` operator for ordered hash tables.
   dollarImpl()
 
-proc sort*[A, B](t: POrderedTable[A, B], 
+proc sort*[A, B](t: OrderedTableRef[A, B], 
                  cmp: proc (x,y: tuple[key: A, val: B]): int) =
   ## sorts `t` according to `cmp`. This modifies the internal list
   ## that kept the insertion order, so insertion order is lost after this
@@ -608,87 +612,89 @@ proc sort*[A, B](t: POrderedTable[A, B],
 # ------------------------------ count tables -------------------------------
 
 type
-  TCountTable* {.final, myShallow.}[
+  CountTable* {.myShallow.}[
       A] = object ## table that counts the number of each key
     data: seq[tuple[key: A, val: int]]
     counter: int
-  PCountTable*[A] = ref TCountTable[A]
+  CountTableRef*[A] = ref CountTable[A]
+
+{.deprecated: [TCountTable: CountTable, PCountTable: CountTableRef].}
 
-proc len*[A](t: TCountTable[A]): int =
+proc len*[A](t: CountTable[A]): int =
   ## returns the number of keys in `t`.
   result = t.counter
 
-iterator pairs*[A](t: TCountTable[A]): tuple[key: A, val: int] =
+iterator pairs*[A](t: CountTable[A]): tuple[key: A, val: int] =
   ## iterates over any (key, value) pair in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].val != 0: yield (t.data[h].key, t.data[h].val)
 
-iterator mpairs*[A](t: var TCountTable[A]): tuple[key: A, val: var int] =
+iterator mpairs*[A](t: var CountTable[A]): tuple[key: A, val: var int] =
   ## iterates over any (key, value) pair in the table `t`. The values can
   ## be modified.
   for h in 0..high(t.data):
     if t.data[h].val != 0: yield (t.data[h].key, t.data[h].val)
 
-iterator keys*[A](t: TCountTable[A]): A =
+iterator keys*[A](t: CountTable[A]): A =
   ## iterates over any key in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].val != 0: yield t.data[h].key
 
-iterator values*[A](t: TCountTable[A]): int =
+iterator values*[A](t: CountTable[A]): int =
   ## iterates over any value in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].val != 0: yield t.data[h].val
 
-iterator mvalues*[A](t: TCountTable[A]): var int =
+iterator mvalues*[A](t: CountTable[A]): var int =
   ## iterates over any value in the table `t`. The values can be modified.
   for h in 0..high(t.data):
     if t.data[h].val != 0: yield t.data[h].val
 
-proc rawGet[A](t: TCountTable[A], key: A): int =
+proc rawGet[A](t: CountTable[A], key: A): int =
   var h: THash = hash(key) and high(t.data) # start with real hash value
   while t.data[h].val != 0:
     if t.data[h].key == key: return h
     h = nextTry(h, high(t.data))
   result = -1
 
-proc `[]`*[A](t: TCountTable[A], key: A): int =
+proc `[]`*[A](t: CountTable[A], key: A): int =
   ## retrieves the value at ``t[key]``. If `key` is not in `t`,
   ## 0 is returned. One can check with ``hasKey`` whether the key
   ## exists.
   var index = rawGet(t, key)
   if index >= 0: result = t.data[index].val
 
-proc mget*[A](t: var TCountTable[A], key: A): var int =
+proc mget*[A](t: var CountTable[A], key: A): var int =
   ## retrieves the value at ``t[key]``. The value can be modified.
   ## If `key` is not in `t`, the ``EInvalidKey`` exception is raised.
   var index = rawGet(t, key)
   if index >= 0: result = t.data[index].val
-  else: raise newException(EInvalidKey, "key not found: " & $key)
+  else: raise newException(KeyError, "key not found: " & $key)
 
-proc hasKey*[A](t: TCountTable[A], key: A): bool =
+proc hasKey*[A](t: CountTable[A], key: A): bool =
   ## returns true iff `key` is in the table `t`.
   result = rawGet(t, key) >= 0
 
-proc rawInsert[A](t: TCountTable[A], data: var seq[tuple[key: A, val: int]],
+proc rawInsert[A](t: CountTable[A], data: var seq[tuple[key: A, val: int]],
                   key: A, val: int) =
   var h: THash = hash(key) and high(data)
   while data[h].val != 0: h = nextTry(h, high(data))
   data[h].key = key
   data[h].val = val
 
-proc enlarge[A](t: var TCountTable[A]) =
+proc enlarge[A](t: var CountTable[A]) =
   var n: seq[tuple[key: A, val: int]]
   newSeq(n, len(t.data) * growthFactor)
   for i in countup(0, high(t.data)):
     if t.data[i].val != 0: rawInsert(t, n, t.data[i].key, t.data[i].val)
   swap(t.data, n)
 
-proc `[]=`*[A](t: var TCountTable[A], key: A, val: int) =
+proc `[]=`*[A](t: var CountTable[A], key: A, val: int) =
   ## puts a (key, value)-pair into `t`. `val` has to be positive.
   assert val > 0
   putImpl()
 
-proc initCountTable*[A](initialSize=64): TCountTable[A] =
+proc initCountTable*[A](initialSize=64): CountTable[A] =
   ## creates a new count table that is empty.
   ##
   ## `initialSize` needs to be a power of two. If you need to accept runtime
@@ -698,16 +704,16 @@ proc initCountTable*[A](initialSize=64): TCountTable[A] =
   result.counter = 0
   newSeq(result.data, initialSize)
 
-proc toCountTable*[A](keys: openArray[A]): TCountTable[A] =
+proc toCountTable*[A](keys: openArray[A]): CountTable[A] =
   ## creates a new count table with every key in `keys` having a count of 1.
   result = initCountTable[A](nextPowerOfTwo(keys.len+10))
   for key in items(keys): result[key] = 1
 
-proc `$`*[A](t: TCountTable[A]): string =
+proc `$`*[A](t: CountTable[A]): string =
   ## The `$` operator for count tables.
   dollarImpl()
 
-proc inc*[A](t: var TCountTable[A], key: A, val = 1) = 
+proc inc*[A](t: var CountTable[A], key: A, val = 1) = 
   ## increments `t[key]` by `val`.
   var index = rawGet(t, key)
   if index >= 0:
@@ -717,7 +723,7 @@ proc inc*[A](t: var TCountTable[A], key: A, val = 1) =
     rawInsert(t, t.data, key, val)
     inc(t.counter)
 
-proc smallest*[A](t: TCountTable[A]): tuple[key: A, val: int] =
+proc smallest*[A](t: CountTable[A]): tuple[key: A, val: int] =
   ## returns the largest (key,val)-pair. Efficiency: O(n)
   assert t.len > 0
   var minIdx = 0
@@ -726,7 +732,7 @@ proc smallest*[A](t: TCountTable[A]): tuple[key: A, val: int] =
   result.key = t.data[minIdx].key
   result.val = t.data[minIdx].val
 
-proc largest*[A](t: TCountTable[A]): tuple[key: A, val: int] =
+proc largest*[A](t: CountTable[A]): tuple[key: A, val: int] =
   ## returns the (key,val)-pair with the largest `val`. Efficiency: O(n)
   assert t.len > 0
   var maxIdx = 0
@@ -735,7 +741,7 @@ proc largest*[A](t: TCountTable[A]): tuple[key: A, val: int] =
   result.key = t.data[maxIdx].key
   result.val = t.data[maxIdx].val
 
-proc sort*[A](t: var TCountTable[A]) =
+proc sort*[A](t: var CountTable[A]) =
   ## sorts the count table so that the entry with the highest counter comes
   ## first. This is destructive! You must not modify `t` afterwards!
   ## You can use the iterators `pairs`,  `keys`, and `values` to iterate over
@@ -756,57 +762,57 @@ proc sort*[A](t: var TCountTable[A]) =
         if j < h: break
     if h == 1: break
 
-proc len*[A](t: PCountTable[A]): int =
+proc len*[A](t: CountTableRef[A]): int =
   ## returns the number of keys in `t`.
   result = t.counter
 
-iterator pairs*[A](t: PCountTable[A]): tuple[key: A, val: int] =
+iterator pairs*[A](t: CountTableRef[A]): tuple[key: A, val: int] =
   ## iterates over any (key, value) pair in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].val != 0: yield (t.data[h].key, t.data[h].val)
 
-iterator mpairs*[A](t: PCountTable[A]): tuple[key: A, val: var int] =
+iterator mpairs*[A](t: CountTableRef[A]): tuple[key: A, val: var int] =
   ## iterates over any (key, value) pair in the table `t`. The values can
   ## be modified.
   for h in 0..high(t.data):
     if t.data[h].val != 0: yield (t.data[h].key, t.data[h].val)
 
-iterator keys*[A](t: PCountTable[A]): A =
+iterator keys*[A](t: CountTableRef[A]): A =
   ## iterates over any key in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].val != 0: yield t.data[h].key
 
-iterator values*[A](t: PCountTable[A]): int =
+iterator values*[A](t: CountTableRef[A]): int =
   ## iterates over any value in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].val != 0: yield t.data[h].val
 
-iterator mvalues*[A](t: PCountTable[A]): var int =
+iterator mvalues*[A](t: CountTableRef[A]): var int =
   ## iterates over any value in the table `t`. The values can be modified.
   for h in 0..high(t.data):
     if t.data[h].val != 0: yield t.data[h].val
 
-proc `[]`*[A](t: PCountTable[A], key: A): int =
+proc `[]`*[A](t: CountTableRef[A], key: A): int =
   ## retrieves the value at ``t[key]``. If `key` is not in `t`,
   ## 0 is returned. One can check with ``hasKey`` whether the key
   ## exists.
   result = t[][key]
 
-proc mget*[A](t: PCountTable[A], key: A): var int =
+proc mget*[A](t: CountTableRef[A], key: A): var int =
   ## retrieves the value at ``t[key]``. The value can be modified.
   ## If `key` is not in `t`, the ``EInvalidKey`` exception is raised.
   result = t[].mget(key)
 
-proc hasKey*[A](t: PCountTable[A], key: A): bool =
+proc hasKey*[A](t: CountTableRef[A], key: A): bool =
   ## returns true iff `key` is in the table `t`.
   result = t[].hasKey(key)
 
-proc `[]=`*[A](t: PCountTable[A], key: A, val: int) =
+proc `[]=`*[A](t: CountTableRef[A], key: A, val: int) =
   ## puts a (key, value)-pair into `t`. `val` has to be positive.
   assert val > 0
   t[][key] = val
 
-proc newCountTable*[A](initialSize=64): PCountTable[A] =
+proc newCountTable*[A](initialSize=64): CountTableRef[A] =
   ## creates a new count table that is empty.
   ##
   ## `initialSize` needs to be a power of two. If you need to accept runtime
@@ -815,28 +821,28 @@ proc newCountTable*[A](initialSize=64): PCountTable[A] =
   new(result)
   result[] = initCountTable[A](initialSize)
 
-proc newCountTable*[A](keys: openArray[A]): PCountTable[A] =
+proc newCountTable*[A](keys: openArray[A]): CountTableRef[A] =
   ## creates a new count table with every key in `keys` having a count of 1.
   result = newCountTable[A](nextPowerOfTwo(keys.len+10))
   for key in items(keys): result[key] = 1
 
-proc `$`*[A](t: PCountTable[A]): string =
+proc `$`*[A](t: CountTableRef[A]): string =
   ## The `$` operator for count tables.
   dollarImpl()
 
-proc inc*[A](t: PCountTable[A], key: A, val = 1) = 
+proc inc*[A](t: CountTableRef[A], key: A, val = 1) = 
   ## increments `t[key]` by `val`.
   t[].inc(key, val)
 
-proc smallest*[A](t: PCountTable[A]): tuple[key: A, val: int] =
+proc smallest*[A](t: CountTableRef[A]): tuple[key: A, val: int] =
   ## returns the largest (key,val)-pair. Efficiency: O(n)
   t[].smallest
 
-proc largest*[A](t: PCountTable[A]): tuple[key: A, val: int] =
+proc largest*[A](t: CountTableRef[A]): tuple[key: A, val: int] =
   ## returns the (key,val)-pair with the largest `val`. Efficiency: O(n)
   t[].largest
 
-proc sort*[A](t: PCountTable[A]) =
+proc sort*[A](t: CountTableRef[A]) =
   ## sorts the count table so that the entry with the highest counter comes
   ## first. This is destructive! You must not modify `t` afterwards!
   ## You can use the iterators `pairs`,  `keys`, and `values` to iterate over