Re-named "recur" to "again".

1 files changed, 18 insertions, 18 deletions

diff --git a/lux-jvm/source/luxc/lang/translation/jvm/extension/host.lux b/lux-jvm/source/luxc/lang/translation/jvm/extension/host.lux
index e32e35869..a8becd813 100644
--- a/lux-jvm/source/luxc/lang/translation/jvm/extension/host.lux
+++ b/lux-jvm/source/luxc/lang/translation/jvm/extension/host.lux
@@ -831,7 +831,7 @@
         body
         
         {synthesis.#Seq _ next}
-        (recur next)
+        (again next)
         
         {synthesis.#Then hidden}
         hidden))
@@ -867,14 +867,14 @@
 (def: (normalize_path normalize)
   (-> (-> Synthesis Synthesis)
       (-> Path Path))
-  (function (recur path)
+  (function (again path)
     (case path
       (^ (synthesis.path/then bodyS))
       (synthesis.path/then (normalize bodyS))
 
       (^template [<tag>]
         [(^ {<tag> leftP rightP})
-         {<tag> (recur leftP) (recur rightP)}])
+         {<tag> (again leftP) (again rightP)}])
       ([synthesis.#Alt]
        [synthesis.#Seq])
 
@@ -886,13 +886,13 @@
        [synthesis.#Access])
 
       {synthesis.#Bit_Fork when then else}
-      {synthesis.#Bit_Fork when (recur then) (maybe#each recur else)}
+      {synthesis.#Bit_Fork when (again then) (maybe#each again else)}
 
       (^template [<tag>]
         [{<tag> [[test then] elses]}
-         {<tag> [[test (recur then)]
+         {<tag> [[test (again then)]
                  (list#each (function (_ [else_test else_then])
-                              [else_test (recur else_then)])
+                              [else_test (again else_then)])
                             elses)]}])
       ([synthesis.#I64_Fork]
        [synthesis.#F64_Fork]
@@ -901,7 +901,7 @@
 
 (def: (normalize_method_body mapping)
   (-> (Dictionary Synthesis Variable) Synthesis Synthesis)
-  (function (recur body)
+  (function (again body)
     (case body
       (^ {synthesis.#Primitive value})
       body
@@ -910,10 +910,10 @@
       body
 
       (^ (synthesis.variant [lefts right? sub]))
-      (synthesis.variant [lefts right? (recur sub)])
+      (synthesis.variant [lefts right? (again sub)])
 
       (^ (synthesis.tuple members))
-      (synthesis.tuple (list#each recur members))
+      (synthesis.tuple (list#each again members))
 
       (^ (synthesis.variable var))
       (|> mapping
@@ -922,22 +922,22 @@
           synthesis.variable)
 
       (^ (synthesis.branch/case [inputS pathS]))
-      (synthesis.branch/case [(recur inputS) (normalize_path recur pathS)])
+      (synthesis.branch/case [(again inputS) (normalize_path again pathS)])
 
       (^ (synthesis.branch/let [inputS register outputS]))
-      (synthesis.branch/let [(recur inputS) register (recur outputS)])
+      (synthesis.branch/let [(again inputS) register (again outputS)])
 
       (^ (synthesis.branch/if [testS thenS elseS]))
-      (synthesis.branch/if [(recur testS) (recur thenS) (recur elseS)])
+      (synthesis.branch/if [(again testS) (again thenS) (again elseS)])
 
       (^ (synthesis.branch/get [path recordS]))
-      (synthesis.branch/get [path (recur recordS)])
+      (synthesis.branch/get [path (again recordS)])
 
       (^ (synthesis.loop/scope [offset initsS+ bodyS]))
-      (synthesis.loop/scope [offset (list#each recur initsS+) (recur bodyS)])
+      (synthesis.loop/scope [offset (list#each again initsS+) (again bodyS)])
 
-      (^ (synthesis.loop/recur updatesS+))
-      (synthesis.loop/recur (list#each recur updatesS+))
+      (^ (synthesis.loop/again updatesS+))
+      (synthesis.loop/again (list#each again updatesS+))
 
       (^ (synthesis.function/abstraction [environment arity bodyS]))
       (synthesis.function/abstraction [(list#each (function (_ captured)
@@ -955,10 +955,10 @@
                                        bodyS])
 
       (^ (synthesis.function/apply [functionS inputsS+]))
-      (synthesis.function/apply [(recur functionS) (list#each recur inputsS+)])
+      (synthesis.function/apply [(again functionS) (list#each again inputsS+)])
 
       {synthesis.#Extension [name inputsS+]}
-      {synthesis.#Extension [name (list#each recur inputsS+)]})))
+      {synthesis.#Extension [name (list#each again inputsS+)]})))
 
 (def: $Object
   (type.class "java.lang.Object" (list)))