rename () to recover (#262)

Bumps minor for `()`->`recover` rename due to `()` triggering Nim compiler bugs for `foo[T](bar)` calls.

cps.nim

@@ -271,8 +271,6 @@ proc dealloc*[T: Continuation](c: sink T; E: typedesc[T]): E {.used, inline.} =
   ## its result may be assigned to another continuation reference.
   nil
 
-{.push experimental: "callOperator".}
-template `()`(c: Continuation): untyped {.used.} =
+template recover*(c: Continuation): untyped {.used.} =
   ## Returns the result, i.e. the return value, of a continuation.
   discard
-{.pop.}

cps.nimble

@@ -1,4 +1,4 @@
-version = "0.4.5"
+version = "0.5.0"
 author = "disruptek"
 description = "continuation-passing style"
 license = "MIT"

cps/environment.nim

@@ -420,38 +420,39 @@ proc genException*(e: var Env): NimNode =
     newLetIdentDef(ex, newRefType(bindName("Exception")), newNilLit())
   result = newDotExpr(e.castToChild(e.first), ex)
 
-proc createResult*(env: Env, exported = false): ProcDef =
+proc createRecover*(env: Env, exported = false): ProcDef =
   ## define a procedure for retrieving the result of a continuation
   ##
   ## `exported` determines whether this procedure will be exported
   let
-    field =
+    field = NimNode:
       if env.rs.hasType:
         env.get                  # the return value is env.result
       else:
         nnkDiscardStmt.newTree:
           newEmptyNode()       # the return value is void
 
   # compose the (exported?) symbol
-  var name = nnkAccQuoted.newTree ident"()"
-  if exported:
-    name = NormNode postfix(name, "*")
+  let name = NimNode ident"recover"
+  var ename =
+    if exported:
+      postfix(name, "*")
+    else:
+      name
 
   result = ProcDef:
-    genAst(name = name.NimNode, field = field.NimNode, c = env.first.NimNode,
-           cont = env.identity.NimNode, tipe = env.rs.typ.NimNode,
-           dismissed=Dismissed, finished=Finished, running=Running):
-      {.push experimental: "callOperator".}
-      proc name(c: cont): tipe {.used.} =
+    genAstOpt({}, name, ename, field, c = env.first.NimNode,
+              cont = env.identity.NimNode, tipe = env.rs.typ.NimNode,
+              dismissed=Dismissed, finished=Finished, running=Running):
+      proc ename(c: cont): tipe {.used.} =
         case c.state
         of dismissed:
           raise Defect.newException:
             "dismissed continuations have no result"
         of finished:
           field
         of running:
-          `()`(trampoline c)
-      {.pop.}
+          name(trampoline c)
 
 proc createWhelp*(env: Env; n: ProcDef, goto: NormNode): ProcDef =
   ## the whelp needs to create a continuation

cps/transform.nim

@@ -624,7 +624,7 @@ proc shimAssign(env: var Env; store: NormNode, expr: NormNode, tail: NormNode):
 
   # swap the call in the assignment statement(s)
   let (child, etype) = setupChildContinuation(env, call)
-  assign = assign.resymCall(call, newCall child)
+  assign = assign.resymCall(call, newCall("recover".asName, child))
 
   # compose the rewrite as an assignment, a lame effort to dealloc
   # the child, and then any remaining statements we were passed
@@ -1198,17 +1198,17 @@ proc cpsTransformProc(T: NimNode, n: NimNode): NormNode =
   for p in [whelp, booty]:
     p.addPragma(bindName"cpsEnvironment", env.identity)
 
-  # the `()` operator recovers the result of a continuation
+  # the `recover` operator recovers the result of a continuation
   #
   # copy the exported-ness from the original proc so that it can be used
   # from other modules
-  let dots = env.createResult(originalProcSym.isExported)
+  let recover = env.createRecover(exported = originalProcSym.isExported)
 
   # "encouraging" a write of the current accumulating type
   env = env.storeType(force = off)
 
   # generated proc bodies, remaining proc, whelp, bootstrap
-  result = newStmtList(types, processMainContinuation, dots, whelp, booty)
+  result = newStmtList(types, processMainContinuation, recover, whelp, booty)
 
   # this is something that happens a lot in cps-generated code, so hide it
   # here to not spam the user with hints.

tests/thooks.nim

@@ -80,7 +80,7 @@ suite "hooks":
         stack 2: foo foo 👍
         boot 3: c nil 👍
         trace 4: foo continuation 👍
-        coop 5: Cont nil genasts.nim
+        coop 5: Cont nil environment.nim
         trace 6: While Loop continuation 👍
         trace 7: Post Call continuation 👍
         tail 8: Cont continuation 👍
@@ -92,9 +92,9 @@ suite "hooks":
         trace 14: Post Call continuation 👍
         pass 15: continuation.mom Cont(continuation) normalizedast.nim
         coop 16: result nil normalizedast.nim
-        dealloc 17: cps environment 😎 genasts.nim
+        dealloc 17: cps environment 😎 environment.nim
         trace 18: Post Child continuation normalizedast.nim
-        coop 19: Cont nil genasts.nim
+        coop 19: Cont nil environment.nim
         trace 20: While Loop continuation 👍
         trace 21: Post Call continuation 👍
         tail 22: Cont continuation 👍
@@ -106,9 +106,9 @@ suite "hooks":
         trace 28: Post Call continuation 👍
         pass 29: continuation.mom Cont(continuation) normalizedast.nim
         coop 30: result nil normalizedast.nim
-        dealloc 31: cps environment 😎 genasts.nim
+        dealloc 31: cps environment 😎 environment.nim
         trace 32: Post Child continuation normalizedast.nim
-        coop 33: Cont nil genasts.nim
+        coop 33: Cont nil environment.nim
         trace 34: While Loop continuation 👍
         trace 35: Post Call continuation 👍
       """.dedent(8).strip()

tests/treturns.nim

@@ -45,8 +45,8 @@ suite "returns and results":
 
     var c = whelp foo(5)
     trampoline c
-    check "call operator works correctly":
-      c() == 25
+    check "recover operator works correctly":
+      recover(c) == 25
 
   block:
     ## assignments to the special result symbol work
@@ -134,8 +134,8 @@ suite "returns and results":
 
     var c = whelp foo()
     trampoline c
-    check "call operator works correctly":
-      c() == 6
+    check "recover operator works correctly":
+      6 == recover c
 
   block:
     ## discarding a continuation return value works