feat(dict): all meth except fromkeys,popitem; fix(py): dict() accepted no arg

Author: litlighilit

Objects/dictobject.nim

@@ -19,11 +19,11 @@ declarePyType Dict(tpToken, reprLock, mutable):
   table: Table[PyObject, PyObject]
 
 
-proc newPyDict* : PyDictObject = 
+proc newPyDict*(table=initTable[PyObject, PyObject]()) : PyDictObject = 
   result = newPyDictSimple()
-  result.table = initTable[PyObject, PyObject]()
+  result.table = table
 
-proc hasKey*(dict: PyDictObject, key: PyObject): bool = 
+proc hasKey*(dict: PyDictObject, key: PyObject): bool =
   return dict.table.hasKey(key)
 proc contains*(dict: PyDictObject, key: PyObject): bool = dict.hasKey key
 
@@ -101,15 +101,16 @@ implDictMagic len, [mutable: read]:
   newPyInt(self.table.len)
 
 implDictMagic hash: unhashable self
-
-implDictMagic New:
-  newPyDict()
-
 implDictMagic eq:
   newPyBool(
     other.ofPyDictObject() and
     self.table == other.PyDictObject.table
   )
+implDictMagic Or(E: PyDictObject), [mutable: read]:
+  let res = newPyDict self.table
+  for (k, v) in E.table.pairs:
+    res.table[k] = v
+  res
 
 template keyError(other: PyObject): PyObject =
   var msg: PyStrObject
@@ -175,7 +176,6 @@ implDictMethod get, [mutable: write]:
   let defval = args[1]
   result.handleBadHash:
     return self.table.getOrDefault(key, defVal)
-  # XXX: Python's dict.get(k, v) doesn't discard TypeError
 
 implDictMethod pop, [mutable: write]:
   checkargnumatleast 1
@@ -190,6 +190,21 @@ implDictMethod pop, [mutable: write]:
   # XXX: Python's dict.pop(k, v) discard TypeError, KeyError
   return defval
 
+implDictMethod setdefault, [mutable: write]:
+  checkargnumatleast 1
+  let key = args[0]
+  checkhashabletmpl(key)
+  let defVal = if args.len == 1: pyNone
+  else:
+    checkargnum 2
+    args[1]
+
+  result.handleBadHash:
+    if key in self:
+      return self[key]
+    self[key] = defVal
+    return defval
+
 implDictMethod clear(), [mutable: write]: self.clear()
 
 implDictMethod copy(), [mutable: read]:
@@ -204,3 +219,5 @@ implDictMethod copy(), [mutable: read]:
 proc update*(d1, d2: PyDictObject) = 
   for k, v in d2.table.pairs:
     d1[k] = v
+
+# .__init__, .update, .keys, etc method is defined in ./dictobjectImpl

Objects/dictobjectImpl.nim

@@ -0,0 +1,65 @@
+
+
+import ./pyobject
+import ../Python/call
+import ./[stringobject, iterobject, numobjects]
+import ./noneobject
+import ./exceptions
+import ./dictobject
+export dictobject
+
+
+# redeclare this for these are "private" macros
+
+methodMacroTmpl(Dict)
+
+
+
+
+proc updateImpl*(self: PyDictObject, E: PyObject): PyObject =
+  if E.ofPyDictObject:
+    self.update PyDictObject E
+    return pyNone
+  let
+    keysFunc = E.callMagic(getattr, newPyAscii"keys")  # getattr(E, "keys")
+    getitem = E.getMagic(getitem)
+  if not keysFunc.isThrownException and not getitem.isNil:
+    let ret = fastCall(keysFunc, @[])
+    if ret.isThrownException: return ret
+    pyForIn i, ret:
+      self[i] = getitem(E, i)
+  else:
+    var idx = 0
+    pyForIn ele, E:
+      let getter = ele.getMagic(getitem)
+      if getter.isNil:
+        return newTypeError newPyAscii(
+          "cannot convert dictionary update sequence element #" &
+          $idx & " to a sequence")
+      # only use getitem
+      let
+        k = getter(ele, pyIntZero)
+        v = getter(ele, pyIntOne)
+      self[k] = v
+      idx.inc
+  pyNone
+
+implDictMagic iOr(E: PyObject), [mutable: write]: self.updateImpl E
+
+# XXX: how to impl using std/table?
+# implDictMethod popitem(), [mutable: write]:
+
+implDictMethod update(E: PyObject), [mutable: write]:
+  # XXX: `**kw` not supported in syntax
+  self.updateImpl E
+
+implDictMagic init:
+  let argsLen = args.len
+  case argsLen
+  of 0: pyNone
+  of 1:
+    let ret = self.updateImpl(args[argsLen-1])
+    if ret.isThrownException: return ret
+    pyNone
+  else:
+    errArgNum argsLen, 1

Objects/exceptions.nim

@@ -195,16 +195,20 @@ template getIterableWithCheck*(obj: PyObject): (PyObject, UnaryMethod) =
     retTuple = (iterobj, iternextFunc)
   retTuple
 
+template errArgNum*(argsLen, expected: int; name="")=
+  bind fmt, newTypeError, newPyStr
+  var msg: string
+  let sargsLen{.inject.} = $argsLen
+  if name != "":
+    msg = name & " takes exactly " & $expected & fmt" argument ({sargsLen} given)"
+  else:
+    msg = "expected " & $expected & fmt" argument ({sargsLen} given)"
+  return newTypeError(newPyStr msg)
 
 template checkArgNum*(expected: int, name="") = 
-  bind fmt, newTypeError, newPyStr
+  bind errArgNum
   if args.len != expected:
-    var msg: string
-    if name != "":
-      msg = name & " takes exactly " & $expected & fmt" argument ({args.len} given)"
-    else:
-      msg = "expected " & $expected & fmt" argument ({args.len} given)"
-    return newTypeError(newPyStr msg)
+    errArgNum args.len, expected, name
 
 
 template checkArgNumAtLeast*(expected: int, name="") = 

Python/bltinmodule.nim

@@ -3,7 +3,7 @@ import strformat
 import neval
 import builtindict
 import ../Objects/[bundle, typeobject, methodobject, descrobject, funcobject,
-  notimplementedobject, sliceobjectImpl, exceptions]
+  notimplementedobject, sliceobjectImpl, dictobjectImpl, exceptions]
 import ../Utils/[utils, macroutils, compat]