From 86538182a50390e7882778cc02e69482e846edd5 Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Mon, 24 May 2021 11:23:40 -0400 Subject: Almost done with Scheme. But will have to postpone finishing it because Kawa is not up to snuff.--- stdlib/source/lux/control/concurrency/atom.lux | 9 +- stdlib/source/lux/control/thread.lux | 3 +- stdlib/source/lux/data/binary.lux | 57 +++- stdlib/source/lux/data/collection/array.lux | 15 +- stdlib/source/lux/data/text/encoding.lux | 17 +- stdlib/source/lux/debug.lux | 90 ++++-- stdlib/source/lux/host.scm.lux | 219 ++++++++++++++ stdlib/source/lux/math.lux | 32 +++ stdlib/source/lux/target/scheme.lux | 137 ++++++--- .../source/lux/tool/compiler/default/platform.lux | 172 +++++------ .../lux/phase/extension/analysis/scheme.lux | 122 ++++++++ .../language/lux/phase/extension/directive/lux.lux | 9 +- .../phase/extension/generation/scheme/common.lux | 243 ++++++++-------- .../lux/phase/extension/generation/scheme/host.lux | 68 +++++ .../lux/phase/generation/python/runtime.lux | 33 +-- .../language/lux/phase/generation/scheme/case.lux | 83 +++--- .../lux/phase/generation/scheme/function.lux | 7 +- .../lux/phase/generation/scheme/runtime.lux | 313 +++++++++++++-------- .../lux/tool/compiler/meta/packager/script.lux | 9 +- stdlib/source/lux/world/file.lux | 3 + stdlib/source/lux/world/program.lux | 31 +- stdlib/source/program/compositor.lux | 40 +-- stdlib/source/test/lux/extension.lux | 6 +- stdlib/source/test/lux/host.scm.lux | 24 ++ stdlib/source/test/lux/world/file.lux | 66 ++--- 25 files changed, 1269 insertions(+), 539 deletions(-) create mode 100644 stdlib/source/lux/host.scm.lux create mode 100644 stdlib/source/test/lux/host.scm.lux (limited to 'stdlib/source') diff --git a/stdlib/source/lux/control/concurrency/atom.lux b/stdlib/source/lux/control/concurrency/atom.lux index 8a46413da..f8a95a41a 100644 --- a/stdlib/source/lux/control/concurrency/atom.lux +++ b/stdlib/source/lux/control/concurrency/atom.lux @@ -27,20 +27,23 @@ @.python "python array new" @.lua "lua array new" @.ruby "ruby array new" - @.php "php array new"} + @.php "php array new" + @.scheme "scheme array new"} (as_is)) (for {@.js "js array write" @.python "python array write" @.lua "lua array write" @.ruby "ruby array write" - @.php "php array write"} + @.php "php array write" + @.scheme "scheme array write"} (as_is)) (for {@.js "js array read" @.python "python array read" @.lua "lua array read" @.ruby "ruby array read" - @.php "php array read"} + @.php "php array read" + @.scheme "scheme array read"} (as_is))] (abstract: #export (Atom a) (with_expansions [ (java/util/concurrent/atomic/AtomicReference a)] diff --git a/stdlib/source/lux/control/thread.lux b/stdlib/source/lux/control/thread.lux index 52c0062eb..74d5940bc 100644 --- a/stdlib/source/lux/control/thread.lux +++ b/stdlib/source/lux/control/thread.lux @@ -46,7 +46,8 @@ @.python ("python array read" 0 (:representation box)) @.lua ("lua array read" 0 (:representation box)) @.ruby ("ruby array read" 0 (:representation box)) - @.php ("php array read" 0 (:representation box))}))) + @.php ("php array read" 0 (:representation box)) + @.scheme ("scheme array read" 0 (:representation box))}))) (def: #export (write value box) (All [a] (-> a (All [!] (-> (Box ! a) (Thread ! Any))))) diff --git a/stdlib/source/lux/data/binary.lux b/stdlib/source/lux/data/binary.lux index 1fa94f565..40a7b3fc7 100644 --- a/stdlib/source/lux/data/binary.lux +++ b/stdlib/source/lux/data/binary.lux @@ -81,7 +81,16 @@ @.python (type: #export Binary - (primitive "bytearray"))} + (primitive "bytearray")) + + @.scheme + (as_is (type: #export Binary + (primitive "bytevector")) + + (host.import: (make-bytevector [Nat] Binary)) + (host.import: (bytevector-u8-ref [Binary Nat] I64)) + (host.import: (bytevector-u8-set! [Binary Nat (I64 Any)] Any)) + (host.import: (bytevector-length [Binary] Nat)))} ## Default (type: #export Binary @@ -99,7 +108,10 @@ @.python (|> binary (:coerce (array.Array (I64 Any))) - "python array length")} + "python array length") + + @.scheme + (..bytevector-length [binary])} ## Default (array.size binary))) @@ -119,7 +131,10 @@ @.python (|> binary (:coerce (array.Array .I64)) - ("python array read" idx))} + ("python array read" idx)) + + @.scheme + (..bytevector-u8-ref [binary idx])} ## Default (|> binary @@ -139,7 +154,9 @@ @.jvm (host.array_write idx (..byte value) binary) @.js (!!write .Frac n.frac "js array write" idx value binary) - @.python (!!write (I64 Any) (:coerce (I64 Any)) "python array write" idx value binary)} + @.python (!!write (I64 Any) (:coerce (I64 Any)) "python array write" idx value binary) + @.scheme (exec (..bytevector-u8-set! [binary idx value]) + binary)} ## Default (array.write! idx (|> value .nat (n.% (hex "100"))) binary))) @@ -158,7 +175,10 @@ @.python (|>> ("python apply" (:coerce host.Function ("python constant" "bytearray"))) - (:coerce Binary))} + (:coerce Binary)) + + @.scheme + (|>> ..make-bytevector)} ## Default array.new)) @@ -238,15 +258,24 @@ (def: #export (write/64 idx value binary) (-> Nat (I64 Any) Binary (Try Binary)) (if (n.< (..!size binary) (n.+ 7 idx)) - (#try.Success (|> binary - (!write idx (i64.right_shift 56 value)) - (!write (n.+ 1 idx) (i64.right_shift 48 value)) - (!write (n.+ 2 idx) (i64.right_shift 40 value)) - (!write (n.+ 3 idx) (i64.right_shift 32 value)) - (!write (n.+ 4 idx) (i64.right_shift 24 value)) - (!write (n.+ 5 idx) (i64.right_shift 16 value)) - (!write (n.+ 6 idx) (i64.right_shift 8 value)) - (!write (n.+ 7 idx) value))) + (for {@.scheme (let [write_high (|>> (!write idx (i64.right_shift 56 value)) + (!write (n.+ 1 idx) (i64.right_shift 48 value)) + (!write (n.+ 2 idx) (i64.right_shift 40 value)) + (!write (n.+ 3 idx) (i64.right_shift 32 value))) + write_low (|>> (!write (n.+ 4 idx) (i64.right_shift 24 value)) + (!write (n.+ 5 idx) (i64.right_shift 16 value)) + (!write (n.+ 6 idx) (i64.right_shift 8 value)) + (!write (n.+ 7 idx) value))] + (|> binary write_high write_low #try.Success))} + (#try.Success (|> binary + (!write idx (i64.right_shift 56 value)) + (!write (n.+ 1 idx) (i64.right_shift 48 value)) + (!write (n.+ 2 idx) (i64.right_shift 40 value)) + (!write (n.+ 3 idx) (i64.right_shift 32 value)) + (!write (n.+ 4 idx) (i64.right_shift 24 value)) + (!write (n.+ 5 idx) (i64.right_shift 16 value)) + (!write (n.+ 6 idx) (i64.right_shift 8 value)) + (!write (n.+ 7 idx) value)))) (exception.throw ..index_out_of_bounds [(..!size binary) idx]))) (structure: #export equivalence diff --git a/stdlib/source/lux/data/collection/array.lux b/stdlib/source/lux/data/collection/array.lux index 73c6767e4..9e8f850f8 100644 --- a/stdlib/source/lux/data/collection/array.lux +++ b/stdlib/source/lux/data/collection/array.lux @@ -49,7 +49,8 @@ @.python ("python array new" size) @.lua ("lua array new" size) @.ruby ("ruby array new" size) - @.php ("php array new" size)})) + @.php ("php array new" size) + @.scheme ("scheme array new" size)})) (def: #export (size array) (All [a] (-> (Array a) Nat)) @@ -69,7 +70,8 @@ @.python ("python array length" array) @.lua ("lua array length" array) @.ruby ("ruby array length" array) - @.php ("php array length" array)})) + @.php ("php array length" array) + @.scheme ("scheme array length" array)})) (template: (!read ) (let [output ( index array)] @@ -99,7 +101,8 @@ @.python (!read "python array read" "python object none?") @.lua (!read "lua array read" "lua object nil?") @.ruby (!read "ruby array read" "ruby object nil?") - @.php (!read "php array read" "php object null?")}) + @.php (!read "php array read" "php object null?") + @.scheme (!read "scheme array read" "scheme object nil?")}) #.None)) (def: #export (write! index value array) @@ -118,7 +121,8 @@ @.python ("python array write" index value array) @.lua ("lua array write" index value array) @.ruby ("ruby array write" index value array) - @.php ("php array write" index value array)})) + @.php ("php array write" index value array) + @.scheme ("scheme array write" index value array)})) (def: #export (delete! index array) (All [a] @@ -134,7 +138,8 @@ @.python ("python array delete" index array) @.lua ("lua array delete" index array) @.ruby ("ruby array delete" index array) - @.php ("php array delete" index array)}) + @.php ("php array delete" index array) + @.scheme ("scheme array delete" index array)}) array)) ) diff --git a/stdlib/source/lux/data/text/encoding.lux b/stdlib/source/lux/data/text/encoding.lux index 3296f78c4..a081233c9 100644 --- a/stdlib/source/lux/data/text/encoding.lux +++ b/stdlib/source/lux/data/text/encoding.lux @@ -207,7 +207,12 @@ (as_is (host.import: Almost_Binary) (host.import: (unpack [host.String host.String] Almost_Binary)) (host.import: (array_values [Almost_Binary] Binary)) - (def: php_byte_array_format "C*"))} + (def: php_byte_array_format "C*")) + + @.scheme + ## https://srfi.schemers.org/srfi-140/srfi-140.html + (as_is (host.import: (string->utf8 [Text] Binary)) + (host.import: (utf8->string [Binary] Text)))} (as_is))) (def: (utf8\encode value) @@ -254,7 +259,10 @@ (|> (..unpack [..php_byte_array_format value]) ..array_values ("php object new" "ArrayObject") - (:coerce Binary))})) + (:coerce Binary)) + + @.scheme + (..string->utf8 value)})) (def: (utf8\decode value) (-> Binary (Try Text)) @@ -295,6 +303,11 @@ @.php (|> value ("php pack" ..php_byte_array_format) + #try.Success) + + @.scheme + (|> value + ..utf8->string #try.Success)}))) (structure: #export utf8 diff --git a/stdlib/source/lux/debug.lux b/stdlib/source/lux/debug.lux index 29919a588..d5bbd3be2 100644 --- a/stdlib/source/lux/debug.lux +++ b/stdlib/source/lux/debug.lux @@ -15,7 +15,7 @@ ["<.>" code]]] [data ["." text - ["%" format (#+ format)]] + ["%" format]] [format [xml (#+ XML)] ["." json]] @@ -28,6 +28,9 @@ ["." template] ["." syntax (#+ syntax:)] ["." code]] + [math + [number + ["i" int]]] [time [instant (#+ Instant)] [duration (#+ Duration)] @@ -90,6 +93,17 @@ @.php (as_is (import: (gettype [.Any] host.String)) (import: (strval [.Any] host.String))) + + @.scheme + (as_is (import: (boolean? [.Any] Bit)) + (import: (integer? [.Any] Bit)) + (import: (real? [.Any] Bit)) + (import: (string? [.Any] Bit)) + (import: (vector? [.Any] Bit)) + (import: (pair? [.Any] Bit)) + (import: (car [.Any] .Any)) + (import: (cdr [.Any] .Any)) + (import: (format [Text .Any] Text))) })) (def: Inspector (-> Any Text)) @@ -130,9 +144,9 @@ (let [last? (case last? (#.Some _) #1 #.None #0)] - (|> (format (%.nat (.nat (java/lang/Integer::longValue tag))) - " " (%.bit last?) - " " (inspect choice)) + (|> (%.format (%.nat (.nat (java/lang/Integer::longValue tag))) + " " (%.bit last?) + " " (inspect choice)) (text.enclose ["(" ")"]))) _ @@ -159,9 +173,9 @@ (cond (not (or ("js object undefined?" variant_tag) ("js object undefined?" variant_flag) ("js object undefined?" variant_value))) - (|> (format (JSON::stringify variant_tag) - " " (%.bit (not ("js object null?" variant_flag))) - " " (inspect variant_value)) + (|> (%.format (JSON::stringify variant_tag) + " " (%.bit (not ("js object null?" variant_flag))) + " " (inspect variant_value)) (text.enclose ["(" ")"])) (not (or ("js object undefined?" ("js object get" "_lux_low" value)) @@ -200,9 +214,9 @@ (if (or ("python object none?" variant_tag) ("python object none?" variant_value)) (..str value) - (|> (format (|> variant_tag (:coerce .Nat) %.nat) - " " (|> variant_flag "python object none?" not %.bit) - " " (inspect variant_value)) + (|> (%.format (|> variant_tag (:coerce .Nat) %.nat) + " " (|> variant_flag "python object none?" not %.bit) + " " (inspect variant_value)) (text.enclose ["(" ")"])))) _ (..str value))) @@ -233,9 +247,9 @@ (if (not (or ("lua object nil?" variant_tag) ("lua object nil?" variant_flag) ("lua object nil?" variant_value))) - (|> (format (|> variant_tag (:coerce .Nat) %.nat) - " " (%.bit (not ("lua object nil?" variant_flag))) - " " (inspect variant_value)) + (|> (%.format (|> variant_tag (:coerce .Nat) %.nat) + " " (%.bit (not ("lua object nil?" variant_flag))) + " " (inspect variant_value)) (text.enclose ["(" ")"])) (inspect_tuple inspect value))) @@ -265,9 +279,9 @@ (if (not (or ("ruby object nil?" variant_tag) ("ruby object nil?" variant_flag) ("ruby object nil?" variant_value))) - (|> (format (|> variant_tag (:coerce .Nat) %.nat) - " " (%.bit (not ("ruby object nil?" variant_flag))) - " " (inspect variant_value)) + (|> (%.format (|> variant_tag (:coerce .Nat) %.nat) + " " (%.bit (not ("ruby object nil?" variant_flag))) + " " (inspect variant_value)) (text.enclose ["(" ")"])) (inspect_tuple inspect value))) @@ -296,14 +310,44 @@ (if (not (or ("php object null?" variant_tag) ("php object null?" variant_flag) ("php object null?" variant_value))) - (|> (format (|> variant_tag (:coerce .Nat) %.nat) - " " (%.bit (not ("php object null?" variant_flag))) - " " (inspect variant_value)) + (|> (%.format (|> variant_tag (:coerce .Nat) %.nat) + " " (%.bit (not ("php object null?" variant_flag))) + " " (inspect variant_value)) (text.enclose ["(" ")"])) (..strval value))) _ (..strval value)) + + @.scheme + (`` (cond (~~ (template [ ] + [( value) + (`` (|> value (~~ (template.splice ))))] + + [..boolean? [(:coerce .Bit) %.bit]] + [..integer? [(:coerce .Int) %.int]] + [..real? [(:coerce .Frac) %.frac]] + [..string? [(:coerce .Text) %.text]] + ["scheme object nil?" [(new> "()" [])]] + [..vector? [(inspect_tuple inspect)]])) + + (..pair? value) + (let [variant_tag (..car value) + variant_rest (..cdr value)] + (if (and (..integer? variant_tag) + (i.> +0 (:coerce Int variant_tag)) + (..pair? variant_rest)) + (let [variant_flag (..car variant_rest) + variant_value (..cdr variant_rest)] + (|> (%.format (|> variant_tag (:coerce .Nat) %.nat) + " " (%.bit (not ("scheme object nil?" variant_flag))) + " " (inspect variant_value)) + (text.enclose ["(" ")"]))) + (..format ["~s" value]))) + + ## else + (..format ["~s" value]) + )) }))) (exception: #export (cannot_represent_value {type Type}) @@ -361,7 +405,7 @@ "#.None" (#.Some elemV) - (format "(#.Some " (elemR elemV) ")")))))))) + (%.format "(#.Some " (elemR elemV) ")")))))))) (def: (variant_representation representation) (-> (Parser Representation) (Parser Representation)) @@ -387,7 +431,7 @@ _ (undefined)))] - (format "(" (%.nat lefts) " " (%.bit right?) " " sub_repr ")")))))) + (%.format "(" (%.nat lefts) " " (%.bit right?) " " sub_repr ")")))))) (def: (tuple_representation representation) (-> (Parser Representation) (Parser Representation)) @@ -405,8 +449,8 @@ (#.Cons headR tailR) (let [[leftV rightV] (:coerce [Any Any] tupleV)] - (format (headR leftV) " " (recur tailR rightV)))))] - (format "[" tuple_body "]")))))) + (%.format (headR leftV) " " (recur tailR rightV)))))] + (%.format "[" tuple_body "]")))))) (def: representation (Parser Representation) diff --git a/stdlib/source/lux/host.scm.lux b/stdlib/source/lux/host.scm.lux new file mode 100644 index 000000000..1dde8ab69 --- /dev/null +++ b/stdlib/source/lux/host.scm.lux @@ -0,0 +1,219 @@ +(.module: + [lux (#- Alias) + ["." meta] + ["@" target] + [abstract + [monad (#+ do)]] + [control + ["." io] + ["<>" parser ("#\." monad) + ["<.>" code (#+ Parser)]]] + [data + ["." product] + ["." maybe] + ["." text + ["%" format (#+ format)]] + [collection + ["." list ("#\." functor fold)]]] + [type + abstract] + [macro (#+ with_gensyms) + [syntax (#+ syntax:)] + ["." code] + ["." template]]]) + +(abstract: #export (Object brand) Any) + +(template [] + [(with_expansions [ (template.identifier [ "'"])] + (abstract: #export Any) + (type: #export + (..Object )))] + + [Nil] + [Function] + ) + +(template [ ] + [(type: #export + )] + + [Boolean Bit] + [Integer Int] + [Float Frac] + [String Text] + ) + +(type: Nilable + [Bit Code]) + +(def: nilable + (Parser Nilable) + (let [token (' #?)] + (<| (<>.and (<>.parses? (.this! token))) + (<>.after (<>.not (.this! token))) + .any))) + +(type: Alias + Text) + +(def: alias + (Parser Alias) + (<>.after (.this! (' #as)) .local_identifier)) + +(type: Field + [Bit Text (Maybe Alias) Nilable]) + +(def: static! + (Parser Any) + (.this! (' #static))) + +(def: field + (Parser Field) + (.form ($_ <>.and + (<>.parses? ..static!) + .local_identifier + (<>.maybe ..alias) + ..nilable))) + +(def: constant + (Parser Field) + (.form ($_ <>.and + (<>\wrap true) + .local_identifier + (<>.maybe ..alias) + ..nilable))) + +(type: Common_Method + {#name Text + #alias (Maybe Alias) + #inputs (List Nilable) + #io? Bit + #try? Bit + #output Nilable}) + +(def: common_method + (Parser Common_Method) + ($_ <>.and + .local_identifier + (<>.maybe ..alias) + (.tuple (<>.some ..nilable)) + (<>.parses? (.this! (' #io))) + (<>.parses? (.this! (' #try))) + ..nilable)) + +(def: input_variables + (-> (List Nilable) (List [Bit Code])) + (|>> list.enumeration + (list\map (function (_ [idx [nilable? type]]) + [nilable? (|> idx %.nat code.local_identifier)])))) + +(def: (nilable_type [nilable? type]) + (-> Nilable Code) + (if nilable? + (` (.Maybe (~ type))) + type)) + +(def: (with_nil g!temp [nilable? input]) + (-> Code [Bit Code] Code) + (if nilable? + (` (case (~ input) + (#.Some (~ g!temp)) + (~ g!temp) + + #.Nil + ("scheme object nil"))) + input)) + +(def: (without_nil g!temp [nilable? outputT] output) + (-> Code Nilable Code Code) + (if nilable? + (` (let [(~ g!temp) (~ output)] + (if ("scheme object nil?" (~ g!temp)) + #.None + (#.Some (~ g!temp))))) + (` (let [(~ g!temp) (~ output)] + (if (not ("scheme object nil?" (~ g!temp))) + (~ g!temp) + (.error! "Nil is an invalid value!")))))) + +(type: Import + (#Function Common_Method) + (#Constant Field)) + +(def: import + (Parser Import) + ($_ <>.or + (.form ..common_method) + ..constant + )) + +(syntax: #export (try expression) + {#.doc (doc (case (try (risky_computation input)) + (#.Right success) + (do_something success) + + (#.Left error) + (recover_from_failure error)))} + (wrap (list (` ("lux try" ((~! io.io) (~ expression))))))) + +(def: (with_io with? without) + (-> Bit Code Code) + (if with? + (` (io.io (~ without))) + without)) + +(def: (io_type io? rawT) + (-> Bit Code Code) + (if io? + (` (io.IO (~ rawT))) + rawT)) + +(def: (with_try with? without_try) + (-> Bit Code Code) + (if with? + (` (..try (~ without_try))) + without_try)) + +(def: (try_type try? rawT) + (-> Bit Code Code) + (if try? + (` (.Either .Text (~ rawT))) + rawT)) + +(def: (make_function g!method g!temp source inputsT io? try? outputT) + (-> Code Code Code (List Nilable) Bit Bit Nilable Code) + (let [g!inputs (input_variables inputsT)] + (` (def: ((~ g!method) + [(~+ (list\map product.right g!inputs))]) + (-> [(~+ (list\map nilable_type inputsT))] + (~ (|> (nilable_type outputT) + (try_type try?) + (io_type io?)))) + (:assume + (~ (<| (with_io io?) + (with_try try?) + (without_nil g!temp outputT) + (` ("scheme apply" + (:coerce ..Function (~ source)) + (~+ (list\map (with_nil g!temp) g!inputs))))))))))) + +(syntax: #export (import: {import ..import}) + (with_gensyms [g!temp] + (case import + (#Function [name alias inputsT io? try? outputT]) + (let [imported (` ("scheme constant" (~ (code.text name))))] + (wrap (list (..make_function (code.local_identifier (maybe.default name alias)) + g!temp + imported + inputsT + io? + try? + outputT)))) + + (#Constant [_ name alias fieldT]) + (let [imported (` ("scheme constant" (~ (code.text name))))] + (wrap (list (` ((~! syntax:) ((~ (code.local_identifier (maybe.default name alias)))) + (\ (~! meta.monad) (~' wrap) + (list (` (.:coerce (~ (nilable_type fieldT)) (~ imported)))))))))) + ))) diff --git a/stdlib/source/lux/math.lux b/stdlib/source/lux/math.lux index 420e0bc83..1928d7c9a 100644 --- a/stdlib/source/lux/math.lux +++ b/stdlib/source/lux/math.lux @@ -245,6 +245,38 @@ (def: #export root/3 (-> Frac Frac) (..pow ("lux f64 /" +3.0 +1.0)))) + + @.scheme + (as_is (template [ ] + [(def: #export + (-> Frac Frac) + (|>> ("scheme apply" ("scheme constant" )) + (:coerce Frac)))] + + [cos "cos"] + [sin "sin"] + [tan "tan"] + + [acos "acos"] + [asin "asin"] + [atan "atan"] + + [exp "exp"] + [log "log"] + + [ceil "ceiling"] + [floor "floor"] + + [root/2 "sqrt"] + ) + + (def: #export (pow param subject) + (-> Frac Frac Frac) + (:coerce Frac ("scheme apply" ("scheme constant" "expt") subject param))) + + (def: #export root/3 + (-> Frac Frac) + (..pow ("lux f64 /" +3.0 +1.0)))) }) (def: #export (round input) diff --git a/stdlib/source/lux/target/scheme.lux b/stdlib/source/lux/target/scheme.lux index ecdaa7324..20bb08be3 100644 --- a/stdlib/source/lux/target/scheme.lux +++ b/stdlib/source/lux/target/scheme.lux @@ -1,23 +1,55 @@ (.module: - [lux (#- Code int or and if function cond let) + [lux (#- Code int or and if cond let) + ["@" target] + ["." host] + [abstract + [equivalence (#+ Equivalence)] + [hash (#+ Hash)]] [control [pipe (#+ new> cond> case>)]] [data ["." text ["%" format (#+ format)]] [collection - ["." list ("#\." functor fold)]]] + ["." list ("#\." functor fold monoid)]]] [macro ["." template]] [math [number + ["n" nat] ["f" frac]]] [type abstract]]) +(for {@.old (as_is (host.import: java/lang/CharSequence) + (host.import: java/lang/String + ["#::." + (replace [java/lang/CharSequence java/lang/CharSequence] java/lang/String)]))} + (as_is)) + +(def: nest + (-> Text Text) + (.let [nested_new_line (format text.new_line text.tab)] + (for {@.old (|>> (:coerce java/lang/String) + (java/lang/String::replace (:coerce java/lang/CharSequence text.new_line) + (:coerce java/lang/CharSequence nested_new_line)))} + (text.replace_all text.new_line nested_new_line)))) + (abstract: #export (Code k) Text + (structure: #export equivalence + (All [brand] (Equivalence (Code brand))) + + (def: (= reference subject) + (\ text.equivalence = (:representation reference) (:representation subject)))) + + (structure: #export hash + (All [brand] (Hash (Code brand))) + + (def: &equivalence ..equivalence) + (def: hash (|>> :representation (\ text.hash hash)))) + (template [ +] [(abstract: #export ( brand) Any) (`` (type: #export (|> Any (~~ (template.splice +)))))] @@ -110,14 +142,14 @@ (`` (|>> (~~ (template [ ] [(text.replace_all )] + ["\" "\\"] + ["|" "\|"] [text.alarm "\a"] [text.back_space "\b"] [text.tab "\t"] [text.new_line "\n"] [text.carriage_return "\r"] [text.double_quote (format "\" text.double_quote)] - ["\" "\\"] - ["|" "\|"] )) ))) @@ -131,10 +163,17 @@ (def: form (-> (List (Code Any)) Code) - (|>> (list\map ..code) - (text.join_with " ") - (text.enclose ["(" ")"]) - :abstraction)) + (.let [nested_new_line (format text.new_line text.tab)] + (|>> (case> #.Nil + (:abstraction "()") + + (#.Cons head tail) + (|> tail + (list\map (|>> :representation nest)) + (#.Cons (:representation head)) + (text.join_with nested_new_line) + (text.enclose ["(" ")"]) + :abstraction))))) (def: #export (apply/* args func) (-> (List Expression) Expression Computation) @@ -154,16 +193,17 @@ (..apply/* (list))) (template [ ] - [(def: #export (apply/0 (..var )))] + [(def: #export + (apply/0 (..var )))] [newline/0 "newline"] ) (template [ + + +] - [(`` (def: #export ( function) + [(`` (def: #export ( procedure) (-> Expression (~~ (template.splice +)) Computation) - (.function (_ (~~ (template.splice +))) - (..apply/* (list (~~ (template.splice +))) function)))) + (function (_ (~~ (template.splice +))) + (..apply/* (list (~~ (template.splice +))) procedure)))) (`` (template [ ] [(def: #export ( (..var )))] @@ -173,40 +213,47 @@ [apply/1 [_0] [Expression] [[exact/1 "exact"] [integer->char/1 "integer->char"] + [char->integer/1 "char->integer"] [number->string/1 "number->string"] + [string->number/1 "string->number"] + [floor/1 "floor"] + [truncate/1 "truncate"] [string/1 "string"] + [string?/1 "string?"] [length/1 "length"] [values/1 "values"] [null?/1 "null?"] [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-hash/1 "string-hash"] [reverse/1 "reverse"] [display/1 "display"] - [exit/1 "exit"]]] + [exit/1 "exit"] + [string-length/1 "string-length"]]] [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"] + [make-string/2 "make-string"]]] [apply/3 [_0 _1 _2] [Expression Expression Expression] [[substring/3 "substring"] - [vector_set!/3 "vector-set!"]]] + [vector-set!/3 "vector-set!"] + [string-contains/3 "string-contains"]]] [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. @@ -222,7 +269,7 @@ ## 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))) @@ -248,10 +295,10 @@ [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"] + [bitwise-and/2 "bitwise-and"] + [bitwise-ior/2 "bitwise-ior"] + [bitwise-xor/2 "bitwise-xor"] ) (template [ ] @@ -268,7 +315,7 @@ (-> (List [ Expression]) Expression Computation) (..form (list (..var ) (|> bindings - (list\map (.function (_ [binding/name binding/value]) + (list\map (function (_ [binding/name binding/value]) (..form (list (|> binding/name 
)
                                                    binding/value))))
                          ..form)
@@ -290,15 +337,6 @@
     (-> Expression Expression Computation)
     (..form (list (..var "when") test then)))
 
-  (def: #export (cond clauses else)
-    (-> (List [Expression Expression]) Expression Computation)
-    (|> (list\fold (.function (_ [test then] next)
-                     (if test then next))
-                   else
-                   (list.reverse clauses))
-        :representation
-        :abstraction))
-
   (def: #export (lambda arguments body)
     (-> Arguments Expression Computation)
     (..form (list (..var "lambda")
@@ -328,4 +366,23 @@
   (def: #export (with_exception_handler handler body)
     (-> Expression Expression Computation)
     (..form (list (..var "with-exception-handler") handler body)))
+
+  (def: #export (call_with_current_continuation body)
+    (-> Expression Computation)
+    (..form (list (..var "call-with-current-continuation") body)))
+
+  (def: #export (guard variable clauses else body)
+    (-> Var (List [Expression Expression]) (Maybe Expression) Expression Computation)
+    (..form (list (..var "guard")
+                  (..form (|> (case else
+                                #.None
+                                (list)
+                                
+                                (#.Some else)
+                                (list (..form (list (..var "else") else))))
+                              (list\compose (list\map (function (_ [when then])
+                                                        (..form (list when then)))
+                                                      clauses))
+                              (list& variable)))
+                  body)))
   )
diff --git a/stdlib/source/lux/tool/compiler/default/platform.lux b/stdlib/source/lux/tool/compiler/default/platform.lux
index cb006d9f7..0ef931275 100644
--- a/stdlib/source/lux/tool/compiler/default/platform.lux
+++ b/stdlib/source/lux/tool/compiler/default/platform.lux
@@ -171,20 +171,21 @@
           
           (Try )))
     (|> (:share []
-                {
-                 state}
-                {(///directive.Operation  Any)
-                 (do ///phase.monad
-                   [_ (///directive.lift_analysis
-                       (///analysis.install analysis_state))
-                    _ (///directive.lift_analysis
-                       (extension.with extender analysers))
-                    _ (///directive.lift_synthesis
-                       (extension.with extender synthesizers))
-                    _ (///directive.lift_generation
-                       (extension.with extender (:assume generators)))
-                    _ (extension.with extender (:assume directives))]
-                   (wrap []))})
+                
+                state
+                
+                (///directive.Operation  Any)
+                (do ///phase.monad
+                  [_ (///directive.lift_analysis
+                      (///analysis.install analysis_state))
+                   _ (///directive.lift_analysis
+                      (extension.with extender analysers))
+                   _ (///directive.lift_synthesis
+                      (extension.with extender synthesizers))
+                   _ (///directive.lift_generation
+                      (extension.with extender (:assume generators)))
+                   _ (extension.with extender (:assume directives))]
+                  (wrap [])))
         (///phase.run' state)
         (\ try.monad map product.left)))
 
@@ -343,70 +344,73 @@
             (->  )))
       (let [current (stm.var initial)
             pending (:share []
-                            {
-                             initial}
-                            {(Var (Dictionary Module ))
-                             (:assume (stm.var (dictionary.new text.hash)))})
+                            
+                            initial
+                            
+                            (Var (Dictionary Module ))
+                            (:assume (stm.var (dictionary.new text.hash))))
             dependence (: (Var Dependence)
                           (stm.var ..independence))]
         (function (_ compile)
           (function (import! importer module)
             (do {! promise.monad}
               [[return signal] (:share []
-                                       {
-                                        initial}
-                                       {(Promise [ (Maybe [
-                                                                   archive.ID
-                                                                   ])])
-                                        (:assume
-                                         (stm.commit
-                                          (do {! stm.monad}
-                                            [dependence (if (text\= archive.runtime_module importer)
-                                                          (stm.read dependence)
-                                                          (do !
-                                                            [[_ dependence] (stm.update (..depend importer module) dependence)]
-                                                            (wrap dependence)))]
-                                            (case (..verify_dependencies importer module dependence)
-                                              (#try.Failure error)
-                                              (wrap [(promise.resolved (#try.Failure error))
-                                                     #.None])
-
-                                              (#try.Success _)
-                                              (do !
-                                                [[archive state] (stm.read current)]
-                                                (if (archive.archived? archive module)
-                                                  (wrap [(promise\wrap (#try.Success [archive state]))
-                                                         #.None])
-                                                  (do !
-                                                    [@pending (stm.read pending)]
-                                                    (case (dictionary.get module @pending)
-                                                      (#.Some [return signal])
-                                                      (wrap [return
-                                                             #.None])
-                                                      
-                                                      #.None
-                                                      (case (if (archive.reserved? archive module)
-                                                              (do try.monad
-                                                                [module_id (archive.id module archive)]
-                                                                (wrap [module_id archive]))
-                                                              (archive.reserve module archive))
-                                                        (#try.Success [module_id archive])
-                                                        (do !
-                                                          [_ (stm.write [archive state] current)
-                                                           #let [[return signal] (:share []
-                                                                                         {
-                                                                                          initial}
-                                                                                         {
-                                                                                          (promise.promise [])})]
-                                                           _ (stm.update (dictionary.put module [return signal]) pending)]
-                                                          (wrap [return
-                                                                 (#.Some [[archive state]
-                                                                          module_id
-                                                                          signal])]))
-                                                        
-                                                        (#try.Failure error)
-                                                        (wrap [(promise\wrap (#try.Failure error))
-                                                               #.None]))))))))))})
+                                       
+                                       initial
+                                       
+                                       (Promise [ (Maybe [
+                                                                  archive.ID
+                                                                  ])])
+                                       (:assume
+                                        (stm.commit
+                                         (do {! stm.monad}
+                                           [dependence (if (text\= archive.runtime_module importer)
+                                                         (stm.read dependence)
+                                                         (do !
+                                                           [[_ dependence] (stm.update (..depend importer module) dependence)]
+                                                           (wrap dependence)))]
+                                           (case (..verify_dependencies importer module dependence)
+                                             (#try.Failure error)
+                                             (wrap [(promise.resolved (#try.Failure error))
+                                                    #.None])
+
+                                             (#try.Success _)
+                                             (do !
+                                               [[archive state] (stm.read current)]
+                                               (if (archive.archived? archive module)
+                                                 (wrap [(promise\wrap (#try.Success [archive state]))
+                                                        #.None])
+                                                 (do !
+                                                   [@pending (stm.read pending)]
+                                                   (case (dictionary.get module @pending)
+                                                     (#.Some [return signal])
+                                                     (wrap [return
+                                                            #.None])
+                                                     
+                                                     #.None
+                                                     (case (if (archive.reserved? archive module)
+                                                             (do try.monad
+                                                               [module_id (archive.id module archive)]
+                                                               (wrap [module_id archive]))
+                                                             (archive.reserve module archive))
+                                                       (#try.Success [module_id archive])
+                                                       (do !
+                                                         [_ (stm.write [archive state] current)
+                                                          #let [[return signal] (:share []
+                                                                                        
+                                                                                        initial
+                                                                                        
+                                                                                        
+                                                                                        (promise.promise []))]
+                                                          _ (stm.update (dictionary.put module [return signal]) pending)]
+                                                         (wrap [return
+                                                                (#.Some [[archive state]
+                                                                         module_id
+                                                                         signal])]))
+                                                       
+                                                       (#try.Failure error)
+                                                       (wrap [(promise\wrap (#try.Failure error))
+                                                              #.None])))))))))))
                _ (case signal
                    #.None
                    (wrap [])
@@ -472,11 +476,12 @@
         (-> Import Static Expander  Compilation  ))
       (let [[compilation_sources compilation_libraries compilation_target compilation_module] compilation
             base_compiler (:share []
-                                  {
-                                   context}
-                                  {(///.Compiler  .Module Any)
-                                   (:assume
-                                    ((//init.compiler expander syntax.prelude (get@ #write platform)) $.key (list)))})
+                                  
+                                  context
+                                  
+                                  (///.Compiler  .Module Any)
+                                  (:assume
+                                   ((//init.compiler expander syntax.prelude (get@ #write platform)) $.key (list))))
             compiler (..parallel
                       context
                       (function (_ import! module_id [archive state] module)
@@ -494,12 +499,13 @@
                             (let [new_dependencies (get@ #///.dependencies compilation)
                                   all_dependencies (list\compose new_dependencies all_dependencies)
                                   continue! (:share []
-                                                    {
-                                                     platform}
-                                                    {(->  (///.Compilation  .Module Any) (List Module)
-                                                         (Action [Archive ]))
-                                                     (:assume
-                                                      recur)})]
+                                                    
+                                                    platform
+                                                    
+                                                    (->  (///.Compilation  .Module Any) (List Module)
+                                                        (Action [Archive ]))
+                                                    (:assume
+                                                     recur))]
                               (do !
                                 [[archive state] (case new_dependencies
                                                    #.Nil
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
index 1c0a89df5..ef13cb2ef 100644
--- 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
@@ -27,8 +27,130 @@
       [///
        ["." phase]]]]]])
 
+(def: array::new
+  Handler
+  (custom
+   [.any
+    (function (_ extension phase archive lengthC)
+      (do phase.monad
+        [lengthA (analysis/type.with_type Nat
+                   (phase archive lengthC))
+         [var_id varT] (analysis/type.with_env check.var)
+         _ (analysis/type.infer (type (Array varT)))]
+        (wrap (#analysis.Extension extension (list lengthA)))))]))
+
+(def: array::length
+  Handler
+  (custom
+   [.any
+    (function (_ extension phase archive arrayC)
+      (do phase.monad
+        [[var_id varT] (analysis/type.with_env check.var)
+         arrayA (analysis/type.with_type (type (Array varT))
+                  (phase archive arrayC))
+         _ (analysis/type.infer Nat)]
+        (wrap (#analysis.Extension extension (list arrayA)))))]))
+
+(def: array::read
+  Handler
+  (custom
+   [(<>.and .any .any)
+    (function (_ extension phase archive [indexC arrayC])
+      (do phase.monad
+        [indexA (analysis/type.with_type Nat
+                  (phase archive indexC))
+         [var_id varT] (analysis/type.with_env check.var)
+         arrayA (analysis/type.with_type (type (Array varT))
+                  (phase archive arrayC))
+         _ (analysis/type.infer varT)]
+        (wrap (#analysis.Extension extension (list indexA arrayA)))))]))
+
+(def: array::write
+  Handler
+  (custom
+   [($_ <>.and .any .any .any)
+    (function (_ extension phase archive [indexC valueC arrayC])
+      (do phase.monad
+        [indexA (analysis/type.with_type Nat
+                  (phase archive indexC))
+         [var_id varT] (analysis/type.with_env check.var)
+         valueA (analysis/type.with_type varT
+                  (phase archive valueC))
+         arrayA (analysis/type.with_type (type (Array varT))
+                  (phase archive arrayC))
+         _ (analysis/type.infer (type (Array varT)))]
+        (wrap (#analysis.Extension extension (list indexA valueA arrayA)))))]))
+
+(def: array::delete
+  Handler
+  (custom
+   [($_ <>.and .any .any)
+    (function (_ extension phase archive [indexC arrayC])
+      (do phase.monad
+        [indexA (analysis/type.with_type Nat
+                  (phase archive indexC))
+         [var_id varT] (analysis/type.with_env check.var)
+         arrayA (analysis/type.with_type (type (Array varT))
+                  (phase archive arrayC))
+         _ (analysis/type.infer (type (Array varT)))]
+        (wrap (#analysis.Extension extension (list indexA arrayA)))))]))
+
+(def: bundle::array
+  Bundle
+  (<| (bundle.prefix "array")
+      (|> bundle.empty
+          (bundle.install "new" array::new)
+          (bundle.install "length" array::length)
+          (bundle.install "read" array::read)
+          (bundle.install "write" array::write)
+          (bundle.install "delete" array::delete)
+          )))
+
+(def: Nil
+  (for {@.scheme
+        host.Nil}
+       Any))
+
+(def: Function
+  (for {@.scheme host.Function}
+       Any))
+
+(def: bundle::object
+  Bundle
+  (<| (bundle.prefix "object")
+      (|> bundle.empty
+          (bundle.install "nil" (/.nullary ..Nil))
+          (bundle.install "nil?" (/.unary Any Bit))
+          )))
+
+(def: scheme::constant
+  Handler
+  (custom
+   [.text
+    (function (_ extension phase archive name)
+      (do phase.monad
+        [_ (analysis/type.infer Any)]
+        (wrap (#analysis.Extension extension (list (analysis.text name))))))]))
+
+(def: scheme::apply
+  Handler
+  (custom
+   [($_ <>.and .any (<>.some .any))
+    (function (_ extension phase archive [abstractionC inputsC])
+      (do {! phase.monad}
+        [abstractionA (analysis/type.with_type ..Function
+                        (phase archive abstractionC))
+         inputsA (monad.map ! (|>> (phase archive) (analysis/type.with_type Any)) inputsC)
+         _ (analysis/type.infer Any)]
+        (wrap (#analysis.Extension extension (list& abstractionA inputsA)))))]))
+
 (def: #export bundle
   Bundle
   (<| (bundle.prefix "scheme")
       (|> bundle.empty
+          (dictionary.merge bundle::array)
+          (dictionary.merge bundle::object)
+
+          (bundle.install "constant" scheme::constant)
+          (bundle.install "apply" scheme::apply)
           )))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/directive/lux.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/directive/lux.lux
index 4b84727aa..458b6bcd5 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/directive/lux.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/directive/lux.lux
@@ -328,10 +328,11 @@
             _ (<| 
                   (///.install extender (:coerce Text name))
                   (:share [anchor expression directive]
-                          {(Handler anchor expression directive)
-                           handler}
-                          {
-                           (:assume handlerV)}))
+                          (Handler anchor expression directive)
+                          handler
+                          
+                          
+                          (:assume handlerV)))
             _ (/////directive.lift_generation
                (/////generation.log! (format  " " (%.text (:coerce Text name)))))]
            (wrap /////directive.no_requirements))
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
index 6a13e29bb..71a122eff 100644
--- 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
@@ -54,145 +54,122 @@
   (|>> 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: 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}
+                 [@input (\ ! map _.var (generation.gensym "input"))
+                  inputG (phase archive input)
+                  elseG (phase archive else)
+                  conditionalsG (: (Operation (List [Expression Expression]))
+                                   (monad.map ! (function (_ [chars branch])
+                                                  (do !
+                                                    [branchG (phase archive branch)]
+                                                    (wrap [(|> chars (list\map (|>> .int _.int (_.=/2 @input))) _.or)
+                                                           branchG])))
+                                              conditionals))]
+                 (wrap (_.let (list [@input inputG])
+                         (list\fold (function (_ [test then] else)
+                                      (_.if test then else))
+                                    elseG
+                                    conditionalsG)))))]))
+
+(def: lux_procs
+  Bundle
+  (|> /.empty
+      (/.install "syntax char case!" lux::syntax_char_case!)
+      (/.install "is" (binary (product.uncurry _.eq?/2)))
+      (/.install "try" (unary //runtime.lux//try))
+      ))
+
+(def: (capped operation parameter subject)
+  (-> (-> Expression Expression Expression)
+      (-> Expression Expression Expression))
+  (//runtime.i64//64 (operation parameter subject)))
+
+(def: i64_procs
+  Bundle
+  (<| (/.prefix "i64")
+      (|> /.empty
+          (/.install "and" (binary (product.uncurry //runtime.i64//and)))
+          (/.install "or" (binary (product.uncurry //runtime.i64//or)))
+          (/.install "xor" (binary (product.uncurry //runtime.i64//xor)))
+          (/.install "left-shift" (binary (product.uncurry //runtime.i64//left_shift)))
+          (/.install "right-shift" (binary (product.uncurry //runtime.i64//right_shift)))
+          (/.install "=" (binary (product.uncurry _.=/2)))
+          (/.install "<" (binary (product.uncurry _.> _.integer->char/1 (_.make-string/2 (_.int +1)))))
+          )))
 
-## (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: f64_procs
+  Bundle
+  (<| (/.prefix "f64")
+      (|> /.empty
+          (/.install "=" (binary (product.uncurry _.=/2)))
+          (/.install "<" (binary (product.uncurry _.string/1))
+          (/.install "decode" (unary //runtime.f64//decode)))))
+
+(def: (text//index [offset sub text])
+  (Trinary Expression)
+  (//runtime.text//index offset sub text))
+
+(def: (text//clip [paramO extraO subjectO])
+  (Trinary Expression)
+  (//runtime.text//clip paramO extraO subjectO))
+
+(def: text_procs
+  Bundle
+  (<| (/.prefix "text")
+      (|> /.empty
+          (/.install "=" (binary (product.uncurry _.string=?/2)))
+          (/.install "<" (binary (product.uncurry _.string> _.time/0
-##        (_.* (_.int +1,000))))
+(def: (io//log! message)
+  (Unary Expression)
+  (_.begin (list (_.display/1 message)
+                 (_.display/1 (_.string text.new_line))
+                 //runtime.unit)))
 
-## (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: io_procs
+  Bundle
+  (<| (/.prefix "io")
+      (|> /.empty
+          (/.install "log" (unary ..io//log!))
+          (/.install "error" (unary _.raise/1))
+          (/.install "current-time" (nullary (function.constant (//runtime.io//current_time //runtime.unit))))
+          )))
 
 (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)
+          (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
index 0a05436c2..55e46ad23 100644
--- 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
@@ -32,8 +32,76 @@
       ["//#" /// #_
        ["#." phase]]]]]])
 
+(def: (array::new size)
+  (Unary Expression)
+  (_.make-vector/2 size _.nil))
+
+(def: array::length
+  (Unary Expression)
+  _.vector-length/1)
+
+(def: (array::read [indexG arrayG])
+  (Binary Expression)
+  (_.vector-ref/2 arrayG indexG))
+
+(def: (array::write [indexG valueG arrayG])
+  (Trinary Expression)
+  (//runtime.array//write indexG valueG arrayG))
+
+(def: (array::delete [indexG arrayG])
+  (Binary Expression)
+  (//runtime.array//write indexG _.nil arrayG))
+
+(def: array
+  Bundle
+  (<| (/.prefix "array")
+      (|> /.empty
+          (/.install "new" (unary array::new))
+          (/.install "length" (unary array::length))
+          (/.install "read" (binary array::read))
+          (/.install "write" (trinary array::write))
+          (/.install "delete" (binary array::delete))
+          )))
+
+(template [  ]
+  [(def:  (Nullary Expression) (function.constant ))
+   (def:  (Unary Expression) (_.eq?/2 ))]
+
+  [object::nil object::nil? _.nil]
+  )
+
+(def: object
+  Bundle
+  (<| (/.prefix "object")
+      (|> /.empty
+          (/.install "nil" (nullary object::nil))
+          (/.install "nil?" (unary object::nil?))
+          )))
+
+(def: scheme::constant
+  (custom
+   [.text
+    (function (_ extension phase archive name)
+      (do ////////phase.monad
+        []
+        (wrap (_.var name))))]))
+
+(def: scheme::apply
+  (custom
+   [($_ <>.and .any (<>.some .any))
+    (function (_ extension phase archive [abstractionS inputsS])
+      (do {! ////////phase.monad}
+        [abstractionG (phase archive abstractionS)
+         inputsG (monad.map ! (phase archive) inputsS)]
+        (wrap (_.apply/* inputsG abstractionG))))]))
+
 (def: #export bundle
   Bundle
   (<| (/.prefix "scheme")
       (|> /.empty
+          (dictionary.merge ..array)
+          (dictionary.merge ..object)
+
+          (/.install "constant" scheme::constant)
+          (/.install "apply" scheme::apply)
           )))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python/runtime.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python/runtime.lux
index 1638a64ca..ec8ff641f 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python/runtime.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python/runtime.lux
@@ -250,19 +250,20 @@
                               (_.set (list wantedTag) (_.- sum_tag wantedTag))
                               (_.set (list sum) sum_value))
                           no_match!)]
-    (<| (_.while (_.bool true))
-        (_.cond (list [(_.= wantedTag sum_tag)
-                       (_.if (_.= wantsLast sum_flag)
-                         (_.return sum_value)
-                         test_recursion!)]
+    (_.while (_.bool true)
+             (_.cond (list [(_.= wantedTag sum_tag)
+                            (_.if (_.= wantsLast sum_flag)
+                              (_.return sum_value)
+                              test_recursion!)]
 
-                      [(_.< wantedTag sum_tag)
-                       test_recursion!]
+                           [(_.< wantedTag sum_tag)
+                            test_recursion!]
 
-                      [(_.= ..unit wantsLast)
-                       (_.return (variant' (_.- wantedTag sum_tag) sum_flag sum_value))])
+                           [(_.= ..unit wantsLast)
+                            (_.return (variant' (_.- wantedTag sum_tag) sum_flag sum_value))])
 
-                no_match!))))
+                     no_match!)
+             #.None)))
 
 (def: runtime//adt
   (Statement Any)
@@ -296,13 +297,8 @@
                            ## This +- is only necessary to guarantee that values within the limits are always longs in Python 2
                            (|> input (_.+ ..i64//+limit) (_.- ..i64//+limit))))))))
 
-(runtime: i64//nat_top
-  (|> (_.int +1)
-      (_.bit_shl (_.int +64))
-      (_.- (_.int +1))))
-
 (def: as_nat
-  (_.% (_.manual "0x10000000000000000")))
+  (_.% ..i64//+iteration))
 
 (runtime: (i64//left_shift param subject)
   (_.return (|> subject
@@ -345,14 +341,14 @@
   [i64//xor _.bit_xor]
   )
 
-(def: version
+(def: python_version
   (Expression Any)
   (|> (_.__import__/1 (_.unicode "sys"))
       (_.the "version_info")
       (_.the "major")))
 
 (runtime: (i64//char value)
-  (_.return (_.? (_.= (_.int +3) ..version)
+  (_.return (_.? (_.= (_.int +3) ..python_version)
                  (_.chr/1 value)
                  (_.unichr/1 value))))
 
@@ -360,7 +356,6 @@
   (Statement Any)
   ($_ _.then
       @i64//64
-      @i64//nat_top
       @i64//left_shift
       @i64//right_shift
       @i64//division
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 8f7d8a8b1..884e20c0f 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
@@ -9,6 +9,8 @@
     [collection
      ["." list ("#\." functor fold)]
      ["." set]]]
+   [macro
+    ["." template]]
    [math
     [number
      ["i" int]]]
@@ -87,7 +89,7 @@
 
 (def: (pop! var)
   (-> Var Computation)
-  (_.set! var var))
+  (_.set! var (_.cdr/1 var)))
 
 (def: save_cursor!
   Computation
@@ -95,7 +97,8 @@
 
 (def: restore_cursor!
   Computation
-  (_.set! @cursor (_.car/1 @savepoint)))
+  (_.begin (list (_.set! @cursor (_.car/1 @savepoint))
+                 (_.set! @savepoint (_.cdr/1 @savepoint)))))
 
 (def: peek
   Computation
@@ -106,17 +109,20 @@
   (pop! @cursor))
 
 (def: pm_error
-  (_.string "PM-ERROR"))
+  (_.string (template.with_locals [pm_error]
+              (template.text [pm_error]))))
 
 (def: fail!
   (_.raise/1 pm_error))
 
-(def: (pm_catch handler)
-  (-> Expression Computation)
-  (_.lambda [(list @alt_error) #.None]
-            (_.if (|> @alt_error (_.eqv?/2 pm_error))
-              handler
-              (_.raise/1 @alt_error))))
+(def: (try_pm on_failure happy_path)
+  (-> Expression Expression Computation)
+  (_.guard @alt_error
+           (list [(_.and (list (_.string?/1 @alt_error)
+                               (_.string=?/2 ..pm_error @alt_error)))
+                  on_failure])
+           #.None
+           happy_path))
 
 (def: (pattern_matching' expression archive)
   (Generator Path)
@@ -158,49 +164,54 @@
                                                  ..peek)
                                             then!])))
                                (#.Cons cons))]
-           (wrap (_.cond clauses ..fail!)))])
+           (wrap (list\fold (function (_ [when then] else)
+                              (_.if when then else))
+                            ..fail!
+                            clauses)))])
       ([#/////synthesis.I64_Fork //primitive.i64 _.=/2]
        [#/////synthesis.F64_Fork //primitive.f64 _.=/2]
-       [#/////synthesis.Text_Fork //primitive.text _.eqv?/2])
+       [#/////synthesis.Text_Fork //primitive.text _.string=?/2])
 
       (^template [  ]
         [(^ ( idx))
-         (///////phase\wrap (_.let (list [@temp (|> idx  .int _.int (//runtime.sum//get ..peek ))])
+         (///////phase\wrap (_.let (list [@temp (|> idx  .int _.int (//runtime.sum//get ..peek (_.bool )))])
                               (_.if (_.null?/1 @temp)
                                 ..fail!
                                 (push_cursor! @temp))))])
-      ([/////synthesis.side/left  _.nil         (<|)]
-       [/////synthesis.side/right (_.string "") inc])
+      ([/////synthesis.side/left  false (<|)]
+       [/////synthesis.side/right true  inc])
+
+      (^ (/////synthesis.member/left 0))
+      (///////phase\wrap (..push_cursor! (_.vector-ref/2 ..peek (_.int +0))))
 
       (^template [ ]
-        [(^ ( idx))
-         (///////phase\wrap (push_cursor! ( (_.int (.int idx)) ..peek)))])
+        [(^ ( lefts))
+         (///////phase\wrap (|> ..peek ( (_.int (.int lefts))) ..push_cursor!))])
       ([/////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))))]))))
+      (^ (/////synthesis.path/seq leftP rightP))
+      (do ///////phase.monad
+        [leftO (recur leftP)
+         rightO (recur rightP)]
+        (wrap (_.begin (list leftO
+                             rightO))))
+      
+      (^ (/////synthesis.path/alt leftP rightP))
+      (do {! ///////phase.monad}
+        [leftO (recur leftP)
+         rightO (recur rightP)]
+        (wrap (try_pm (_.begin (list restore_cursor!
+                                     rightO))
+                      (_.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!)))))
+  (\ ///////phase.monad map
+     (try_pm (_.raise/1 (_.string "Invalid expression for pattern-matching.")))
+     (pattern_matching' expression archive pathP)))
 
 (def: #export (case expression archive [valueS pathP])
   (Generator [Synthesis Path])
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 edcdb89b4..380352c5b 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
@@ -89,9 +89,10 @@
                                                      output_func_args (//runtime.slice arityO
                                                                                        (|> @num_args (_.-/2 arityO))
                                                                                        @curried)]
-                                                 (|> @self
-                                                     (apply_poly arity_args)
-                                                     (apply_poly output_func_args))))
+                                                 (_.begin (list ## (_.display/1 (_.string (format "!!! PRE [slice]" text.new_line)))
+                                                                (|> @self
+                                                                    (apply_poly arity_args)
+                                                                    (apply_poly output_func_args))))))
                                              ## (|> @num_args (_. @self
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 d6ae1cffd..815b5a8a5 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
@@ -53,41 +53,9 @@
 (type: #export (Generator i)
   (-> Phase Archive i (Operation Expression)))
 
-(def: unit
+(def: #export unit
   (_.string /////synthesis.unit))
 
-(def: (flag value)
-  (-> Bit Computation)
-  (if value
-    ..unit
-    _.nil))
-
-(def: (variant' tag last? value)
-  (-> Expression Expression Expression Computation)
-  (<| (_.cons/2 tag)
-      (_.cons/2 last?)
-      value))
-
-(def: #export (variant [lefts right? value])
-  (-> (Variant Expression) Computation)
-  (variant' (_.int (.int lefts)) (flag right?) value))
-
-(def: #export none
-  Computation
-  (variant [0 #0 ..unit]))
-
-(def: #export some
-  (-> Expression Computation)
-  (|>> [0 #1] ..variant))
-
-(def: #export left
-  (-> Expression Computation)
-  (|>> [0 #0] ..variant))
-
-(def: #export right
-  (-> Expression Computation)
-  (|>> [0 #1] ..variant))
-
 (syntax: #export (with_vars {vars (.tuple (<>.some .local_identifier))}
                    body)
   (do {! meta.monad}
@@ -137,41 +105,6 @@
                                  (_.define_function (~ runtime_name) [(list (~+ inputsC)) #.None]
                                                     (~ code))))))))))))))
 
-(runtime: (slice offset length list)
-  (<| (_.if (_.null?/1 list)
-        list)
-      (_.if (|> offset (_.>/2 (_.int +0)))
-        (slice (|> offset (_.-/2 (_.int +1)))
-               length
-               (_.cdr/1 list)))
-      (_.if (|> length (_.>/2 (_.int +0)))
-        (_.cons/2 (_.car/1 list)
-                  (slice offset
-                         (|> length (_.-/2 (_.int +1)))
-                         (_.cdr/1 list))))
-      _.nil))
-
-(runtime: (lux//try op)
-  (with_vars [error]
-    (_.with_exception_handler
-      (_.lambda [(list error) #.None]
-                (..left error))
-      (_.lambda [(list) #.None]
-                (..right (_.apply/* (list ..unit) op))))))
-
-(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))))
-
-(def: runtime//lux
-  Computation
-  (_.begin (list @lux//try
-                 @lux//program_args)))
-
 (def: last_index
   (-> Expression Computation)
   (|>> _.length/1 (_.-/2 (_.int +1))))
@@ -182,50 +115,62 @@
      (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)))))))
+                          (_.vector-ref/2 tuple last_index_right)))))))
 
 (runtime: (tuple//right lefts tuple)
   (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)
-                          ## Needs recursion.
-                          (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))
-                          @slice))))
+           (<| (_.if (_.=/2 last_index_right right_index)
+                 (_.vector-ref/2 tuple right_index))
+               (_.if (_.>/2 last_index_right right_index)
+                 ## Needs recursion.
+                 (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))
+                      @slice))))
      )))
 
+(def: (variant' tag last? value)
+  (-> Expression Expression Expression Computation)
+  ($_ _.cons/2
+      tag
+      last?
+      value))
+
+(runtime: (sum//make tag last? value)
+  (variant' tag last? value))
+
+(def: #export (variant [lefts right? value])
+  (-> (Variant Expression) Computation)
+  (..sum//make (_.int (.int lefts)) (_.bool right?) value))
+
 (runtime: (sum//get sum last? wanted_tag)
-  (with_vars [sum_tag sum_flag sum_value]
+  (with_vars [sum_tag sum_flag sum_value sum_temp sum_dump]
     (let [no_match _.nil
-          is_last? (|> sum_flag (_.eqv?/2 ..unit))
-          test_recursion (_.if is_last?
+          test_recursion (_.if sum_flag
                            ## Must recurse.
                            (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_temp (_.cdr/1 sum)]))
+          (_.let (list [sum_flag (_.car/1 sum_temp)]
+                       [sum_value (_.cdr/1 sum_temp)]))
+          (_.if (_.=/2 wanted_tag sum_tag)
+            (_.if (_.eqv?/2 last? sum_flag)
               sum_value
               test_recursion))
-          (_.if (|> wanted_tag (_.>/2 sum_tag))
+          (_.if (_. last? (_.eqv?/2 ..unit))
-                             (|> wanted_tag (_. sum_tag (_.-/2 wanted_tag)) sum_flag sum_value))
           no_match))))
 
@@ -233,36 +178,178 @@
   Computation
   (_.begin (list @tuple//left
                  @tuple//right
-                 @sum//get)))
+                 @sum//get
+                 @sum//make)))
+
+(def: #export none
+  Computation
+  (|> ..unit [0 #0] variant))
+
+(def: #export some
+  (-> Expression Computation)
+  (|>> [1 #1] ..variant))
+
+(def: #export left
+  (-> Expression Computation)
+  (|>> [0 #0] ..variant))
+
+(def: #export right
+  (-> Expression Computation)
+  (|>> [1 #1] ..variant))
+
+(runtime: (slice offset length list)
+  (<| (_.if (_.null?/1 list)
+        list)
+      (_.if (|> offset (_.>/2 (_.int +0)))
+        (slice (|> offset (_.-/2 (_.int +1)))
+               length
+               (_.cdr/1 list)))
+      (_.if (|> length (_.>/2 (_.int +0)))
+        (_.cons/2 (_.car/1 list)
+                  (slice offset
+                         (|> length (_.-/2 (_.int +1)))
+                         (_.cdr/1 list))))
+      _.nil))
 
-(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"))))))
+(runtime: (lux//try op)
+  (with_vars [error]
+    (_.with_exception_handler
+      (_.lambda [(list error) #.None]
+                (..left error))
+      (_.lambda [(list) #.None]
+                (..right (_.apply/* (list ..unit) op))))))
 
-(def: runtime//bit
+(runtime: (lux//program_args program_args)
+  (with_vars [@loop @input @output]
+    (_.letrec (list [@loop (_.lambda [(list @input @output) #.None]
+                                     (_.if (_.null?/1 @input)
+                                       @output
+                                       (_.apply/2 @loop (_.cdr/1 @input) (..some (_.vector/* (list (_.car/1 @input) @output))))))])
+              (_.apply/2 @loop (_.reverse/1 program_args) ..none))))
+
+(def: runtime//lux
   Computation
-  (_.begin (list @i64//logical_right_shift)))
+  (_.begin (list @lux//try
+                 @lux//program_args)))
+
+(def: i64//+limit (_.manual "+9223372036854775807"
+                            ## "+0x7FFFFFFFFFFFFFFF"
+                            ))
+(def: i64//-limit (_.manual "-9223372036854775808"
+                            ## "-0x8000000000000000"
+                            ))
+(def: i64//+iteration (_.manual "+18446744073709551616"
+                                ## "+0x10000000000000000"
+                                ))
+(def: i64//-iteration (_.manual "-18446744073709551616"
+                                ## "-0x10000000000000000"
+                                ))
+(def: i64//+cap (_.manual "+9223372036854775808"
+                          ## "+0x8000000000000000"
+                          ))
+(def: i64//-cap (_.manual "-9223372036854775809"
+                          ## "-0x8000000000000001"
+                          ))
+
+(runtime: (i64//64 input)
+  (with_vars [temp]
+    (`` (<| (~~ (template [   ]
+                  [(_.if (|> input )
+                     (_.let (list [temp (_.remainder/2  input)])
+                       (_.if (|> temp )
+                         (|> temp (_.-/2 ) (_.+/2 ))
+                         temp)))]
+
+                  [(_.>/2 ..i64//+limit) ..i64//+iteration ..i64//+cap ..i64//-limit]
+                  [(_. subject
+      (_.arithmetic-shift/2 (_.remainder/2 (_.int +64) param))
+      ..i64//64))
+
+(def: as_nat
+  (_.remainder/2 ..i64//+iteration))
+
+(runtime: (i64//right_shift shift subject)
+  (_.let (list [shift (_.remainder/2 (_.int +64) shift)])
+    (_.if (_.=/2 (_.int +0) shift)
+      subject
+      (|> subject
+          ..as_nat
+          (_.arithmetic-shift/2 (_.-/2 shift (_.int +0)))))))
+
+(template [ ]
+  [(runtime: ( left right)
+     (..i64//64 ( (..as_nat left) (..as_nat right))))]
+
+  [i64//or _.bitwise-ior/2]
+  [i64//xor _.bitwise-xor/2]
+  [i64//and _.bitwise-and/2]
+  )
+
+(runtime: (i64//division param subject)
+  (|> subject (_.//2 param) _.truncate/1 ..i64//64))
 
-(runtime: (frac//decode input)
+(def: runtime//i64
+  Computation
+  (_.begin (list @i64//64
+                 @i64//left_shift
+                 @i64//right_shift
+                 @i64//or
+                 @i64//xor
+                 @i64//and
+                 @i64//division)))
+
+(runtime: (f64//decode 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
-        (..some @output)))))
+    (let [output_is_not_a_number? (_.not/1 (_.=/2 @output @output))
+          input_is_not_a_number? (_.string=?/2 (_.string "+nan.0") input)]
+      (_.let (list [@output (_.string->number/1 input)])
+        (_.if (_.and (list output_is_not_a_number?
+                           (_.not/1 input_is_not_a_number?)))
+          ..none
+          (..some @output))))))
+
+(def: runtime//f64
+  Computation
+  (_.begin (list @f64//decode)))
+
+(runtime: (text//index offset sub text)
+  (with_vars [index]
+    (_.let (list [index (_.string-contains/3 text sub offset)])
+      (_.if index
+        (..some index)
+        ..none))))
+
+(runtime: (text//clip offset length text)
+  (_.substring/3 text offset (_.+/2 offset length)))
+
+(runtime: (text//char index text)
+  (_.char->integer/1 (_.string-ref/2 text index)))
+
+(def: runtime//text
+  (_.begin (list @text//index
+                 @text//clip
+                 @text//char)))
+
+(runtime: (array//write idx value array)
+  (_.begin (list (_.vector-set!/3 array idx value)
+                 array)))
 
-(def: runtime//frac
+(def: runtime//array
   Computation
-  (_.begin
-   (list @frac//decode)))
+  ($_ _.then
+      @array//write
+      ))
 
 (runtime: (io//current_time _)
   (|> (_.apply/0 (_.var "current-second"))
       (_.*/2 (_.int +1,000))
-      _.exact/1))
+      _.exact/1
+      _.truncate/1))
 
 (def: runtime//io
   (_.begin (list @io//current_time)))
@@ -271,9 +358,11 @@
   Computation
   (_.begin (list @slice
                  runtime//lux
-                 runtime//bit
+                 runtime//i64
                  runtime//adt
-                 runtime//frac
+                 runtime//f64
+                 runtime//text
+                 runtime//array
                  runtime//io
                  )))
 
diff --git a/stdlib/source/lux/tool/compiler/meta/packager/script.lux b/stdlib/source/lux/tool/compiler/meta/packager/script.lux
index c874cfd88..95026ae37 100644
--- a/stdlib/source/lux/tool/compiler/meta/packager/script.lux
+++ b/stdlib/source/lux/tool/compiler/meta/packager/script.lux
@@ -54,10 +54,11 @@
                            (function (_ content)
                              (sequence so_far
                                        (:share [directive]
-                                               {directive
-                                                so_far}
-                                               {directive
-                                                (:assume content)}))))))
+                                               directive
+                                               so_far
+                                               
+                                               directive
+                                               (:assume content)))))))
                   so_far)))
 
 (def: #export (package header to_code sequence scope)
diff --git a/stdlib/source/lux/world/file.lux b/stdlib/source/lux/world/file.lux
index 52a56aa04..3b80a7ea8 100644
--- a/stdlib/source/lux/world/file.lux
+++ b/stdlib/source/lux/world/file.lux
@@ -1568,6 +1568,9 @@
                        ..default_separator)
                      ))
                )
+
+        @.scheme
+        (as_is)
         }))
 
 (template [    ]
diff --git a/stdlib/source/lux/world/program.lux b/stdlib/source/lux/world/program.lux
index d6fe4c2e3..0abdb2225 100644
--- a/stdlib/source/lux/world/program.lux
+++ b/stdlib/source/lux/world/program.lux
@@ -24,7 +24,9 @@
      ["." list ("#\." functor)]]]
    [math
     [number
-     ["i" int]]]]
+     ["i" int]]]
+   [type
+    abstract]]
   [//
    [file (#+ Path)]
    [shell (#+ Exit)]])
@@ -229,7 +231,18 @@
                ## https://www.php.net/manual/en/function.getenv.php
                ## https://www.php.net/manual/en/function.array-keys.php
                (host.import: (array_keys [(Array host.String)] (Array host.String)))
-               )}
+               )
+
+        @.scheme
+        (as_is (host.import: (exit [Int] #io Nothing))
+               ## https://srfi.schemers.org/srfi-98/srfi-98.html
+               (abstract: Pair Any)
+               (abstract: PList Any)
+               (host.import: (get-environment-variables [] #io PList))
+               (host.import: (car [Pair] Text))
+               (host.import: (cdr [Pair] Text))
+               (host.import: (car #as head [PList] Pair))
+               (host.import: (cdr #as tail [PList] PList)))}
        (as_is)))
 
 (structure: #export default
@@ -275,7 +288,16 @@
                               array.to_list
                               (list\map (function (_ variable)
                                           [variable ("php array read" (:coerce Nat variable) environment)]))
-                              (dictionary.from_list text.hash))))}
+                              (dictionary.from_list text.hash))))
+            @.scheme (do io.monad
+                       [input (..get-environment-variables [])]
+                       (loop [input input
+                              output environment.empty]
+                         (if ("scheme object nil?" input)
+                           (wrap output)
+                           (let [entry (..head input)]
+                             (recur (..tail input)
+                                    (dictionary.put (..car entry) (..cdr entry) output))))))}
            ## TODO: Replace dummy implementation.
            (io.io environment.empty))))
   
@@ -346,4 +368,5 @@
             @.python (os::_exit [code])
             @.lua (os/exit [code])
             @.ruby (RubyKernel::exit [code])
-            @.php (..exit [code])}))))
+            @.php (..exit [code])
+            @.scheme (..exit [code])}))))
diff --git a/stdlib/source/program/compositor.lux b/stdlib/source/program/compositor.lux
index a66022594..03e9b281d 100644
--- a/stdlib/source/program/compositor.lux
+++ b/stdlib/source/program/compositor.lux
@@ -78,15 +78,17 @@
           (#try.Success content)
           (do (try.with monad)
             [package (:share [!]
-                             {(Monad !)
-                              monad}
-                             {(! (Try (File !)))
-                              (:assume (file.get_file monad file_system package))})]
+                             (Monad !)
+                             monad
+                             
+                             (! (Try (File !)))
+                             (:assume (file.get_file monad file_system package)))]
             (!.use (\ (:share [!]
-                              {(Monad !)
-                               monad}
-                              {(File !)
-                               (:assume package)})
+                              (Monad !)
+                              monad
+                              
+                              (File !)
+                              (:assume package))
                       over_write)
                    [content]))
           
@@ -134,17 +136,19 @@
               [#let [[compilation_sources compilation_libraries compilation_target compilation_module] compilation]
                import (/import.import (get@ #platform.&file_system platform) compilation_libraries)
                [state archive] (:share []
-                                       {(Platform )
-                                        platform}
-                                       {(Promise (Try [(directive.State+ )
-                                                       Archive]))
-                                        (:assume (platform.initialize static compilation_module expander host_analysis platform generation_bundle host_directive_bundle program anchorT,expressionT,directiveT extender
-                                                                      import compilation_sources))})
+                                       (Platform )
+                                       platform
+                                       
+                                       (Promise (Try [(directive.State+ )
+                                                      Archive]))
+                                       (:assume (platform.initialize static compilation_module expander host_analysis platform generation_bundle host_directive_bundle program anchorT,expressionT,directiveT extender
+                                                                     import compilation_sources)))
                [archive state] (:share []
-                                       {(Platform )
-                                        platform}
-                                       {(Promise (Try [Archive (directive.State+ )]))
-                                        (:assume (platform.compile import static expander platform compilation [archive state]))})
+                                       (Platform )
+                                       platform
+                                       
+                                       (Promise (Try [Archive (directive.State+ )]))
+                                       (:assume (platform.compile import static expander platform compilation [archive state])))
                _ (ioW.freeze (get@ #platform.&file_system platform) static archive)
                program_context (promise\wrap ($/program.context archive))
                _ (promise.future (..package! io.monad file.default packager,package static archive program_context))]
diff --git a/stdlib/source/test/lux/extension.lux b/stdlib/source/test/lux/extension.lux
index cdd934e3e..8ff1cdc00 100644
--- a/stdlib/source/test/lux/extension.lux
+++ b/stdlib/source/test/lux/extension.lux
@@ -7,7 +7,8 @@
     ["." python]
     ["." lua]
     ["." ruby]
-    ["." php]]
+    ["." php]
+    ["." scheme]]
    [abstract
     [monad (#+ do)]]
    [control
@@ -69,7 +70,8 @@
                      @.python (python.unicode self)
                      @.lua (lua.string self)
                      @.ruby (ruby.string self)
-                     @.php (php.string self)})))))
+                     @.php (php.string self)
+                     @.scheme (scheme.string self)})))))
 
 (for {@.old
       (as_is)}
diff --git a/stdlib/source/test/lux/host.scm.lux b/stdlib/source/test/lux/host.scm.lux
new file mode 100644
index 000000000..0b6cac81b
--- /dev/null
+++ b/stdlib/source/test/lux/host.scm.lux
@@ -0,0 +1,24 @@
+(.module:
+  [lux #*
+   ["_" test (#+ Test)]
+   [abstract
+    [monad (#+ do)]]
+   [control
+    ["." try]]
+   [data
+    ["." text ("#\." equivalence)]]
+   [math
+    ["." random (#+ Random)]
+    [number
+     ["." nat]
+     ["." frac]]]]
+  {1
+   ["." /]})
+
+(def: #export test
+  Test
+  (do {! random.monad}
+    []
+    (<| (_.covering /._)
+        (_.test "TBD"
+                true))))
diff --git a/stdlib/source/test/lux/world/file.lux b/stdlib/source/test/lux/world/file.lux
index b59202972..002d76c42 100644
--- a/stdlib/source/test/lux/world/file.lux
+++ b/stdlib/source/test/lux/world/file.lux
@@ -35,40 +35,40 @@
   (let [millis +1,000]
     (|>> (i./ millis) (i.* millis))))
 
-(def: (creation_and_deletion number)
-  (-> Nat Test)
-  (random\wrap
-   (do promise.monad
-     [#let [path (format "temp_file_" (%.nat number))]
-      result (promise.future
-              (do (try.with io.monad)
-                [#let [check_existence! (: (IO (Try Bit))
-                                           (try.lift io.monad (/.exists? io.monad /.default path)))]
-                 pre! check_existence!
-                 file (!.use (\ /.default create_file) path)
-                 post! check_existence!
-                 _ (!.use (\ file delete) [])
-                 remains? check_existence!]
-                (wrap (and (not pre!)
-                           post!
-                           (not remains?)))))]
-     (_.assert "Can create/delete files."
-               (try.default #0 result)))))
+## (def: (creation_and_deletion number)
+##   (-> Nat Test)
+##   (random\wrap
+##    (do promise.monad
+##      [#let [path (format "temp_file_" (%.nat number))]
+##       result (promise.future
+##               (do (try.with io.monad)
+##                 [#let [check_existence! (: (IO (Try Bit))
+##                                            (try.lift io.monad (/.exists? io.monad /.default path)))]
+##                  pre! check_existence!
+##                  file (!.use (\ /.default create_file) path)
+##                  post! check_existence!
+##                  _ (!.use (\ file delete) [])
+##                  remains? check_existence!]
+##                 (wrap (and (not pre!)
+##                            post!
+##                            (not remains?)))))]
+##      (_.assert "Can create/delete files."
+##                (try.default #0 result)))))
 
-(def: (read_and_write number data)
-  (-> Nat Binary Test)
-  (random\wrap
-   (do promise.monad
-     [#let [path (format "temp_file_" (%.nat number))]
-      result (promise.future
-              (do (try.with io.monad)
-                [file (!.use (\ /.default create_file) path)
-                 _ (!.use (\ file over_write) data)
-                 content (!.use (\ file content) [])
-                 _ (!.use (\ file delete) [])]
-                (wrap (\ binary.equivalence = data content))))]
-     (_.assert "Can write/read files."
-               (try.default #0 result)))))
+## (def: (read_and_write number data)
+##   (-> Nat Binary Test)
+##   (random\wrap
+##    (do promise.monad
+##      [#let [path (format "temp_file_" (%.nat number))]
+##       result (promise.future
+##               (do (try.with io.monad)
+##                 [file (!.use (\ /.default create_file) path)
+##                  _ (!.use (\ file over_write) data)
+##                  content (!.use (\ file content) [])
+##                  _ (!.use (\ file delete) [])]
+##                 (wrap (\ binary.equivalence = data content))))]
+##      (_.assert "Can write/read files."
+##                (try.default #0 result)))))
 
 (def: #export test
   Test
-- 
cgit v1.2.3