Merge pull request #22 from hamidb80/nested

fix Nested

Author: hamidb80

iterrr.nimble

@@ -1,6 +1,6 @@
 # Package
 
-version       = "0.4.3"
+version       = "0.4.5"
 author        = "hamidb80"
 description   = "iterate faster. functional style, lazy like, extensible iterator library"
 license       = "MIT"

src/iterrr.nim

@@ -72,12 +72,14 @@ func genBracketExprOf(id: NimNode, len: int): seq[NimNode] =
   for i in 0 ..< len:
     result.add newTree(nnkBracketExpr, id, newIntLitNode i)
 
-func replacedIteratorIdents(expr: NimNode, aliases: seq[NimNode]): NimNode =
+func replacedIteratorIdents(expr: NimNode,
+  aliases: seq[NimNode], by: NimNode): NimNode =
+
   case aliases.len:
-  of 0: expr
-  of 1: expr.replacedIdent(aliases[0], ident "it")
+  of 0: expr.replacedIdent(ident "it", by)
+  of 1: expr.replacedIdent(aliases[0], by)
   else:
-    expr.replacedIdents(aliases, genBracketExprOf(ident"it", aliases.len))
+    expr.replacedIdents(aliases, genBracketExprOf(by, aliases.len))
 
 func toIterrrPack(calls: seq[NimNode]): IterrrPack =
   var hasReducer = false
@@ -120,14 +122,14 @@ func toIterrrPack(calls: seq[NimNode]): IterrrPack =
 
   assert hasReducer, "must set reducer"
 
-func detectTypeImpl(itrbl: NimNode, ttrfs: seq[TypeTransformer]): NimNode =
+func detectTypeImpl(itrbl, iterIdent: NimNode, ttrfs: seq[TypeTransformer]): NimNode =
   var cursor = inlineQuote default(typeof(`itrbl`))
 
   for t in ttrfs:
     cursor =
       case t.kind:
       of hoMap:
-        replacedIdent(t.expr, ident "it", cursor)
+        replacedIdent(t.expr, iterIdent, cursor)
 
       of hoCustom:
         newCall ident"default":
@@ -137,8 +139,8 @@ func detectTypeImpl(itrbl: NimNode, ttrfs: seq[TypeTransformer]): NimNode =
 
   inlineQuote typeof(`cursor`)
 
-func detectType(itrbl: NimNode, callChain: seq[HigherOrderCall]): NimNode =
-  detectTypeImpl itrbl:
+func detectType(itrbl, iterIdent: NimNode, callChain: seq[HigherOrderCall]): NimNode =
+  detectTypeImpl itrbl, iterIdent:
     var temp: seq[TypeTransformer]
     for c in callChain:
       case c.kind:
@@ -152,10 +154,10 @@ func detectType(itrbl: NimNode, callChain: seq[HigherOrderCall]): NimNode =
 
     temp
 
-func resolveIteratorAliases(ipack: var IterrrPack) =
+func resolveIteratorAliases(ipack: var IterrrPack, iterIdent: NimNode) =
   for c in ipack.callChain.mitems:
     if c.kind != hoCustom:
-      c.expr = c.expr.replacedIteratorIdents(c.iteratorIdentAliases)
+      c.expr = c.expr.replacedIteratorIdents(c.iteratorIdentAliases, iterIdent)
 
 proc resolveUniqIdents(node: NimNode, by: string) =
   ## appends `by` to every nnkAccQuote node recursively
@@ -168,17 +170,18 @@ proc resolveUniqIdents(node: NimNode, by: string) =
 proc iterrrImpl(itrbl: NimNode, calls: seq[NimNode],
     code: NimNode = nil): NimNode =
 
+  let uniqLoopIdent = ident "loopIdent_" & genUniqId()
+
   # var ipack = toIterrrPack inspect calls
   var ipack = toIterrrPack calls
-  resolveIteratorAliases ipack
+  resolveIteratorAliases ipack, uniqLoopIdent
 
   let
     hasCustomCode = code != nil
     noAcc = hasCustomCode and eqident(ipack.reducer.caller, "each")
     hasInplaceReducer = eqident(ipack.reducer.caller, "reduce")
 
     accIdent = ident "acc"
-    itIdent = ident "it"
     mainLoopIdent = ident "mainLoop"
     reducerStateUpdaterProcIdent = ipack.reducer.caller
     reducerFinalizerProcIdent = ipack.reducer.caller &. "Finalizer"
@@ -193,7 +196,7 @@ proc iterrrImpl(itrbl: NimNode, calls: seq[NimNode],
 
       else:
         let
-          dtype = detectType(itrbl, ipack.callChain)
+          dtype = detectType(itrbl, uniqLoopIdent, ipack.callChain)
           reducerInitCall = newTree(nnkBracketExpr, reducerInitProcIdent,
               dtype).newCall.add:
             ipack.reducer.params
@@ -218,30 +221,36 @@ proc iterrrImpl(itrbl: NimNode, calls: seq[NimNode],
   var
     wrappers: seq[tuple[code: NimNode, dtype: NimNode, params: seq[NimNode],
         info: AdapterInfo]]
+
     loopBody =
       if noAcc:
-        code.replacedIteratorIdents(ipack.reducer.params)
+        code.replacedIteratorIdents(ipack.reducer.params, uniqLoopIdent)
 
       elif hasInplaceReducer:
         if ipack.reducer.idents.len == 2:
           let k = ipack.reducer.idents[1].kind
+
           case k:
           of nnkIdent:
-            code.replacedIdents(ipack.reducer.idents, [accIdent, itIdent])
+            code.replacedIdents(ipack.reducer.idents, [accIdent, uniqLoopIdent])
+
           of nnkTupleConstr:
             let
               customIdents = ipack.reducer.idents[1].toseq
-              repls = genBracketExprOf(ident "it", customIdents.len)
-            code.replacedIdents(ipack.reducer.idents[0] & customIdents, @[
-                accIdent] & repls)
+              repls = genBracketExprOf(uniqLoopIdent, customIdents.len)
+
+            code.replacedIdents(
+              ipack.reducer.idents[0] & customIdents,
+              @[accIdent] & repls)
+
           else:
             err "invalid inplace reducer custom ident type. got: " & $k
         else:
-          code
+          code.replacedIdent ident"it", uniqLoopIdent
 
       else:
         quote:
-          if not `reducerStateUpdaterProcIdent`(`accIdent`, `itIdent`):
+          if not `reducerStateUpdaterProcIdent`(`accIdent`, `uniqLoopIdent`):
             break `mainLoopIdent`
 
 
@@ -255,7 +264,7 @@ proc iterrrImpl(itrbl: NimNode, calls: seq[NimNode],
       of hoMap:
         quote:
           block:
-            let `itIdent` = `p`
+            let `uniqLoopIdent` = `p`
             `loopBody`
 
       of hoFilter:
@@ -275,7 +284,7 @@ proc iterrrImpl(itrbl: NimNode, calls: seq[NimNode],
 
       of hoCustom:
         let adptr = customAdapters[call.name.strval]
-        var code = copy adptr.wrapperCode
+        var code = adptr.wrapperCode.copy.replacedIdent(ident"it", uniqLoopIdent)
 
         code.resolveUniqIdents $i
 
@@ -288,23 +297,23 @@ proc iterrrImpl(itrbl: NimNode, calls: seq[NimNode],
             else:
               quote:
                 block:
-                  let `itIdent` = `yval`
+                  let `uniqLoopIdent` = `yval`
                   `loopBody`
 
         wrappers.add:
           let dtype = # speed optimzation for adptr who don't use generic type. like `cycle` and `flatten`
             if adptr.iterTypePaths.len == 0:
               newEmptyNode()
             else:
-              detectType(itrbl, ipack.callChain[0..i-1])
+              detectType(itrbl, uniqLoopIdent, ipack.callChain[0..i-1])
 
           (code, dtype, call.params, adptr)
 
         code.getNode(adptr.loopPath)[ForBody]
 
 
   result = quote:
-    for `itIdent` in `itrbl`:
+    for `uniqLoopIdent` in `itrbl`:
       `loopBody`
 
   for w in wrappers.ritems:

src/iterrr/adapters.nim

@@ -1,14 +1,51 @@
-import std/[macros, tables, sugar, strutils]
+import std/[macros, tables, strutils]
 import macroplus
 import helper
 
+
+type AdapterInfo* = ref object
+  wrapperCode*: NimNode
+  loopPath*: NodePath
+  iterTypePaths*, yeildPaths*, loopIterPaths*, argsValuePaths*: seq[NodePath]
+
 # impl ------------------------------------------
 
-type
-  AdapterInfo* = ref object
-    wrapperCode*: NimNode
-    loopPath*: NodePath
-    iterTypePaths*, yeildPaths*, argsValuePaths*: seq[NodePath]
+proc fillAdapterInfoImpl(a: var AdapterInfo, path: var NodePath,
+    body: NimNode, itrType, loopName: NimNode) =
+
+  template goFurther: untyped =
+    fillAdapterInfoImpl a, path, ch, itrType, loopName
+
+  for i, ch in body:
+    path.add i
+    if ch.kind == nnkYieldStmt:
+      a.yeildPaths.add path
+
+    elif ch.eqIdent itrType:
+      a.iterTypePaths.add path
+
+    elif ch.eqIdent ident "it":
+      a.loopIterPaths.add path
+
+    elif ch.kind == nnkForStmt and eqIdent(ch[ForRange], loopName):
+      if a.loopPath == @[]:
+        a.loopPath = path
+        goFurther()
+
+      else:
+        err "there must be only one for loop over main iterable"
+
+    else:
+      goFurther()
+
+    path.del path.high
+
+proc fillAdapterInfo(avp: seq[NodePath], body: NimNode,
+  itrType, loopName: NimNode): AdapterInfo =
+
+  var path: NodePath
+  result = AdapterInfo(argsValuePaths: avp, wrapperCode: body)
+  fillAdapterInfoImpl result, path, body, itrType, loopName
 
 var customAdapters* {.compileTime.}: Table[string, AdapterInfo]
 
@@ -34,19 +71,8 @@ macro adapter*(iterDef): untyped =
     body.insert 0, argsDef
 
   let
-    adptr = AdapterInfo(
-      argsValuePaths: argsValuePathsAcc,
-      wrapperCode: body,
-      yeildPaths: findPaths(body, (n) => n.kind == nnkYieldStmt),
-      iterTypePaths: findPaths(body, (n) => n.eqIdent itrblId[IdentDefType]),
-      loopPath: (
-        let temp = findPaths(body,
-          (n) => n.kind == nnkForStmt and eqIdent(n[ForRange], itrblId[IdentDefName]))
-
-        assert temp.len == 1, "there must be only one for loop over main iterable"
-        temp[0]
-      ))
-
+    adptr = fillAdapterInfo(argsValuePathsAcc, body,
+      itrblId[IdentDefType], itrblId[IdentDefName])
     name = nimIdentNormalize getName iterdef[RoutineName]
     typename = block:
       let i = ident name & "Type"

src/iterrr/helper.nim

@@ -29,7 +29,7 @@ func getName*(node: NimNode): string =
   ## extracts the name for ident and exported ident
   ## `id` => "id"
   ## `id`* => "id
-  
+
   case node.kind:
   of nnkIdent:
     node.strVal
@@ -46,7 +46,7 @@ proc replacedIdents*(root: NimNode, targets, bys: openArray[NimNode]): NimNode =
   if root.kind == nnkIdent:
     for i, target in targets:
       if eqIdent(root, target):
-        return bys[i]
+        return bys[i] # FIXME
 
     root
 
@@ -138,3 +138,10 @@ func findPaths*(node: NimNode,
   fn: proc(node: NimNode): bool): seq[NodePath] {.inline.} =
 
   findPathsImpl node, fn, @[], result
+
+# ------------------------
+
+var c {.compileTime.} = 0
+proc genUniqId*(): string =
+  inc c
+  $c

tests/test.nim

@@ -30,6 +30,13 @@ suite "main entities":
     check "yes".items |> map((c, it)).do(inc c).toSeq() == @[(0, 'y'), (1, 'e'),
         (2, 's')]
 
+test "nested":
+  let r = @[@[1, 2], @[3, 4]].pairs |>
+    map[ia, a](
+      a.pairs |> map[ib, _]((ia, ib)).toseq()).toseq()
+
+  check r == @[@[(0, 0), (0, 1)], @[(1, 0), (1, 1)]]
+
 suite "custom ident :: []":
   test "1":
     check (1..10) |> filter[i](i < 5).toSeq() == @[1, 2, 3, 4]
@@ -115,11 +122,11 @@ suite "non-operator":
     check ("hello".items.iterrr filter(it != 'l').count()) == 3
     check iterrr("hello".items, filter(it != 'l').count()) == 3
 
-  test "inplace reducer":
-    let prod = (3..6).iterrr reduce(1):
-      acc *= it
+  # test "inplace reducer":
+  #   let prod = (3..6).iterrr reduce(1):
+  #     acc *= it
 
-    check prod == 3*4*5*6
+  #   check prod == 3*4*5*6
 
   test "each":
     var acc: seq[int]