Wrestling with JPHP.

9 files changed, 472 insertions, 323 deletions

diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux
index 1bb7efa07..b2deead45 100644
--- a/stdlib/source/lux.lux
+++ b/stdlib/source/lux.lux
@@ -1559,7 +1559,7 @@
                                 ({(#Left msg)
                                   (#Left msg)
 
-                                  (#Right state' a)
+                                  (#Right [state' a])
                                   (f a state')}
                                  (ma state))))})
 
@@ -2205,7 +2205,7 @@
            1 "1" 2 "2" 3 "3"
            4 "4" 5 "5" 6 "6"
            7 "7" 8 "8" 9 "9"
-           _ ("lux io error" "undefined")}
+           _ ("lux io error" "@digit::format Undefined behavior.")}
           digit))
 
 (def:''' (nat\encode value)
@@ -2700,7 +2700,7 @@
          (int\encode value)
 
          [_ (#Rev value)]
-         ("lux io error" "Undefined behavior.")
+         ("lux io error" "@code\encode Undefined behavior.")
          
          [_ (#Frac value)]
          (frac\encode value)
@@ -4943,7 +4943,7 @@
      [#Record "{" "}" rejoin_all_pairs])
 
     [new_location (#Rev value)]
-    ("lux io error" "Undefined behavior.")
+    ("lux io error" "@doc_example->Text Undefined behavior.")
     ))
 
 (def: (with_baseline baseline [file line column])
@@ -5510,6 +5510,12 @@
     _
     (fail (..wrong_syntax_error (name_of ..:assume)))))
 
+(def: location
+  {#.doc "The location of the current expression being analyzed."}
+  (Meta Location)
+  (function (_ compiler)
+    (#Right [compiler (get@ #location compiler)])))
+
 (macro: #export (undefined tokens)
   {#.doc (doc "Meant to be used as a stand-in for functions with undefined implementations."
               "Undefined expressions will type-check against everything, so they make good dummy implementations."
@@ -5519,7 +5525,12 @@
                 (undefined)))}
   (case tokens
     #Nil
-    (return (list (` (..error! "Undefined behavior."))))
+    (do meta_monad
+      [location ..location
+       #let [[module line column] location
+             location ($_ "lux text concat" (text\encode module) "," (nat\encode line) "," (nat\encode column))
+             message ($_ "lux text concat" "Undefined behavior @ " location)]]
+      (wrap (list (` (..error! (~ (text$ message)))))))
     
     _
     (fail (..wrong_syntax_error (name_of ..undefined)))))
diff --git a/stdlib/source/lux/target/php.lux b/stdlib/source/lux/target/php.lux
index 4cb2f0602..1b1b91e88 100644
--- a/stdlib/source/lux/target/php.lux
+++ b/stdlib/source/lux/target/php.lux
@@ -2,17 +2,26 @@
   [lux (#- Location Code Global static int if cond or and not comment for)
    ["@" target]
    ["." host]
+   [abstract
+    [equivalence (#+ Equivalence)]
+    [hash (#+ Hash)]
+    ["." enum]]
    [control
-    [pipe (#+ case> cond> new>)]]
+    [pipe (#+ case> cond> new>)]
+    [parser
+     ["<.>" code]]]
    [data
     ["." text
      ["%" format (#+ format)]]
     [collection
      ["." list ("#\." functor fold)]]]
    [macro
-    ["." template]]
+    [syntax (#+ syntax:)]
+    ["." template]
+    ["." code]]
    [math
     [number
+     ["n" nat]
      ["f" frac]]]
    [type
     abstract]])
@@ -47,6 +56,18 @@
 (abstract: #export (Code brand)
   Text
 
+  (structure: #export equivalence
+    (All [brand] (Equivalence (Code brand)))
+
+    (def: (= reference subject)
+      (\ text.equivalence = (:representation reference) (:representation subject))))
+
+  (structure: #export hash
+    (All [brand] (Hash (Code brand)))
+
+    (def: &equivalence ..equivalence)
+    (def: hash (|>> :representation (\ text.hash hash))))
+
   (def: #export manual
     (-> Text Code)
     (|>> :abstraction))
@@ -154,8 +175,13 @@
 
   (def: #export (apply/* args func)
     (-> (List Expression) Expression Computation)
-    (:abstraction
-     (format (:representation func) (..arguments args))))
+    (|> (format (:representation func) (..arguments args))
+        :abstraction))
+
+  ## TODO: Remove when no longer using JPHP.
+  (def: #export (apply/*' args func)
+    (-> (List Expression) Expression Computation)
+    (apply/* (list& func args) (..constant "call_user_func")))
 
   (def: parameters
     (-> (List Argument) Text)
@@ -189,47 +215,72 @@
           ..group
           :abstraction)))
 
-  (template [<apply> <input_var>+ <input_type>+ <function>+]
-    [(`` (def: #export (<apply> [(~~ (template.splice <input_var>+))] function)
-           (-> [(~~ (template.splice <input_type>+))] Expression Computation)
-           (..apply/* (list (~~ (template.splice <input_var>+))) function)))
-
-     (`` (template [<lux_name> <php_name>]
-           [(def: #export (<lux_name> args)
-              (-> [(~~ (template.splice <input_type>+))] Computation)
-              (<apply> args (..constant <php_name>)))]
-           
-           (~~ (template.splice <function>+))))]
-
-    [apply/0 [] []
-     [[func_num_args/0 "func_num_args"]
-      [func_get_args/0 "func_get_args"]
-      [time/0          "time"]]]
-    [apply/1 [in0] [Expression]
-     [[is_null/1   "is_null"]
-      [empty/1     "empty"]
-      [count/1     "count"]
-      [strlen/1    "strlen"]
-      [array_pop/1 "array_pop"]
-      [array_reverse/1 "array_reverse"]
-      [intval/1    "intval"]
-      [floatval/1  "floatval"]
-      [strval/1    "strval"]
-      [ord/1       "ord"]
-      [chr/1       "chr"]
-      [print/1     "print"]
-      [exit/1      "exit"]]]
-    [apply/2 [in0 in1] [Expression Expression]
-     [[call_user_func_array/2 "call_user_func_array"]
-      [array_slice/2          "array_slice"]
-      [array_push/2           "array_push"]]]
-    [apply/3 [in0 in1 in2] [Expression Expression Expression]
-     [[array_slice/3 "array_slice"]
-      [array_splice/3 "array_splice"]
-      [strpos/3 "strpos"]
-      [substr/3 "substr"]]]
+  (syntax: (arity_inputs {arity <code>.nat})
+    (wrap (case arity
+            0 (.list)
+            _ (|> (dec arity)
+                  (enum.range n.enum 0)
+                  (list\map (|>> %.nat code.local_identifier))))))
+
+  (syntax: (arity_types {arity <code>.nat})
+    (wrap (list.repeat arity (` ..Expression))))
+
+  (template [<arity> <function>+]
+    [(with_expansions [<apply> (template.identifier ["apply/" <arity>])
+                       <inputs> (arity_inputs <arity>)
+                       <types> (arity_types <arity>)
+                       <definitions> (template.splice <function>+)]
+       (def: #export (<apply> function [<inputs>])
+         (-> Expression [<types>] Computation)
+         (..apply/* (.list <inputs>) function))
+
+       (template [<function>]
+         [(`` (def: #export (~~ (template.identifier [<function> "/" <arity>]))
+                (<apply> (..constant <function>))))]
+
+         <definitions>))]
+
+    [0
+     [["func_num_args"]
+      ["func_get_args"]
+      ["time"]
+      ["phpversion"]]]
+
+    [1
+     [["is_null"]
+      ["empty"]
+      ["count"]
+      ["array_pop"]
+      ["array_reverse"]
+      ["intval"]
+      ["floatval"]
+      ["strval"]
+      ["ord"]
+      ["chr"]
+      ["print"]
+      ["exit"]
+      ["iconv_strlen"] ["strlen"]]]
+
+    [2
+     [["call_user_func_array"]
+      ["array_slice"]
+      ["array_push"]
+      ["pack"]
+      ["unpack"]
+      ["iconv_strpos"] ["strpos"]]]
+
+    [3
+     [["array_slice"]
+      ["array_splice"]
+      ["iconv"]
+      ["iconv_strpos"] ["strpos"]
+      ["iconv_substr"] ["substr"]]]
     )
 
+  (def: #export (key_value key value)
+    (-> Expression Expression Expression)
+    (:abstraction (format (:representation key) " => " (:representation value))))
+
   (def: #export (array/* values)
     (-> (List Expression) Literal)
     (|> values
@@ -274,9 +325,9 @@
 
   (def: #export (? test then else)
     (-> Expression Expression Expression Computation)
-    (|> (format (:representation test) " ? "
-                (:representation then) " : "
-                (:representation else))
+    (|> (format (..group (:representation test)) " ? "
+                (..group (:representation then)) " : "
+                (..group (:representation else)))
         ..group
         :abstraction))
 
@@ -343,7 +394,7 @@
   (def: #export (if test then! else!)
     (-> Expression Statement Statement Statement)
     (:abstraction
-     (format "if " (..group (:representation test)) " "
+     (format "if" (..group (:representation test)) " "
              (..block (:representation then!))
              " else "
              (..block (:representation else!)))))
@@ -351,7 +402,7 @@
   (def: #export (when test then!)
     (-> Expression Statement Statement)
     (:abstraction
-     (format "if " (..group (:representation test)) " "
+     (format "if" (..group (:representation test)) " "
              (..block (:representation then!)))))
 
   (def: #export (then pre! post!)
@@ -364,14 +415,14 @@
   (def: #export (while test body!)
     (-> Expression Statement Statement)
     (:abstraction
-     (format "while " (..group (:representation test)) " "
+     (format "while" (..group (:representation test)) " "
              (..block (:representation body!)))))
 
   (def: #export (do_while test body!)
     (-> Expression Statement Statement)
     (:abstraction
      (format "do " (..block (:representation body!))
-             " while " (..group (:representation test))
+             " while" (..group (:representation test))
              ..statement_suffix)))
 
   (def: #export (for_each array value body!)
@@ -414,15 +465,15 @@
 
   (def: #export (define name value)
     (-> Constant Expression Expression)
-    (..apply/2 [(|> name :representation ..string)
-                value]
-               (..constant "define")))
+    (..apply/2 (..constant "define")
+               [(|> name :representation ..string)
+                value]))
 
   (def: #export (define_function name arguments body!)
     (-> Constant (List Argument) Statement Statement)
     (:abstraction
      (format "function " (:representation name)
-             " " (..parameters arguments)
+             (..parameters arguments)
              " "
              (..block (:representation body!)))))
 
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/php/common.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/php/common.lux
index ab2f480fe..572f1f2a8 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/php/common.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/php/common.lux
@@ -47,8 +47,8 @@
       (#try.Failure error)
       (/////.throw extension.invalid_syntax [extension_name %synthesis input]))))
 
-## (template: (!unary function)
-##   (|>> list _.apply/* (|> (_.var function))))
+(template: (!unary function)
+  (|>> list _.apply/* (|> (_.constant function))))
 
 ## ## TODO: Get rid of this ASAP
 ## (def: lux::syntax_char_case!
@@ -83,103 +83,98 @@
 ##                                                       conditionalsG))]]
 ##                  (wrap (_.apply/1 closure inputG))))]))
 
-## (def: lux_procs
-##   Bundle
-##   (|> /.empty
-##       (/.install "syntax char case!" lux::syntax_char_case!)
-##       (/.install "is" (binary (product.uncurry _.=)))
-##       (/.install "try" (unary //runtime.lux//try))))
+(def: lux_procs
+  Bundle
+  (|> /.empty
+      ## (/.install "syntax char case!" lux::syntax_char_case!)
+      (/.install "is" (binary (product.uncurry _.=)))
+      ## (/.install "try" (unary //runtime.lux//try))
+      ))
 
-## (def: i64_procs
-##   Bundle
-##   (<| (/.prefix "i64")
-##       (|> /.empty
-##           (/.install "and" (binary (product.uncurry _.bit_and)))
-##           (/.install "or" (binary (product.uncurry _.bit_or)))
-##           (/.install "xor" (binary (product.uncurry _.bit_xor)))
-##           (/.install "left-shift" (binary (product.uncurry //runtime.i64//left_shift)))
-##           (/.install "right-shift" (binary (product.uncurry //runtime.i64//right_shift)))
-##           (/.install "=" (binary (product.uncurry _.=)))
-##           (/.install "+" (binary (product.uncurry _.+)))
-##           (/.install "-" (binary (product.uncurry _.-)))
-##           (/.install "<" (binary (product.uncurry _.<)))
-##           (/.install "*" (binary (product.uncurry _.*)))
-##           (/.install "/" (binary (product.uncurry //runtime.i64//division)))
-##           (/.install "%" (binary (product.uncurry //runtime.i64//remainder)))
-##           (/.install "f64" (unary (_./ (_.float +1.0))))
-##           (/.install "char" (unary (_.apply/1 (_.var "utf8.char"))))
-##           )))
+(def: i64_procs
+  Bundle
+  (<| (/.prefix "i64")
+      (|> /.empty
+          (/.install "and" (binary (product.uncurry _.bit_and)))
+          (/.install "or" (binary (product.uncurry _.bit_or)))
+          (/.install "xor" (binary (product.uncurry _.bit_xor)))
+          (/.install "left-shift" (binary (product.uncurry _.bit_shl)))
+          (/.install "right-shift" (binary (product.uncurry //runtime.i64//right_shift)))
+          (/.install "=" (binary (product.uncurry _.=)))
+          (/.install "+" (binary (product.uncurry _.+)))
+          (/.install "-" (binary (product.uncurry _.-)))
+          (/.install "<" (binary (product.uncurry _.<)))
+          (/.install "*" (binary (product.uncurry _.*)))
+          (/.install "/" (binary (product.uncurry _./)))
+          (/.install "%" (binary (product.uncurry _.%)))
+          (/.install "f64" (unary (_./ (_.float +1.0))))
+          (/.install "char" (unary //runtime.i64//char))
+          )))
 
-## (def: f64//decode
-##   (Unary Expression)
-##   (|>> list _.apply/* (|> (_.var "tonumber")) _.return (_.closure (list)) //runtime.lux//try))
+(def: (f64//% [parameter subject])
+  (Binary Expression)
+  (_./ (_.float +1.0) (_.% parameter subject)))
 
-## (def: f64_procs
-##   Bundle
-##   (<| (/.prefix "f64")
-##       (|> /.empty
-##           (/.install "+" (binary (product.uncurry _.+)))
-##           (/.install "-" (binary (product.uncurry _.-)))
-##           (/.install "*" (binary (product.uncurry _.*)))
-##           (/.install "/" (binary (product.uncurry _./)))
-##           (/.install "%" (binary (product.uncurry (function.flip (_.apply/2 (_.var "math.fmod"))))))
-##           (/.install "=" (binary (product.uncurry _.=)))
-##           (/.install "<" (binary (product.uncurry _.<)))
-##           (/.install "i64" (unary (!unary "math.floor")))
-##           (/.install "encode" (unary (_.apply/2 (_.var "string.format") (_.string "%.17g"))))
-##           (/.install "decode" (unary ..f64//decode)))))
+(def: f64_procs
+  Bundle
+  (<| (/.prefix "f64")
+      (|> /.empty
+          (/.install "+" (binary (product.uncurry _.+)))
+          (/.install "-" (binary (product.uncurry _.-)))
+          (/.install "*" (binary (product.uncurry _.*)))
+          (/.install "/" (binary (product.uncurry _./)))
+          (/.install "%" (binary ..f64//%))
+          (/.install "=" (binary (product.uncurry _.=)))
+          (/.install "<" (binary (product.uncurry _.<)))
+          (/.install "i64" (unary _.intval/1))
+          (/.install "encode" (unary _.strval/1))
+          (/.install "decode" (unary //runtime.f64//decode)))))
 
-## (def: (text//char [paramO subjectO])
-##   (Binary Expression)
-##   (//runtime.text//char (_.+ (_.int +1) paramO) subjectO))
+(def: (text//clip [paramO extraO subjectO])
+  (Trinary Expression)
+  (//runtime.text//clip paramO extraO subjectO))
 
-## (def: (text//clip [paramO extraO subjectO])
-##   (Trinary Expression)
-##   (//runtime.text//clip subjectO paramO extraO))
+(def: (text//index [startO partO textO])
+  (Trinary Expression)
+  (//runtime.text//index textO partO startO))
 
-## (def: (text//index [startO partO textO])
-##   (Trinary Expression)
-##   (//runtime.text//index textO partO startO))
+(def: text_procs
+  Bundle
+  (<| (/.prefix "text")
+      (|> /.empty
+          (/.install "=" (binary (product.uncurry _.=)))
+          (/.install "<" (binary (product.uncurry _.<)))
+          (/.install "concat" (binary (product.uncurry (function.flip _.concat))))
+          (/.install "index" (trinary ..text//index))
+          (/.install "size" (unary //runtime.text//size))
+          (/.install "char" (binary (product.uncurry //runtime.text//char)))
+          (/.install "clip" (trinary ..text//clip))
+          )))
 
-## (def: text_procs
-##   Bundle
-##   (<| (/.prefix "text")
-##       (|> /.empty
-##           (/.install "=" (binary (product.uncurry _.=)))
-##           (/.install "<" (binary (product.uncurry _.<)))
-##           (/.install "concat" (binary (product.uncurry (function.flip _.concat))))
-##           (/.install "index" (trinary ..text//index))
-##           (/.install "size" (unary //runtime.text//size))
-##           ## TODO: Use version below once the Lua compiler becomes self-hosted.
-##           ## (/.install "size" (unary (for {@.lua (!unary "utf8.len")}
-##           ##                               (!unary "string.len"))))
-##           (/.install "char" (binary ..text//char))
-##           (/.install "clip" (trinary ..text//clip))
-##           )))
+(def: io//log!
+  (Unary Expression)
+  (|>> _.print/1
+       (_.or //runtime.unit)))
 
-## (def: (io//log! messageO)
-##   (Unary Expression)
-##   (|> (_.apply/* (list messageO) (_.var "print"))
-##       (_.or //runtime.unit)))
+(def: io//current-time
+  (Nullary Expression)
+  (|>> _.time/0
+       (_.* (_.int +1,000))))
 
-## (def: io_procs
-##   Bundle
-##   (<| (/.prefix "io")
-##       (|> /.empty
-##           (/.install "log" (unary ..io//log!))
-##           (/.install "error" (unary (!unary "error")))
-##           (/.install "current-time" (nullary (function.constant (|> (_.var "os.time")
-##                                                                     (_.apply/* (list))
-##                                                                     (_.* (_.int +1,000)))))))))
+(def: io_procs
+  Bundle
+  (<| (/.prefix "io")
+      (|> /.empty
+          (/.install "log" (unary ..io//log!))
+          (/.install "error" (unary //runtime.io//throw!))
+          (/.install "current-time" (nullary ..io//current-time)))))
 
 (def: #export bundle
   Bundle
   (<| (/.prefix "lux")
-      /.empty
-      ## (|> lux_procs
-      ##     (dictionary.merge i64_procs)
-      ##     (dictionary.merge f64_procs)
-      ##     (dictionary.merge text_procs)
-      ##     (dictionary.merge io_procs)
-      ##     )
-      ))
+      (|> /.empty
+          (dictionary.merge lux_procs)
+          (dictionary.merge i64_procs)
+          (dictionary.merge f64_procs)
+          (dictionary.merge text_procs)
+          (dictionary.merge io_procs))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux
index 50eddb998..39ba71730 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux
@@ -159,8 +159,8 @@
 
 (def: (io//log! messageG)
   (Unary Expression)
-  (_.or //runtime.unit
-        (_.print/2 messageG (_.string text.new_line))))
+  (|> (_.print/2 messageG (_.string text.new_line))
+      (_.or //runtime.unit)))
 
 (def: io//error!
   (Unary Expression)
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/case.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/case.lux
index e129af245..b04d8e766 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/case.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/case.lux
@@ -231,46 +231,43 @@
 (def: (pattern_matching generate archive pathP)
   (-> Phase Archive Path (Operation Statement))
   (do ///////phase.monad
-    [pattern_matching! (pattern_matching' generate archive pathP)]
+    [iteration! (pattern_matching' generate archive pathP)]
     (wrap ($_ _.then
               (_.do_while (_.bool false)
-                          pattern_matching!)
+                          iteration!)
               (_.throw (_.new (_.constant "Exception") (list (_.string ////synthesis/case.pattern_matching_error))))))))
 
 (def: (gensym prefix)
   (-> Text (Operation Text))
   (\ ///////phase.monad map (|>> %.nat (format prefix)) /////generation.next))
 
+(def: #export dependencies
+  (-> Path (List Var))
+  (|>> ////synthesis/case.storage
+       (get@ #////synthesis/case.dependencies)
+       set.to_list
+       (list\map (function (_ variable)
+                   (.case variable
+                     (#///////variable.Local register)
+                     (..register register)
+                     
+                     (#///////variable.Foreign register)
+                     (..capture register))))))
+
 (def: #export (case generate archive [valueS pathP])
   (Generator [Synthesis Path])
   (do {! ///////phase.monad}
     [initG (generate archive valueS)
-     pattern_matching! (pattern_matching generate archive pathP)
-     @case (..gensym "case")
-     #let [@caseG (_.global @case)
-           @caseL (_.var @case)]
-     @init (\ ! map _.var (..gensym "init"))
-     #let [@dependencies+ (|> (////synthesis/case.storage pathP)
-                              (get@ #////synthesis/case.dependencies)
-                              set.to_list
-                              (list\map (function (_ variable)
-                                          [false (.case variable
-                                                   (#///////variable.Local register)
-                                                   (..register register)
-                                                   
-                                                   (#///////variable.Foreign register)
-                                                   (..capture register))])))]
-     #let [directive ($_ _.then
-                         (<| _.;
-                             (_.set @caseL)
-                             (_.closure (list (_.reference @caseL)) (list& [#0 @init]
-                                                                           @dependencies+))
-                             ($_ _.then
-                                 (_.; (_.set @cursor (_.array/* (list @init))))
-                                 (_.; (_.set @savepoint (_.array/* (list))))
-                                 pattern_matching!))
-                         (_.; (_.set @caseG @caseL)))]
+     [[case_module case_artifact] pattern_matching!] (/////generation.with_new_context archive
+                                                       (pattern_matching generate archive pathP))
+     #let [@case (_.constant (///reference.artifact [case_module case_artifact]))
+           @dependencies+ (..dependencies (/////synthesis.path/seq (/////synthesis.path/then valueS)
+                                                                   pathP))
+           directive (<| (_.define_function @case (list\map _.parameter @dependencies+))
+                         ($_ _.then
+                             (_.; (_.set @cursor (_.array/* (list initG))))
+                             (_.; (_.set @savepoint (_.array/* (list))))
+                             pattern_matching!))]
      _ (/////generation.execute! directive)
-     _ (/////generation.save! @case directive)]
-    (wrap (_.apply/* (list& initG (list\map product.right @dependencies+))
-                     @caseG))))
+     _ (/////generation.save! (%.nat case_artifact) directive)]
+    (wrap (_.apply/* @dependencies+ @case))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/function.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/function.lux
index 718ee1e79..66d9eb37d 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/function.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/function.lux
@@ -33,7 +33,7 @@
   (do {! ///////phase.monad}
     [functionG (expression archive functionS)
      argsG+ (monad.map ! (expression archive) argsS+)]
-    (wrap (_.apply/* argsG+ functionG))))
+    (wrap (_.apply/*' argsG+ functionG))))
 
 (def: capture
   (-> Register Var)
@@ -69,7 +69,7 @@
                              (do !
                                [function_name (\ ! map ///reference.artifact
                                                  (/////generation.context archive))]
-                               (/////generation.with_anchor (_.var function_name)
+                               (/////generation.with_anchor (_.global function_name)
                                  (expression archive bodyS))))
      closureG+ (monad.map ! (expression archive) environment)
      #let [@curried (_.var "curried")
@@ -86,10 +86,7 @@
                                   (list.indices arity))]
      #let [[definition instantiation] (..with_closure closureG+ @selfG @selfL
                                         ($_ _.then
-                                            (_.echo (_.string "'ello, world! "))
                                             (_.; (_.set @num_args (_.func_num_args/0 [])))
-                                            (_.echo @num_args) (_.echo (_.string " ~ ")) (_.echo arityG)
-                                            (_.echo (_.string text.new_line))
                                             (_.; (_.set @curried (_.func_get_args/0 [])))
                                             (_.cond (list [(|> @num_args (_.= arityG))
                                                            ($_ _.then
@@ -98,25 +95,13 @@
                                                           [(|> @num_args (_.> arityG))
                                                            (let [arity_inputs (_.array_slice/3 [@curried (_.int +0) arityG])
                                                                  extra_inputs (_.array_slice/2 [@curried arityG])
-                                                                 next (_.call_user_func_array/2 [@selfL arity_inputs])
-                                                                 done (_.call_user_func_array/2 [next extra_inputs])]
-                                                             ($_ _.then
-                                                                 (_.echo (_.string "STAGED ")) (_.echo (_.count/1 arity_inputs))
-                                                                 (_.echo (_.string " + ")) (_.echo (_.count/1 extra_inputs))
-                                                                 (_.echo (_.string text.new_line))
-                                                                 (_.echo (_.string "@selfL ")) (_.echo @selfL) (_.echo (_.string text.new_line))
-                                                                 (_.echo (_.string "  next ")) (_.echo next) (_.echo (_.string text.new_line))
-                                                                 (_.echo (_.string "  done ")) (_.echo done) (_.echo (_.string text.new_line))
-                                                                 (_.return done)))])
+                                                                 next (_.call_user_func_array/2 [@selfL arity_inputs])]
+                                                             (_.return (_.call_user_func_array/2 [next extra_inputs])))])
                                                     ## (|> @num_args (_.< arityG))
                                                     (let [@missing (_.var "missing")]
                                                       (_.return (<| (_.closure (list (_.reference @selfL) (_.reference @curried)) (list))
                                                                     ($_ _.then
                                                                         (_.; (_.set @missing (_.func_get_args/0 [])))
-                                                                        (_.echo (_.string "NEXT ")) (_.echo (_.count/1 @curried))
-                                                                        (_.echo (_.string " ")) (_.echo (_.count/1 @missing))
-                                                                        (_.echo (_.string " ")) (_.echo (_.count/1 (_.array_merge/+ @curried (list @missing))))
-                                                                        (_.echo (_.string text.new_line))
                                                                         (_.return (_.call_user_func_array/2 [@selfL (_.array_merge/+ @curried (list @missing))])))))))
                                             ))]
      _ (/////generation.execute! definition)
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/loop.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/loop.lux
index 1bc853e64..cdac65275 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/loop.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/loop.lux
@@ -19,41 +19,69 @@
    ["#." case]
    ["/#" // #_
     ["#." reference]
-    ["//#" /// #_
-     ["."synthesis (#+ Scope Synthesis)]
-     ["#." generation]
-     ["//#" /// #_
-      ["#." phase]
-      [meta
-       [archive (#+ Archive)]]
-      [reference
-       [variable (#+ Register)]]]]]])
+    ["/#" // #_
+     [synthesis
+      ["." case]]
+     ["/#" // #_
+      ["."synthesis (#+ Scope Synthesis)]
+      ["#." generation]
+      ["//#" /// #_
+       ["#." phase]
+       [meta
+        [archive (#+ Archive)]]
+       [reference
+        [variable (#+ Register)]]]]]]])
 
-(def: #export (scope generate archive [start initsS+ bodyS])
+(def: #export (scope expression archive [start initsS+ bodyS])
   (Generator (Scope Synthesis))
-  (do {! ///////phase.monad}
-    [@loop (\ ! map (|>> %.nat (format "loop")) /////generation.next)
-     #let [@loopG (_.global @loop)
-           @loopL (_.var @loop)]
-     initsO+ (monad.map ! (generate archive) initsS+)
-     bodyO (/////generation.with_anchor @loopL
-             (generate archive bodyS))
-     #let [directive ($_ _.then
-                         (<| _.;
-                             (_.set @loopL)
-                             (_.closure (list (_.reference @loopL))
-                                        (|> initsS+
-                                            list.enumeration
-                                            (list\map (|>> product.left (n.+ start) //case.register [#0])))
-                                        (_.return bodyO)))
-                         (_.; (_.set @loopG @loopL)))]
-     _ (/////generation.execute! directive)
-     _ (/////generation.save! @loop directive)]
-    (wrap (_.apply/* initsO+ @loopG))))
+  (case initsS+
+    ## function/false/non-independent loop
+    #.Nil
+    (expression archive bodyS)
+
+    ## true loop
+    _
+    (do {! ///////phase.monad}
+      [initsO+ (monad.map ! (expression archive) initsS+)
+       [[loop_module loop_artifact] bodyO] (/////generation.with_new_context archive
+                                             (do !
+                                               [loop_context (/////generation.context archive)]
+                                               (/////generation.with_anchor (_.var (///reference.artifact loop_context))
+                                                 (expression archive bodyS))))
+       #let [locals (|> initsS+
+                        list.enumeration
+                        (list\map (|>> product.left (n.+ start) //case.register _.parameter)))
+             [directive instantiation] (: [Statement Expression]
+                                          (case (|> (synthesis.path/then bodyS)
+                                                    //case.dependencies
+                                                    (set.from_list _.hash)
+                                                    (set.difference (set.from_list _.hash (list\map product.right locals)))
+                                                    set.to_list)
+                                            #.Nil
+                                            (let [@loop (_.var (///reference.artifact [loop_module loop_artifact]))]
+                                              [(_.; (_.set @loop
+                                                           (_.closure (list (_.reference @loop))
+                                                                      locals
+                                                                      (_.return bodyO))))
+                                               @loop])
+
+                                            foreigns
+                                            (let [@loop (_.constant (///reference.artifact [loop_module loop_artifact]))]
+                                              [(<| (_.define_function @loop (list\map _.parameter foreigns))
+                                                   (let [@loop (_.var (///reference.artifact [loop_module loop_artifact]))]
+                                                     (_.return (_.set @loop
+                                                                      (_.closure (list& (_.reference @loop)
+                                                                                        (list\map _.reference foreigns))
+                                                                                 locals
+                                                                                 (_.return bodyO))))))
+                                               (_.apply/* foreigns @loop)])))]
+       _ (/////generation.execute! directive)
+       _ (/////generation.save! (%.nat loop_artifact) directive)]
+      (wrap (_.apply/* initsO+ instantiation)))))
 
-(def: #export (recur generate archive argsS+)
+(def: #export (recur expression archive argsS+)
   (Generator (List Synthesis))
   (do {! ///////phase.monad}
     [@scope /////generation.anchor
-     argsO+ (monad.map ! (generate archive) argsS+)]
+     argsO+ (monad.map ! (expression archive) argsS+)]
     (wrap (_.apply/* argsO+ @scope))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/runtime.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/runtime.lux
index 3a50bba43..7b3e55481 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/runtime.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/runtime.lux
@@ -38,7 +38,7 @@
 
 (template [<name> <base>]
   [(type: #export <name>
-     (<base> Var Expression Statement))]
+     (<base> Location Expression Statement))]
 
   [Operation /////generation.Operation]
   [Phase /////generation.Phase]
@@ -67,38 +67,6 @@
     ..unit
     _.null))
 
-(def: #export variant_tag_field "_lux_tag")
-(def: #export variant_flag_field "_lux_flag")
-(def: #export variant_value_field "_lux_value")
-
-(def: (variant' tag last? value)
-  (-> Expression Expression Expression Literal)
-  (_.array/** (list [(_.string ..variant_tag_field) tag]
-                    [(_.string ..variant_flag_field) last?]
-                    [(_.string ..variant_value_field) value])))
-
-(def: #export (variant tag last? value)
-  (-> Nat Bit Expression Literal)
-  (variant' (_.int (.int tag))
-            (..flag last?)
-            value))
-
-(def: #export none
-  Literal
-  (..variant 0 #0 ..unit))
-
-(def: #export some
-  (-> Expression Literal)
-  (..variant 1 #1))
-
-(def: #export left
-  (-> Expression Literal)
-  (..variant 0 #0))
-
-(def: #export right
-  (-> Expression Literal)
-  (..variant 1 #1))
-
 (def: (feature name definition)
   (-> Constant (-> Constant Statement) Statement)
   (definition name))
@@ -158,32 +126,7 @@
                                             (..with_vars [(~+ inputsC)]
                                               (_.define_function (~ g!_)
                                                                  (list (~+ (list\map (|>> (~) [false] (`)) inputsC)))
-                                                (~ code))))))))))))))))
-
-(runtime: (lux//try op)
-  (with_vars [value]
-    (_.try ($_ _.then
-               (_.; (_.set value (_.apply/1 [..unit] op)))
-               (_.return (..right value)))
-           (list (with_vars [error]
-                   {#_.class (_.constant "Exception")
-                    #_.exception error
-                    #_.handler (_.return (..left (_.do "getMessage" (list) error)))})))))
-
-(runtime: (lux//program_args inputs)
-  (with_vars [head tail]
-    ($_ _.then
-        (_.; (_.set tail ..none))
-        (<| (_.for_each (_.array_reverse/1 inputs) head)
-            (_.; (_.set tail (..some (_.array/* (list head tail))))))
-        (_.return tail))))
-
-(def: runtime//lux
-  Statement
-  ($_ _.then
-      @lux//try
-      @lux//program_args
-      ))
+                                                                 (~ code))))))))))))))))
 
 (runtime: (io//throw! message)
   ($_ _.then
@@ -196,8 +139,11 @@
       @io//throw!
       ))
 
+(def: #export tuple_size_field
+  "_lux_size")
+
 (def: tuple_size
-  _.count/1)
+  (_.nth (_.string ..tuple_size_field)))
 
 (def: last_index
   (|>> ..tuple_size (_.- (_.int +1))))
@@ -205,6 +151,11 @@
 (with_expansions [<recur> (as_is ($_ _.then
                                      (_.; (_.set lefts (_.- last_index_right lefts)))
                                      (_.; (_.set tuple (_.nth last_index_right tuple)))))]
+  (runtime: (tuple//make size values)
+    ($_ _.then
+        (_.; (_.set (..tuple_size values) size))
+        (_.return values)))
+
   (runtime: (tuple//left lefts tuple)
     (with_vars [last_index_right]
       (<| (_.while (_.bool true))
@@ -227,9 +178,42 @@
                             [(_.> last_index_right right_index)
                              ## Needs recursion.
                              <recur>])
-                      (_.return (_.array_slice/2 [tuple right_index])))
+                      ($_ _.then
+                          (_.echo (_.string (format "[tuple//right] _.array_slice/2" text.new_line)))
+                          (_.return (_.array_slice/2 [tuple right_index]))))
               )))))
 
+(def: #export variant_tag_field "_lux_tag")
+(def: #export variant_flag_field "_lux_flag")
+(def: #export variant_value_field "_lux_value")
+
+(runtime: (sum//make tag last? value)
+  (_.return (_.array/** (list [(_.string ..variant_tag_field) tag]
+                              [(_.string ..variant_flag_field) last?]
+                              [(_.string ..variant_value_field) value]))))
+
+(def: #export (variant tag last? value)
+  (-> Nat Bit Expression Computation)
+  (sum//make (_.int (.int tag))
+             (..flag last?)
+             value))
+
+(def: #export none
+  Computation
+  (..variant 0 #0 ..unit))
+
+(def: #export some
+  (-> Expression Computation)
+  (..variant 1 #1))
+
+(def: #export left
+  (-> Expression Computation)
+  (..variant 0 #0))
+
+(def: #export right
+  (-> Expression Computation)
+  (..variant 1 #1))
+
 (runtime: (sum//get sum wantsLast wantedTag)
   (let [no_match! (_.return _.null)
         sum_tag (_.nth (_.string ..variant_tag_field) sum)
@@ -238,83 +222,178 @@
         ## sum_flag (_.nth (_.int +1) sum)
         sum_value (_.nth (_.string ..variant_value_field) sum)
         ## sum_value (_.nth (_.int +2) sum)
-        is_last? (_.= (_.string "") sum_flag)
+        is_last? (_.= ..unit sum_flag)
         test_recursion! (_.if is_last?
                           ## Must recurse.
-                          (_.return (sum//get sum_value wantsLast (_.- sum_tag wantedTag)))
+                          ($_ _.then
+                              (_.; (_.set wantedTag (_.- sum_tag wantedTag)))
+                              (_.; (_.set sum sum_value)))
                           no_match!)]
-    ($_ _.then
-        (_.echo (_.string "sum//get ")) (_.echo (_.count/1 sum))
-        (_.echo (_.string " ")) (_.echo (_.apply/1 [sum] (_.constant "gettype")))
-        (_.echo (_.string " ")) (_.echo sum_tag)
-        (_.echo (_.string " ")) (_.echo wantedTag)
-        (_.echo (_.string text.new_line))
+    (<| (_.while (_.bool true))
         (_.cond (list [(_.= sum_tag wantedTag)
                        (_.if (_.= wantsLast sum_flag)
                          (_.return sum_value)
                          test_recursion!)]
 
-                      [(_.> sum_tag wantedTag)
+                      [(_.< wantedTag sum_tag)
                        test_recursion!]
 
-                      [(_.and (_.< sum_tag wantedTag)
-                              (_.= (_.string "") wantsLast))
-                       (_.return (variant' (_.- wantedTag sum_tag) sum_flag sum_value))])
-                no_match!)
-        )))
+                      [(_.= ..unit wantsLast)
+                       (_.return (sum//make (_.- wantedTag sum_tag) sum_flag sum_value))])
+                no_match!))))
 
 (def: runtime//adt
   Statement
   ($_ _.then
+      @tuple//make
       @tuple//left
       @tuple//right
+      @sum//make
       @sum//get
       ))
 
-(runtime: (i64//logic_right_shift param subject)
+(runtime: (lux//try op)
+  (with_vars [value]
+    (_.try ($_ _.then
+               (_.; (_.set value (_.apply/1 op [..unit])))
+               (_.return (..right value)))
+           (list (with_vars [error]
+                   {#_.class (_.constant "Exception")
+                    #_.exception error
+                    #_.handler (_.return (..left (_.do "getMessage" (list) error)))})))))
+
+(runtime: (lux//program_args inputs)
+  (with_vars [head tail]
+    ($_ _.then
+        (_.; (_.set tail ..none))
+        (<| (_.for_each (_.array_reverse/1 inputs) head)
+            (_.; (_.set tail (..some (_.array/* (list head tail))))))
+        (_.return tail))))
+
+(def: runtime//lux
+  Statement
+  ($_ _.then
+      @lux//try
+      @lux//program_args
+      ))
+
+(runtime: (i64//right_shift param subject)
   (let [mask (|> (_.int +1)
                  (_.bit_shl (_.- param (_.int +64)))
                  (_.- (_.int +1)))]
     (_.return (|> subject
-                  (_.bit_shr param)
-                  (_.bit_and mask)))))
+                  (_.bit_and mask)
+                  (_.bit_shr param)))))
+
+(def: jphp?
+  (_.= (_.string "5.6.99") (_.phpversion/0 [])))
+
+(runtime: (i64//char code)
+  (_.if ..jphp?
+    (_.return (_.chr/1 [code]))
+    (_.return (|> code
+                  [(_.string "V")]
+                  _.pack/2
+                  [(_.string "UTF-32LE") (_.string "UTF-8")]
+                  _.iconv/3))))
 
 (def: runtime//i64
   Statement
   ($_ _.then
-      @i64//logic_right_shift
+      @i64//right_shift
+      @i64//char
       ))
 
+(runtime: (text//size value)
+  (_.if ..jphp?
+    (_.return (_.strlen/1 [value]))
+    (_.return (_.iconv_strlen/1 [value]))))
+
 (runtime: (text//index subject param start)
   (with_vars [idx]
-    ($_ _.then
-        (_.; (_.set idx (_.strpos/3 [subject param start])))
-        (_.if (_.= (_.bool false) idx)
-          (_.return ..none)
-          (_.return (..some idx))))))
+    (_.if ..jphp?
+      ($_ _.then
+          (_.; (_.set idx (_.strpos/3 [subject param start])))
+          (_.if (_.= (_.bool false) idx)
+            (_.return ..none)
+            (_.return (..some idx))))
+      ($_ _.then
+          (_.; (_.set idx (_.iconv_strpos/3 [subject param start])))
+          (_.if (_.= (_.bool false) idx)
+            (_.return ..none)
+            (_.return (..some idx)))))))
+
+(def: (within? top value)
+  (-> Expression Expression Computation)
+  (_.and (|> value (_.>= (_.int +0)))
+         (|> value (_.< top))))
+
+(runtime: (text//clip offset length text)
+  (_.if ..jphp?
+    (_.return (_.substr/3 [text offset length]))
+    (_.return (_.iconv_substr/3 [text offset length]))))
+
+(runtime: (text//char idx text)
+  (_.if (|> idx (within? (text//size text)))
+    (let [code_point (: (-> Expression Computation)
+                        (|>> [(_.string "UTF-8") (_.string "UTF-32LE")]
+                             _.iconv/3
+                             [(_.string "V")]
+                             _.unpack/2
+                             (_.nth (_.int +1))))]
+      (_.if ..jphp?
+        (_.return (code_point (_.substr/3 [text idx (_.int +1)])))
+        (_.return (code_point (_.iconv_substr/3 [text idx (_.int +1)])))))
+    (_.throw (_.new (_.constant "Exception") (list (_.string "[Lux Error] Cannot get char from text."))))))
 
 (def: runtime//text
   Statement
   ($_ _.then
+      @text//size
       @text//index
+      @text//clip
+      @text//char
+      ))
+
+(runtime: (f64//decode value)
+  (with_vars [output]
+    ($_ _.then
+        (_.; (_.set output (_.floatval/1 value)))
+        (_.if (_.= (_.float +0.0) output)
+          (_.if ($_ _.or
+                    (_.= (_.string "0.0") output)
+                    (_.= (_.string "+0.0") output)
+                    (_.= (_.string "-0.0") output)
+                    (_.= (_.string "0") output)
+                    (_.= (_.string "+0") output)
+                    (_.= (_.string "-0") output))
+            (_.return (..some output))
+            (_.return ..none))
+          (_.return (..some output)))
+        )))
+
+(def: runtime//f64
+  Statement
+  ($_ _.then
+      @f64//decode
       ))
 
 (def: check_necessary_conditions!
   Statement
-  (let [condition (_.= (_.int +8)
-                       (_.constant "PHP_INT_SIZE"))
-        error_message (_.string (format "Cannot run program!" text.new_line
-                                        "Lux/PHP programs require 64-bit PHP builds!"))]
-    (_.when (_.not condition)
-            (_.throw (_.new (_.constant "Exception") (list error_message))))))
+  (let [i64_support? (_.= (_.int +8) (_.constant "PHP_INT_SIZE"))
+        i64_error (_.string (format "Cannot run program!" text.new_line
+                                    "Lux/PHP programs require 64-bit PHP builds!"))]
+    (_.when (_.not i64_support?)
+            (_.throw (_.new (_.constant "Exception") (list i64_error))))))
 
 (def: runtime
   Statement
   ($_ _.then
       check_necessary_conditions!
-      runtime//lux
       runtime//adt
+      runtime//lux
       runtime//i64
+      runtime//f64
       runtime//text
       runtime//io
       ))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/reference.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/reference.lux
index 5f4d3fbd1..bd1db66bf 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/reference.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/reference.lux
@@ -20,14 +20,17 @@
   (for {## In the case of Lua, there is a limit of 200 locals in a function's scope.
         @.lua (not ("lua script universe"))
         ## Cannot make all definitions be local variables because of limitations with JRuby.
-        @.ruby (not ("ruby script universe"))}
+        @.ruby (not ("ruby script universe"))
+        ## Cannot make all definitions be local variables because of limitations with PHP itself.
+        @.php (not ("php script universe"))}
        #0))
 
 (def: universe_label
   Text
   (with_expansions [<label> (format "u" (%.nat (if ..universe 1 0)))]
     (for {@.lua <label>
-          @.ruby <label>}
+          @.ruby <label>
+          @.php <label>}
          "")))
 
 (def: #export (artifact [module artifact])