v0.4.0 Can now unpack nested structures.

Author: technicallyagd

changeLog.md

@@ -1,5 +1,13 @@
 # Change Log
 
+## v0.4.0
+
+- Supports nested unpacking.
+
+## v0.3.2
+
+- Implements hack to enable rest unpacking after `var`. i.e. `[var _ as *a, b] <- someSeq`
+
 ## v0.3.1
 
 - Renames rename syntax. From the originally confusing `{name: anotherName} <- tim` and `unpackObject(name = anotherName)` to clear and descriptive `as` for both. (i.e. `{name as anotherName} <- tim` and `unpackObject(name as anotherName)`.)
@@ -10,7 +18,7 @@
 
 ## v0.2.0
 
-- Deprecating `unpack`, `lunpack`, and `vunpack` in favor of `unpackObject`, `unpackSeq`, `aUnpackObjec`, and `aUnpackSeq`. The new interface is more similar to the `<-` syntax, and the programmers will have more control over how the data source will be unpacked.
+- Deprecating `unpack`, `lunpack`, and `vunpack` in favor of `unpackObject`, `unpackSeq`, `aUnpackObject`, and `aUnpackSeq`. The new interface is more similar to the `<-` syntax, and the programmers will have more control over how the data source will be unpacked.
 
 - Adds example and tests to demonstrate how to flexibly unpack named tuples (like a boss).
 

readme.md

@@ -90,10 +90,10 @@ tim.someProcWithSideEffects(arg).unpackObject(name as tim0, job as job0)
 # {name as tim0, job as job0} <- tim.someProcWithSideEffects(arg)
 
 # is expanded into:
-# let someUniqueSym1212498 = tim.someProcWithSideEffects(arg)
+# let someUniqueSym1_212_498 = tim.someProcWithSideEffects(arg)
 # let
-#   tim0 = someUniqueSym1212498.name
-#   job0 = someUniqueSym1212498.job
+#   tim0 = someUniqueSym1_212_498.name
+#   job0 = someUniqueSym1_212_498.job
 
 # if you haven't noticed,
 # this means we can unpack named tuples like objects
@@ -116,7 +116,14 @@ let (_, diz, _, iz, _, _, _, it) = someTuple
 # with vanilla nim
 let (youNeedTo, writeSoMany, underscoresMan, _, _, _, _, _) = someTuple
 
+# also supports nested unpacking
+let nestedTuple = ((123, 321), (-3, (1, 2, 3, 4)))
+
+# This nesting is unnecessarily deep, but it's supported.
+[ [run, outOf], [names, [_, _, toUse, now]]] <- nestedTuple
+
 # to be continued...
+
 ```
 
 See [tests/theTest.nim](tests/theTest.nim) for more usages.
@@ -188,10 +195,26 @@ Under the hood, `unpack` just attaches `[countFromStart..^countFromEnd]` to what
 
 Unless you implement the `..` operator (and its friends) yourself though.
 
-##### Only one rest operator per unpack
+##### Only one rest operator per unpacked sequence
 
 `[*a, *b, c] <- someSeq` is not allowed. It might be possible, but I think it will be really messy (plus I am lazy). Same restriction applies to both Python and JavaScript, so I think it's okay to skip this part for now.
 
+However, using rest operator in different parts of the nested sequence is fine, since they have different index counters, so this will work:
+
+```nim
+[[*a, b], [c, d, *e], *f, g, h] <- someNestedSeq
+# is expanded into:
+# let
+#   b = someNestedSeq[0][^1]
+#   a = someNestedSeq[0][0..^2]
+#   c = someNestedSeq[1][0]
+#   d = someNestedSeq[1][1]
+#   e = someNestedSeq[1][2..^1]
+#   h = someNestedSeq[^1]
+#   g = someNestedSeq[^2]
+#   f = someNestedSeq[2..^3]
+```
+
 ##### Can't guard against incorrect index access at compile time
 
 Since we have no way to know the sequence length at compile time, (well, at least I don't know a way). We can't know if you are trying to do something goofy like:

src/unpack.nim

@@ -31,32 +31,84 @@ proc getRealDest(dest: NimNode; restCount: var int): NimNode =
     result = result[1]
   else: discard
 
-proc unpackSequenceInternal(srcNode, dests: NimNode; sec,
-  statement: NimNodeKind): NimNode =
-  result = newStmtList()
-  var section = sec.newTree()
-  var stNode = statement.newTree(newEmptyNode(), newEmptyNode())
-  if statement != nnkAsgn:
-    stNode.add(newEmptyNode())
-  var src = srcNode
-  # Creates a temporary symbol to store proc result.
-  if src.kind != nnkSym:
-    src = genSym(nskLet, "src")
-    result.add(newLetStmt(src, srcNode))
+proc processSeqUnpack(section, src, dests, stNode: NimNode): NimNode
+
+
+proc processObjectUnpack(section, src, dests, stNode: NimNode): NimNode =
+  result = section
+  for dest in dests.children:
+    case dest.kind:
+    of nnkInfix:
+      if dest[0].strVal == renameOp:
+        var realDest = dest[1]
+        case realDest.kind:
+        of nnkVarTy:
+          realDest = realDest[0]
+        else: discard
+        var newNode = stNode.copyNimTree
+        var newSource = nnkDotExpr.newTree(src, realDest)
+        let newDest = dest[2]
+        case newDest.kind:
+        of nnkCurly:
+          result = processObjectUnpack(result, newSource, newDest, stNode)
+        of nnkBracket:
+          result = processSeqUnpack(result, newSource, newDest, stNode)
+        else:
+          newNode[0] = newDest
+          newNode[^1] = newSource
+          result.add(newNode)
+      else:
+        error("Only `" & renameOp & "` is allowed as the infix",
+            dest[0])
+    of nnkExprColonExpr, nnkExprEqExpr:
+      var realDest = dest[0]
+      case realDest.kind:
+      of nnkVarTy:
+        realDest = realDest[0]
+      else: discard
+      var newNode = stNode.copyNimTree
+      newNode[0] = dest[1]
+      newNode[^1] = nnkDotExpr.newTree(src, realDest)
+      warning("This syntax is being deprecated, please use `{" &
+          realDest.strVal & " as " & dest[
+          1].strVal & "}` instead", dest)
+      result.add(newNode)
+    else:
+      var realDest = dest
+      case dest.kind:
+      of nnkVarTy:
+        realDest = dest[0]
+      else: discard
+      var newNode = stNode.copyNimTree
+      newNode[0] = realDest
+      newNode[^1] = nnkDotExpr.newTree(src, realDest)
+      result.add(newNode)
+
+proc processSeqUnpack(section, src, dests, stNode: NimNode): NimNode =
   var
     startInd = 0
     endCount = 0
     restCount = 0
     restDest = newLit(0)
+  result = section
   # First pass from the front
   for dest in dests.children:
     let realDest = getRealDest(dest, restCount)
     var newNode = stNode.copyNimTree
-    if realDest.strVal != skipOp:
-      if restCount == 0:
-        newNode[0] = realDest
-        newNode[^1] = nnkBracketExpr.newTree(src, newLit(startInd))
-        section.add(newNode)
+    let newSource = nnkBracketExpr.newTree(src, newLit(startInd))
+    let newDest = realDest
+    case realDest.kind:
+    of nnkCurly:
+      result = processObjectUnpack(result, newSource, newDest, stNode)
+    of nnkBracket:
+      result = processSeqUnpack(result, newSource, newDest, stNode)
+    else:
+      if realDest.strVal != skipOp:
+        if restCount == 0:
+
+          newNode[0] = realDest
+          newNode[^1] = newSource
+          result.add(newNode)
     if restCount == 0: startInd += 1
     else:
       if restDest.kind == nnkIntLit:
@@ -67,14 +119,21 @@ proc unpackSequenceInternal(srcNode, dests: NimNode; sec,
     for endInd in 1..endCount:
       let realDest = getRealDest(dests[^endInd], restCount)
       var newNode = stNode.copyNimTree
-
-      if realDest.strVal != skipOp:
-        newNode[0] = realDest
-        newNode[^1] = nnkBracketExpr.newTree(src, nnkPrefix.newTree(
+      let newSource = nnkBracketExpr.newTree(src, nnkPrefix.newTree(
           newIdentNode("^"),
           newLit(endInd)
         ))
-        section.add(newNode)
+      let newDest = realDest
+      case realDest.kind:
+      of nnkCurly:
+        result = processObjectUnpack(result, newSource, newDest, stNode)
+      of nnkBracket:
+        result = processSeqUnpack(result, newSource, newDest, stNode)
+      else:
+        if realDest.strVal != skipOp:
+          newNode[0] = realDest
+          newNode[^1] = newSource
+          result.add(newNode)
   # Adds rest statement
   if restCount == 1:
     var newNode = stNode.copyNimTree
@@ -85,64 +144,36 @@ proc unpackSequenceInternal(srcNode, dests: NimNode; sec,
         newLit(startInd),
         newLit(endCount+1)
       ))
-      section.add(newNode)
-
-
-  result.add(section)
+      result.add(newNode)
 
-proc unpackObjectInternal(srcNode, dests: NimNode; sec,
-  statement: NimNodeKind): NimNode =
-  result = newStmtList()
+proc prepareHead(srcNode: NimNode; sec,
+  statement: NimNodeKind): (NimNode, NimNode, NimNode, NimNode) =
+  var tobeResult = newStmtList()
   var section = sec.newTree()
   var stNode = statement.newTree(newEmptyNode(), newEmptyNode())
   if statement != nnkAsgn:
     stNode.add(newEmptyNode())
   var src = srcNode
   # Creates a temporary symbol to store proc result.
   if src.kind != nnkSym:
-    ## echo src.treeRepr
     src = genSym(nskLet, "src")
-    result.add(newLetStmt(src, srcNode))
-  for dest in dests.children:
-    case dest.kind:
-    of nnkInfix:
-      if dest[0].strVal == renameOp:
-        var realDest = dest[1]
-        case realDest.kind:
-        of nnkVarTy:
-          realDest = realDest[0]
-        else: discard
-        var newNode = stNode.copyNimTree
-        newNode[0] = dest[2]
-        newNode[^1] = nnkDotExpr.newTree(src, realDest)
-        section.add(newNode)
-      else:
-        error("Only `" & renameOp & "` is allowed as the infix", dest[0])
-    of nnkExprColonExpr, nnkExprEqExpr:
-      var realDest = dest[0]
-      case realDest.kind:
-      of nnkVarTy:
-        realDest = realDest[0]
-      else: discard
-      var newNode = stNode.copyNimTree
-      newNode[0] = dest[1]
-      newNode[^1] = nnkDotExpr.newTree(src, realDest)
-      warning("This syntax is being deprecated, please use `{" &
-          realDest.strVal & " as " & dest[
-          1].strVal & "}` instead", dest)
+    tobeResult.add(newLetStmt(src, srcNode))
+  (tobeResult, section, src, stNode)
 
-      section.add(newNode)
-    else:
-      var realDest = dest
-      case dest.kind:
-      of nnkVarTy:
-        realDest = dest[0]
-      else: discard
-      var newNode = stNode.copyNimTree
-      newNode[0] = realDest
-      newNode[^1] = nnkDotExpr.newTree(src, realDest)
-      section.add(newNode)
+proc unpackSequenceInternal(srcNode, dests: NimNode; sec,
+  statement: NimNodeKind): NimNode =
+  var (tobeResult, section, src, stNode) = prepareHead(srcNode, sec,
+      statement)
+  result = tobeResult
+  section = processSeqUnpack(section, src, dests, stNode)
+  result.add(section)
 
+proc unpackObjectInternal(srcNode, dests: NimNode; sec,
+  statement: NimNodeKind): NimNode =
+  var (tobeResult, section, src, stNode) = prepareHead(srcNode, sec,
+    statement)
+  result = tobeResult
+  section = processObjectUnpack(section, src, dests, stNode)
   result.add(section)
 
 macro `<-`*(dests: untyped; src: typed): typed =
@@ -243,3 +274,4 @@ macro aUnpackSeq*(src: typed; dests: varargs[untyped]): typed =
   ## var a, b, c: int
   ## src.aUnpackSeq(a, b, c)
   result = unpackSequenceInternal(src, dests, nnkStmtList, nnkAsgn)
+

tests/nestedUnpack.nim

@@ -0,0 +1,92 @@
+import unittest
+
+import unpack
+import macros
+
+type
+  Person = object
+    name, job: string
+    hobby: seq[string]
+let testSeq = @[@[2, 4], @[6, 4], @[3, 4, 5]]
+let testTuple = ((2, 4), 6, ((3, 4), 5))
+let timName = "Tim"
+let johnName = "John"
+let fluffer = "Fluffer"
+let bobber = "Bobber"
+let waterBottle = "water bottle"
+let timHobby = @[waterBottle, "stapler"]
+let people = [Person(name: timName, job: fluffer, hobby: timHobby),
+    Person(name: johnName, job: bobber)]
+
+suite "Unpacking nested sequence":
+  test "should unpack nested sequence":
+    testSeq.unpackSeq([a, b], [c])
+    check [a, c, b] == [2, 6, 4]
+    # is expanded into:
+    # let
+    #   a = testSeq[0][0]
+    #   b = testSeq[0][1]
+    #   c = testSeq[1][0]
+  test "should unpack nested tuples":
+    testTuple.unpackSeq([a, b], c, [_, d])
+    check [a, c, b, d] == [2, 6, 4, 5]
+
+  test "should unpack nested sequence of objects with sequences":
+    people.unpackSeq({name, job, hobby as [a, _]}, john)
+    # expands into:
+    # let
+    #   name = people[0].name
+    #   job = people[0].job
+    #   a = people[0].hobby[0]
+    #   john = people[1]
+    check name == timName
+    check job == fluffer
+    check a == waterBottle
+    check john.name == johnName
+
+  test "<- should also unpack nested sequence of objects with sequences":
+    [var {name, job, hobby as [a, _]}, john] <- people
+    # expands into:
+    # var
+    #   name = people[0].name
+    #   job = people[0].job
+    #   a = people[0].hobby[0]
+    #   john = people[1]
+    check name == timName
+    check job == fluffer
+    check a == waterBottle
+    check john.name == johnName
+    job = bobber
+    check job == bobber
+
+
+type
+  Cult = object
+    members: array[2, Person]
+    name: string
+let
+  tinyCult = "tinyCult"
+  theCult = Cult(members: people, name: tinyCult)
+
+suite "Unpacking nested objects":
+
+  test "should also unpack nested objects":
+    {members as [_, john], name} <- theCult
+    check john.name == johnName
+    check name == tinyCult
+  test "should work with variables definition":
+    {var members as [_, john], name} <- theCult
+    check john.name == johnName
+    check name == tinyCult
+
+    john.name = timName
+    check john.name == timName
+
+  test "should work with reassignment as well":
+
+    {var members as [_, john], name} <- theCult
+    check john.name == johnName
+    check name == tinyCult
+
+    {members as [{name}, _]} <-- theCult
+    check name == timName