prepare for upcoming parsing change of unary operators

compiler/importer.nim

@@ -9,7 +9,7 @@
 
 # This module implements the symbol importing mechanism.
 
-import 
+import
   intsets, strutils, os, ast, astalgo, msgs, options, idents, rodread, lookups,
   semdata, passes, renderer
 
@@ -73,12 +73,12 @@ proc rawImportSymbol(c: PContext, s: PSym) =
     if etyp.kind in {tyBool, tyEnum} and sfPure notin s.flags:
       for j in countup(0, sonsLen(etyp.n) - 1):
         var e = etyp.n.sons[j].sym
-        if e.kind != skEnumField: 
+        if e.kind != skEnumField:
-          internalError(s.info, "rawImportSymbol") 
+          internalError(s.info, "rawImportSymbol")
           # BUGFIX: because of aliases for enums the symbol may already
           # have been put into the symbol table
           # BUGFIX: but only iff they are the same symbols!
-        var it: TIdentIter 
+        var it: TIdentIter
         check = initIdentIter(it, c.importTable.symbols, e.name)
         while check != nil:
           if check.id == e.id:
@@ -92,7 +92,7 @@ proc rawImportSymbol(c: PContext, s: PSym) =
     if s.kind == skConverter: addConverter(c, s)
     if hasPattern(s): addPattern(c, s)
 
-proc importSymbol(c: PContext, n: PNode, fromMod: PSym) =        
+proc importSymbol(c: PContext, n: PNode, fromMod: PSym) =
   let ident = lookups.considerQuotedIdent(n)
   let s = strTableGet(fromMod.tab, ident)
   if s == nil:
@@ -143,7 +143,7 @@ proc importForwarded(c: PContext, n: PNode, exceptSet: IntSet) =
   of nkExportExceptStmt:
     localError(n.info, errGenerated, "'export except' not implemented")
   else:
-    for i in 0 ..safeLen(n)-1:
+    for i in 0..safeLen(n)-1:
       importForwarded(c, n.sons[i], exceptSet)
 
 proc importModuleAs(n: PNode, realModule: PSym): PSym =
@@ -155,7 +155,7 @@ proc importModuleAs(n: PNode, realModule: PSym): PSym =
     # some misguided guy will write 'import abc.foo as foo' ...
     result = createModuleAlias(realModule, n.sons[1].ident, realModule.info)
 
-proc myImportModule(c: PContext, n: PNode): PSym = 
+proc myImportModule(c: PContext, n: PNode): PSym =
   var f = checkModuleName(n)
   if f != InvalidFileIDX:
     result = importModuleAs(n, gImportModule(c.module, f))
@@ -164,10 +164,10 @@ proc myImportModule(c: PContext, n: PNode): PSym =
     if sfDeprecated in result.flags:
       message(n.info, warnDeprecated, result.name.s)
 
-proc evalImport(c: PContext, n: PNode): PNode = 
+proc evalImport(c: PContext, n: PNode): PNode =
   result = n
   var emptySet: IntSet
-  for i in countup(0, sonsLen(n) - 1): 
+  for i in countup(0, sonsLen(n) - 1):
     var m = myImportModule(c, n.sons[i])
     if m != nil:
       # ``addDecl`` needs to be done before ``importAllSymbols``!
@@ -175,7 +175,7 @@ proc evalImport(c: PContext, n: PNode): PNode =
       importAllSymbolsExcept(c, m, emptySet)
       #importForwarded(c, m.ast, emptySet)
 
-proc evalFrom(c: PContext, n: PNode): PNode = 
+proc evalFrom(c: PContext, n: PNode): PNode =
   result = n
   checkMinSonsLen(n, 2)
   var m = myImportModule(c, n.sons[0])
@@ -186,7 +186,7 @@ proc evalFrom(c: PContext, n: PNode): PNode =
       if n.sons[i].kind != nkNilLit:
         importSymbol(c, n.sons[i], m)
 
-proc evalImportExcept*(c: PContext, n: PNode): PNode = 
+proc evalImportExcept*(c: PContext, n: PNode): PNode =
   result = n
   checkMinSonsLen(n, 2)
   var m = myImportModule(c, n.sons[0])
@@ -194,7 +194,7 @@ proc evalImportExcept*(c: PContext, n: PNode): PNode =
     n.sons[0] = newSymNode(m)
     addDecl(c, m)               # add symbol to symbol table of module
     var exceptSet = initIntSet()
-    for i in countup(1, sonsLen(n) - 1): 
+    for i in countup(1, sonsLen(n) - 1):
       let ident = lookups.considerQuotedIdent(n.sons[i])
       exceptSet.incl(ident.id)
     importAllSymbolsExcept(c, m, exceptSet)

compiler/ropes.nim

@@ -55,21 +55,21 @@
 #  share leaves across different rope trees.
 #  To cache them they are inserted in a `cache` array.
 
-import 
+import
   strutils, platform, hashes, crc, options
 
 type
   TFormatStr* = string # later we may change it to CString for better
-                       # performance of the code generator (assignments 
+                       # performance of the code generator (assignments
                        # copy the format strings
                        # though it is not necessary)
   PRope* = ref TRope
-  TRope*{.acyclic.} = object of RootObj # the empty rope is represented 
+  TRope*{.acyclic.} = object of RootObj # the empty rope is represented
                                         # by nil to safe space
     left*, right*: PRope
     length*: int
     data*: string             # != nil if a leaf
-  
+
   TRopeSeq* = seq[PRope]
 
   TRopesError* = enum
@@ -99,14 +99,14 @@ proc ropeInvariant*(r: PRope): bool
 
 var errorHandler*: proc(err: TRopesError, msg: string, useWarning = false)
   # avoid dependency on msgs.nim
-  
+
-proc ropeLen(a: PRope): int = 
+proc ropeLen(a: PRope): int =
   if a == nil: result = 0
   else: result = a.length
-  
+
-proc newRope*(data: string = nil): PRope = 
+proc newRope*(data: string = nil): PRope =
   new(result)
-  if data != nil: 
+  if data != nil:
     result.length = len(data)
     result.data = data
 
@@ -119,17 +119,17 @@ proc newMutableRope*(capacity = 30): PRope =
 proc freezeMutableRope*(r: PRope) {.inline.} =
   r.length = r.data.len
 
-var 
+var
-  cache: array[0..2048*2 -1, PRope]
+  cache: array[0..2048*2 - 1, PRope]
 
 proc resetRopeCache* =
   for i in low(cache)..high(cache):
     cache[i] = nil
 
-proc ropeInvariant(r: PRope): bool = 
+proc ropeInvariant(r: PRope): bool =
-  if r == nil: 
+  if r == nil:
     result = true
-  else: 
+  else:
     result = true #
                   #    if r.data <> snil then
                   #      result := true
@@ -137,13 +137,13 @@ proc ropeInvariant(r: PRope): bool =
                   #      result := (r.left <> nil) and (r.right <> nil);
                   #      if result then result := ropeInvariant(r.left);
                   #      if result then result := ropeInvariant(r.right);
-                  #    end 
+                  #    end
 
 var gCacheTries* = 0
 var gCacheMisses* = 0
 var gCacheIntTries* = 0
 
-proc insertInCache(s: string): PRope = 
+proc insertInCache(s: string): PRope =
   inc gCacheTries
   var h = hash(s) and high(cache)
   result = cache[h]
@@ -151,7 +151,7 @@ proc insertInCache(s: string): PRope =
     inc gCacheMisses
     result = newRope(s)
     cache[h] = result
-  
+
 proc toRope(s: string): PRope =
   if s.len == 0:
     result = nil
@@ -159,21 +159,21 @@ proc toRope(s: string): PRope =
     result = insertInCache(s)
   assert(ropeInvariant(result))
 
-proc ropeSeqInsert(rs: var TRopeSeq, r: PRope, at: Natural) = 
+proc ropeSeqInsert(rs: var TRopeSeq, r: PRope, at: Natural) =
   var length = len(rs)
-  if at > length: 
+  if at > length:
     setLen(rs, at + 1)
-  else: 
+  else:
     setLen(rs, length + 1)    # move old rope elements:
-  for i in countdown(length, at + 1): 
+  for i in countdown(length, at + 1):
     rs[i] = rs[i - 1] # this is correct, I used pen and paper to validate it
   rs[at] = r
 
-proc newRecRopeToStr(result: var string, resultLen: var int, r: PRope) = 
+proc newRecRopeToStr(result: var string, resultLen: var int, r: PRope) =
   var stack = @[r]
-  while len(stack) > 0: 
+  while len(stack) > 0:
     var it = pop(stack)
-    while it.data == nil: 
+    while it.data == nil:
       add(stack, it.right)
       it = it.left
     assert(it.data != nil)
@@ -181,15 +181,15 @@ proc newRecRopeToStr(result: var string, resultLen: var int, r: PRope) =
     inc(resultLen, it.length)
     assert(resultLen <= len(result))
 
-proc ropeToStr(p: PRope): string = 
+proc ropeToStr(p: PRope): string =
-  if p == nil: 
+  if p == nil:
     result = ""
-  else: 
+  else:
     result = newString(p.length)
     var resultLen = 0
     newRecRopeToStr(result, resultLen, p)
 
-proc con(a, b: PRope): PRope = 
+proc con(a, b: PRope): PRope =
   if a == nil: result = b
   elif b == nil: result = a
   else:
@@ -201,7 +201,7 @@ proc con(a, b: PRope): PRope =
 proc con(a: PRope, b: string): PRope = result = con(a, toRope(b))
 proc con(a: string, b: PRope): PRope = result = con(toRope(a), b)
 
-proc con(a: varargs[PRope]): PRope = 
+proc con(a: varargs[PRope]): PRope =
   for i in countup(0, high(a)): result = con(result, a[i])
 
 proc ropeConcat*(a: varargs[PRope]): PRope =
@@ -216,11 +216,11 @@ proc app(a: var PRope, b: PRope) = a = con(a, b)
 proc app(a: var PRope, b: string) = a = con(a, b)
 proc prepend(a: var PRope, b: PRope) = a = con(b, a)
 
-proc writeRope*(f: File, c: PRope) = 
+proc writeRope*(f: File, c: PRope) =
   var stack = @[c]
-  while len(stack) > 0: 
+  while len(stack) > 0:
     var it = pop(stack)
-    while it.data == nil: 
+    while it.data == nil:
       add(stack, it.right)
       it = it.left
       assert(it != nil)
@@ -239,28 +239,28 @@ var
   rnl* = tnl.newRope
   softRnl* = tnl.newRope
 
-proc ropef(frmt: TFormatStr, args: varargs[PRope]): PRope = 
+proc ropef(frmt: TFormatStr, args: varargs[PRope]): PRope =
   var i = 0
   var length = len(frmt)
   result = nil
   var num = 0
-  while i <= length - 1: 
+  while i <= length - 1:
-    if frmt[i] == '$': 
+    if frmt[i] == '$':
       inc(i)                  # skip '$'
       case frmt[i]
-      of '$': 
+      of '$':
         app(result, "$")
         inc(i)
-      of '#': 
+      of '#':
         inc(i)
         app(result, args[num])
         inc(num)
-      of '0'..'9': 
+      of '0'..'9':
         var j = 0
-        while true: 
+        while true:
           j = (j * 10) + ord(frmt[i]) - ord('0')
           inc(i)
-          if (i > length + 0 - 1) or not (frmt[i] in {'0'..'9'}): break 
+          if (i > length + 0 - 1) or not (frmt[i] in {'0'..'9'}): break
         num = j
         if j > high(args) + 1:
           errorHandler(rInvalidFormatStr, $(j))
@@ -278,7 +278,7 @@ proc ropef(frmt: TFormatStr, args: varargs[PRope]): PRope =
     while i < length:
       if frmt[i] != '$': inc(i)
       else: break
-    if i - 1 >= start: 
+    if i - 1 >= start:
       app(result, substr(frmt, start, i - 1))
   assert(ropeInvariant(result))
 
@@ -293,13 +293,13 @@ else:
     return r
   {.pop.}
 
-proc appf(c: var PRope, frmt: TFormatStr, args: varargs[PRope]) = 
+proc appf(c: var PRope, frmt: TFormatStr, args: varargs[PRope]) =
   app(c, ropef(frmt, args))
 
-const 
+const
   bufSize = 1024              # 1 KB is reasonable
 
-proc auxRopeEqualsFile(r: PRope, bin: var File, buf: pointer): bool = 
+proc auxRopeEqualsFile(r: PRope, bin: var File, buf: pointer): bool =
   if r.data != nil:
     if r.length > bufSize:
       errorHandler(rTokenTooLong, r.data)
@@ -307,56 +307,56 @@ proc auxRopeEqualsFile(r: PRope, bin: var File, buf: pointer): bool =
     var readBytes = readBuffer(bin, buf, r.length)
     result = readBytes == r.length and
         equalMem(buf, addr(r.data[0]), r.length) # BUGFIX
-  else: 
+  else:
     result = auxRopeEqualsFile(r.left, bin, buf)
     if result: result = auxRopeEqualsFile(r.right, bin, buf)
-  
+
-proc ropeEqualsFile(r: PRope, f: string): bool = 
+proc ropeEqualsFile(r: PRope, f: string): bool =
   var bin: File
   result = open(bin, f)
-  if not result: 
+  if not result:
     return                    # not equal if file does not exist
   var buf = alloc(bufSize)
   result = auxRopeEqualsFile(r, bin, buf)
-  if result: 
+  if result:
     result = readBuffer(bin, buf, bufSize) == 0 # really at the end of file?
   dealloc(buf)
   close(bin)
 
-proc crcFromRopeAux(r: PRope, startVal: TCrc32): TCrc32 = 
+proc crcFromRopeAux(r: PRope, startVal: TCrc32): TCrc32 =
-  if r.data != nil: 
+  if r.data != nil:
     result = startVal
-    for i in countup(0, len(r.data) - 1): 
+    for i in countup(0, len(r.data) - 1):
       result = updateCrc32(r.data[i], result)
-  else: 
+  else:
     result = crcFromRopeAux(r.left, startVal)
     result = crcFromRopeAux(r.right, result)
 
-proc newCrcFromRopeAux(r: PRope, startVal: TCrc32): TCrc32 = 
+proc newCrcFromRopeAux(r: PRope, startVal: TCrc32): TCrc32 =
   # XXX profiling shows this is actually expensive
   var stack: TRopeSeq = @[r]
   result = startVal
-  while len(stack) > 0: 
+  while len(stack) > 0:
     var it = pop(stack)
-    while it.data == nil: 
+    while it.data == nil:
       add(stack, it.right)
       it = it.left
     assert(it.data != nil)
     var i = 0
     var L = len(it.data)
-    while i < L: 
+    while i < L:
       result = updateCrc32(it.data[i], result)
       inc(i)
 
-proc crcFromRope(r: PRope): TCrc32 = 
+proc crcFromRope(r: PRope): TCrc32 =
   result = newCrcFromRopeAux(r, InitCrc32)
 
-proc writeRopeIfNotEqual(r: PRope, filename: string): bool = 
+proc writeRopeIfNotEqual(r: PRope, filename: string): bool =
   # returns true if overwritten
   var c: TCrc32
   c = crcFromFile(filename)
-  if c != crcFromRope(r): 
+  if c != crcFromRope(r):
     writeRope(r, filename)
     result = true
-  else: 
+  else:
     result = false

compiler/semtypes.nim

@@ -228,7 +228,7 @@ proc semArrayIndex(c: PContext, n: PNode): PType =
       if not isOrdinalType(e.typ.lastSon):
         localError(n[1].info, errOrdinalTypeExpected)
       result = makeRangeWithStaticExpr(c, e)
-      if c.inGenericContext >0: result.flags.incl tfUnresolved
+      if c.inGenericContext > 0: result.flags.incl tfUnresolved
     elif e.kind in nkCallKinds and hasGenericArguments(e):
       if not isOrdinalType(e.typ):
         localError(n[1].info, errOrdinalTypeExpected)

compiler/types.nim

@@ -434,7 +434,7 @@ proc typeToString(typ: PType, prefer: TPreferedDesc = preferName): string =
         result = "int literal(" & $t.n.intVal & ")"
   of tyGenericBody, tyGenericInst, tyGenericInvocation:
     result = typeToString(t.sons[0]) & '['
-    for i in countup(1, sonsLen(t) -1 -ord(t.kind != tyGenericInvocation)):
+    for i in countup(1, sonsLen(t)-1-ord(t.kind != tyGenericInvocation)):
       if i > 1: add(result, ", ")
       add(result, typeToString(t.sons[i], preferGenericArg))
     add(result, ']')

lib/core/macros.nim

@@ -734,14 +734,14 @@ proc basename*(a: NimNode): NimNode =
   of nnkIdent: return a
   of nnkPostfix, nnkPrefix: return a[1]
   else:
-    quit "Do not know how to get basename of ("& treeRepr(a) &")\n"& repr(a)
+    quit "Do not know how to get basename of (" & treeRepr(a) & ")\n" & repr(a)
 
 proc `basename=`*(a: NimNode; val: string) {.compileTime.}=
   case a.kind
   of nnkIdent: macros.`ident=`(a,  !val)
   of nnkPostfix, nnkPrefix: a[1] = ident(val)
   else:
-    quit "Do not know how to get basename of ("& treeRepr(a)& ")\n"& repr(a)
+    quit "Do not know how to get basename of (" & treeRepr(a) & ")\n" & repr(a)
 
 proc postfix*(node: NimNode; op: string): NimNode {.compileTime.} =
   newNimNode(nnkPostfix).add(ident(op), node)

lib/pure/collections/sequtils.nim

@@ -81,7 +81,7 @@ proc deduplicate*[T](seq1: seq[T]): seq[T] =
     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.
   ##
@@ -181,7 +181,7 @@ iterator filter*[T](seq1: seq[T], pred: proc(item: T): bool {.closure.}): T =
   ##   for n in filter(numbers, proc (x: int): bool = x mod 2 == 0):
   ##     echo($n)
   ##   # echoes 4, 8, 4 in separate lines
-  for i in countup(0, len(seq1) -1):
+  for i in countup(0, len(seq1)-1):
     var item = seq1[i]
     if pred(item): yield seq1[i]
 
@@ -228,7 +228,7 @@ proc delete*[T](s: var seq[T], first=0, last=0) =
   ##   var dest = @[1,1,1,2,2,2,2,2,2,1,1,1,1,1]
   ##   dest.delete(3, 8)
   ##   assert outcome == dest
-  
+
   var i = first
   var j = last+1
   var newLen = len(s)-j+i
@@ -246,12 +246,12 @@ proc insert*[T](dest: var seq[T], src: openArray[T], pos=0) =
   ##
   ##.. code-block::
   ##   var dest = @[1,1,1,1,1,1,1,1]
-  ##   let 
+  ##   let
   ##     src = @[2,2,2,2,2,2]
   ##     outcome = @[1,1,1,2,2,2,2,2,2,1,1,1,1,1]
   ##   dest.insert(src, 3)
   ##   assert dest == outcome
-  
+
   var j = len(dest) - 1
   var i = len(dest) + len(src) - 1
   dest.setLen(i + 1)
@@ -553,12 +553,12 @@ when isMainModule:
     var dest = @[1,1,1,2,2,2,2,2,2,1,1,1,1,1]
     dest.delete(3, 8)
     assert outcome == dest, """\
-    Deleting range 3-9 from [1,1,1,2,2,2,2,2,2,1,1,1,1,1] 
+    Deleting range 3-9 from [1,1,1,2,2,2,2,2,2,1,1,1,1,1]
     is [1,1,1,1,1,1,1,1]"""
 
   block: # insert tests
     var dest = @[1,1,1,1,1,1,1,1]
-    let 
+    let
       src = @[2,2,2,2,2,2]
       outcome = @[1,1,1,2,2,2,2,2,2,1,1,1,1,1]
     dest.insert(src, 3)
@@ -610,7 +610,7 @@ when isMainModule:
     let
       a = @[1, 2, 3]
       b: seq[int] = @[]
-    
+
     doAssert a.repeat(3) == @[1, 2, 3, 1, 2, 3, 1, 2, 3]
     doAssert a.repeat(0) == @[]
     #doAssert a.repeat(-1) == @[] # will not compile!

lib/pure/collections/tables.nim

@@ -192,7 +192,7 @@ proc `[]`*[A, B](t: Table[A, B], key: A): 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.
+  ## If `key` is not in `t`, the ``KeyError`` exception is raised.
   var hc: THash
   var index = rawGet(t, key, hc)
   if index >= 0: result = t.data[index].val
@@ -314,7 +314,7 @@ proc initTable*[A, B](initialSize=64): Table[A, B] =
   result.counter = 0
   newSeq(result.data, initialSize)
 
-proc toTable*[A, B](pairs: openArray[(A, 
+proc toTable*[A, B](pairs: openArray[(A,
                     B)]): Table[A, B] =
   ## creates a new hash table that contains the given `pairs`.
   result = initTable[A, B](rightSize(pairs.len))
@@ -532,7 +532,7 @@ proc hasKey*[A, B](t: OrderedTable[A, B], key: A): bool =
   var hc: THash
   result = rawGet(t, key, hc) >= 0
 
-proc rawInsert[A, B](t: var OrderedTable[A, B], 
+proc rawInsert[A, B](t: var OrderedTable[A, B],
                      data: var OrderedKeyValuePairSeq[A, B],
                      key: A, val: B, hc: THash, h: THash) =
   rawInsertImpl()
@@ -584,7 +584,7 @@ proc initOrderedTable*[A, B](initialSize=64): OrderedTable[A, B] =
   result.last = -1
   newSeq(result.data, initialSize)
 
-proc toOrderedTable*[A, B](pairs: openArray[(A, 
+proc toOrderedTable*[A, B](pairs: openArray[(A,
                            B)]): OrderedTable[A, B] =
   ## creates a new ordered hash table that contains the given `pairs`.
   result = initOrderedTable[A, B](rightSize(pairs.len))
@@ -594,7 +594,7 @@ proc `$`*[A, B](t: OrderedTable[A, B]): string =
   ## The `$` operator for ordered hash tables.
   dollarImpl()
 
-proc sort*[A, B](t: var OrderedTable[A, B], 
+proc sort*[A, B](t: var OrderedTable[A, B],
                  cmp: proc (x,y: (A, B)): int) =
   ## sorts `t` according to `cmp`. This modifies the internal list
   ## that kept the insertion order, so insertion order is lost after this
@@ -617,7 +617,7 @@ proc sort*[A, B](t: var OrderedTable[A, B],
       while i < insize:
         inc(psize)
         q = t.data[q].next
-        if q < 0: break 
+        if q < 0: break
         inc(i)
       qsize = insize
       while psize > 0 or (qsize > 0 and q >= 0):
@@ -625,7 +625,7 @@ proc sort*[A, B](t: var OrderedTable[A, B],
           e = q; q = t.data[q].next; dec(qsize)
         elif qsize == 0 or q < 0:
           e = p; p = t.data[p].next; dec(psize)
-        elif cmp((t.data[p].key, t.data[p].val), 
+        elif cmp((t.data[p].key, t.data[p].val),
                  (t.data[q].key, t.data[q].val)) <= 0:
           e = p; p = t.data[p].next; dec(psize)
         else:
@@ -730,7 +730,7 @@ proc `$`*[A, B](t: OrderedTableRef[A, B]): string =
   ## The `$` operator for ordered hash tables.
   dollarImpl()
 
-proc sort*[A, B](t: OrderedTableRef[A, B], 
+proc sort*[A, B](t: OrderedTableRef[A, B],
                  cmp: proc (x,y: (A, B)): int) =
   ## sorts `t` according to `cmp`. This modifies the internal list
   ## that kept the insertion order, so insertion order is lost after this
@@ -848,7 +848,7 @@ proc `$`*[A](t: CountTable[A]): string =
   ## The `$` operator for count tables.
   dollarImpl()
 
-proc inc*[A](t: var CountTable[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:
@@ -965,7 +965,7 @@ proc `$`*[A](t: CountTableRef[A]): string =
   ## The `$` operator for count tables.
   dollarImpl()
 
-proc inc*[A](t: CountTableRef[A], key: A, val = 1) = 
+proc inc*[A](t: CountTableRef[A], key: A, val = 1) =
   ## increments `t[key]` by `val`.
   t[].inc(key, val)
 

todo.txt

@@ -1,16 +1,16 @@
 version 0.10.4
 ==============
 
+- improve the parser; deal with  echo $foo  gotcha
 - improve GC-unsafety warnings
 - make 'nil' work for 'add' and 'len'
-- disallow negative indexing
-- improve the parser; deal with  echo $foo  gotcha
 - add "all threads are blocked" detection to 'spawn'
 
 
 version 1.0
 ===========
 
+- disallow negative indexing
 - figure out why C++ bootstrapping is so much slower
 - nimsuggest: auto-completion needs to work in 'class' macros
 - improve the docs for inheritance