From 3f23fb8c846acfd7cf04481f12839469c63a1148 Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Thu, 18 Mar 2021 16:27:04 -0400 Subject: Updates for Scheme compiler. --- compilers.md | 63 --- .../bookmark/tool/build_server_protocol.md | 4 + lux-php/commands.md | 37 ++ lux-php/source/program.lux | 2 +- lux-scheme/commands.md | 24 ++ lux-scheme/project.clj | 2 +- lux-scheme/source/program.lux | 428 +++++++++++++-------- stdlib/source/lux/target/scheme.lux | 152 ++++---- .../lux/phase/extension/analysis/scheme.lux | 34 ++ .../lux/phase/extension/generation/scheme.lux | 17 + .../phase/extension/generation/scheme/common.lux | 198 ++++++++++ .../lux/phase/extension/generation/scheme/host.lux | 39 ++ .../language/lux/phase/generation/php/case.lux | 14 +- .../language/lux/phase/generation/php/function.lux | 26 +- .../language/lux/phase/generation/php/loop.lux | 4 +- .../language/lux/phase/generation/php/runtime.lux | 5 - .../lux/phase/generation/php/structure.lux | 12 +- .../language/lux/phase/generation/scheme.lux | 100 ++--- .../language/lux/phase/generation/scheme/case.lux | 262 +++++++------ .../lux/phase/generation/scheme/function.lux | 132 +++---- .../language/lux/phase/generation/scheme/loop.lux | 77 ++-- .../lux/phase/generation/scheme/reference.lux | 10 +- .../lux/phase/generation/scheme/runtime.lux | 302 ++++++++------- .../lux/phase/generation/scheme/structure.lux | 48 +-- stdlib/source/test/lux.lux | 10 +- 25 files changed, 1246 insertions(+), 756 deletions(-) create mode 100644 documentation/bookmark/tool/build_server_protocol.md create mode 100644 lux-php/commands.md create mode 100644 lux-scheme/commands.md create mode 100644 stdlib/source/lux/tool/compiler/language/lux/phase/extension/analysis/scheme.lux create mode 100644 stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme.lux create mode 100644 stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme/common.lux create mode 100644 stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme/host.lux diff --git a/compilers.md b/compilers.md index 996322c7c..7a9afdc4c 100644 --- a/compilers.md +++ b/compilers.md @@ -1,42 +1,3 @@ -# PHP compiler - -## Test - -``` -cd ~/lux/lux-php/ && lein lux auto test -cd ~/lux/lux-php/ && lein clean && lein lux auto test -``` - -## Build - -``` -## Develop -## NOTE: Must set lux/control/concurrency/thread.parallelism = 1 before compiling to make sure JPHP doesn't cause trouble. -cd ~/lux/lux-php/ \ -&& lein clean \ -&& lein lux auto build - -## Build JVM-based compiler -## NOTE: Must set lux/control/concurrency/thread.parallelism = 1 before compiling to make sure JPHP doesn't cause trouble. -cd ~/lux/lux-php/ \ -&& lein clean \ -&& lein lux build \ -&& mv target/program.jar jvm_based_compiler.jar -``` - -## Try - -``` -## Compile Lux's Standard Library's tests using a JVM-based compiler. -cd ~/lux/stdlib/ \ -&& lein clean \ -&& time java -jar ~/lux/lux-php/target/program.jar build --source ~/lux/stdlib/source --target ~/lux/stdlib/target --module test/lux - -php -f ~/lux/stdlib/target/program.php -``` - ---- - # Common Lisp compiler ## Test @@ -61,30 +22,6 @@ cd ~/lux/lux-cl/ && java -jar target/program.jar build --source ~/lux/stdlib/sou --- -# Scheme compiler - -## Test - -``` -cd ~/lux/lux-scheme/ && lein lux auto test -cd ~/lux/lux-scheme/ && lein clean && lein lux auto test -``` - -## Build - -``` -cd ~/lux/lux-scheme/ && lein lux auto build -cd ~/lux/lux-scheme/ && lein clean && lein lux auto build -``` - -## Try - -``` -cd ~/lux/lux-scheme/ && java -jar target/program.jar build --source ~/lux/stdlib/source --target ~/lux/stdlib/target --module test/lux -``` - ---- - # R compiler ## Test diff --git a/documentation/bookmark/tool/build_server_protocol.md b/documentation/bookmark/tool/build_server_protocol.md new file mode 100644 index 000000000..b82b95373 --- /dev/null +++ b/documentation/bookmark/tool/build_server_protocol.md @@ -0,0 +1,4 @@ +# Reference + +1. [Build Server Protocol](https://build-server-protocol.github.io/) + diff --git a/lux-php/commands.md b/lux-php/commands.md new file mode 100644 index 000000000..618c13c52 --- /dev/null +++ b/lux-php/commands.md @@ -0,0 +1,37 @@ +# PHP compiler + +## Test + +``` +cd ~/lux/lux-php/ && lein lux auto test +cd ~/lux/lux-php/ && lein clean && lein lux auto test +``` + +## Build + +``` +## Develop +## NOTE: Must set lux/control/concurrency/thread.parallelism = 1 before compiling to make sure JPHP doesn't cause trouble. +cd ~/lux/lux-php/ \ +&& lein clean \ +&& lein lux auto build + +## Build JVM-based compiler +## NOTE: Must set lux/control/concurrency/thread.parallelism = 1 before compiling to make sure JPHP doesn't cause trouble. +cd ~/lux/lux-php/ \ +&& lein clean \ +&& lein lux build \ +&& mv target/program.jar jvm_based_compiler.jar +``` + +## Try + +``` +## Compile Lux's Standard Library's tests using a JVM-based compiler. +cd ~/lux/stdlib/ \ +&& lein clean \ +&& time java -jar ~/lux/lux-php/target/program.jar build --source ~/lux/stdlib/source --target ~/lux/stdlib/target --module test/lux + +php -f ~/lux/stdlib/target/program.php +``` + diff --git a/lux-php/source/program.lux b/lux-php/source/program.lux index a13039760..716405587 100644 --- a/lux-php/source/program.lux +++ b/lux-php/source/program.lux @@ -483,7 +483,7 @@ (let [global (reference.artifact context) @global (_.global global)] (do try.monad - [#let [definition (_.; (_.set @global input))] + [#let [definition (_.set! @global input)] _ (run! definition) value (run! (_.return @global))] (wrap [global value definition])))) diff --git a/lux-scheme/commands.md b/lux-scheme/commands.md new file mode 100644 index 000000000..055e90d8f --- /dev/null +++ b/lux-scheme/commands.md @@ -0,0 +1,24 @@ +# Scheme compiler + +## Test + +``` +cd ~/lux/lux-scheme/ && lein lux auto test +cd ~/lux/lux-scheme/ && lein clean && lein lux auto test +``` + +## Build + +``` +## Develop +cd ~/lux/lux-scheme/ \ +&& lein clean \ +&& lein lux auto build +``` + +## Try + +``` +cd ~/lux/lux-scheme/ && java -jar target/program.jar build --source ~/lux/stdlib/source --target ~/lux/stdlib/target --module test/lux +``` + diff --git a/lux-scheme/project.clj b/lux-scheme/project.clj index ab96d66dc..63cf89031 100644 --- a/lux-scheme/project.clj +++ b/lux-scheme/project.clj @@ -22,7 +22,7 @@ :plugins [[com.github.luxlang/lein-luxc ~version]] :dependencies [[com.github.luxlang/luxc-jvm ~version] [com.github.luxlang/stdlib ~version] - [kawa-scheme/kawa-core "2.4"]] + [com.github.arvyy/kawa "3.1.1"]] :manifest {"lux" ~version} :source-paths ["source"] diff --git a/lux-scheme/source/program.lux b/lux-scheme/source/program.lux index 8eb29a3aa..da9317961 100644 --- a/lux-scheme/source/program.lux +++ b/lux-scheme/source/program.lux @@ -1,88 +1,122 @@ (.module: [lux #* + [program (#+ program:)] + ["." host] ["." debug] - ["." host (#+ import: interface: do-to object)] [abstract - [monad (#+ do)]] + ["." monad (#+ do)]] [control + [pipe (#+ exec> case>)] + ["." try (#+ Try)] ["." exception (#+ exception:)] ["." io (#+ IO io)] - [parser - [cli (#+ program:)]]] + [concurrency + ["." promise (#+ Promise)]]] [data ["." maybe] - ["." error (#+ Error)] - [number - ["." i64]] - ["." text ("#@." hash) - format] + ["." text ("#\." hash) + ["%" format (#+ format)] + ["." encoding]] [collection ["." array (#+ Array)]]] [macro ["." template]] - [world - ["." file]] - [target + [math + [number (#+ hex) + ["n" nat] + ["." i64]]] + ["." world #_ + ["." file] + ["#/." program]] + ["@" target ["_" scheme]] [tool [compiler - ["." name] - ["." synthesis] - [phase - [macro (#+ Expander)] - ["." generation - ["." scheme - ["." runtime] - ["." extension]]]] + [phase (#+ Operation Phase)] + [reference + [variable (#+ Register)]] + [language + [lux + [program (#+ Program)] + [generation (#+ Context Host)] + ["." synthesis] + [analysis + [macro (#+ Expander)]] + [phase + ["." extension (#+ Extender Handler) + ["#/." bundle] + ["." analysis #_ + ["#" scheme]] + ["." generation #_ + ["#" scheme]]] + [generation + ["." reference] + ["." scheme + ["." runtime]]]]]] [default - ["." platform (#+ Platform)]]]]] + ["." platform (#+ Platform)]] + [meta + ["." packager #_ + ["#" script]]]]]] [program ["/" compositor - ["/." cli]]]) + ["#." cli] + ["#." static]]]) -(import: #long java/lang/Boolean) -(import: #long java/lang/String) +(host.import: java/lang/Boolean) +(host.import: java/lang/String) -(import: #long (java/lang/Class a)) +(host.import: (java/lang/Class a)) -(import: #long java/lang/Object - (toString [] java/lang/String) - (getClass [] (java/lang/Class java/lang/Object))) +(host.import: java/lang/Object + ["#::." + (toString [] java/lang/String) + (getClass [] (java/lang/Class java/lang/Object))]) -(import: #long java/lang/Long - (intValue [] java/lang/Integer)) +(host.import: java/lang/Long + ["#::." + (intValue [] java/lang/Integer)]) -(import: #long java/lang/Integer - (longValue [] java/lang/Long)) +(host.import: java/lang/Integer + ["#::." + (longValue [] java/lang/Long)]) -(import: #long gnu/math/IntNum - (new #manual [int]) - (longValue [] long)) +(host.import: gnu/math/IntNum + ["#::." + (new #manual [int]) + (longValue [] long)]) -(import: #long gnu/math/DFloNum - (doubleValue [] double)) +(host.import: gnu/math/DFloNum + ["#::." + (doubleValue [] double)]) -(import: #long gnu/lists/FString - (toString [] String)) +(host.import: gnu/lists/FString + ["#::." + (toString [] String)]) -(import: #long gnu/lists/Pair - (getCar [] java/lang/Object) - (getCdr [] java/lang/Object)) +(host.import: gnu/lists/Pair + ["#::." + (getCar [] java/lang/Object) + (getCdr [] java/lang/Object)]) -(import: #long (gnu/lists/FVector E) - (getBufferLength [] int) - (getRaw [int] E)) +(host.import: (gnu/lists/FVector E) + ["#::." + (getBufferLength [] int) + (getRaw [int] E)]) -(import: #long gnu/expr/ModuleMethod - (apply2 [java/lang/Object java/lang/Object] #try java/lang/Object)) +(host.import: gnu/mapping/Procedure + ["#::." + (apply2 [java/lang/Object java/lang/Object] #try java/lang/Object)]) -(import: #long gnu/mapping/Environment) +(host.import: gnu/mapping/Environment) -(import: #long gnu/expr/Language - (eval [java/lang/String] #try java/lang/Object)) +(host.import: gnu/expr/Language + ["#::." + (eval [java/lang/String] #try java/lang/Object)]) -(import: #long kawa/standard/Scheme - (#static getR7rsInstance [] kawa/standard/Scheme)) +(host.import: kawa/standard/Scheme + ["#::." + (#static getR7rsInstance [] kawa/standard/Scheme)]) (def: (variant? value) (-> Any Bit) @@ -90,7 +124,7 @@ (#.Some array) ## TODO: Get rid of this coercion ASAP. (let [array (:coerce (Array java/lang/Object) array)] - (and (n/= 3 (array.size array)) + (and (n.= 3 (array.size array)) (case (array.read 0 array) (#.Some tag) (case (host.check java/lang/Integer tag) @@ -107,29 +141,30 @@ false)) (template [] - [(interface: + [(host.interface: (getValue [] java/lang/Object)) - (`` (import: #long (~~ (template.identifier ["program/" ])) - (getValue [] java/lang/Object)))] + (`` (host.import: (~~ (template.identifier ["program/" ])) + ["#::." + (getValue [] java/lang/Object)]))] [VariantValue] [TupleValue] ) -(def: (variant-value lux-value cdr? value) +(def: (variant_value lux_value cdr? value) (-> (-> java/lang/Object java/lang/Object) Bit (Array java/lang/Object) gnu/lists/Pair) - (object [] gnu/lists/Pair [program/VariantValue] + (host.object [] gnu/lists/Pair [program/VariantValue] [] ## Methods (program/VariantValue - (getValue self) java/lang/Object + [] (getValue self) java/lang/Object (:coerce java/lang/Object value)) (gnu/lists/Pair - (getCar self) java/lang/Object + [] (getCar self) java/lang/Object (if cdr? (case (array.read 1 value) - (#.Some flag-is-set) + (#.Some flag_is_set) (:coerce java/lang/Object "") #.None @@ -140,71 +175,71 @@ (:coerce java/lang/Integer) gnu/math/IntNum::new))) (gnu/lists/Pair - (getCdr self) java/lang/Object + [] (getCdr self) java/lang/Object (if cdr? (|> value (array.read 2) maybe.assume - lux-value) - (variant-value lux-value true value))))) + lux_value) + (variant_value lux_value true value))))) -(def: (tuple-value lux-value value) +(def: (tuple_value lux_value value) (-> (-> java/lang/Object java/lang/Object) (Array java/lang/Object) gnu/lists/FVector) - (object [] gnu/lists/SimpleVector [program/TupleValue] + (host.object [] gnu/lists/SimpleVector [program/TupleValue] [] ## Methods (program/TupleValue - (getValue self) java/lang/Object + [] (getValue self) java/lang/Object (:coerce java/lang/Object value)) (gnu/lists/SimpleVector - (getBufferLength self) int - (host.long-to-int (array.size value))) + [] (getBufferLength self) int + (host.long_to_int (array.size value))) (gnu/lists/SimpleVector - (getRaw self {idx int}) java/lang/Object + [] (getRaw self {idx int}) java/lang/Object (|> value (array.read (|> idx java/lang/Integer::longValue (:coerce Nat))) maybe.assume - lux-value)) + lux_value)) (gnu/lists/SimpleVector - (getBuffer self) java/lang/Object - (error! "tuple-value getBuffer")) + [] (getBuffer self) java/lang/Object + (undefined)) (gnu/lists/SimpleVector - (setBuffer self {_ java/lang/Object}) void - (error! "tuple-value setBuffer")) + [] (setBuffer self {_ java/lang/Object}) void + (undefined)) (gnu/lists/SimpleVector - (clearBuffer self {_ int} {_ int}) void - (error! "tuple-value clearBuffer")) + [] (clearBuffer self {_ int} {_ int}) void + (undefined)) (gnu/lists/SimpleVector - (copyBuffer self {_ int}) void - (error! "tuple-value copyBuffer")) + [] (copyBuffer self {_ int}) void + (undefined)) (gnu/lists/SimpleVector - (newInstance self {_ int}) gnu/lists/SimpleVector - (error! "tuple-value newInstance")) + [] (newInstance self {_ int}) gnu/lists/SimpleVector + (undefined)) )) -(exception: (unknown-kind-of-host-object {object java/lang/Object}) +(exception: (unknown_kind_of_host_object {object java/lang/Object}) (exception.report ["Class" (java/lang/Object::toString (java/lang/Object::getClass object))] ["Object" (java/lang/Object::toString object)])) -(exception: (cannot-apply-a-non-function {object java/lang/Object}) +(exception: (cannot_apply_a_non_function {object java/lang/Object}) (exception.report ["Class" (java/lang/Object::toString (java/lang/Object::getClass object))] ["Object" (java/lang/Object::toString object)])) -(def: (lux-value value) +(def: (lux_value value) (-> java/lang/Object java/lang/Object) (<| (case (host.check [java/lang/Object] value) (#.Some value) ## TODO: Get rid of the coercions below. (if (variant? value) - (variant-value lux-value false (:coerce (Array java/lang/Object) value)) - (tuple-value lux-value (:coerce (Array java/lang/Object) value))) + (variant_value lux_value false (:coerce (Array java/lang/Object) value)) + (tuple_value lux_value (:coerce (Array java/lang/Object) value))) #.None) value)) (type: (Reader a) - (-> a (Error Any))) + (-> a (Try Any))) (def: (variant tag flag value) (-> Nat Bit Any Any) @@ -215,49 +250,49 @@ (host.null))) value]) -(def: (read-variant read host-object) +(def: (read_variant read host_object) (-> (Reader java/lang/Object) (Reader gnu/lists/Pair)) - (do error.monad - [tag (read (gnu/lists/Pair::getCar host-object)) - #let [host-object (:coerce gnu/lists/Pair (gnu/lists/Pair::getCdr host-object)) - flag (case (host.check java/lang/String (gnu/lists/Pair::getCar host-object)) + (do try.monad + [tag (read (gnu/lists/Pair::getCar host_object)) + #let [host_object (:coerce gnu/lists/Pair (gnu/lists/Pair::getCdr host_object)) + flag (case (host.check java/lang/String (gnu/lists/Pair::getCar host_object)) (#.Some _) true #.None false)] - value (read (gnu/lists/Pair::getCdr host-object))] + value (read (gnu/lists/Pair::getCdr host_object))] (wrap (..variant (:coerce Nat tag) flag value)))) -(def: (read-tuple read host-object) +(def: (read_tuple read host_object) (-> (Reader java/lang/Object) (Reader (gnu/lists/FVector java/lang/Object))) - (let [size (.nat (gnu/lists/FVector::getBufferLength host-object))] + (let [size (.nat (gnu/lists/FVector::getBufferLength host_object))] (loop [idx 0 output (: (Array Any) (array.new size))] - (if (n/< size idx) - (case (read (gnu/lists/FVector::getRaw (.int idx) host-object)) - (#error.Failure error) - (#error.Failure error) + (if (n.< size idx) + (case (read (gnu/lists/FVector::getRaw (.int idx) host_object)) + (#try.Failure error) + (#try.Failure error) - (#error.Success lux-value) - (recur (inc idx) (array.write idx (: Any lux-value) output))) - (#error.Success output))))) + (#try.Success lux_value) + (recur (inc idx) (array.write! idx (: Any lux_value) output))) + (#try.Success output))))) -(def: (read host-object) +(def: (read host_object) (Reader java/lang/Object) (`` (<| (~~ (template [] - [(case (host.check host-object) - (#.Some host-object) - (#error.Success host-object) + [(case (host.check host_object) + (#.Some host_object) + (#try.Success host_object) #.None)] - [java/lang/Boolean] [java/lang/String] [gnu/expr/ModuleMethod] + [java/lang/Boolean] [java/lang/String] [gnu/mapping/Procedure] )) (~~ (template [ ] - [(case (host.check host-object) - (#.Some host-object) - (#error.Success ( host-object)) + [(case (host.check host_object) + (#.Some host_object) + (#try.Success ( host_object)) #.None)] [gnu/math/IntNum gnu/math/IntNum::longValue] @@ -266,90 +301,163 @@ [program/VariantValue program/VariantValue::getValue] [program/TupleValue program/TupleValue::getValue] )) - (case (host.check gnu/lists/Pair host-object) - (#.Some host-object) - (read-variant read host-object) + (case (host.check gnu/lists/Pair host_object) + (#.Some host_object) + (read_variant read host_object) #.None) - (case (host.check gnu/lists/FVector host-object) - (#.Some host-object) - (read-tuple read (:coerce (gnu/lists/FVector java/lang/Object) host-object)) + (case (host.check gnu/lists/FVector host_object) + (#.Some host_object) + (read_tuple read (:coerce (gnu/lists/FVector java/lang/Object) host_object)) #.None) ## else - (exception.throw ..unknown-kind-of-host-object host-object)))) + (exception.throw ..unknown_kind_of_host_object host_object)))) -(def: ensure-macro - (-> Macro (Maybe gnu/expr/ModuleMethod)) - (|>> (:coerce java/lang/Object) (host.check gnu/expr/ModuleMethod))) +(def: ensure_macro + (-> Macro (Maybe gnu/mapping/Procedure)) + (|>> (:coerce java/lang/Object) (host.check gnu/mapping/Procedure))) (def: (expander macro inputs lux) Expander - (case (ensure-macro macro) + (case (ensure_macro macro) (#.Some macro) - (case (gnu/expr/ModuleMethod::apply2 (lux-value (:coerce java/lang/Object inputs)) - (lux-value (:coerce java/lang/Object lux)) + (case (gnu/mapping/Procedure::apply2 (lux_value (:coerce java/lang/Object inputs)) + (lux_value (:coerce java/lang/Object lux)) macro) - (#error.Success output) + (#try.Success output) (|> output ..read - (:coerce (Error (Error [Lux (List Code)])))) + (:coerce (Try (Try [Lux (List Code)])))) - (#error.Failure error) - (#error.Failure error)) + (#try.Failure error) + (#try.Failure error)) #.None - (exception.throw ..cannot-apply-a-non-function (:coerce java/lang/Object macro))) + (exception.throw ..cannot_apply_a_non_function (:coerce java/lang/Object macro))) ) (def: separator "$") -(type: Host - (generation.Host _.Expression _.Expression)) - (def: host - (IO Host) + (IO (Host _.Expression _.Expression)) (io (let [interpreter (kawa/standard/Scheme::getR7rsInstance) - evaluate! (function (evaluate! alias input) - (do error.monad - [output (gnu/expr/Language::eval (_.code input) interpreter)] - (read output)))] - (: Host + run! (: (-> (_.Code Any) (Try Any)) + (function (_ input) + (do try.monad + [output (gnu/expr/Language::eval (_.code input) interpreter)] + (read output))))] + (: (Host _.Expression _.Expression) (structure - (def: evaluate! evaluate!) - (def: (execute! alias input) + (def: (evaluate! context code) + (run! code)) + + (def: (execute! input) (gnu/expr/Language::eval (_.code input) interpreter)) - (def: (define! [module name] input) - (let [global (format (text.replace-all .module-separator ..separator module) - ..separator (name.normalize name) - "___" (%n (text@hash name))) + + (def: (define! context input) + (let [global (reference.artifact context) @global (_.var global)] - (do error.monad - [#let [definition (_.define-constant @global input)] + (do try.monad + [#let [definition (_.define_constant @global input)] _ (gnu/expr/Language::eval (_.code definition) interpreter) - value (evaluate! global @global)] - (wrap [global value definition]))))))))) + value (run! @global)] + (wrap [global value definition])))) + + (def: (ingest context content) + (|> content (\ encoding.utf8 decode) try.assume (:coerce _.Expression))) + + (def: (re_learn context content) + (run! content)) + + (def: (re_load context content) + (do try.monad + [_ (run! content)] + (run! (_.var (reference.artifact context))))) + ))))) (def: platform - (IO (Platform IO _.Var _.Expression _.Expression)) + (IO (Platform _.Var _.Expression _.Expression)) (do io.monad [host ..host] - (wrap {#platform.&monad io.monad - #platform.&file-system file.system + (wrap {#platform.&file_system (file.async file.default) #platform.host host #platform.phase scheme.generate - #platform.runtime runtime.generate}))) + #platform.runtime runtime.generate + #platform.write (|>> _.code (\ encoding.utf8 encode))}))) -(def: (program program) - (-> _.Expression _.Expression) +(def: (program context program) + (Program _.Expression _.Expression) (_.apply/2 program ## TODO: Figure out how to always get the command-line ## arguments. ## It appears that it differs between Scheme implementations. - (runtime.lux//program-args _.nil) + (runtime.lux//program_args _.nil) _.nil)) -(program: [{service /cli.service}] - (/.compiler ..expander - ..platform - extension.bundle - ..program - service)) +(for {@.old + (def: extender + Extender + ## TODO: Stop relying on coercions ASAP. + (<| (:coerce Extender) + (function (@self handler)) + (:coerce Handler) + (function (@self name phase)) + (:coerce Phase) + (function (@self archive parameters)) + (:coerce Operation) + (function (@self state)) + (:coerce Try) + try.assume + (:coerce Try) + (#try.Failure "YOLO"))) + + @.scheme + (def: (extender handler) + Extender + (:assume handler))}) + +(def: (declare_success! _) + (-> Any (Promise Any)) + (promise.future (\ world/program.default exit +0))) + +(def: (then pre post) + (-> _.Expression _.Expression _.Expression) + (_.manual (format (_.code pre) + text.new_line + (_.code post)))) + +(def: (scope body) + (-> _.Expression _.Expression) + (let [@program (_.var "lux_program")] + ($_ ..then + (_.define_function @program [(list) #.None] body) + (_.apply/* (list) @program) + ))) + +(`` (program: [{service /cli.service}] + (let [extension ".scm"] + (do io.monad + [platform ..platform] + (exec (do promise.monad + [_ (/.compiler {#/static.host @.scheme + #/static.host_module_extension extension + #/static.target (/cli.target service) + #/static.artifact_extension extension} + ..expander + analysis.bundle + (io.io platform) + generation.bundle + extension/bundle.empty + ..program + [_.Var _.Expression _.Expression] + ..extender + service + [(packager.package (_.manual "") + _.code + ..then + ..scope) + (format (/cli.target service) + (\ file.default separator) + "program" + extension)])] + (..declare_success! [])) + (io.io [])))))) diff --git a/stdlib/source/lux/target/scheme.lux b/stdlib/source/lux/target/scheme.lux index b5cf7c76d..ecdaa7324 100644 --- a/stdlib/source/lux/target/scheme.lux +++ b/stdlib/source/lux/target/scheme.lux @@ -1,16 +1,17 @@ (.module: - [lux (#- Code Global int or and if function cond let) + [lux (#- Code int or and if function cond let) [control [pipe (#+ new> cond> case>)]] [data - [number - ["f" frac]] ["." text ["%" format (#+ format)]] [collection ["." list ("#\." functor fold)]]] [macro ["." template]] + [math + [number + ["f" frac]]] [type abstract]]) @@ -28,7 +29,6 @@ [(abstract: #export Any) (`` (type: #export (|> (~~ (template.splice +)))))] - [Global Global' [Expression' Code]] [Var Var' [Expression' Code]] [Computation Computation' [Expression' Code]] ) @@ -37,9 +37,17 @@ {#mandatory (List Var) #rest (Maybe Var)}) - (def: #export code (-> (Code Any) Text) (|>> :representation)) + (def: #export manual + (-> Text Code) + (|>> :abstraction)) - (def: #export var (-> Text Var) (|>> :abstraction)) + (def: #export code + (-> (Code Any) Text) + (|>> :representation)) + + (def: #export var + (-> Text Var) + (|>> :abstraction)) (def: (arguments [mandatory rest]) (-> Arguments (Code Any)) @@ -53,14 +61,14 @@ (|> (format " . " (:representation rest)) (format (|> mandatory (list\map ..code) - (text.join-with " "))) + (text.join_with " "))) (text.enclose ["(" ")"]) :abstraction)) #.None (|> mandatory (list\map ..code) - (text.join-with " ") + (text.join_with " ") (text.enclose ["(" ")"]) :abstraction))) @@ -80,34 +88,34 @@ (def: #export float (-> Frac Computation) - (|>> (cond> [(f.= f.positive-infinity)] + (|>> (cond> [(f.= f.positive_infinity)] [(new> "+inf.0" [])] - [(f.= f.negative-infinity)] + [(f.= f.negative_infinity)] [(new> "-inf.0" [])] - [f.not-a-number?] + [f.not_a_number?] [(new> "+nan.0" [])] ## else [%.frac]) :abstraction)) - (def: #export positive-infinity Computation (..float f.positive-infinity)) - (def: #export negative-infinity Computation (..float f.negative-infinity)) - (def: #export not-a-number Computation (..float f.not-a-number)) + (def: #export positive_infinity Computation (..float f.positive_infinity)) + (def: #export negative_infinity Computation (..float f.negative_infinity)) + (def: #export not_a_number Computation (..float f.not_a_number)) (def: sanitize (-> Text Text) (`` (|>> (~~ (template [ ] - [(text.replace-all )] + [(text.replace_all )] [text.alarm "\a"] - [text.back-space "\b"] + [text.back_space "\b"] [text.tab "\t"] - [text.new-line "\n"] - [text.carriage-return "\r"] - [text.double-quote (format "\" text.double-quote)] + [text.new_line "\n"] + [text.carriage_return "\r"] + [text.double_quote (format "\" text.double_quote)] ["\" "\\"] ["|" "\|"] )) @@ -121,36 +129,32 @@ (-> Text Computation) (|>> (format "'") :abstraction)) - (def: #export global - (-> Text Global) - (|>> :abstraction)) - (def: form (-> (List (Code Any)) Code) (|>> (list\map ..code) - (text.join-with " ") + (text.join_with " ") (text.enclose ["(" ")"]) :abstraction)) - (def: #export (apply/* func args) - (-> Expression (List Expression) Computation) + (def: #export (apply/* args func) + (-> (List Expression) Expression Computation) (..form (#.Cons func args))) (template [ ] - [(def: #export + [(def: #export ( members) (-> (List Expression) Computation) - (apply/* (..global )))] + (..apply/* members (..var )))] [vector/* "vector"] [list/* "list"] ) - (def: #export (apply/0 func) + (def: #export apply/0 (-> Expression Computation) - (..apply/* func (list))) + (..apply/* (list))) - (template [ ] - [(def: #export (apply/0 (..global )))] + (template [ ] + [(def: #export (apply/0 (..var )))] [newline/0 "newline"] ) @@ -159,10 +163,10 @@ [(`` (def: #export ( function) (-> Expression (~~ (template.splice +)) Computation) (.function (_ (~~ (template.splice +))) - (..apply/* function (list (~~ (template.splice +))))))) + (..apply/* (list (~~ (template.splice +))) function)))) (`` (template [ ] - [(def: #export ( (..global )))] + [(def: #export ( (..var )))] (~~ (template.splice +))))] @@ -177,12 +181,12 @@ [car/1 "car"] [cdr/1 "cdr"] [raise/1 "raise"] - [error-object-message/1 "error-object-message"] - [make-vector/1 "make-vector"] - [vector-length/1 "vector-length"] + [error_object_message/1 "error-object-message"] + [make_vector/1 "make-vector"] + [vector_length/1 "vector-length"] [not/1 "not"] - [string-length/1 "string-length"] - [string-hash/1 "string-hash"] + [string_length/1 "string-length"] + [string_hash/1 "string-hash"] [reverse/1 "reverse"] [display/1 "display"] [exit/1 "exit"]]] @@ -190,19 +194,19 @@ [apply/2 [_0 _1] [Expression Expression] [[append/2 "append"] [cons/2 "cons"] - [make-vector/2 "make-vector"] - ## [vector-ref/2 "vector-ref"] - [list-tail/2 "list-tail"] + [make_vector/2 "make-vector"] + ## [vector_ref/2 "vector-ref"] + [list_tail/2 "list-tail"] [map/2 "map"] - [string-ref/2 "string-ref"] - [string-append/2 "string-append"]]] + [string_ref/2 "string-ref"] + [string_append/2 "string-append"]]] [apply/3 [_0 _1 _2] [Expression Expression Expression] [[substring/3 "substring"] - [vector-set!/3 "vector-set!"]]] + [vector_set!/3 "vector-set!"]]] [apply/5 [_0 _1 _2 _3 _4] [Expression Expression Expression Expression Expression] - [[vector-copy!/5 "vector-copy!"]]] + [[vector_copy!/5 "vector-copy!"]]] ) ## TODO: define "vector-ref/2" like a normal apply/2 function. @@ -218,14 +222,14 @@ ## 1. To carry on, and then, when it's time to compile the compiler ## itself into Scheme, switch from 'invoke' to normal 'vector-ref'. ## Either way, the 'invoke' needs to go away. - (def: #export (vector-ref/2 vector index) + (def: #export (vector_ref/2 vector index) (-> Expression Expression Computation) (..form (list (..var "invoke") vector (..symbol "getRaw") index))) - (template [ ] - [(def: #export ( param subject) + (template [ ] + [(def: #export ( param subject) (-> Expression Expression Computation) - (..apply/2 (..global ) subject param))] + (..apply/2 (..var ) subject param))] [=/2 "="] [eq?/2 "eq?"] @@ -244,25 +248,25 @@ [remainder/2 "remainder"] [quotient/2 "quotient"] [mod/2 "mod"] - [arithmetic-shift/2 "arithmetic-shift"] - [bit-and/2 "bitwise-and"] - [bit-or/2 "bitwise-ior"] - [bit-xor/2 "bitwise-xor"] + [arithmetic_shift/2 "arithmetic-shift"] + [bit_and/2 "bitwise-and"] + [bit_or/2 "bitwise-ior"] + [bit_xor/2 "bitwise-xor"] ) - (template [ ] - [(def: #export + (template [ ] + [(def: #export (-> (List Expression) Computation) - (|>> (list& (..global )) ..form))] + (|>> (list& (..var )) ..form))] [or "or"] [and "and"] ) - (template [ 
]
-    [(def: #export ( bindings body)
+  (template [   
]
+    [(def: #export ( bindings body)
        (-> (List [ Expression]) Expression Computation)
-       (..form (list (..global )
+       (..form (list (..var )
                      (|> bindings
                          (list\map (.function (_ [binding/name binding/value])
                                      (..form (list (|> binding/name 
)
@@ -273,18 +277,18 @@
     [let           "let"           Var       (<|)]
     [let*          "let*"          Var       (<|)]
     [letrec        "letrec"        Var       (<|)]
-    [let-values    "let-values"    Arguments ..arguments]
-    [let*-values   "let*-values"   Arguments ..arguments]
-    [letrec-values "letrec-values" Arguments ..arguments]
+    [let_values    "let-values"    Arguments ..arguments]
+    [let*_values   "let*-values"   Arguments ..arguments]
+    [letrec_values "letrec-values" Arguments ..arguments]
     )
 
   (def: #export (if test then else)
     (-> Expression Expression Expression Computation)
-    (..form (list (..global "if") test then else)))
+    (..form (list (..var "if") test then else)))
 
   (def: #export (when test then)
     (-> Expression Expression Computation)
-    (..form (list (..global "when") test then)))
+    (..form (list (..var "when") test then)))
 
   (def: #export (cond clauses else)
     (-> (List [Expression Expression]) Expression Computation)
@@ -297,31 +301,31 @@
 
   (def: #export (lambda arguments body)
     (-> Arguments Expression Computation)
-    (..form (list (..global "lambda")
+    (..form (list (..var "lambda")
                   (..arguments arguments)
                   body)))
 
-  (def: #export (define-function name arguments body)
+  (def: #export (define_function name arguments body)
     (-> Var Arguments Expression Computation)
-    (..form (list (..global "define")
+    (..form (list (..var "define")
                   (|> arguments
                       (update@ #mandatory (|>> (#.Cons name)))
                       ..arguments)
                   body)))
 
-  (def: #export (define-constant name value)
+  (def: #export (define_constant name value)
     (-> Var Expression Computation)
-    (..form (list (..global "define") name value)))
+    (..form (list (..var "define") name value)))
 
   (def: #export begin
     (-> (List Expression) Computation)
-    (|>> (#.Cons (..global "begin")) ..form))
+    (|>> (#.Cons (..var "begin")) ..form))
 
   (def: #export (set! name value)
     (-> Var Expression Computation)
-    (..form (list (..global "set!") name value)))
+    (..form (list (..var "set!") name value)))
 
-  (def: #export (with-exception-handler handler body)
+  (def: #export (with_exception_handler handler body)
     (-> Expression Expression Computation)
-    (..form (list (..global "with-exception-handler") handler body)))
+    (..form (list (..var "with-exception-handler") handler body)))
   )
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/analysis/scheme.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/analysis/scheme.lux
new file mode 100644
index 000000000..1c0a89df5
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/analysis/scheme.lux
@@ -0,0 +1,34 @@
+(.module:
+  [lux #*
+   ["." host]
+   [abstract
+    ["." monad (#+ do)]]
+   [control
+    ["<>" parser
+     ["" code (#+ Parser)]]]
+   [data
+    [collection
+     ["." array (#+ Array)]
+     ["." dictionary]
+     ["." list]]]
+   ["." type
+    ["." check]]
+   ["@" target
+    ["_" scheme]]]
+  [//
+   ["/" lux (#+ custom)]
+   [//
+    ["." bundle]
+    [//
+     ["." analysis #_
+      ["#/." type]]
+     [//
+      ["." analysis (#+ Analysis Operation Phase Handler Bundle)]
+      [///
+       ["." phase]]]]]])
+
+(def: #export bundle
+  Bundle
+  (<| (bundle.prefix "scheme")
+      (|> bundle.empty
+          )))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme.lux
new file mode 100644
index 000000000..945e90e57
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme.lux
@@ -0,0 +1,17 @@
+(.module:
+  [lux #*
+   [data
+    [collection
+     ["." dictionary]]]]
+  ["." / #_
+   ["#." common]
+   ["#." host]
+   [////
+    [generation
+     [scheme
+      [runtime (#+ Bundle)]]]]])
+
+(def: #export bundle
+  Bundle
+  (dictionary.merge /common.bundle
+                    /host.bundle))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme/common.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme/common.lux
new file mode 100644
index 000000000..6a13e29bb
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme/common.lux
@@ -0,0 +1,198 @@
+(.module:
+  [lux #*
+   [abstract
+    ["." monad (#+ do)]]
+   [control
+    ["." function]
+    ["." try]
+    ["<>" parser
+     ["" synthesis (#+ Parser)]]]
+   [data
+    ["." product]
+    ["." text
+     ["%" format (#+ format)]]
+    [collection
+     ["." dictionary]
+     ["." set]
+     ["." list ("#\." functor fold)]]]
+   [math
+    [number
+     ["f" frac]]]
+   ["@" target
+    ["_" scheme (#+ Expression)]]]
+  ["." //// #_
+   ["/" bundle]
+   ["/#" // #_
+    ["." extension]
+    [generation
+     [extension (#+ Nullary Unary Binary Trinary
+                    nullary unary binary trinary)]
+     ["." reference]
+     ["//" scheme #_
+      ["#." runtime (#+ Operation Phase Handler Bundle Generator)]
+      ["#." case]]]
+    [//
+     ["." synthesis (#+ %synthesis)]
+     ["." generation]
+     [///
+      ["#" phase]]]]])
+
+(def: #export (custom [parser handler])
+  (All [s]
+    (-> [(Parser s)
+         (-> Text (Generator s))]
+        Handler))
+  (function (_ extension_name phase archive input)
+    (case (.run parser input)
+      (#try.Success input')
+      (handler extension_name phase archive input')
+
+      (#try.Failure error)
+      (/////.throw extension.invalid_syntax [extension_name %synthesis input]))))
+
+(template: (!unary function)
+  (|>> list _.apply/* (|> (_.constant function))))
+
+## TODO: Get rid of this ASAP
+## (def: lux::syntax_char_case!
+##   (..custom [($_ <>.and
+##                  .any
+##                  .any
+##                  (<>.some (.tuple ($_ <>.and
+##                                          (.tuple (<>.many .i64))
+##                                          .any))))
+##              (function (_ extension_name phase archive [input else conditionals])
+##                (do {! /////.monad}
+##                  [inputG (phase archive input)
+##                   [[context_module context_artifact] elseG] (generation.with_new_context archive
+##                                                               (phase archive else))
+##                   @input (\ ! map _.var (generation.gensym "input"))
+##                   conditionalsG (: (Operation (List [Expression Expression]))
+##                                    (monad.map ! (function (_ [chars branch])
+##                                                   (do !
+##                                                     [branchG (phase archive branch)]
+##                                                     (wrap [(|> chars
+##                                                                (list\map (|>> .int _.int (_.=== @input)))
+##                                                                (list\fold (function (_ clause total)
+##                                                                             (if (is? _.null total)
+##                                                                               clause
+##                                                                               (_.or clause total)))
+##                                                                           _.null))
+##                                                            branchG])))
+##                                               conditionals))
+##                   #let [foreigns (|> conditionals
+##                                      (list\map (|>> product.right synthesis.path/then //case.dependencies))
+##                                      (list& (//case.dependencies (synthesis.path/then else)))
+##                                      list.concat
+##                                      (set.from_list _.hash)
+##                                      set.to_list)
+##                         @expression (_.constant (reference.artifact [context_module context_artifact]))
+##                         directive (_.define_function @expression (list& (_.parameter @input) (list\map _.reference foreigns))
+##                                                      (list\fold (function (_ [test then] else)
+##                                                                   (_.if test (_.return then) else))
+##                                                                 (_.return elseG)
+##                                                                 conditionalsG))]
+##                   _ (generation.execute! directive)
+##                   _ (generation.save! (%.nat context_artifact) directive)]
+##                  (wrap (_.apply/* (list& inputG foreigns) @expression))))]))
+
+## (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: (left_shift [parameter subject])
+##   (Binary Expression)
+##   (_.bit_shl (_.% (_.int +64) parameter) subject))
+
+## (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 ..left_shift))
+##           (/.install "right-shift" (binary (product.uncurry //runtime.i64//right_shift)))
+##           (/.install "=" (binary (product.uncurry _.==)))
+##           (/.install "<" (binary (product.uncurry _.<)))
+##           (/.install "+" (binary (product.uncurry //runtime.i64//+)))
+##           (/.install "-" (binary (product.uncurry //runtime.i64//-)))
+##           (/.install "*" (binary (product.uncurry //runtime.i64//*)))
+##           (/.install "/" (binary (function (_ [parameter subject])
+##                                    (_.intdiv/2 [subject parameter]))))
+##           (/.install "%" (binary (product.uncurry _.%)))
+##           (/.install "f64" (unary (_./ (_.float +1.0))))
+##           (/.install "char" (unary //runtime.i64//char))
+##           )))
+
+## (def: (f64//% [parameter subject])
+##   (Binary Expression)
+##   (_.fmod/2 [subject parameter]))
+
+## (def: (f64//encode subject)
+##   (Unary Expression)
+##   (_.number_format/2 [subject (_.int +17)]))
+
+## (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 _.*)))
+##           (/.install "/" (binary (product.uncurry _./)))
+##           (/.install "%" (binary ..f64//%))
+##           (/.install "i64" (unary _.intval/1))
+##           (/.install "encode" (unary ..f64//encode))
+##           (/.install "decode" (unary //runtime.f64//decode)))))
+
+## (def: (text//clip [paramO extraO subjectO])
+##   (Trinary Expression)
+##   (//runtime.text//clip paramO extraO subjectO))
+
+## (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: io//current-time
+##   (Nullary Expression)
+##   (|>> _.time/0
+##        (_.* (_.int +1,000))))
+
+## (def: io_procs
+##   Bundle
+##   (<| (/.prefix "io")
+##       (|> /.empty
+##           (/.install "log" (unary //runtime.io//log!))
+##           (/.install "error" (unary //runtime.io//throw!))
+##           (/.install "current-time" (nullary ..io//current-time)))))
+
+(def: #export bundle
+  Bundle
+  (<| (/.prefix "lux")
+      (|> /.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/scheme/host.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme/host.lux
new file mode 100644
index 000000000..0a05436c2
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/scheme/host.lux
@@ -0,0 +1,39 @@
+(.module:
+  [lux #*
+   [abstract
+    ["." monad (#+ do)]]
+   [control
+    ["." function]
+    ["<>" parser
+     ["" synthesis (#+ Parser)]]]
+   [data
+    [collection
+     ["." dictionary]
+     ["." list]]
+    [text
+     ["%" format (#+ format)]]]
+   [target
+    ["_" scheme (#+ Var Expression)]]]
+  ["." // #_
+   ["#." common (#+ custom)]
+   ["//#" /// #_
+    ["/" bundle]
+    ["/#" // #_
+     ["." extension]
+     [generation
+      [extension (#+ Nullary Unary Binary Trinary
+                     nullary unary binary trinary)]
+      ["." reference]
+      ["//" scheme #_
+       ["#." runtime (#+ Operation Phase Handler Bundle
+                         with_vars)]]]
+     ["/#" // #_
+      ["." generation]
+      ["//#" /// #_
+       ["#." phase]]]]]])
+
+(def: #export bundle
+  Bundle
+  (<| (/.prefix "scheme")
+      (|> /.empty
+          )))
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 419c0ed2f..137c72c71 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
@@ -57,7 +57,7 @@
     [valueO (expression archive valueS)
      body! (statement expression archive bodyS)]
     (wrap ($_ _.then
-              (_.; (_.set (..register register) valueO))
+              (_.set! (..register register) valueO)
               body!))))
 
 (def: #export (if expression archive [testS thenS elseS])
@@ -121,7 +121,7 @@
 
 (def: restore!
   Statement
-  (_.; (_.set @cursor (_.array_pop/1 @savepoint))))
+  (_.set! @cursor (_.array_pop/1 @savepoint)))
 
 (def: fail! _.break)
 
@@ -135,7 +135,7 @@
   [(def: ( simple? idx)
      (-> Bit Nat Statement)
      ($_ _.then
-         (_.; (_.set @temp (|> idx  .int _.int (//runtime.sum//get ..peek ))))
+         (_.set! @temp (|> idx  .int _.int (//runtime.sum//get ..peek )))
          (.if simple?
            (_.when (_.is_null/1 @temp)
                    fail!)
@@ -169,7 +169,7 @@
       (///////phase\wrap ..pop!)
 
       (#/////synthesis.Bind register)
-      (///////phase\wrap (_.; (_.set (..register register) ..peek)))
+      (///////phase\wrap (_.set! (..register register) ..peek))
 
       (#/////synthesis.Bit_Fork when thenP elseP)
       (do {! ///////phase.monad}
@@ -227,7 +227,7 @@
       (do ///////phase.monad
         [then! (recur thenP)]
         (///////phase\wrap ($_ _.then
-                               (_.; (_.set (..register register) ..peek_and_pop))
+                               (_.set! (..register register) ..peek_and_pop)
                                then!)))
 
       ## (^ (/////synthesis.!multi_pop nextP))
@@ -279,8 +279,8 @@
     [stack_init (expression archive valueS)
      pattern_matching! (pattern_matching statement expression archive pathP)]
     (wrap ($_ _.then
-              (_.; (_.set @cursor (_.array/* (list stack_init))))
-              (_.; (_.set @savepoint (_.array/* (list))))
+              (_.set! @cursor (_.array/* (list stack_init)))
+              (_.set! @savepoint (_.array/* (list)))
               pattern_matching!))))
 
 (def: #export (case statement expression archive [valueS pathP])
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 c6fa5687c..8dad09d37 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
@@ -51,19 +51,19 @@
   (case inits
     #.Nil
     [($_ _.then
-         (_.; (_.set @selfL (_.closure (list (_.reference @selfL)) (list) body!)))
-         (_.; (_.set @selfG @selfL)))
+         (_.set! @selfL (_.closure (list (_.reference @selfL)) (list) body!))
+         (_.set! @selfG @selfL))
      @selfG]
 
     _
     (let [@inits (|> (list.enumeration inits)
                      (list\map (|>> product.left ..capture)))]
-      [(_.; (_.set @selfG (_.closure (list) (list\map _.parameter @inits)
-                                     ($_ _.then
-                                         (_.; (_.set @selfL (_.closure (list& (_.reference @selfL) (list\map _.reference @inits))
-                                                                       (list)
-                                                                       body!)))
-                                         (_.return @selfL)))))
+      [(_.set! @selfG (_.closure (list) (list\map _.parameter @inits)
+                                 ($_ _.then
+                                     (_.set! @selfL (_.closure (list& (_.reference @selfL) (list\map _.reference @inits))
+                                                               (list)
+                                                               body!))
+                                     (_.return @selfL))))
        (_.apply/* inits @selfG)])))
 
 (def: #export (function statement expression archive [environment arity bodyS])
@@ -82,17 +82,17 @@
            @scope (..@scope function_name)
            @selfG (_.global (///reference.artifact function_name))
            @selfL (_.var (///reference.artifact function_name))
-           initialize_self! (_.; (_.set (//case.register 0) @selfL))
+           initialize_self! (_.set! (//case.register 0) @selfL)
            initialize! (list\fold (.function (_ post pre!)
                                     ($_ _.then
                                         pre!
-                                        (_.; (_.set (..input post) (_.nth (|> post .int _.int) @curried)))))
+                                        (_.set! (..input post) (_.nth (|> post .int _.int) @curried))))
                                   initialize_self!
                                   (list.indices arity))]
      #let [[definition instantiation] (..with_closure closureG+ @selfG @selfL
                                         ($_ _.then
-                                            (_.; (_.set @num_args (_.func_num_args/0 [])))
-                                            (_.; (_.set @curried (_.func_get_args/0 [])))
+                                            (_.set! @num_args (_.func_num_args/0 []))
+                                            (_.set! @curried (_.func_get_args/0 []))
                                             (_.cond (list [(|> @num_args (_.=== arityG))
                                                            ($_ _.then
                                                                initialize!
@@ -107,7 +107,7 @@
                                                     (let [@missing (_.var "missing")]
                                                       (_.return (<| (_.closure (list (_.reference @selfL) (_.reference @curried)) (list))
                                                                     ($_ _.then
-                                                                        (_.; (_.set @missing (_.func_get_args/0 [])))
+                                                                        (_.set! @missing (_.func_get_args/0 []))
                                                                         (_.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 d3e91b925..41289ed58 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
@@ -42,7 +42,7 @@
       list.enumeration
       (list\map (function (_ [register value])
                   (let [variable (//case.register (n.+ offset register))]
-                    (_.; (_.set variable value)))))
+                    (_.set! variable value))))
       list.reverse
       (list\fold _.then body)))
 
@@ -112,7 +112,7 @@
     [[offset @scope] /////generation.anchor
      argsO+ (monad.map ! (expression archive) argsS+)]
     (wrap ($_ _.then
-              (_.; (_.set @temp (_.array/* argsO+)))
+              (_.set! @temp (_.array/* argsO+))
               (..setup offset
                        (|> argsO+
                            list.enumeration
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 651e3854f..d5e831e09 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
@@ -55,9 +55,6 @@
 (type: #export (Generator! i)
   (-> Phase! Phase Archive i (Operation Statement)))
 
-(def: prefix
-  "LuxRuntime")
-
 (def: #export unit
   (_.string /////synthesis.unit))
 
@@ -597,8 +594,6 @@
       runtime//io
       ))
 
-(def: #export artifact ..prefix)
-
 (def: #export generate
   (Operation [Registry Output])
   (do ///////phase.monad
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/structure.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/structure.lux
index ed4fe4ae1..5f7a4e358 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/structure.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/php/structure.lux
@@ -16,28 +16,26 @@
     ["//#" /// #_
      ["#." phase ("#\." monad)]]]])
 
-(def: #export (tuple generate archive elemsS+)
+(def: #export (tuple expression archive elemsS+)
   (Generator (Tuple Synthesis))
   (case elemsS+
     #.Nil
     (///////phase\wrap (//primitive.text /////synthesis.unit))
 
     (#.Cons singletonS #.Nil)
-    (generate archive singletonS)
+    (expression archive singletonS)
 
     _
     (let [size (_.int (.int (list.size elemsS+)))]
       (|> elemsS+
-          (monad.map ///////phase.monad (generate archive))
-          ## (///////phase\map (|>> (list& (_.key_value (_.string //runtime.tuple_size_field) size))
-          ##                        _.array/*))
+          (monad.map ///////phase.monad (expression archive))
           (///////phase\map (|>> _.array/*
                                  (//runtime.tuple//make size)))))))
 
-(def: #export (variant generate archive [lefts right? valueS])
+(def: #export (variant expression archive [lefts right? valueS])
   (Generator (Variant Synthesis))
   (let [tag (if right?
               (inc lefts)
               lefts)]
     (///////phase\map (//runtime.variant tag right?)
-                      (generate archive valueS))))
+                      (expression archive valueS))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme.lux
index a6e03cfd4..be476cf74 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme.lux
@@ -1,60 +1,60 @@
 (.module:
   [lux #*
    [abstract
-    [monad (#+ do)]]]
-  [/
+    [monad (#+ do)]]
+   [control
+    ["." exception (#+ exception:)]]
+   [target
+    ["_" scheme]]]
+  ["." / #_
    [runtime (#+ Phase)]
-   ["." primitive]
-   ["." structure]
-   ["." reference ("#\." system)]
-   ["." function]
-   ["." case]
-   ["." loop]
-   ["." ///
-    ["." extension]
-    [//
-     ["." synthesis]]]])
-
-(def: #export (generate synthesis)
+   ["#." primitive]
+   ["#." structure]
+   ["#." reference]
+   ["#." case]
+   ["#." loop]
+   ["#." function]
+   ["/#" // #_
+    ["#." reference]
+    ["/#" // #_
+     ["#." extension]
+     ["/#" // #_
+      [analysis (#+)]
+      ["#." synthesis]
+      ["//#" /// #_
+       ["#." phase ("#\." monad)]
+       [reference (#+)
+        [variable (#+)]]]]]]])
+
+(def: #export (generate archive synthesis)
   Phase
   (case synthesis
     (^template [ ]
       [(^ ( value))
-       (\ ///.monad wrap ( value))])
-    ([synthesis.bit  primitive.bit]
-     [synthesis.i64  primitive.i64]
-     [synthesis.f64  primitive.f64]
-     [synthesis.text primitive.text])
-
-    (^ (synthesis.variant variantS))
-    (structure.variant generate variantS)
-
-    (^ (synthesis.tuple members))
-    (structure.tuple generate members)
-
-    (#synthesis.Reference value)
-    (reference\reference value)
-
-    (^ (synthesis.branch/case case))
-    (case.case generate case)
-
-    (^ (synthesis.branch/let let))
-    (case.let generate let)
+       (//////phase\wrap ( value))])
+    ([////synthesis.bit  /primitive.bit]
+     [////synthesis.i64  /primitive.i64]
+     [////synthesis.f64  /primitive.f64]
+     [////synthesis.text /primitive.text])
 
-    (^ (synthesis.branch/if if))
-    (case.if generate if)
+    (#////synthesis.Reference value)
+    (//reference.reference /reference.system archive value)
 
-    (^ (synthesis.loop/scope scope))
-    (loop.scope generate scope)
-
-    (^ (synthesis.loop/recur updates))
-    (loop.recur generate updates)
-
-    (^ (synthesis.function/abstraction abstraction))
-    (function.function generate abstraction)
-
-    (^ (synthesis.function/apply application))
-    (function.apply generate application)
-
-    (#synthesis.Extension extension)
-    (extension.apply generate extension)))
+    (^template [ ]
+      [(^ ( value))
+       ( generate archive value)])
+    ([////synthesis.variant /structure.variant]
+     [////synthesis.tuple /structure.tuple]
+     [////synthesis.branch/let /case.let]
+     [////synthesis.branch/if /case.if]
+     [////synthesis.branch/get /case.get]
+     [////synthesis.function/apply /function.apply]
+
+     [////synthesis.branch/case /case.case]
+     [////synthesis.loop/scope /loop.scope]
+     [////synthesis.loop/recur /loop.recur]
+     [////synthesis.function/abstraction /function.function])
+
+    (#////synthesis.Extension extension)
+    (///extension.apply archive generate extension)
+    ))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/case.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/case.lux
index 5f460b749..8f7d8a8b1 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/case.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/case.lux
@@ -1,43 +1,66 @@
 (.module:
   [lux (#- case let if)
    [abstract
-    [monad (#+ do)]]
-   [control
-    ["ex" exception (#+ exception:)]]
+    ["." monad (#+ do)]]
    [data
-    ["." number]
-    ["." text]
+    ["." product]
+    ["." text
+     ["%" format (#+ format)]]
     [collection
-     ["." list ("#\." functor fold)]]]
+     ["." list ("#\." functor fold)]
+     ["." set]]]
+   [math
+    [number
+     ["i" int]]]
    [target
     ["_" scheme (#+ Expression Computation Var)]]]
   ["." // #_
-   ["#." runtime (#+ Operation Phase)]
+   ["#." runtime (#+ Operation Phase Generator)]
+   ["#." reference]
    ["#." primitive]
-   ["#/" // #_
+   ["/#" // #_
     ["#." reference]
-    ["#/" // ("#\." monad)
-     ["#/" // #_
-      [reference (#+ Register)]
-      ["#." synthesis (#+ Synthesis Path)]]]]])
+    ["/#" // #_
+     ["#." synthesis #_
+      ["#/." case]]
+     ["/#" // #_
+      ["#." synthesis (#+ Member Synthesis Path)]
+      ["#." generation]
+      ["//#" /// #_
+       [reference
+        ["#." variable (#+ Register)]]
+       ["#." phase ("#\." monad)]
+       [meta
+        [archive (#+ Archive)]]]]]]])
 
 (def: #export register
-  (///reference.local _.var))
-
-(def: #export (let generate [valueS register bodyS])
-  (-> Phase [Synthesis Register Synthesis]
-      (Operation Computation))
-  (do ////.monad
-    [valueO (generate valueS)
-     bodyO (generate bodyS)]
+  (-> Register Var)
+  (|>> (///reference.local //reference.system) :assume))
+
+(def: #export capture
+  (-> Register Var)
+  (|>> (///reference.foreign //reference.system) :assume))
+
+(def: #export (let expression archive [valueS register bodyS])
+  (Generator [Synthesis Register Synthesis])
+  (do ///////phase.monad
+    [valueO (expression archive valueS)
+     bodyO (expression archive bodyS)]
     (wrap (_.let (list [(..register register) valueO])
             bodyO))))
 
-(def: #export (record-get generate valueS pathP)
-  (-> Phase Synthesis (List (Either Nat Nat))
-      (Operation Expression))
-  (do ////.monad
-    [valueO (generate valueS)]
+(def: #export (if expression archive [testS thenS elseS])
+  (Generator [Synthesis Synthesis Synthesis])
+  (do ///////phase.monad
+    [testO (expression archive testS)
+     thenO (expression archive thenS)
+     elseO (expression archive elseS)]
+    (wrap (_.if testO thenO elseO))))
+
+(def: #export (get expression archive [pathP valueS])
+  (Generator [(List Member) Synthesis])
+  (do ///////phase.monad
+    [valueO (expression archive valueS)]
     (wrap (list\fold (function (_ side source)
                        (.let [method (.case side
                                        (^template [ ]
@@ -47,27 +70,18 @@
                                         [#.Right //runtime.tuple//right]))]
                          (method source)))
                      valueO
-                     pathP))))
-
-(def: #export (if generate [testS thenS elseS])
-  (-> Phase [Synthesis Synthesis Synthesis]
-      (Operation Computation))
-  (do ////.monad
-    [testO (generate testS)
-     thenO (generate thenS)
-     elseO (generate elseS)]
-    (wrap (_.if testO thenO elseO))))
+                     (list.reverse pathP)))))
 
 (def: @savepoint (_.var "lux_pm_cursor_savepoint"))
 (def: @cursor (_.var "lux_pm_cursor"))
 (def: @temp (_.var "lux_pm_temp"))
-(def: @alt-error (_.var "alt_error"))
+(def: @alt_error (_.var "alt_error"))
 
 (def: (push! value var)
   (-> Expression Var Computation)
   (_.set! var (_.cons/2 value var)))
 
-(def: (push-cursor! value)
+(def: (push_cursor! value)
   (-> Expression Computation)
   (push! value @cursor))
 
@@ -75,97 +89,123 @@
   (-> Var Computation)
   (_.set! var var))
 
-(def: save-cursor!
+(def: save_cursor!
   Computation
   (push! @cursor @savepoint))
 
-(def: restore-cursor!
+(def: restore_cursor!
   Computation
   (_.set! @cursor (_.car/1 @savepoint)))
 
-(def: cursor-top
+(def: peek
   Computation
   (_.car/1 @cursor))
 
-(def: pop-cursor!
+(def: pop_cursor!
   Computation
   (pop! @cursor))
 
-(def: pm-error (_.string "PM-ERROR"))
+(def: pm_error
+  (_.string "PM-ERROR"))
 
-(def: fail-pm! (_.raise/1 pm-error))
+(def: fail!
+  (_.raise/1 pm_error))
 
-(def: (pm-catch handler)
+(def: (pm_catch handler)
   (-> Expression Computation)
-  (_.lambda [(list @alt-error) #.None]
-            (_.if (|> @alt-error (_.eqv?/2 pm-error))
+  (_.lambda [(list @alt_error) #.None]
+            (_.if (|> @alt_error (_.eqv?/2 pm_error))
               handler
-              (_.raise/1 @alt-error))))
-
-(def: (pattern-matching' generate pathP)
-  (-> Phase Path (Operation Expression))
-  (.case pathP
-    (^ (/////synthesis.path/then bodyS))
-    (generate bodyS)
-
-    #/////synthesis.Pop
-    (////\wrap pop-cursor!)
-
-    (#/////synthesis.Bind register)
-    (////\wrap (_.define-constant (..register register) ..cursor-top))
-
-    (^template [  <=>]
-      [(^ ( value))
-       (////\wrap (_.when (|> value  (<=> cursor-top) _.not/1)
-                          fail-pm!))])
-    ([/////synthesis.path/bit  //primitive.bit           _.eqv?/2]
-     [/////synthesis.path/i64  (<| //primitive.i64 .int) _.=/2]
-     [/////synthesis.path/f64  //primitive.f64           _.=/2]
-     [/////synthesis.path/text //primitive.text          _.eqv?/2])
-
-    (^template [  ]
-      [(^ ( idx))
-       (////\wrap (_.let (list [@temp (|> idx  .int _.int (//runtime.sum//get cursor-top ))])
-                    (_.if (_.null?/1 @temp)
-                      fail-pm!
-                      (push-cursor! @temp))))])
-    ([/////synthesis.side/left  _.nil         (<|)]
-     [/////synthesis.side/right (_.string "") inc])
-
-    (^template [ ]
-      [(^ ( idx))
-       (////\wrap (push-cursor! ( (_.int (.int idx)) cursor-top)))])
-    ([/////synthesis.member/left  //runtime.tuple//left]
-     [/////synthesis.member/right //runtime.tuple//right])
-
-    (^template [ ]
-      [(^ ( leftP rightP))
-       (do ////.monad
-         [leftO (pattern-matching' generate leftP)
-          rightO (pattern-matching' generate rightP)]
-         (wrap ))])
-    ([/////synthesis.path/seq (_.begin (list leftO
-                                             rightO))]
-     [/////synthesis.path/alt (_.with-exception-handler
-                                (pm-catch (_.begin (list restore-cursor!
-                                                         rightO)))
-                                (_.lambda [(list) #.None]
-                                          (_.begin (list save-cursor!
-                                                         leftO))))])))
-
-(def: (pattern-matching generate pathP)
-  (-> Phase Path (Operation Computation))
-  (do ////.monad
-    [pattern-matching! (pattern-matching' generate pathP)]
-    (wrap (_.with-exception-handler
-            (pm-catch (_.raise/1 (_.string "Invalid expression for pattern-matching.")))
+              (_.raise/1 @alt_error))))
+
+(def: (pattern_matching' expression archive)
+  (Generator Path)
+  (function (recur pathP)
+    (.case pathP
+      (#/////synthesis.Then bodyS)
+      (expression archive bodyS)
+
+      #/////synthesis.Pop
+      (///////phase\wrap pop_cursor!)
+
+      (#/////synthesis.Bind register)
+      (///////phase\wrap (_.define_constant (..register register) ..peek))
+
+      (#/////synthesis.Bit_Fork when thenP elseP)
+      (do {! ///////phase.monad}
+        [then! (recur thenP)
+         else! (.case elseP
+                 (#.Some elseP)
+                 (recur elseP)
+
+                 #.None
+                 (wrap ..fail!))]
+        (wrap (.if when
+                (_.if ..peek
+                  then!
+                  else!)
+                (_.if ..peek
+                  else!
+                  then!))))
+
+      (^template [  <=>]
+        [( cons)
+         (do {! ///////phase.monad}
+           [clauses (monad.map ! (function (_ [match then])
+                                   (do !
+                                     [then! (recur then)]
+                                     (wrap [(<=> (|> match )
+                                                 ..peek)
+                                            then!])))
+                               (#.Cons cons))]
+           (wrap (_.cond clauses ..fail!)))])
+      ([#/////synthesis.I64_Fork //primitive.i64 _.=/2]
+       [#/////synthesis.F64_Fork //primitive.f64 _.=/2]
+       [#/////synthesis.Text_Fork //primitive.text _.eqv?/2])
+
+      (^template [  ]
+        [(^ ( idx))
+         (///////phase\wrap (_.let (list [@temp (|> idx  .int _.int (//runtime.sum//get ..peek ))])
+                              (_.if (_.null?/1 @temp)
+                                ..fail!
+                                (push_cursor! @temp))))])
+      ([/////synthesis.side/left  _.nil         (<|)]
+       [/////synthesis.side/right (_.string "") inc])
+
+      (^template [ ]
+        [(^ ( idx))
+         (///////phase\wrap (push_cursor! ( (_.int (.int idx)) ..peek)))])
+      ([/////synthesis.member/left  //runtime.tuple//left]
+       [/////synthesis.member/right //runtime.tuple//right])
+
+      (^template [ ]
+        [(^ ( leftP rightP))
+         (do ///////phase.monad
+           [leftO (recur leftP)
+            rightO (recur rightP)]
+           (wrap ))])
+      ([/////synthesis.path/seq (_.begin (list leftO
+                                               rightO))]
+       [/////synthesis.path/alt (_.with_exception_handler
+                                  (pm_catch (_.begin (list restore_cursor!
+                                                           rightO)))
+                                  (_.lambda [(list) #.None]
+                                            (_.begin (list save_cursor!
+                                                           leftO))))]))))
+
+(def: (pattern_matching expression archive pathP)
+  (Generator Path)
+  (do ///////phase.monad
+    [pattern_matching! (pattern_matching' expression archive pathP)]
+    (wrap (_.with_exception_handler
+            (pm_catch (_.raise/1 (_.string "Invalid expression for pattern-matching.")))
             (_.lambda [(list) #.None]
-                      pattern-matching!)))))
+                      pattern_matching!)))))
 
-(def: #export (case generate [valueS pathP])
-  (-> Phase [Synthesis Path] (Operation Computation))
-  (do {! ////.monad}
-    [valueO (generate valueS)]
+(def: #export (case expression archive [valueS pathP])
+  (Generator [Synthesis Path])
+  (do {! ///////phase.monad}
+    [valueO (expression archive valueS)]
     (<| (\ ! map (_.let (list [@cursor (_.list/* (list valueO))]
                               [@savepoint (_.list/* (list))])))
-        (pattern-matching generate pathP))))
+        (pattern_matching expression archive pathP))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/function.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/function.lux
index 97725a8f2..edcdb89b4 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/function.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/function.lux
@@ -6,50 +6,52 @@
     pipe]
    [data
     ["." product]
-    [text
+    ["." text
      ["%" format (#+ format)]]
     [collection
-     ["." list ("#\." functor)]]]
+     ["." list ("#\." functor fold)]]]
    [target
     ["_" scheme (#+ Expression Computation Var)]]]
   ["." // #_
-   ["#." runtime (#+ Operation Phase)]
+   ["#." runtime (#+ Operation Phase Generator)]
    ["#." reference]
    ["#." case]
-   ["#/" //
+   ["/#" // #_
     ["#." reference]
-    ["#/" // ("#\." monad)
-     ["#/" // #_
-      [reference (#+ Register Variable)]
+    ["//#" /// #_
+     [analysis (#+ Variant Tuple Abstraction Application Analysis)]
+     [synthesis (#+ Synthesis)]
+     ["#." generation (#+ Context)]
+     ["//#" /// #_
       [arity (#+ Arity)]
-      [analysis (#+ Variant Tuple Environment Abstraction Application Analysis)]
-      [synthesis (#+ Synthesis)]]]]])
+      ["#." phase ("#\." monad)]
+      [reference
+       [variable (#+ Register Variable)]]]]]])
 
-(def: #export (apply generate [functionS argsS+])
-  (-> Phase (Application Synthesis) (Operation Computation))
-  (do {! ////.monad}
-    [functionO (generate functionS)
-     argsO+ (monad.map ! generate argsS+)]
-    (wrap (_.apply/* functionO argsO+))))
+(def: #export (apply expression archive [functionS argsS+])
+  (Generator (Application Synthesis))
+  (do {! ///////phase.monad}
+    [functionO (expression archive functionS)
+     argsO+ (monad.map ! (expression archive) argsS+)]
+    (wrap (_.apply/* argsO+ functionO))))
 
-(def: #export capture
-  (///reference.foreign _.var))
+(def: capture
+  (-> Register Var)
+  (|>> (///reference.foreign //reference.system) :assume))
 
-(def: (with-closure function-name inits function-definition)
-  (-> Text (List Expression) Computation (Operation Computation))
-  (////\wrap
+(def: (with_closure inits function_definition)
+  (-> (List Expression) Computation (Operation Computation))
+  (///////phase\wrap
    (case inits
      #.Nil
-     function-definition
+     function_definition
 
      _
-     (let [@closure (_.var (format function-name "___CLOSURE"))]
-       (_.letrec (list [@closure
-                        (_.lambda [(|> (list.enumeration inits)
-                                  (list\map (|>> product.left ..capture)))
-                              #.None]
-                             function-definition)])
-                 (_.apply/* @closure inits))))))
+     (|> function_definition
+         (_.lambda [(|> (list.enumeration inits)
+                        (list\map (|>> product.left ..capture)))
+                    #.None])
+         (_.apply/* inits)))))
 
 (def: @curried (_.var "curried"))
 (def: @missing (_.var "missing"))
@@ -57,42 +59,42 @@
 (def: input
   (|>> inc //case.register))
 
-(def: #export (function generate [environment arity bodyS])
-  (-> Phase (Abstraction Synthesis) (Operation Computation))
-  (do {! ////.monad}
-    [[function-name bodyO] (///.with-context
+(def: #export (function expression archive [environment arity bodyS])
+  (Generator (Abstraction Synthesis))
+  (do {! ///////phase.monad}
+    [[function_name bodyO] (/////generation.with_new_context archive
                              (do !
-                               [function-name ///.context]
-                               (///.with-anchor (_.var function-name)
-                                 (generate bodyS))))
-     closureO+ (: (Operation (List Expression))
-                  (monad.map ! (\ //reference.system variable) environment))
+                               [@self (\ ! map (|>> ///reference.artifact _.var)
+                                         (/////generation.context archive))]
+                               (/////generation.with_anchor @self
+                                 (expression archive bodyS))))
+     closureO+ (monad.map ! (expression archive) environment)
      #let [arityO (|> arity .int _.int)
-           apply-poly (.function (_ args func)
-                        (_.apply/2 (_.global "apply") func args))
-           @num-args (_.var "num_args")
-           @function (_.var function-name)]]
-    (with-closure function-name closureO+
-      (_.letrec (list [@function (_.lambda [(list) (#.Some @curried)]
-                                      (_.let (list [@num-args (_.length/1 @curried)])
-                                        (<| (_.if (|> @num-args (_.=/2 arityO))
-                                              (<| (_.let (list [(//case.register 0) @function]))
-                                                  (_.let-values (list [[(|> (list.indices arity)
-                                                                            (list\map ..input))
-                                                                        #.None]
-                                                                       (_.apply/2 (_.global "apply") (_.global "values") @curried)]))
-                                                  bodyO))
-                                            (_.if (|> @num-args (_.>/2 arityO))
-                                              (let [arity-args (//runtime.slice (_.int +0) arityO @curried)
-                                                    output-func-args (//runtime.slice arityO
-                                                                                      (|> @num-args (_.-/2 arityO))
-                                                                                      @curried)]
-                                                (|> @function
-                                                    (apply-poly arity-args)
-                                                    (apply-poly output-func-args))))
-                                            ## (|> @num-args (_. @function
-                                                     (apply-poly (_.append/2 @curried @missing)))))
-                                        ))])
-                @function))))
+           apply_poly (.function (_ args func)
+                        (_.apply/2 (_.var "apply") func args))
+           @num_args (_.var "num_args")
+           @self (_.var (///reference.artifact function_name))]]
+    (with_closure closureO+
+      (_.letrec (list [@self (_.lambda [(list) (#.Some @curried)]
+                                       (_.let (list [@num_args (_.length/1 @curried)])
+                                         (<| (_.if (|> @num_args (_.=/2 arityO))
+                                               (<| (_.let (list [(//case.register 0) @self]))
+                                                   (_.let_values (list [[(|> (list.indices arity)
+                                                                             (list\map ..input))
+                                                                         #.None]
+                                                                        (_.apply/2 (_.var "apply") (_.var "values") @curried)]))
+                                                   bodyO))
+                                             (_.if (|> @num_args (_.>/2 arityO))
+                                               (let [arity_args (//runtime.slice (_.int +0) arityO @curried)
+                                                     output_func_args (//runtime.slice arityO
+                                                                                       (|> @num_args (_.-/2 arityO))
+                                                                                       @curried)]
+                                                 (|> @self
+                                                     (apply_poly arity_args)
+                                                     (apply_poly output_func_args))))
+                                             ## (|> @num_args (_. @self
+                                                           (apply_poly (_.append/2 @curried @missing)))))
+                                         ))])
+                @self))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/loop.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/loop.lux
index 053a32c15..633b0da5a 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/loop.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/loop.lux
@@ -4,39 +4,60 @@
     ["." monad (#+ do)]]
    [data
     ["." product]
-    ["." text]
-    [number
-     ["n" nat]]
+    ["." text
+     ["%" format (#+ format)]]
     [collection
-     ["." list ("#\." functor)]]]
+     ["." list ("#\." functor fold)]
+     ["." set (#+ Set)]]]
+   [math
+    [number
+     ["n" nat]]]
    [target
     ["_" scheme (#+ Computation Var)]]]
   ["." // #_
-   [runtime (#+ Operation Phase)]
+   [runtime (#+ Operation Phase Generator)]
    ["#." case]
-   ["#/" //
-    ["#/" //
-     [//
-      [synthesis (#+ Scope Synthesis)]]]]])
+   ["/#" // #_
+    ["#." reference]
+    ["/#" // #_
+     [synthesis
+      ["." case]]
+     ["/#" // #_
+      ["."synthesis (#+ Scope Synthesis)]
+      ["#." generation]
+      ["//#" /// #_
+       ["#." phase]
+       [meta
+        [archive (#+ Archive)]]
+       [reference
+        [variable (#+ Register)]]]]]]])
+
+(def: @scope
+  (_.var "scope"))
 
-(def: @scope (_.var "scope"))
+(def: #export (scope expression archive [start initsS+ bodyS])
+  (Generator (Scope Synthesis))
+  (case initsS+
+    ## function/false/non-independent loop
+    #.Nil
+    (expression archive bodyS)
 
-(def: #export (scope generate [start initsS+ bodyS])
-  (-> Phase (Scope Synthesis) (Operation Computation))
-  (do {! ////.monad}
-    [initsO+ (monad.map ! generate initsS+)
-     bodyO (///.with-anchor @scope
-             (generate bodyS))]
-    (wrap (_.letrec (list [@scope (_.lambda [(|> initsS+
-                                            list.enumeration
-                                            (list\map (|>> product.left (n.+ start) //case.register)))
-                                        #.None]
-                                       bodyO)])
-                    (_.apply/* @scope initsO+)))))
+    ## true loop
+    _
+    (do {! ///////phase.monad}
+      [initsO+ (monad.map ! (expression archive) initsS+)
+       bodyO (/////generation.with_anchor @scope
+               (expression archive bodyS))]
+      (wrap (_.letrec (list [@scope (_.lambda [(|> initsS+
+                                                   list.enumeration
+                                                   (list\map (|>> product.left (n.+ start) //case.register)))
+                                               #.None]
+                                              bodyO)])
+                      (_.apply/* initsO+ @scope))))))
 
-(def: #export (recur generate argsS+)
-  (-> Phase (List Synthesis) (Operation Computation))
-  (do {! ////.monad}
-    [@scope ///.anchor
-     argsO+ (monad.map ! generate argsS+)]
-    (wrap (_.apply/* @scope argsO+))))
+(def: #export (recur expression archive argsS+)
+  (Generator (List Synthesis))
+  (do {! ///////phase.monad}
+    [@scope /////generation.anchor
+     argsO+ (monad.map ! (expression archive) argsS+)]
+    (wrap (_.apply/* argsO+ @scope))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/reference.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/reference.lux
index b9add2e48..4e8ae26cf 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/reference.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/reference.lux
@@ -3,8 +3,10 @@
    [target
     ["_" scheme (#+ Expression)]]]
   [///
-   ["." reference]])
+   [reference (#+ System)]])
 
-(def: #export system
-  (reference.system (: (-> Text Expression) _.global)
-                    (: (-> Text Expression) _.var)))
+(structure: #export system
+  (System Expression)
+
+  (def: constant _.var)
+  (def: variable _.var))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/runtime.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/runtime.lux
index 45dcd3eb2..d6ae1cffd 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/runtime.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/runtime.lux
@@ -1,47 +1,65 @@
 (.module:
-  [lux #*
+  [lux (#- Location inc)
+   ["." meta]
    [abstract
-    [monad (#+ do)]]
+    ["." monad (#+ do)]]
    [control
     ["." function]
-    ["p" parser ("#\." monad)
-     ["s" code (#+ Parser)]]]
+    ["<>" parser
+     ["<.>" code]]]
    [data
-    [number (#+ hex)]
-    [text
-     ["%" format (#+ format)]]
+    ["." product]
+    ["." text ("#\." hash)
+     ["%" format (#+ format)]
+     ["." encoding]]
     [collection
-     ["." list ("#\." monad)]]]
-   [macro
-    ["." code]
-    [syntax (#+ syntax:)]]
-   [target
+     ["." list ("#\." functor)]
+     ["." row]]]
+   ["." macro
+    [syntax (#+ syntax:)]
+    ["." code]]
+   [math
+    [number (#+ hex)
+     ["." i64]]]
+   ["@" target
     ["_" scheme (#+ Expression Computation Var)]]]
-  ["." ///
-   ["#/" //
-    ["#/" // #_
-     [analysis (#+ Variant)]
-     ["#." name]
-     ["#." synthesis]]]])
+  ["." /// #_
+   ["#." reference]
+   ["//#" /// #_
+    [analysis (#+ Variant)]
+    ["#." synthesis (#+ Synthesis)]
+    ["#." generation]
+    ["//#" ///
+     ["#." phase]
+     [reference
+      [variable (#+ Register)]]
+     [meta
+      [archive (#+ Output Archive)
+       ["." artifact (#+ Registry)]]]]]])
+
+(def: module_id
+  0)
 
 (template [ ]
   [(type: #export 
      ( Var Expression Expression))]
 
-  [Operation ///.Operation]
-  [Phase ///.Phase]
-  [Handler ///.Handler]
-  [Bundle ///.Bundle]
+  [Operation /////generation.Operation]
+  [Phase /////generation.Phase]
+  [Handler /////generation.Handler]
+  [Bundle /////generation.Bundle]
   )
 
-(def: prefix Text "LuxRuntime")
+(type: #export (Generator i)
+  (-> Phase Archive i (Operation Expression)))
 
-(def: unit (_.string /////synthesis.unit))
+(def: unit
+  (_.string /////synthesis.unit))
 
 (def: (flag value)
   (-> Bit Computation)
   (if value
-    (_.string "")
+    ..unit
     _.nil))
 
 (def: (variant' tag last? value)
@@ -70,44 +88,54 @@
   (-> Expression Computation)
   (|>> [0 #1] ..variant))
 
-(def: declaration
-  (Parser [Text (List Text)])
-  (p.either (p.and s.local-identifier (p\wrap (list)))
-            (s.form (p.and s.local-identifier (p.some s.local-identifier)))))
-
-(syntax: (runtime: {[name args] declaration}
-           definition)
-  (let [implementation (code.local-identifier (format "@@" name))
-        runtime (format prefix "__" (/////name.normalize name))
-        @runtime (` (_.var (~ (code.text runtime))))
-        argsC+ (list\map code.local-identifier args)
-        argsLC+ (list\map (|>> /////name.normalize (format "LRV__") code.text (~) (_.var) (`))
-                          args)
-        declaration (` ((~ (code.local-identifier name))
-                        (~+ argsC+)))
-        type (` (-> (~+ (list.repeat (list.size argsC+) (` _.Expression)))
-                    _.Computation))]
-    (wrap (list (` (def: (~' #export) (~ declaration)
-                     (~ type)
-                     (~ (case argsC+
-                          #.Nil
-                          @runtime
-
-                          _
-                          (` (_.apply/* (~ @runtime) (list (~+ argsC+))))))))
-                (` (def: (~ implementation)
-                     _.Computation
-                     (~ (case argsC+
-                          #.Nil
-                          (` (_.define-constant (~ @runtime) [(list) #.None] (~ definition)))
-
-                          _
-                          (` (let [(~+ (|> (list.zip/2 argsC+ argsLC+)
-                                           (list\map (function (_ [left right])
-                                                       (list left right)))
-                                           list\join))]
-                               (_.define-function (~ @runtime) [(list (~+ argsLC+)) #.None]
-                                                  (~ definition))))))))))))
+(syntax: #export (with_vars {vars (.tuple (<>.some .local_identifier))}
+                   body)
+  (do {! meta.monad}
+    [ids (monad.seq ! (list.repeat (list.size vars) meta.count))]
+    (wrap (list (` (let [(~+ (|> vars
+                                 (list.zip/2 ids)
+                                 (list\map (function (_ [id var])
+                                             (list (code.local_identifier var)
+                                                   (` (_.var (~ (code.text (format "v" (%.nat id)))))))))
+                                 list.concat))]
+                     (~ body)))))))
+
+(syntax: (runtime: {declaration (<>.or .local_identifier
+                                       (.form (<>.and .local_identifier
+                                                            (<>.some .local_identifier))))}
+           code)
+  (do meta.monad
+    [runtime_id meta.count]
+    (macro.with_gensyms [g!_]
+      (let [runtime (code.local_identifier (///reference.artifact [..module_id runtime_id]))
+            runtime_name (` (_.var (~ (code.text (%.code runtime)))))]
+        (case declaration
+          (#.Left name)
+          (macro.with_gensyms [g!_]
+            (let [g!name (code.local_identifier name)]
+              (wrap (list (` (def: #export (~ g!name)
+                               Var
+                               (~ runtime_name)))
+                          
+                          (` (def: (~ (code.local_identifier (format "@" name)))
+                               _.Computation
+                               (_.define_constant (~ runtime_name) (~ code))))))))
+          
+          (#.Right [name inputs])
+          (macro.with_gensyms [g!_]
+            (let [g!name (code.local_identifier name)
+                  inputsC (list\map code.local_identifier inputs)
+                  inputs_typesC (list\map (function.constant (` _.Expression))
+                                          inputs)]
+              (wrap (list (` (def: #export ((~ g!name) (~+ inputsC))
+                               (-> (~+ inputs_typesC) _.Computation)
+                               (_.apply/* (list (~+ inputsC)) (~ runtime_name))))
+
+                          (` (def: (~ (code.local_identifier (format "@" name)))
+                               _.Computation
+                               (..with_vars [(~+ inputsC)]
+                                 (_.define_function (~ runtime_name) [(list (~+ inputsC)) #.None]
+                                                    (~ code))))))))))))))
 
 (runtime: (slice offset length list)
   (<| (_.if (_.null?/1 list)
@@ -123,113 +151,104 @@
                          (_.cdr/1 list))))
       _.nil))
 
-(syntax: #export (with-vars {vars (s.tuple (p.many s.local-identifier))}
-                   body)
-  (wrap (list (` (let [(~+ (|> vars
-                               (list\map (function (_ var)
-                                           (list (code.local-identifier var)
-                                                 (` (_.var (~ (code.text (format "LRV__" (/////name.normalize var)))))))))
-                               list\join))]
-                   (~ body))))))
-
 (runtime: (lux//try op)
-  (with-vars [error]
-    (_.with-exception-handler
+  (with_vars [error]
+    (_.with_exception_handler
       (_.lambda [(list error) #.None]
                 (..left error))
       (_.lambda [(list) #.None]
-                (..right (_.apply/* op (list ..unit)))))))
+                (..right (_.apply/* (list ..unit) op))))))
 
-(runtime: (lux//program-args program-args)
-  (with-vars [@loop @input @output]
+(runtime: (lux//program_args program_args)
+  (with_vars [@loop @input @output]
     (_.letrec (list [@loop (_.lambda [(list @input @output) #.None]
                                      (_.if (_.eqv?/2 _.nil @input)
                                        @output
                                        (_.apply/2 @loop (_.cdr/1 @input) (..some (_.vector/* (list (_.car/1 @input) @output))))))])
-              (_.apply/2 @loop (_.reverse/1 program-args) ..none))))
+              (_.apply/2 @loop (_.reverse/1 program_args) ..none))))
 
 (def: runtime//lux
   Computation
-  (_.begin (list @@lux//try
-                 @@lux//program-args)))
+  (_.begin (list @lux//try
+                 @lux//program_args)))
 
-(def: last-index
+(def: last_index
   (-> Expression Computation)
   (|>> _.length/1 (_.-/2 (_.int +1))))
 
 (runtime: (tuple//left lefts tuple)
-  (with-vars [last-index-right]
+  (with_vars [last_index_right]
     (_.begin
-     (list (_.define-constant last-index-right (..last-index tuple))
-           (_.if (_.>/2 lefts last-index-right)
+     (list (_.define_constant last_index_right (..last_index tuple))
+           (_.if (_.>/2 lefts last_index_right)
              ## No need for recursion
-             (_.vector-ref/2 tuple lefts)
+             (_.vector_ref/2 tuple lefts)
              ## Needs recursion
-             (tuple//left (_.-/2 last-index-right lefts)
-                          (_.vector-ref/2 tuple last-index-right)))))))
+             (tuple//left (_.-/2 last_index_right lefts)
+                          (_.vector_ref/2 tuple last_index_right)))))))
 
 (runtime: (tuple//right lefts tuple)
-  (with-vars [last-index-right right-index @slice]
+  (with_vars [last_index_right right_index @slice]
     (_.begin
-     (list (_.define-constant last-index-right (..last-index tuple))
-           (_.define-constant right-index (_.+/2 (_.int +1) lefts))
-           (_.cond (list [(_.=/2 last-index-right right-index)
-                          (_.vector-ref/2 tuple right-index)]
-                         [(_.>/2 last-index-right right-index)
+     (list (_.define_constant last_index_right (..last_index tuple))
+           (_.define_constant right_index (_.+/2 (_.int +1) lefts))
+           (_.cond (list [(_.=/2 last_index_right right_index)
+                          (_.vector_ref/2 tuple right_index)]
+                         [(_.>/2 last_index_right right_index)
                           ## Needs recursion.
-                          (tuple//right (_.-/2 last-index-right lefts)
-                                        (_.vector-ref/2 tuple last-index-right))])
+                          (tuple//right (_.-/2 last_index_right lefts)
+                                        (_.vector_ref/2 tuple last_index_right))])
                    (_.begin
-                    (list (_.define-constant @slice (_.make-vector/1 (_.-/2 right-index (_.length/1 tuple))))
-                          (_.vector-copy!/5 @slice (_.int +0) tuple right-index (_.length/1 tuple))
+                    (list (_.define_constant @slice (_.make_vector/1 (_.-/2 right_index (_.length/1 tuple))))
+                          (_.vector_copy!/5 @slice (_.int +0) tuple right_index (_.length/1 tuple))
                           @slice))))
      )))
 
-(runtime: (sum//get sum last? wanted-tag)
-  (with-vars [sum-tag sum-flag sum-value]
-    (let [no-match _.nil
-          is-last? (|> sum-flag (_.eqv?/2 (_.string "")))
-          test-recursion (_.if is-last?
+(runtime: (sum//get sum last? wanted_tag)
+  (with_vars [sum_tag sum_flag sum_value]
+    (let [no_match _.nil
+          is_last? (|> sum_flag (_.eqv?/2 ..unit))
+          test_recursion (_.if is_last?
                            ## Must recurse.
-                           (sum//get sum-value
+                           (sum//get sum_value
                                      last?
-                                     (|> wanted-tag (_.-/2 sum-tag)))
-                           no-match)]
-      (<| (_.let (list [sum-tag (_.car/1 sum)]
-                       [sum-value (_.cdr/1 sum)]))
-          (_.let (list [sum-flag (_.car/1 sum-value)]
-                       [sum-value (_.cdr/1 sum-value)]))
-          (_.if (|> wanted-tag (_.=/2 sum-tag))
-            (_.if (|> sum-flag (_.eqv?/2 last?))
-              sum-value
-              test-recursion))
-          (_.if (|> wanted-tag (_.>/2 sum-tag))
-            test-recursion)
-          (_.if (_.and (list (|> last? (_.eqv?/2 (_.string "")))
-                             (|> wanted-tag (_. sum-tag (_.-/2 wanted-tag)) sum-flag sum-value))
-          no-match))))
+                                     (|> wanted_tag (_.-/2 sum_tag)))
+                           no_match)]
+      (<| (_.let (list [sum_tag (_.car/1 sum)]
+                       [sum_value (_.cdr/1 sum)]))
+          (_.let (list [sum_flag (_.car/1 sum_value)]
+                       [sum_value (_.cdr/1 sum_value)]))
+          (_.if (|> wanted_tag (_.=/2 sum_tag))
+            (_.if (|> sum_flag (_.eqv?/2 last?))
+              sum_value
+              test_recursion))
+          (_.if (|> wanted_tag (_.>/2 sum_tag))
+            test_recursion)
+          (_.if (_.and (list (|> last? (_.eqv?/2 ..unit))
+                             (|> wanted_tag (_. sum_tag (_.-/2 wanted_tag)) sum_flag sum_value))
+          no_match))))
 
 (def: runtime//adt
   Computation
-  (_.begin (list @@tuple//left
-                 @@tuple//right
-                 @@sum//get)))
+  (_.begin (list @tuple//left
+                 @tuple//right
+                 @sum//get)))
 
-(runtime: (i64//logical-right-shift shift input)
+(runtime: (i64//logical_right_shift shift input)
   (_.if (_.=/2 (_.int +0) shift)
     input
     (|> input
-        (_.arithmetic-shift/2 (_.*/2 (_.int -1) shift))
-        (_.bit-and/2 (_.int (hex "+7FFFFFFFFFFFFFFF"))))))
+        (_.arithmetic_shift/2 (_.*/2 (_.int -1) shift))
+        (_.bit_and/2 (_.int (hex "+7FFFFFFFFFFFFFFF"))))))
 
 (def: runtime//bit
   Computation
-  (_.begin (list @@i64//logical-right-shift)))
+  (_.begin (list @i64//logical_right_shift)))
 
 (runtime: (frac//decode input)
-  (with-vars [@output]
-    (_.let (list [@output ((_.apply/1 (_.global "string->number")) input)])
+  (with_vars [@output]
+    (_.let (list [@output ((_.apply/1 (_.var "string->number")) input)])
       (_.if (_.and (list (_.not/1 (_.=/2 @output @output))
                          (_.not/1 (_.eqv?/2 (_.string "+nan.0") input))))
         ..none
@@ -238,19 +257,19 @@
 (def: runtime//frac
   Computation
   (_.begin
-   (list @@frac//decode)))
+   (list @frac//decode)))
 
-(runtime: (io//current-time _)
-  (|> (_.apply/* (_.global "current-second") (list))
+(runtime: (io//current_time _)
+  (|> (_.apply/0 (_.var "current-second"))
       (_.*/2 (_.int +1,000))
       _.exact/1))
 
 (def: runtime//io
-  (_.begin (list @@io//current-time)))
+  (_.begin (list @io//current_time)))
 
 (def: runtime
   Computation
-  (_.begin (list @@slice
+  (_.begin (list @slice
                  runtime//lux
                  runtime//bit
                  runtime//adt
@@ -259,9 +278,14 @@
                  )))
 
 (def: #export generate
-  (Operation Any)
-  (///.with-buffer
-    (do ////.monad
-      [_ (///.execute! ..runtime)
-       _ (///.save! ..prefix ..runtime)]
-      (///.save-buffer! ""))))
+  (Operation [Registry Output])
+  (do ///////phase.monad
+    [_ (/////generation.execute! ..runtime)
+     _ (/////generation.save! (%.nat ..module_id) ..runtime)]
+    (wrap [(|> artifact.empty
+               artifact.resource
+               product.right)
+           (row.row [(%.nat ..module_id)
+                     (|> ..runtime
+                         _.code
+                         (\ encoding.utf8 encode))])])))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/structure.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/structure.lux
index bb11d2e1f..951fa494d 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/structure.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/scheme/structure.lux
@@ -2,36 +2,38 @@
   [lux #*
    [abstract
     ["." monad (#+ do)]]
+   [data
+    [collection
+     ["." list]]]
    [target
     ["_" scheme (#+ Expression)]]]
-  [//
-   ["." runtime (#+ Operation Phase)]
-   ["." primitive]
-   ["." ///
-    [//
-     [analysis (#+ Variant Tuple)]
-     ["." synthesis (#+ Synthesis)]]]])
+  ["." // #_
+   ["#." runtime (#+ Operation Phase Generator)]
+   ["#." primitive]
+   ["///#" //// #_
+    [analysis (#+ Variant Tuple)]
+    ["#." synthesis (#+ Synthesis)]
+    ["//#" /// #_
+     ["#." phase ("#\." monad)]]]])
 
-(def: #export (tuple generate elemsS+)
-  (-> Phase (Tuple Synthesis) (Operation Expression))
+(def: #export (tuple expression archive elemsS+)
+  (Generator (Tuple Synthesis))
   (case elemsS+
     #.Nil
-    (\ ///.monad wrap (primitive.text synthesis.unit))
+    (///////phase\wrap (//primitive.text /////synthesis.unit))
 
     (#.Cons singletonS #.Nil)
-    (generate singletonS)
+    (expression archive singletonS)
 
     _
-    (do {! ///.monad}
-      [elemsT+ (monad.map ! generate elemsS+)]
-      (wrap (_.vector/* elemsT+)))))
+    (|> elemsS+
+        (monad.map ///////phase.monad (expression archive))
+        (///////phase\map _.vector/*))))
 
-(def: #export (variant generate [lefts right? valueS])
-  (-> Phase (Variant Synthesis) (Operation Expression))
-  (do ///.monad
-    [valueT (generate valueS)]
-    (wrap (runtime.variant [(if right?
-                              (inc lefts)
-                              lefts)
-                            right?
-                            valueT]))))
+(def: #export (variant expression archive [lefts right? valueS])
+  (Generator (Variant Synthesis))
+  (let [tag (if right?
+              (inc lefts)
+              lefts)]
+    (///////phase\map (|>> [tag right?] //runtime.variant)
+                      (expression archive valueS))))
diff --git a/stdlib/source/test/lux.lux b/stdlib/source/test/lux.lux
index 8d9f68922..8532b3e12 100644
--- a/stdlib/source/test/lux.lux
+++ b/stdlib/source/test/lux.lux
@@ -11,7 +11,9 @@
       [monad (#+ do)]
       [predicate (#+ Predicate)]]
      [control
-      ["." io (#+ io)]]
+      ["." io (#+ io)]
+      [concurrency
+       ["." atom (#+ Atom)]]]
      [data
       ["." name]
       [text
@@ -52,12 +54,14 @@
 (def: identity
   Test
   (do {! random.monad}
-    [self (random.unicode 1)]
+    [#let [object (: (Random (Atom Text))
+                     (\ ! map atom.atom (random.unicode 1)))]
+     self object]
     ($_ _.and
         (_.test "Every value is identical to itself."
                 (is? self self))
         (do !
-          [other (random.unicode 1)]
+          [other object]
           (_.test "Values created separately can't be identical."
                   (not (is? self other))))
         )))
-- 
cgit v1.2.3