aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorEduardo Julian2021-02-25 01:50:24 -0400
committerEduardo Julian2021-02-25 01:50:24 -0400
commit47b320b854a6f28621c5d5d118cac31db27e7c50 (patch)
tree5cace9a14e0800987c220dff5e03a02913645c05
parentae7fc0207c8d3281882261642f6a8e0579985aa0 (diff)
Updates for Ruby compiler.
-rw-r--r--compilers.md12
-rw-r--r--lux-bootstrapper/src/lux/analyser/parser.clj7
-rw-r--r--lux-python/source/program.lux5
-rw-r--r--lux-ruby/project.clj2
-rw-r--r--lux-ruby/source/program.lux479
-rw-r--r--stdlib/source/lux/target/ruby.lux256
-rw-r--r--stdlib/source/lux/tool/compiler/language/lux/phase/extension/analysis/ruby.lux34
-rw-r--r--stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux113
-rw-r--r--stdlib/source/lux/tool/compiler/language/lux/phase/generation/python.lux18
-rw-r--r--stdlib/source/lux/tool/compiler/language/lux/phase/generation/python/case.lux21
-rw-r--r--stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby.lux69
-rw-r--r--stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux258
-rw-r--r--stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux81
-rw-r--r--stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux45
-rw-r--r--stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/reference.lux15
-rw-r--r--stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux313
16 files changed, 991 insertions, 737 deletions
diff --git a/compilers.md b/compilers.md
index beba9dcc3..5aabf4445 100644
--- a/compilers.md
+++ b/compilers.md
@@ -245,8 +245,16 @@ cd ~/lux/lux-ruby/ && lein clean && lein lux auto test
## Build
```
-cd ~/lux/lux-ruby/ && lein lux auto build
-cd ~/lux/lux-ruby/ && lein clean && lein lux auto build
+## Develop
+cd ~/lux/lux-ruby/ \
+&& lein clean \
+&& lein lux auto build
+
+## Build JVM-based compiler
+cd ~/lux/lux-ruby/ \
+&& lein clean \
+&& lein lux build \
+&& mv target/program.jar jvm_based_compiler.jar
```
## Try
diff --git a/lux-bootstrapper/src/lux/analyser/parser.clj b/lux-bootstrapper/src/lux/analyser/parser.clj
index 6a46bab3c..15224573c 100644
--- a/lux-bootstrapper/src/lux/analyser/parser.clj
+++ b/lux-bootstrapper/src/lux/analyser/parser.clj
@@ -40,12 +40,15 @@
(return (&/|list head))))
state*))))
+(def ^:private class-name-regex
+ #"^([a-zA-Z0-9_\.$]+)")
+
(def ^:private parse-name
- (|do [[_ _ =name] (&reader/read-regex #"^([a-zA-Z0-9_\.]+)")]
+ (|do [[_ _ =name] (&reader/read-regex class-name-regex)]
(return =name)))
(def ^:private parse-name?
- (|do [[_ _ =name] (&reader/read-regex? #"^([a-zA-Z0-9_\.]+)")]
+ (|do [[_ _ =name] (&reader/read-regex? class-name-regex)]
(return =name)))
(def ^:private parse-ident
diff --git a/lux-python/source/program.lux b/lux-python/source/program.lux
index 166dee982..366395232 100644
--- a/lux-python/source/program.lux
+++ b/lux-python/source/program.lux
@@ -281,7 +281,10 @@
(wrap [global value definition]))))
(def: (ingest context content)
- (|> content (\ encoding.utf8 decode) try.assume (:coerce (_.Statement Any))))
+ (|> content
+ (\ encoding.utf8 decode)
+ try.assume
+ (:coerce (_.Statement Any))))
(def: (re_learn context content)
(execute! content))
diff --git a/lux-ruby/project.clj b/lux-ruby/project.clj
index c6cdfb6d9..88b172b40 100644
--- a/lux-ruby/project.clj
+++ b/lux-ruby/project.clj
@@ -22,7 +22,7 @@
:plugins [[com.github.luxlang/lein-luxc ~version]]
:dependencies [[com.github.luxlang/luxc-jvm ~version]
[com.github.luxlang/stdlib ~version]
- [org.jruby/jruby-complete "9.2.6.0"]]
+ [org.jruby/jruby-complete "9.2.15.0"]]
:manifest {"lux" ~version}
:source-paths ["source"]
diff --git a/lux-ruby/source/program.lux b/lux-ruby/source/program.lux
index 48a398233..e373e20b5 100644
--- a/lux-ruby/source/program.lux
+++ b/lux-ruby/source/program.lux
@@ -1,93 +1,131 @@
(.module:
[lux #*
+ [program (#+ program:)]
+ ["." host (#+ import:)]
+ ["." meta]
[abstract
["." monad (#+ do)]]
[control
- pipe
- [cli (#+ program:)]
- ["p" parser]
+ [pipe (#+ new>)]
+ ["." try (#+ Try)]
["." exception (#+ exception:)]
- ["." io (#+ IO io)]]
+ ["." io (#+ IO io)]
+ [concurrency
+ ["." promise (#+ Promise)]]
+ ["<>" parser
+ ["<.>" code]]]
[data
["." maybe]
- ["." error (#+ Error)]
- [number
- ["." i64]]
- ["." text ("#@." hash)
- format]
+ ["." text ("#\." hash)
+ ["%" format (#+ format)]
+ ["." encoding]]
[collection
- ["." array (#+ Array)]
- ["." list ("#@." functor)]]]
+ ["." array (#+ Array)]]]
["." macro
- ["s" syntax (#+ syntax:)]
- ["." code]
- ["." template]]
- [world
- ["." file]]
- ["." host (#+ import: interface: do-to object)
+ [syntax (#+ syntax:)]
+ ["." template]
+ ["." code]]
+ [math
+ [number
+ ["n" nat]
+ ["." i64]]]
+ ["." world #_
+ ["." file]
+ ["#/." program]]
+ ["@" target
["_" ruby]]
[tool
[compiler
- ["." name]
- ["." synthesis]
- [phase
- [macro (#+ Expander)]
- ["." generation
- ["." ruby
- ["." runtime]
- ["." extension]]]]
+ [phase (#+ Operation Phase)]
+ [reference
+ [variable (#+ Register)]]
+ [language
+ [lux
+ [program (#+ Program)]
+ [generation (#+ Context Host)]
+ ["." synthesis]
+ [analysis
+ [macro (#+ Expander)]]
+ [phase
+ ["." extension (#+ Bundle Extender Handler)
+ ["#/." bundle]
+ ["." analysis #_
+ ["#" ruby]]
+ ["." generation #_
+ ["#" ruby]]]
+ [generation
+ ["." reference]
+ ["." ruby
+ ["." runtime]]]]]]
[default
- ["." platform (#+ Platform)]]]]]
+ ["." platform (#+ Platform)]]
+ [meta
+ ["." packager #_
+ ["#" script]]]]]]
[program
["/" compositor
- ["/." cli]]])
+ ["/." cli]
+ ["/." static]]])
+
+(import: java/lang/String)
-(import: #long java/lang/String)
+(import: (java/lang/Class a))
-(import: #long (java/lang/Class a))
+(import: java/lang/Object
+ ["#::."
+ (toString [] java/lang/String)
+ (getClass [] (java/lang/Class java/lang/Object))])
-(import: #long java/lang/Object
- (toString [] java/lang/String)
- (getClass [] (java/lang/Class java/lang/Object)))
+(import: java/lang/Integer)
-(import: #long java/lang/Integer)
+(import: java/lang/Long
+ ["#::."
+ (intValue [] java/lang/Integer)])
-(import: #long java/lang/Long
- (intValue [] java/lang/Integer))
+(import: org/jruby/RubyArray
+ ["#::."
+ (getLength [] int)
+ (get [int] #? Object)])
-(import: #long org/jruby/RubyArray
- (getLength [] int)
- (get [int] #? Object))
+(import: org/jruby/RubyHash
+ ["#::."
+ (get [java/lang/Object] #? java/lang/Object)])
-(import: #long org/jruby/RubyHash
- (get [Object] #? Object))
+(import: org/jruby/Ruby
+ ["#::."
+ (getCurrentContext [] org/jruby/runtime/ThreadContext)])
-(import: #long org/jruby/runtime/builtin/IRubyObject)
+(import: org/jruby/runtime/builtin/IRubyObject)
-(import: #long org/jruby/runtime/ThreadContext)
+(import: org/jruby/runtime/ThreadContext)
(template [<name>]
- [(interface: <name>
+ [(host.interface: <name>
(getValue [] java/lang/Object))
(`` (import: (~~ (template.identifier ["program/" <name>]))
- (getValue [] java/lang/Object)))]
+ ["#::."
+ (getValue [] java/lang/Object)]))]
[StructureValue]
)
-(syntax: (method-inputs {input-classes (s.tuple (p.some s.any))})
- (monad.map @ (function (_ class)
- (do @
- [var (macro.gensym "input")]
- (wrap (code.record (list [var class])))))
- input-classes))
+(syntax: (method_inputs {input_classes (<code>.tuple (<>.some <code>.any))})
+ (monad.map meta.monad
+ (function (_ class)
+ (do meta.monad
+ [var (macro.gensym "input")]
+ (wrap (code.record (list [var class])))))
+ input_classes))
-(import: #long org/jruby/runtime/JavaSites$CheckedSites)
+(import: org/jruby/runtime/JavaSites$CheckedSites)
+(import: org/jruby/runtime/builtin/Variable)
+(import: org/jruby/runtime/builtin/InstanceVariables)
+(import: org/jruby/runtime/builtin/InternalVariables)
-(def: (lux-structure value)
+(def: (lux_structure value)
(-> (Array java/lang/Object) org/jruby/runtime/builtin/IRubyObject)
- (with-expansions [<checkers> (template [<name>]
+ (with_expansions [<checkers> (template [<name>]
[[<name> [] boolean]]
[isNil] [isTaint] [isClass] [isFrozen]
@@ -119,13 +157,26 @@
)
<placeholders> (template [<name> <inputs> <output>]
[(org/jruby/runtime/builtin/IRubyObject
- (<name> (~~ (method-inputs <inputs>)))
+ (<name> self (~~ (method_inputs <inputs>)))
<output>
(error! (template.text ["UNIMPLEMENTED METHOD: " <name>])))]
+ [getRuntime [] org/jruby/Ruby]
+ [copySpecialInstanceVariables [org/jruby/runtime/builtin/IRubyObject] void]
+ [syncVariables [org/jruby/runtime/builtin/IRubyObject] void]
+ [syncVariables [(java/util/List (org/jruby/runtime/builtin/Variable java/lang/Object))] void]
+ [dataWrapStruct [java/lang/Object] void]
+ [addFinalizer [org/jruby/runtime/builtin/IRubyObject] void]
+ [removeFinalizers [] void]
+ [getVariable [int] java/lang/Object]
+ [setVariable [int java/lang/Object] void]
+ [getVariableList [] (java/util/List (org/jruby/runtime/builtin/Variable java/lang/Object))]
+ [getVariableNameList [] (java/util/List java/lang/String)]
+ [getVariableCount [] int]
[getJavaClass [] (java/lang/Class java/lang/Object)]
[asJavaString [] java/lang/String]
[getInstanceVariables [] org/jruby/runtime/builtin/InstanceVariables]
+ [getInternalVariables [] org/jruby/runtime/builtin/InternalVariables]
[convertToInteger [] org/jruby/RubyInteger]
[convertToInteger [java/lang/String] org/jruby/RubyInteger]
[convertToInteger [int java/lang/String] org/jruby/RubyInteger]
@@ -164,10 +215,10 @@
java/lang/String]
org/jruby/runtime/builtin/IRubyObject]
- ## [checkCallMethod
- ## [org/jruby/runtime/ThreadContext
- ## org/jruby/runtime/JavaSites$CheckedSites]
- ## org/jruby/runtime/builtin/IRubyObject]
+ [checkCallMethod
+ [org/jruby/runtime/ThreadContext
+ org/jruby/runtime/JavaSites$CheckedSites]
+ org/jruby/runtime/builtin/IRubyObject]
<checkers>
<markers>
@@ -175,219 +226,297 @@
<class>
<call>
)]
- (`` (object [] [program/StructureValue
- org/jruby/runtime/builtin/IRubyObject]
+ (`` (host.object [] [program/StructureValue
+ org/jruby/runtime/builtin/IRubyObject]
[]
## Methods
(program/StructureValue
- (getValue)
+ [] (getValue self)
java/lang/Object
(:coerce (Array java/lang/Object) value))
(org/jruby/runtime/builtin/IRubyObject
- (callMethod {thread-context org/jruby/runtime/ThreadContext}
- {member java/lang/String}
- {inputs [org/jruby/runtime/builtin/IRubyObject]})
+ [] (callMethod self
+ {thread_context org/jruby/runtime/ThreadContext}
+ {member java/lang/String}
+ {inputs [org/jruby/runtime/builtin/IRubyObject]})
org/jruby/runtime/builtin/IRubyObject
(exec
- (log! (format "Was called: " (%t member)))
+ ("lux io log" (format "Was called: " (%.text member)))
(error! "OOPS!")))
<placeholders>
))))
-(import: #long org/jruby/RubyProc
- (call [org/jruby/runtime/ThreadContext [org/jruby/runtime/builtin/IRubyObject]]
- org/jruby/runtime/builtin/IRubyObject))
+(import: org/jruby/RubyProc
+ ["#::."
+ (call [org/jruby/runtime/ThreadContext [org/jruby/runtime/builtin/IRubyObject]]
+ #try org/jruby/runtime/builtin/IRubyObject)])
-(import: #long org/jruby/Ruby
- (getCurrentContext [] org/jruby/runtime/ThreadContext))
-
-(import: #long org/jruby/javasupport/JavaArray
- (new [org/jruby/Ruby java/lang/Object]))
+(import: org/jruby/javasupport/JavaArray
+ ["#::."
+ (new [org/jruby/Ruby java/lang/Object])])
(type: Translator
- (-> java/lang/Object (Error Any)))
+ (-> java/lang/Object (Try Any)))
-(def: (read-tuple read host-object)
- (-> Translator org/jruby/RubyArray (Error Any))
- (let [size (:coerce Nat (org/jruby/RubyArray::getLength host-object))]
+(def: (read_tuple read host_object)
+ (-> Translator org/jruby/RubyArray (Try Any))
+ (let [size (:coerce Nat (org/jruby/RubyArray::getLength host_object))]
(loop [idx 0
output (:coerce (Array Any) (array.new size))]
- (if (n/< size idx)
- (case (org/jruby/RubyArray::get (.int idx) host-object)
+ (if (n.< size idx)
+ (case (org/jruby/RubyArray::get (.int idx) host_object)
#.None
(recur (inc idx) output)
(#.Some value)
(case (read value)
- (#error.Failure error)
- (#error.Failure error)
+ (#try.Failure error)
+ (#try.Failure error)
- (#error.Success lux-value)
- (recur (inc idx) (array.write idx lux-value output))))
- (#error.Success output)))))
+ (#try.Success lux_value)
+ (recur (inc idx) (array.write! idx lux_value output))))
+ (#try.Success output)))))
-(exception: (unknown-kind-of-object {object java/lang/Object})
+(exception: (unknown_kind_of_object {object java/lang/Object})
(exception.report
["Class" (java/lang/Object::toString (java/lang/Object::getClass object))]
["Object" (java/lang/Object::toString object)]))
-(def: (read-variant read host-object)
- (-> Translator org/jruby/RubyHash (Error Any))
- (case [(org/jruby/RubyHash::get runtime.variant-tag-field host-object)
- (org/jruby/RubyHash::get runtime.variant-flag-field host-object)
- (org/jruby/RubyHash::get runtime.variant-value-field host-object)]
+(def: (read_variant read host_object)
+ (-> Translator org/jruby/RubyHash (Try Any))
+ (case [(org/jruby/RubyHash::get runtime.variant_tag_field host_object)
+ (org/jruby/RubyHash::get runtime.variant_flag_field host_object)
+ (org/jruby/RubyHash::get runtime.variant_value_field host_object)]
(^multi [(#.Some tag) ?flag (#.Some value)]
[(read value)
(#.Some value)])
- (#error.Success [(java/lang/Long::intValue (:coerce java/lang/Long tag))
- (: Any (case ?flag
- (#.Some _)
- ""
+ (#try.Success [(java/lang/Long::intValue (:coerce java/lang/Long tag))
+ (: Any (case ?flag
+ (#.Some _)
+ ""
- #.None
- (host.null)))
- value])
+ #.None
+ (host.null)))
+ value])
_
- (exception.throw ..unknown-kind-of-object host-object)))
+ (exception.throw ..unknown_kind_of_object host_object)))
-(exception: #export nil-has-no-lux-representation)
+(exception: #export nil_has_no_lux_representation)
-(def: (read host-object)
+(def: (read host_object)
Translator
- (`` (<| (if (host.null? host-object)
- (exception.throw nil-has-no-lux-representation []))
- (~~ (template [<class> <post-processing>]
- [(case (host.check <class> host-object)
- (#.Some typed-object)
- (|> typed-object <post-processing>)
+ (`` (<| (if (host.null? host_object)
+ (exception.throw ..nil_has_no_lux_representation []))
+ (~~ (template [<class> <post_processing>]
+ [(case (host.check <class> host_object)
+ (#.Some typed_object)
+ (|> typed_object <post_processing>)
_)]
- [java/lang/Boolean #error.Success]
- [java/lang/Long #error.Success]
- [java/lang/Double #error.Success]
- [java/lang/String #error.Success]
- [org/jruby/RubyArray (read-tuple read)]
- [org/jruby/RubyHash (read-variant read)]
- [org/jruby/RubySymbol #error.Success]
- [org/jruby/RubyProc #error.Success]
+ [java/lang/Boolean #try.Success]
+ [java/lang/Long #try.Success]
+ [java/lang/Double #try.Success]
+ [java/lang/String #try.Success]
+ [org/jruby/RubyArray (read_tuple read)]
+ [org/jruby/RubyHash (read_variant read)]
+ [org/jruby/RubySymbol #try.Success]
+ [org/jruby/RubyProc #try.Success]
))
- (exception.throw ..unknown-kind-of-object host-object)
+ (exception.throw ..unknown_kind_of_object host_object)
)))
-(exception: (cannot-apply-a-non-function {object java/lang/Object})
+(exception: (cannot_apply_a_non_function {object java/lang/Object})
(exception.report
["Non-function" (java/lang/Object::toString object)]))
-(import: #long org/jruby/embed/internal/LocalContextProvider
- (getRuntime [] org/jruby/Ruby))
+(import: org/jruby/embed/internal/LocalContextProvider
+ ["#::."
+ (getRuntime [] org/jruby/Ruby)])
-(import: #long org/jruby/embed/ScriptingContainer
- (new [])
- (runScriptlet [java/lang/String] #try #? java/lang/Object)
- (getProvider [] org/jruby/embed/internal/LocalContextProvider))
+(import: org/jruby/embed/ScriptingContainer
+ ["#::."
+ (new [])
+ (runScriptlet [java/lang/String] #try #? java/lang/Object)
+ (getProvider [] org/jruby/embed/internal/LocalContextProvider)])
## TODO; Figure out a way to not need "interpreter" to be a global variable.
(def: interpreter (org/jruby/embed/ScriptingContainer::new))
-(def: ensure-macro
+(def: ensure_macro
(-> Macro (Maybe org/jruby/RubyProc))
(|>> (:coerce java/lang/Object) (host.check org/jruby/RubyProc)))
-(template: (!ruby-runtime)
+(template: (!ruby_runtime)
(|> ..interpreter
org/jruby/embed/ScriptingContainer::getProvider
org/jruby/embed/internal/LocalContextProvider::getRuntime))
-(template: (!ruby-thread-context)
- (|> (!ruby-runtime)
+(template: (!ruby_thread_context)
+ (|> (!ruby_runtime)
org/jruby/Ruby::getCurrentContext))
-(def: to-host
+(def: to_host
(-> Any org/jruby/runtime/builtin/IRubyObject)
(|>> (:coerce (Array java/lang/Object))
- ..lux-structure
- ## (org/jruby/javasupport/JavaArray::new (!ruby-runtime))
+ ..lux_structure
+ ## (org/jruby/javasupport/JavaArray::new (!ruby_runtime))
))
-(def: (call-macro inputs lux macro)
- (-> (List Code) Lux org/jruby/RubyProc (Error (Error [Lux (List Code)])))
- (<| :assume
- ..read
- (:coerce java/lang/Object)
- (org/jruby/RubyProc::call (!ruby-thread-context)
- (|> (host.array org/jruby/runtime/builtin/IRubyObject 2)
- (host.array-write 0 (..to-host inputs))
- (host.array-write 1 (..to-host lux)))
- macro)))
+(def: (call_macro inputs lux macro)
+ (-> (List Code) Lux org/jruby/RubyProc (Try (Try [Lux (List Code)])))
+ (:assume
+ (do try.monad
+ [expansion (org/jruby/RubyProc::call (!ruby_thread_context)
+ (|> (host.array org/jruby/runtime/builtin/IRubyObject 2)
+ (host.array_write 0 (..to_host inputs))
+ (host.array_write 1 (..to_host lux)))
+ macro)]
+ (..read (:coerce java/lang/Object expansion)))))
(def: (expander macro inputs lux)
Expander
- (case (ensure-macro macro)
+ (case (ensure_macro macro)
(#.Some macro)
- (case (call-macro inputs lux macro)
- (#error.Success output)
+ (case (call_macro inputs lux macro)
+ (#try.Success output)
(|> output
(:coerce java/lang/Object)
..read
- (:coerce (Error (Error [Lux (List Code)]))))
+ (:coerce (Try (Try [Lux (List Code)]))))
- (#error.Failure error)
- (#error.Failure error))
+ (#try.Failure error)
+ (#try.Failure error))
#.None
- (exception.throw cannot-apply-a-non-function (:coerce java/lang/Object macro))))
+ (exception.throw ..cannot_apply_a_non_function (:coerce java/lang/Object macro))))
(def: separator "___")
-(type: Host
- (generation.Host (_.Expression Any) (_.Statement Any)))
-
(def: host
- (IO Host)
- (io (let [run! (: (-> Text (_.Code Any) (Error Any))
- (function (_ dummy-name code)
- (do error.monad
+ (IO (Host _.Expression _.Statement))
+ (io (let [run! (: (-> (_.Code Any) (Try Any))
+ (function (_ code)
+ (do try.monad
[output (org/jruby/embed/ScriptingContainer::runScriptlet (_.code code) ..interpreter)]
(..read (maybe.default (:coerce java/lang/Object [])
output)))))]
- (: Host
+ (: (Host _.Expression _.Statement)
(structure
- (def: evaluate! run!)
+ (def: (evaluate! context code)
+ (run! code))
+
(def: execute! run!)
- (def: (define! [module name] input)
- (let [global (format (text.replace-all .module-separator ..separator module)
- ..separator (name.normalize name)
- "___" (%n (text@hash name)))
+
+ (def: (define! context input)
+ (let [global (reference.artifact context)
@global (_.global global)]
- (do error.monad
+ (do try.monad
[#let [definition (_.set (list @global) input)]
- _ (run! global definition)
- value (run! global @global)]
- (wrap [global value definition])))))))))
+ _ (run! definition)
+ value (run! @global)]
+ (wrap [global value definition]))))
+
+ (def: (ingest context content)
+ (|> content
+ (\ encoding.utf8 decode)
+ try.assume
+ (:coerce _.Statement)))
+
+ (def: (re_learn context content)
+ (run! content))
+
+ (def: (re_load context content)
+ (do try.monad
+ [_ (run! content)]
+ (run! (_.global (reference.artifact context))))))))))
(def: platform
- (IO (Platform IO _.LVar (_.Expression Any) (_.Statement Any)))
+ (IO (Platform _.LVar _.Expression _.Statement))
(do io.monad
[host ..host]
- (wrap {#platform.&monad io.monad
- #platform.&file-system file.system
+ (wrap {#platform.&file_system (file.async file.default)
#platform.host host
#platform.phase ruby.generate
- #platform.runtime runtime.generate})))
+ #platform.runtime runtime.generate
+ #platform.write (|>> _.code (\ encoding.utf8 encode))})))
-(def: (program program)
- (-> (_.Expression Any) (_.Statement Any))
- (_.statement (_.apply/* (list (runtime.lux//program-args _.command-line-arguments)
+(def: (program context program)
+ (Program _.Expression _.Statement)
+ (_.statement (_.apply/* (list (runtime.lux//program_args _.command_line_arguments)
_.nil)
program)))
+(import: org/jruby/RubyString
+ ["#::."
+ (#static newInternalFromJavaExternal [org/jruby/Ruby java/lang/String] org/jruby/RubyString)])
+
+(def: extender
+ Extender
+ ## TODO: Stop relying on coercions ASAP.
+ (<| (:coerce Extender)
+ (function (@self handler))
+ (:coerce Handler)
+ (function (@self name phase))
+ (:coerce Phase)
+ (function (@self archive parameters))
+ (:coerce Operation)
+ (function (@self state))
+ (:coerce Try)
+ try.assume
+ (:coerce Try)
+ (do try.monad
+ [handler (try.from_maybe (..ensure_macro handler))
+ output (org/jruby/RubyProc::call (!ruby_thread_context)
+ (|> (host.array org/jruby/runtime/builtin/IRubyObject 5)
+ (host.array_write 0 (org/jruby/RubyString::newInternalFromJavaExternal (!ruby_runtime) name))
+ (host.array_write 1 (..to_host phase))
+ (host.array_write 2 (..to_host archive))
+ (host.array_write 3 (..to_host parameters))
+ (host.array_write 4 (..to_host state)))
+ handler)]
+ (..read (:coerce java/lang/Object output)))))
+
+(def: (declare_success! _)
+ (-> Any (Promise Any))
+ (promise.future (\ world/program.default exit +0)))
+
+(def: (scope body!)
+ (-> _.Statement _.Statement)
+ (let [@program (_.local "lux_program")]
+ ($_ _.then
+ (_.function @program (list) body!)
+ (_.statement (_.apply/* (list) @program))
+ )))
+
(program: [{service /cli.service}]
- (/.compiler ..expander
- ..platform
- extension.bundle
- ..program
- service))
+ (let [extension ".rb"]
+ (exec (do promise.monad
+ [_ (/.compiler {#/static.host @.ruby
+ #/static.host_module_extension extension
+ #/static.target (/cli.target service)
+ #/static.artifact_extension extension}
+ ..expander
+ analysis.bundle
+ ..platform
+ generation.bundle
+ extension/bundle.empty
+ ..program
+ [_.LVar
+ _.Expression
+ _.Statement]
+ ..extender
+ service
+ [(packager.package (: _.Statement (_.manual ""))
+ _.code
+ _.then
+ ..scope)
+ (format (/cli.target service)
+ (\ file.default separator)
+ "program"
+ extension)])]
+ (..declare_success! []))
+ (io.io []))))
diff --git a/stdlib/source/lux/target/ruby.lux b/stdlib/source/lux/target/ruby.lux
index e1df6bba6..c170f3504 100644
--- a/stdlib/source/lux/target/ruby.lux
+++ b/stdlib/source/lux/target/ruby.lux
@@ -1,26 +1,40 @@
(.module:
- [lux (#- Code Global static int if cond function or and not comment)
+ [lux (#- Location Code static int if cond function or and not comment)
+ ["@" target]
+ ["." host]
[control
[pipe (#+ case> cond> new>)]]
[data
- [number
- ["f" frac]]
["." text
["%" format (#+ format)]]
[collection
["." list ("#\." functor fold)]]]
[macro
["." template]]
+ [math
+ [number
+ ["f" frac]]]
[type
abstract]])
-(def: input-separator ", ")
-(def: statement-suffix ";")
+(def: input_separator ", ")
+(def: statement_suffix ";")
+
+(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)
- (|>> (format text.new-line)
- (text.replace-all text.new-line (format text.new-line text.tab))))
+ (.let [nested_new_line (format text.new_line text.tab)]
+ (for {@.old (|>> (format text.new_line)
+ (:coerce java/lang/String)
+ (java/lang/String::replace (:coerce java/lang/CharSequence text.new_line)
+ (:coerce java/lang/CharSequence nested_new_line)))}
+ (|>> (format text.new_line)
+ (text.replace_all text.new_line nested_new_line)))))
(abstract: #export (Code brand)
Text
@@ -33,82 +47,76 @@
(-> (Code Any) Text)
(|>> :representation))
- (template [<type> <super>]
- [(with-expansions [<brand> (template.identifier [<type> "'"])]
- (`` (abstract: #export (<brand> brand) Any))
- (`` (type: #export (<type> brand)
- (<super> (<brand> brand)))))]
+ (template [<type> <super>+]
+ [(with_expansions [<brand> (template.identifier [<type> "'"])]
+ (abstract: (<brand> brand) Any)
+ (`` (type: #export <type> (|> Any <brand> (~~ (template.splice <super>+))))))]
- [Expression Code]
- [Computation Expression]
- [Location Computation]
- [Var Location]
- [Statement Code]
+ [Expression [Code]]
+ [Computation [Expression' Code]]
+ [Location [Computation' Expression' Code]]
+ [Var [Location' Computation' Expression' Code]]
+ [LVar [Var' Location' Computation' Expression' Code]]
+ [Statement [Code]]
)
- (template [<type> <super>]
- [(with-expansions [<brand> (template.identifier [<type> "'"])]
- (`` (abstract: #export <brand> Any))
- (`` (type: #export <type> (<super> <brand>))))]
-
- [Literal Computation]
- [Access Location]
+ (template [<type> <super>+]
+ [(with_expansions [<brand> (template.identifier [<type> "'"])]
+ (abstract: #export <brand> Any)
+ (`` (type: #export <type> (|> <brand> (~~ (template.splice <super>+))))))]
+
+ [Literal [Computation' Expression' Code]]
+ [Access [Location' Computation' Expression' Code]]
+ [GVar [Var' Location' Computation' Expression' Code]]
+ [IVar [Var' Location' Computation' Expression' Code]]
+ [SVar [Var' Location' Computation' Expression' Code]]
+ [LVar* [LVar' Var' Location' Computation' Expression' Code]]
+ [LVar** [LVar' Var' Location' Computation' Expression' Code]]
)
- (template [<var> <brand> <prefix> <constructor>]
- [(abstract: #export <brand> Any)
-
- (type: #export <var> (Var <brand>))
-
- (def: #export <constructor>
+ (template [<var> <prefix> <constructor>]
+ [(def: #export <constructor>
(-> Text <var>)
(|>> (format <prefix>) :abstraction))]
- [GVar Global "$" global]
- [IVar Instance "@" instance]
- [SVar Static "@@" static]
+ [GVar "$" global]
+ [IVar "@" instance]
+ [SVar "@@" static]
)
- (abstract: #export (Local brand) Any)
- (type: #export LVar (Var (Local Any)))
-
(def: #export local
(-> Text LVar)
(|>> :abstraction))
- (template [<var> <brand> <prefix> <modifier> <unpacker>]
- [(abstract: #export <brand> Any)
-
- (type: #export <var> (Var (Local <brand>)))
-
- (template [<name> <input> <output>]
+ (template [<var> <prefix> <modifier> <unpacker>]
+ [(template [<name> <input> <output>]
[(def: #export <name>
(-> <input> <output>)
(|>> :representation (format <prefix>) :abstraction))]
[<modifier> LVar <var>]
- [<unpacker> (Expression Any) (Computation Any)]
+ [<unpacker> Expression Computation]
)]
- [LVar* Poly "*" variadic splat]
- [LVar** PolyKV "**" variadic-kv double-splat]
+ [LVar* "*" variadic splat]
+ [LVar** "**" variadic_kv double_splat]
)
- (template [<ruby-name> <lux-name>]
- [(def: #export <lux-name> (..global <ruby-name>))]
-
- ["@" latest-error]
- ["_" last-string-read]
- ["." last-line-number-read]
- ["&" last-string-matched]
- ["~" last-regexp-match]
- ["=" case-insensitivity-flag]
- ["/" input-record-separator]
- ["\" output-record-separator]
- ["0" script-name]
- ["*" command-line-arguments]
- ["$" process-id]
- ["?" exit-status]
+ (template [<ruby_name> <lux_name>]
+ [(def: #export <lux_name> (..global <ruby_name>))]
+
+ ["@" latest_error]
+ ["_" last_string_read]
+ ["." last_line_number_read]
+ ["&" last_string_matched]
+ ["~" last_regexp_match]
+ ["=" case_insensitivity_flag]
+ ["/" input_record_separator]
+ ["\" output_record_separator]
+ ["0" script_name]
+ ["*" command_line_arguments]
+ ["$" process_id]
+ ["?" exit_status]
)
(def: #export nil
@@ -124,17 +132,17 @@
(def: sanitize
(-> Text Text)
(`` (|>> (~~ (template [<find> <replace>]
- [(text.replace-all <find> <replace>)]
+ [(text.replace_all <find> <replace>)]
["\" "\\"]
[text.tab "\t"]
- [text.vertical-tab "\v"]
+ [text.vertical_tab "\v"]
[text.null "\0"]
- [text.back-space "\b"]
- [text.form-feed "\f"]
- [text.new-line "\n"]
- [text.carriage-return "\r"]
- [text.double-quote (format "\" text.double-quote)]
+ [text.back_space "\b"]
+ [text.form_feed "\f"]
+ [text.new_line "\n"]
+ [text.carriage_return "\r"]
+ [text.double_quote (format "\" text.double_quote)]
))
)))
@@ -149,63 +157,63 @@
(def: #export float
(-> Frac Literal)
- (|>> (cond> [(f.= f.positive-infinity)]
+ (|>> (cond> [(f.= f.positive_infinity)]
[(new> "(+1.0/0.0)" [])]
- [(f.= f.negative-infinity)]
+ [(f.= f.negative_infinity)]
[(new> "(-1.0/0.0)" [])]
- [(f.= f.not-a-number)]
+ [(f.= f.not_a_number)]
[(new> "(+0.0/-0.0)" [])]
## else
[%.frac])
:abstraction))
- (def: #export (array-range from to array)
- (-> (Expression Any) (Expression Any) (Expression Any) (Computation Any))
+ (def: #export (array_range from to array)
+ (-> Expression Expression Expression Computation)
(|> (format (:representation from) ".." (:representation to))
(text.enclose ["[" "]"])
(format (:representation array))
:abstraction))
(def: #export array
- (-> (List (Expression Any)) Literal)
+ (-> (List Expression) Literal)
(|>> (list\map (|>> :representation))
- (text.join-with ..input-separator)
+ (text.join_with ..input_separator)
(text.enclose ["[" "]"])
:abstraction))
(def: #export hash
- (-> (List [(Expression Any) (Expression Any)]) Literal)
+ (-> (List [Expression Expression]) Literal)
(|>> (list\map (.function (_ [k v])
(format (:representation k) " => " (:representation v))))
- (text.join-with ..input-separator)
+ (text.join_with ..input_separator)
(text.enclose ["{" "}"])
:abstraction))
(def: #export (apply/* args func)
- (-> (List (Expression Any)) (Expression Any) (Computation Any))
+ (-> (List Expression) Expression Computation)
(|> args
(list\map (|>> :representation))
- (text.join-with ..input-separator)
+ (text.join_with ..input_separator)
(text.enclose ["(" ")"])
(format (:representation func))
:abstraction))
(def: #export (the field object)
- (-> Text (Expression Any) Access)
+ (-> Text Expression Access)
(:abstraction (format (:representation object) "." field)))
(def: #export (nth idx array)
- (-> (Expression Any) (Expression Any) Access)
+ (-> Expression Expression Access)
(|> (:representation idx)
(text.enclose ["[" "]"])
(format (:representation array))
:abstraction))
(def: #export (? test then else)
- (-> (Expression Any) (Expression Any) (Expression Any) (Computation Any))
+ (-> Expression Expression Expression Computation)
(|> (format (:representation test) " ? "
(:representation then) " : "
(:representation else))
@@ -213,92 +221,92 @@
:abstraction))
(def: #export statement
- (-> (Expression Any) (Statement Any))
+ (-> Expression Statement)
(|>> :representation
- (text.suffix ..statement-suffix)
+ (text.suffix ..statement_suffix)
:abstraction))
(def: #export (then pre! post!)
- (-> (Statement Any) (Statement Any) (Statement Any))
+ (-> Statement Statement Statement)
(:abstraction
(format (:representation pre!)
- text.new-line
+ text.new_line
(:representation post!))))
(def: #export (set vars value)
- (-> (List (Location Any)) (Expression Any) (Statement Any))
+ (-> (List Location) Expression Statement)
(:abstraction
(format (|> vars
(list\map (|>> :representation))
- (text.join-with ..input-separator))
- " = " (:representation value) ..statement-suffix)))
+ (text.join_with ..input_separator))
+ " = " (:representation value) ..statement_suffix)))
(def: (block content)
(-> Text Text)
(format content
- text.new-line "end" ..statement-suffix))
+ text.new_line "end" ..statement_suffix))
(def: #export (if test then! else!)
- (-> (Expression Any) (Statement Any) (Statement Any) (Statement Any))
+ (-> Expression Statement Statement Statement)
(<| :abstraction
..block
(format "if " (:representation test)
- text.new-line (..nest (:representation then!))
- text.new-line "else"
- text.new-line (..nest (:representation else!)))))
+ text.new_line (..nest (:representation then!))
+ text.new_line "else"
+ text.new_line (..nest (:representation else!)))))
(template [<name> <block>]
[(def: #export (<name> test then!)
- (-> (Expression Any) (Statement Any) (Statement Any))
+ (-> Expression Statement Statement)
(<| :abstraction
..block
(format <block> " " (:representation test)
- text.new-line (..nest (:representation then!)))))]
+ text.new_line (..nest (:representation then!)))))]
[when "if"]
[while "while"]
)
- (def: #export (for-in var array iteration!)
- (-> LVar (Expression Any) (Statement Any) (Statement Any))
+ (def: #export (for_in var array iteration!)
+ (-> LVar Expression Statement Statement)
(<| :abstraction
..block
(format "for " (:representation var)
" in " (:representation array)
" do "
- text.new-line (..nest (:representation iteration!)))))
+ text.new_line (..nest (:representation iteration!)))))
(type: #export Rescue
{#classes (List Text)
#exception LVar
- #rescue (Statement Any)})
+ #rescue Statement})
(def: #export (begin body! rescues)
- (-> (Statement Any) (List Rescue) (Statement Any))
+ (-> Statement (List Rescue) Statement)
(<| :abstraction
..block
(format "begin"
- text.new-line (:representation body!)
+ text.new_line (:representation body!)
(|> rescues
(list\map (.function (_ [classes exception rescue])
- (format text.new-line "rescue " (text.join-with ..input-separator classes)
+ (format text.new_line "rescue " (text.join_with ..input_separator classes)
" => " (:representation exception)
- text.new-line (..nest (:representation rescue)))))
- (text.join-with text.new-line)))))
+ text.new_line (..nest (:representation rescue)))))
+ (text.join_with text.new_line)))))
(def: #export (return value)
- (-> (Expression Any) (Statement Any))
- (:abstraction (format "return " (:representation value) ..statement-suffix)))
+ (-> Expression Statement)
+ (:abstraction (format "return " (:representation value) ..statement_suffix)))
(def: #export (raise message)
- (-> (Expression Any) (Computation Any))
+ (-> Expression Computation)
(:abstraction (format "raise " (:representation message))))
(template [<name> <keyword>]
[(def: #export <name>
- (Statement Any)
+ Statement
(|> <keyword>
- (text.suffix ..statement-suffix)
+ (text.suffix ..statement_suffix)
:abstraction))]
[next "next"]
@@ -307,21 +315,21 @@
)
(def: #export (function name args body!)
- (-> LVar (List (Var Any)) (Statement Any) (Statement Any))
+ (-> LVar (List Var) Statement Statement)
(<| :abstraction
..block
(format "def " (:representation name)
(|> args
(list\map (|>> :representation))
- (text.join-with ..input-separator)
+ (text.join_with ..input_separator)
(text.enclose ["(" ")"]))
- text.new-line (:representation body!))))
+ text.new_line (:representation body!))))
(def: #export (lambda name args body!)
- (-> (Maybe LVar) (List (Var Any)) (Statement Any) Literal)
+ (-> (Maybe LVar) (List Var) Statement Literal)
(let [proc (|> (format (|> args
(list\map (|>> :representation))
- (text.join-with ..input-separator)
+ (text.join_with ..input_separator)
(text.enclose' "|"))
" "
(:representation body!))
@@ -338,7 +346,7 @@
(template [<op> <name>]
[(def: #export (<name> parameter subject)
- (-> (Expression Any) (Expression Any) (Computation Any))
+ (-> Expression Expression Computation)
(:abstraction (format "(" (:representation subject) " " <op> " " (:representation parameter) ")")))]
["==" =]
@@ -356,30 +364,30 @@
["||" or]
["&&" and]
- [ "|" bit-or]
- [ "&" bit-and]
- [ "^" bit-xor]
+ [ "|" bit_or]
+ [ "&" bit_and]
+ [ "^" bit_xor]
- ["<<" bit-shl]
- [">>" bit-shr]
+ ["<<" bit_shl]
+ [">>" bit_shr]
)
(def: #export (not subject)
- (-> (Expression Any) (Computation Any))
+ (-> Expression Computation)
(:abstraction (format "(!" (:representation subject) ")")))
(def: #export (comment commentary on)
(All [brand] (-> Text (Code brand) (Code brand)))
- (:abstraction (format "# " (..sanitize commentary) text.new-line
+ (:abstraction (format "# " (..sanitize commentary) text.new_line
(:representation on))))
)
(def: #export (do method args object)
- (-> Text (List (Expression Any)) (Expression Any) (Computation Any))
+ (-> Text (List Expression) Expression Computation)
(|> object (..the method) (..apply/* args)))
(def: #export (cond clauses else!)
- (-> (List [(Expression Any) (Statement Any)]) (Statement Any) (Statement Any))
+ (-> (List [Expression Statement]) Statement Statement)
(list\fold (.function (_ [test then!] next!)
(..if test then! next!))
else!
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/analysis/ruby.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/analysis/ruby.lux
new file mode 100644
index 000000000..3b9f4ad75
--- /dev/null
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/analysis/ruby.lux
@@ -0,0 +1,34 @@
+(.module:
+ [lux #*
+ ["." host]
+ [abstract
+ ["." monad (#+ do)]]
+ [control
+ ["<>" parser
+ ["<c>" code (#+ Parser)]]]
+ [data
+ [collection
+ ["." array (#+ Array)]
+ ["." dictionary]
+ ["." list]]]
+ ["." type
+ ["." check]]
+ ["@" target
+ ["_" ruby]]]
+ [//
+ ["/" lux (#+ custom)]
+ [//
+ ["." bundle]
+ [//
+ ["." analysis #_
+ ["#/." type]]
+ [//
+ ["." analysis (#+ Analysis Operation Phase Handler Bundle)]
+ [///
+ ["." phase]]]]]])
+
+(def: #export bundle
+ Bundle
+ (<| (bundle.prefix "ruby")
+ (|> bundle.empty
+ )))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux
index 0ab831668..d43f3833a 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux
@@ -3,64 +3,88 @@
[abstract
["." monad (#+ do)]]
[control
- ["." function]]
+ ["." function]
+ ["." try]
+ ["<>" parser
+ ["<s>" synthesis (#+ Parser)]]]
[data
["." product]
- ["." text]
- [number
- ["f" frac]]
+ ["." text
+ ["%" format (#+ format)]]
[collection
- ["." dictionary]]]
+ ["." dictionary]
+ ["." list ("#\." functor fold)]]]
+ [math
+ [number
+ ["f" frac]]]
[target
["_" ruby (#+ Expression)]]]
- [////
+ ["." //// #_
["/" bundle]
- [//
+ ["/#" // #_
+ ["." extension]
[generation
[extension (#+ Nullary Unary Binary Trinary
nullary unary binary trinary)]
["//" ruby #_
- ["#." runtime (#+ Operation Phase Handler Bundle)]]]]])
+ ["#." runtime (#+ Operation Phase Handler Bundle Generator)]]]
+ [//
+ [synthesis (#+ %synthesis)]
+ ["." generation]
+ [///
+ ["#" phase]]]]])
+
+(def: #export (custom [parser handler])
+ (All [s]
+ (-> [(Parser s)
+ (-> Text (Generator s))]
+ Handler))
+ (function (_ extension_name phase archive input)
+ (case (<s>.run parser input)
+ (#try.Success input')
+ (handler extension_name phase archive input')
-(def: lux-procs
+ (#try.Failure error)
+ (/////.throw extension.invalid_syntax [extension_name %synthesis input]))))
+
+(def: lux_procs
Bundle
(|> /.empty
(/.install "is" (binary (product.uncurry _.=)))
(/.install "try" (unary //runtime.lux//try))))
-(def: keep-i64
+(def: keep_i64
(All [input]
- (-> (-> input (Expression Any))
- (-> input (Expression Any))))
- (function.compose (_.bit-and (_.manual "0xFFFFFFFFFFFFFFFF"))))
+ (-> (-> input Expression)
+ (-> input Expression)))
+ (function.compose (_.bit_and (_.manual "0xFFFFFFFFFFFFFFFF"))))
-(def: i64-procs
+(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 (..keep-i64 (product.uncurry _.bit-shl))))
- (/.install "logical-right-shift" (binary (product.uncurry //runtime.i64//logic-right-shift)))
- (/.install "arithmetic-right-shift" (binary (product.uncurry _.bit-shr)))
+ (/.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 (..keep_i64 (product.uncurry _.bit_shl))))
+ (/.install "right-shift" (binary (product.uncurry //runtime.i64//logic_right_shift)))
(/.install "=" (binary (product.uncurry _.=)))
- (/.install "+" (binary (..keep-i64 (product.uncurry _.+))))
- (/.install "-" (binary (..keep-i64 (product.uncurry _.-))))
+ (/.install "+" (binary (..keep_i64 (product.uncurry _.+))))
+ (/.install "-" (binary (..keep_i64 (product.uncurry _.-))))
)))
-(def: int-procs
+(def: int_procs
Bundle
(<| (/.prefix "int")
(|> /.empty
(/.install "<" (binary (product.uncurry _.<)))
- (/.install "*" (binary (..keep-i64 (product.uncurry _.*))))
+ (/.install "*" (binary (..keep_i64 (product.uncurry _.*))))
(/.install "/" (binary (product.uncurry _./)))
(/.install "%" (binary (product.uncurry _.%)))
(/.install "frac" (unary (_./ (_.float +1.0))))
(/.install "char" (unary (_.do "chr" (list)))))))
-(def: frac-procs
+(def: frac_procs
Bundle
(<| (/.prefix "frac")
(|> /.empty
@@ -76,18 +100,18 @@
(/.install "decode" (unary //runtime.f64//decode)))))
(def: (text//char [subjectO paramO])
- (Binary (Expression Any))
+ (Binary Expression)
(//runtime.text//char subjectO paramO))
(def: (text//clip [paramO extraO subjectO])
- (Trinary (Expression Any))
+ (Trinary Expression)
(//runtime.text//clip subjectO paramO extraO))
(def: (text//index [startO partO textO])
- (Trinary (Expression Any))
+ (Trinary Expression)
(//runtime.text//index textO partO startO))
-(def: text-procs
+(def: text_procs
Bundle
(<| (/.prefix "text")
(|> /.empty
@@ -101,43 +125,38 @@
)))
(def: (io//log! messageG)
- (Unary (Expression Any))
- (_.or (_.apply/* (list (|> messageG (_.+ (_.string text.new-line))))
+ (Unary Expression)
+ (_.or (_.apply/* (list (|> messageG (_.+ (_.string text.new_line))))
(_.local "puts"))
//runtime.unit))
(def: io//error!
- (Unary (Expression Any))
+ (Unary Expression)
_.raise)
-(def: (io//exit! code)
- (Unary (Expression Any))
- (_.apply/* (list code) (_.local "exit")))
-
-(def: (io//current-time! _)
- (Nullary (Expression Any))
+(def: (io//current_time! _)
+ (Nullary Expression)
(|> (_.local "Time")
(_.do "now" (list))
(_.do "to_f" (list))
(_.* (_.float +1000.0))
(_.do "to_i" (list))))
-(def: io-procs
+(def: io_procs
Bundle
(<| (/.prefix "io")
(|> /.empty
(/.install "log" (unary ..io//log!))
(/.install "error" (unary ..io//error!))
- (/.install "exit" (unary ..io//exit!))
- (/.install "current-time" (nullary ..io//current-time!)))))
+ (/.install "current-time" (nullary ..io//current_time!)))))
(def: #export bundle
Bundle
(<| (/.prefix "lux")
- (|> lux-procs
- (dictionary.merge ..i64-procs)
- (dictionary.merge ..int-procs)
- (dictionary.merge ..frac-procs)
- (dictionary.merge ..text-procs)
- (dictionary.merge ..io-procs)
+ (|> lux_procs
+ (dictionary.merge ..i64_procs)
+ (dictionary.merge ..int_procs)
+ (dictionary.merge ..frac_procs)
+ (dictionary.merge ..text_procs)
+ (dictionary.merge ..io_procs)
)))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python.lux
index 2de025059..cdaabfc08 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python.lux
@@ -48,17 +48,13 @@
(^ (////synthesis.branch/case case))
(/case.case! false statement expression archive case)
- (^ (////synthesis.branch/let let))
- (/case.let! statement expression archive let)
-
- (^ (////synthesis.branch/if if))
- (/case.if! statement expression archive if)
-
- (^ (////synthesis.loop/scope scope))
- (/loop.scope! statement expression archive scope)
-
- (^ (////synthesis.loop/recur updates))
- (/loop.recur! statement expression archive updates)
+ (^template [<tag> <generator>]
+ [(^ (<tag> value))
+ (<generator> statement expression archive value)])
+ ([////synthesis.branch/let /case.let!]
+ [////synthesis.branch/if /case.if!]
+ [////synthesis.loop/scope /loop.scope!]
+ [////synthesis.loop/recur /loop.recur!])
(^ (////synthesis.function/abstraction abstraction))
(//////phase\map _.return (/function.function statement expression archive abstraction))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python/case.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python/case.lux
index 62225bb9c..eb6ae3e19 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python/case.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/python/case.lux
@@ -177,7 +177,7 @@
(-> Bit Phase! Phase Archive Path (Operation (Statement Any)))
(function (recur pathP)
(.case pathP
- (^ (/////synthesis.path/then bodyS))
+ (#/////synthesis.Then bodyS)
(statement expression archive bodyS)
#/////synthesis.Pop
@@ -203,31 +203,20 @@
else!
then!))))
- (#/////synthesis.I64_Fork cons)
- (do {! ///////phase.monad}
- [clauses (monad.map ! (function (_ [match then])
- (do !
- [then! (recur then)]
- (wrap [(_.= (//primitive.i64 (.int match))
- ..peek)
- then!])))
- (#.Cons cons))]
- (wrap (_.cond clauses
- ..fail_pm!)))
-
(^template [<tag> <format>]
[(<tag> cons)
(do {! ///////phase.monad}
[clauses (monad.map ! (function (_ [match then])
(\ ! map
- (|>> [(_.= (<format> match)
+ (|>> [(_.= (|> match <format>)
..peek)])
(recur then)))
(#.Cons cons))]
(wrap (_.cond clauses
..fail_pm!)))])
- ([#/////synthesis.F64_Fork //primitive.f64]
- [#/////synthesis.Text_Fork //primitive.text])
+ ([#/////synthesis.I64_Fork (<| //primitive.i64 .int)]
+ [#/////synthesis.F64_Fork (<| //primitive.f64)]
+ [#/////synthesis.Text_Fork (<| //primitive.text)])
(^template [<complex> <simple> <choice>]
[(^ (<complex> idx))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby.lux
index d7e02b980..9524441f2 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby.lux
@@ -1,21 +1,30 @@
(.module:
[lux #*
[abstract
- [monad (#+ do)]]]
+ [monad (#+ do)]]
+ [control
+ ["." exception (#+ exception:)]]
+ [target
+ ["_" ruby]]]
["." / #_
- [runtime (#+ Phase)]
+ [runtime (#+ Phase Phase!)]
["#." primitive]
["#." structure]
- ["#." reference ("#\." system)]
+ ["#." reference]
["#." function]
["#." case]
["#." loop]
- ["//#" /// #_
- ["#." extension]
+ ["/#" // #_
+ ["#." reference]
["/#" // #_
- ["#." synthesis]
- ["//#" /// #_
- ["#." phase ("#\." monad)]]]]])
+ ["#." extension]
+ ["/#" // #_
+ [analysis (#+)]
+ ["#." synthesis]
+ ["//#" /// #_
+ ["#." phase ("#\." monad)]
+ [reference (#+)
+ [variable (#+)]]]]]]])
(def: #export (generate archive synthesis)
Phase
@@ -28,35 +37,25 @@
[////synthesis.f64 /primitive.f64]
[////synthesis.text /primitive.text])
- (^ (////synthesis.variant variantS))
- (/structure.variant generate archive variantS)
-
- (^ (////synthesis.tuple members))
- (/structure.tuple generate archive members)
+ (^template [<tag> <generator>]
+ [(^ (<tag> value))
+ (<generator> generate archive value)])
+ ([////synthesis.variant /structure.variant]
+ [////synthesis.tuple /structure.tuple]
+
+ [////synthesis.branch/case /case.case]
+ [////synthesis.branch/let /case.let]
+ [////synthesis.branch/if /case.if]
+ [////synthesis.branch/get /case.get]
+
+ [////synthesis.loop/scope /loop.scope]
+ [////synthesis.loop/recur /loop.recur]
+
+ [////synthesis.function/abstraction /function.function]
+ [////synthesis.function/apply /function.apply])
(#////synthesis.Reference value)
- (/reference\reference archive value)
-
- (^ (////synthesis.branch/case case))
- (/case.case generate archive case)
-
- (^ (////synthesis.branch/let let))
- (/case.let generate archive let)
-
- (^ (////synthesis.branch/if if))
- (/case.if generate archive if)
-
- (^ (////synthesis.loop/scope scope))
- (/loop.scope generate archive scope)
-
- (^ (////synthesis.loop/recur updates))
- (/loop.recur generate archive updates)
-
- (^ (////synthesis.function/abstraction abstraction))
- (/function.function generate archive abstraction)
-
- (^ (////synthesis.function/apply application))
- (/function.apply generate archive application)
+ (//reference.reference /reference.system archive value)
(#////synthesis.Extension extension)
(///extension.apply archive generate extension)))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux
index bd85ca44a..fd9916a9b 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux
@@ -1,21 +1,24 @@
(.module:
[lux (#- case let if)
[abstract
- [monad (#+ do)]]
+ ["." monad (#+ do)]]
[control
- ["ex" exception (#+ exception:)]]
+ [exception (#+ exception:)]]
[data
- ["." text]
- [number
- ["n" nat]
- ["i" int]]
+ ["." text
+ ["%" format (#+ format)]]
[collection
["." list ("#\." functor fold)]
["." set]]]
+ [math
+ [number
+ ["n" nat]
+ ["i" int]]]
[target
- ["_" ruby (#+ Expression Statement)]]]
+ ["_" ruby (#+ Expression LVar Statement)]]]
["." // #_
- ["#." runtime (#+ Operation Phase Generator)]
+ ["#." runtime (#+ Operation Phase Generator Phase! Generator!)]
+ ["#." reference]
["#." primitive]
["/#" // #_
["#." reference]
@@ -23,35 +26,46 @@
[synthesis
["." case]]
["/#" // #_
- ["#." synthesis (#+ Synthesis Path)]
+ ["#." synthesis (#+ Member Synthesis Path)]
["#." generation]
["//#" /// #_
- ["#." reference (#+ Register)]
+ [reference
+ ["#." variable (#+ Register)]]
["#." phase ("#\." monad)]
[meta
[archive (#+ Archive)]]]]]]])
(def: #export register
- (///reference.local _.local))
+ (-> Register LVar)
+ (|>> (///reference.local //reference.system) :assume))
(def: #export capture
- (///reference.foreign _.local))
+ (-> Register LVar)
+ (|>> (///reference.foreign //reference.system) :assume))
-(def: #export (let generate archive [valueS register bodyS])
+(def: #export (let expression archive [valueS register bodyS])
(Generator [Synthesis Register Synthesis])
(do ///////phase.monad
- [valueO (generate archive valueS)
- bodyO (generate archive bodyS)]
+ [valueO (expression archive valueS)
+ bodyO (expression archive bodyS)]
## TODO: Find some way to do 'let' without paying the price of the closure.
(wrap (|> bodyO
_.return
(_.lambda #.None (list (..register register)))
(_.do "call" (list valueO))))))
-(def: #export (record-get generate archive [valueS pathP])
- (Generator [Synthesis (List (Either Nat Nat))])
+(def: #export (if expression archive [testS thenS elseS])
+ (Generator [Synthesis Synthesis Synthesis])
+ (do ///////phase.monad
+ [testO (expression archive testS)
+ thenO (expression archive thenS)
+ elseO (expression archive elseS)]
+ (wrap (_.? testO thenO elseO))))
+
+(def: #export (get expression archive [pathP valueS])
+ (Generator [(List Member) Synthesis])
(do ///////phase.monad
- [valueO (generate archive valueS)]
+ [valueO (expression archive valueS)]
(wrap (list\fold (function (_ side source)
(.let [method (.case side
(^template [<side> <accessor>]
@@ -61,56 +75,48 @@
[#.Right //runtime.tuple//right]))]
(method source)))
valueO
- pathP))))
-
-(def: #export (if generate archive [testS thenS elseS])
- (Generator [Synthesis Synthesis Synthesis])
- (do ///////phase.monad
- [testO (generate archive testS)
- thenO (generate archive thenS)
- elseO (generate archive elseS)]
- (wrap (_.? testO thenO elseO))))
+ (list.reverse pathP)))))
(def: @savepoint (_.local "lux_pm_savepoint"))
(def: @cursor (_.local "lux_pm_cursor"))
(def: @temp (_.local "lux_pm_temp"))
(def: (push! value)
- (-> (Expression Any) (Statement Any))
+ (-> Expression Statement)
(_.statement (|> @cursor (_.do "push" (list value)))))
-(def: peek-and-pop
- (Expression Any)
+(def: peek_and_pop
+ Expression
(|> @cursor (_.do "pop" (list))))
(def: pop!
- (Statement Any)
- (_.statement ..peek-and-pop))
+ Statement
+ (_.statement ..peek_and_pop))
(def: peek
- (Expression Any)
+ Expression
(_.nth (_.int -1) @cursor))
(def: save!
- (Statement Any)
- (.let [cursor (_.array-range (_.int +0) (_.int -1) @cursor)]
+ Statement
+ (.let [cursor (_.array_range (_.int +0) (_.int -1) @cursor)]
(_.statement (|> @savepoint (_.do "push" (list cursor))))))
(def: restore!
- (Statement Any)
+ Statement
(_.set (list @cursor) (|> @savepoint (_.do "pop" (list)))))
(def: fail! _.break)
-(def: (multi-pop! pops)
- (-> Nat (Statement Any))
+(def: (multi_pop! pops)
+ (-> Nat Statement)
(_.statement (_.do "slice!" (list (_.int (i.* -1 (.int pops)))
(_.int (.int pops)))
@cursor)))
(template [<name> <flag> <prep>]
[(def: (<name> simple? idx)
- (-> Bit Nat (Statement Any))
+ (-> Bit Nat Statement)
($_ _.then
(_.set (list @temp) (|> idx <prep> .int _.int (//runtime.sum//get ..peek <flag>)))
(.if simple?
@@ -120,12 +126,12 @@
fail!
(..push! @temp)))))]
- [left-choice _.nil (<|)]
- [right-choice (_.string "") inc]
+ [left_choice _.nil (<|)]
+ [right_choice (_.string "") inc]
)
(def: (alternation pre! post!)
- (-> (Statement Any) (Statement Any) (Statement Any))
+ (-> Statement Statement Statement)
($_ _.then
(_.while (_.bool true)
($_ _.then
@@ -135,88 +141,112 @@
..restore!
post!)))
-(def: (pattern-matching' generate archive pathP)
- (-> Phase Archive Path (Operation (Statement Any)))
- (.case pathP
- (^ (/////synthesis.path/then bodyS))
- (///////phase\map _.return (generate archive bodyS))
-
- #/////synthesis.Pop
- (///////phase\wrap ..pop!)
-
- (#/////synthesis.Bind register)
- (///////phase\wrap (_.set (list (..register register)) ..peek))
-
- (^template [<tag> <format>]
- [(^ (<tag> value))
- (///////phase\wrap (_.when (|> value <format> (_.= ..peek) _.not)
- fail!))])
- ([/////synthesis.path/bit //primitive.bit]
- [/////synthesis.path/i64 //primitive.i64]
- [/////synthesis.path/f64 //primitive.f64]
- [/////synthesis.path/text //primitive.text])
-
- (^template [<complex> <simple> <choice>]
- [(^ (<complex> idx))
- (///////phase\wrap (<choice> false idx))
-
- (^ (<simple> idx nextP))
- (|> nextP
- (pattern-matching' generate archive)
- (///////phase\map (_.then (<choice> true idx))))])
- ([/////synthesis.side/left /////synthesis.simple-left-side ..left-choice]
- [/////synthesis.side/right /////synthesis.simple-right-side ..right-choice])
-
- (^ (/////synthesis.member/left 0))
- (///////phase\wrap (|> ..peek (_.nth (_.int +0)) ..push!))
-
- (^template [<pm> <getter>]
- [(^ (<pm> lefts))
- (///////phase\wrap (|> ..peek (<getter> (_.int (.int lefts))) ..push!))])
- ([/////synthesis.member/left //runtime.tuple//left]
- [/////synthesis.member/right //runtime.tuple//right])
-
- (^ (/////synthesis.!bind-top register thenP))
- (do ///////phase.monad
- [then! (pattern-matching' generate archive thenP)]
- (///////phase\wrap ($_ _.then
- (_.set (list (..register register)) ..peek-and-pop)
- then!)))
-
- (^ (/////synthesis.!multi-pop nextP))
- (.let [[extra-pops nextP'] (case.count-pops nextP)]
+(def: (pattern_matching' expression archive)
+ (-> Phase Archive Path (Operation Statement))
+ (function (recur pathP)
+ (.case pathP
+ (#/////synthesis.Then bodyS)
+ (///////phase\map _.return (expression archive bodyS))
+
+ #/////synthesis.Pop
+ (///////phase\wrap ..pop!)
+
+ (#/////synthesis.Bind register)
+ (///////phase\wrap (_.set (list (..register register)) ..peek))
+
+ (#/////synthesis.Bit_Fork when thenP elseP)
+ (do {! ///////phase.monad}
+ [then! (recur thenP)
+ else! (.case elseP
+ (#.Some elseP)
+ (recur elseP)
+
+ #.None
+ (wrap ..fail!))]
+ (wrap (.if when
+ (_.if ..peek
+ then!
+ else!)
+ (_.if ..peek
+ else!
+ then!))))
+
+ (^template [<tag> <format>]
+ [(<tag> cons)
+ (do {! ///////phase.monad}
+ [clauses (monad.map ! (function (_ [match then])
+ (\ ! map
+ (|>> [(_.= (|> match <format>)
+ ..peek)])
+ (recur then)))
+ (#.Cons cons))]
+ (wrap (_.cond clauses
+ ..fail!)))])
+ ([#/////synthesis.I64_Fork (<| //primitive.i64 .int)]
+ [#/////synthesis.F64_Fork (<| //primitive.f64)]
+ [#/////synthesis.Text_Fork (<| //primitive.text)])
+
+ (^template [<complex> <simple> <choice>]
+ [(^ (<complex> idx))
+ (///////phase\wrap (<choice> false idx))
+
+ (^ (<simple> idx nextP))
+ (|> nextP
+ recur
+ (///////phase\map (_.then (<choice> true idx))))])
+ ([/////synthesis.side/left /////synthesis.simple_left_side ..left_choice]
+ [/////synthesis.side/right /////synthesis.simple_right_side ..right_choice])
+
+ (^ (/////synthesis.member/left 0))
+ (///////phase\wrap (|> ..peek (_.nth (_.int +0)) ..push!))
+
+ (^template [<pm> <getter>]
+ [(^ (<pm> lefts))
+ (///////phase\wrap (|> ..peek (<getter> (_.int (.int lefts))) ..push!))])
+ ([/////synthesis.member/left //runtime.tuple//left]
+ [/////synthesis.member/right //runtime.tuple//right])
+
+ (^ (/////synthesis.!bind_top register thenP))
(do ///////phase.monad
- [next! (pattern-matching' generate archive nextP')]
+ [then! (recur thenP)]
(///////phase\wrap ($_ _.then
- (..multi-pop! (n.+ 2 extra-pops))
- next!))))
-
- (^template [<tag> <combinator>]
- [(^ (<tag> preP postP))
- (do ///////phase.monad
- [pre! (pattern-matching' generate archive preP)
- post! (pattern-matching' generate archive postP)]
- (wrap (<combinator> pre! post!)))])
- ([/////synthesis.path/seq _.then]
- [/////synthesis.path/alt ..alternation])))
-
-(def: (pattern-matching generate archive pathP)
- (-> Phase Archive Path (Operation (Statement Any)))
+ (_.set (list (..register register)) ..peek_and_pop)
+ then!)))
+
+ (^ (/////synthesis.!multi_pop nextP))
+ (.let [[extra_pops nextP'] (case.count_pops nextP)]
+ (do ///////phase.monad
+ [next! (recur nextP')]
+ (///////phase\wrap ($_ _.then
+ (..multi_pop! (n.+ 2 extra_pops))
+ next!))))
+
+ (^template [<tag> <combinator>]
+ [(^ (<tag> preP postP))
+ (do ///////phase.monad
+ [pre! (recur preP)
+ post! (recur postP)]
+ (wrap (<combinator> pre! post!)))])
+ ([/////synthesis.path/seq _.then]
+ [/////synthesis.path/alt ..alternation]))))
+
+(def: (pattern_matching expression archive pathP)
+ (-> Phase Archive Path (Operation Statement))
(do ///////phase.monad
- [pattern-matching! (pattern-matching' generate archive pathP)]
+ [pattern_matching! (pattern_matching' expression archive pathP)]
(wrap ($_ _.then
(_.while (_.bool true)
- pattern-matching!)
- (_.statement (_.raise (_.string case.pattern-matching-error)))))))
+ pattern_matching!)
+ (_.statement (_.raise (_.string case.pattern_matching_error)))))))
-(def: #export (case generate archive [valueS pathP])
+(def: #export (case expression archive [valueS pathP])
(Generator [Synthesis Path])
(do ///////phase.monad
- [initG (generate archive valueS)
- pattern-matching! (pattern-matching generate archive pathP)]
+ [initG (expression archive valueS)
+ pattern_matching! (pattern_matching expression archive pathP)]
(wrap (|> ($_ _.then
(_.set (list @cursor) (_.array (list initG)))
(_.set (list @savepoint) (_.array (list)))
- pattern-matching!)
+ pattern_matching!)
(_.lambda #.None (list))
(_.do "call" (list))))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux
index 091c8fb6a..d153670b7 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux
@@ -2,47 +2,53 @@
[lux (#- function)
[abstract
["." monad (#+ do)]]
- [control
- pipe]
[data
["." product]
+ [text
+ ["%" format (#+ format)]]
[collection
["." list ("#\." functor fold)]]]
[target
- ["_" ruby (#+ Expression Statement)]]]
+ ["_" ruby (#+ LVar Expression Statement)]]]
["." // #_
- [runtime (#+ Operation Phase Generator)]
+ [runtime (#+ Operation Phase Generator Phase! Generator!)]
["#." reference]
["#." case]
+ ["#." loop]
["/#" // #_
["#." reference]
["//#" /// #_
[analysis (#+ Variant Tuple Environment Abstraction Application Analysis)]
[synthesis (#+ Synthesis)]
- ["#." generation]
+ ["#." generation (#+ Context)]
["//#" /// #_
- [reference (#+ Register Variable)]
[arity (#+ Arity)]
- ["#." phase]]]]])
+ ["#." phase]
+ [reference
+ [variable (#+ Register Variable)]]
+ [meta
+ [archive (#+ Archive)
+ ["." artifact]]]]]]])
-(def: #export (apply generate archive [functionS argsS+])
+(def: #export (apply expression archive [functionS argsS+])
(Generator (Application Synthesis))
(do {! ///////phase.monad}
- [functionO (generate archive functionS)
- argsO+ (monad.map ! (generate archive) argsS+)]
+ [functionO (expression archive functionS)
+ argsO+ (monad.map ! (expression archive) argsS+)]
(wrap (_.do "call" argsO+ functionO))))
(def: #export capture
- (///reference.foreign _.local))
+ (-> Register LVar)
+ (|>> (///reference.foreign //reference.system) :assume))
-(def: (with-closure inits function-definition)
- (-> (List (Expression Any)) (Expression Any) (Expression Any))
+(def: (with_closure inits function_definition)
+ (-> (List Expression) Expression Expression)
(case inits
#.Nil
- function-definition
+ function_definition
_
- (|> function-definition
+ (|> function_definition
_.return
(_.lambda #.None
(|> (list.enumeration inits)
@@ -52,47 +58,46 @@
(def: input
(|>> inc //case.register))
-(def: #export (function generate archive [environment arity bodyS])
+(def: #export (function expression archive [environment arity bodyS])
(Generator (Abstraction Synthesis))
(do {! ///////phase.monad}
- [[function-name bodyO] (/////generation.with-new-context
+ [[function_name bodyO] (/////generation.with_new_context archive
(do !
- [function-name (\ ! map ///reference.artifact-name
- /////generation.context)]
- (/////generation.with-anchor (_.local function-name)
- (generate archive bodyS))))
- closureO+ (: (Operation (List (Expression Any)))
- (monad.map ! (\ //reference.system variable) environment))
- #let [function-name (///reference.artifact-name function-name)
+ [function_name (\ ! map ///reference.artifact
+ (/////generation.context archive))]
+ (/////generation.with_anchor (_.local function_name)
+ (expression archive bodyS))))
+ closureO+ (monad.map ! (expression archive) environment)
+ #let [function_name (///reference.artifact function_name)
@curried (_.local "curried")
arityO (|> arity .int _.int)
limitO (|> arity dec .int _.int)
- @num-args (_.local "num_args")
- @self (_.local function-name)
- initialize-self! (_.set (list (//case.register 0)) @self)
+ @num_args (_.local "num_args")
+ @self (_.local function_name)
+ initialize_self! (_.set (list (//case.register 0)) @self)
initialize! (list\fold (.function (_ post pre!)
($_ _.then
pre!
(_.set (list (..input post)) (_.nth (|> post .int _.int) @curried))))
- initialize-self!
+ initialize_self!
(list.indices arity))]]
- (wrap (with-closure closureO+
+ (wrap (with_closure closureO+
(_.lambda (#.Some @self) (list (_.variadic @curried))
($_ _.then
- (_.set (list @num-args) (_.the "length" @curried))
- (_.cond (list [(|> @num-args (_.= arityO))
+ (_.set (list @num_args) (_.the "length" @curried))
+ (_.cond (list [(|> @num_args (_.= arityO))
($_ _.then
initialize!
(_.return bodyO))]
- [(|> @num-args (_.> arityO))
+ [(|> @num_args (_.> arityO))
(let [slice (.function (_ from to)
- (_.array-range from to @curried))
- arity-args (_.splat (slice (_.int +0) limitO))
- output-func-args (_.splat (slice arityO @num-args))]
+ (_.array_range from to @curried))
+ arity_args (_.splat (slice (_.int +0) limitO))
+ output_func_args (_.splat (slice arityO @num_args))]
(_.return (|> @self
- (_.do "call" (list arity-args))
- (_.do "call" (list output-func-args)))))])
- ## (|> @num-args (_.< arityO))
+ (_.do "call" (list arity_args))
+ (_.do "call" (list output_func_args)))))])
+ ## (|> @num_args (_.< arityO))
(let [@missing (_.local "missing")]
(_.return (_.lambda #.None (list (_.variadic @missing))
(_.return (|> @self
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux
index cecea44e9..3a6152337 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux
@@ -4,34 +4,43 @@
["." monad (#+ do)]]
[data
["." product]
- [number
- ["n" nat]]
[text
["%" format (#+ format)]]
[collection
- ["." list ("#\." functor)]]]
+ ["." list ("#\." functor fold)]
+ ["." set]]]
+ [math
+ [number
+ ["n" nat]]]
[target
- ["_" ruby (#+ Expression LVar)]]]
+ ["_" ruby (#+ Expression LVar Statement)]]]
["." // #_
- [runtime (#+ Operation Phase Generator)]
+ [runtime (#+ Operation Phase Generator Phase! Generator!)]
["#." case]
- ["///#" //// #_
- [synthesis (#+ Scope Synthesis)]
- ["#." generation]
- ["//#" /// #_
- ["#." phase]]]])
+ ["/#" // #_
+ ["#." reference]
+ ["/#" // #_
+ [synthesis
+ ["." case]]
+ ["/#" // #_
+ ["." synthesis (#+ Scope Synthesis)]
+ ["#." generation]
+ ["//#" /// #_
+ ["#." phase]
+ [reference
+ ["#." variable (#+ Register)]]]]]]])
-(def: loop-name
+(def: loop_name
(-> Nat LVar)
(|>> %.nat (format "loop") _.local))
-(def: #export (scope generate archive [start initsS+ bodyS])
+(def: #export (scope expression archive [start initsS+ bodyS])
(Generator (Scope Synthesis))
(do {! ///////phase.monad}
- [@loop (\ ! map ..loop-name /////generation.next)
- initsO+ (monad.map ! (generate archive) initsS+)
- bodyO (/////generation.with-anchor @loop
- (generate archive bodyS))]
+ [@loop (\ ! map ..loop_name /////generation.next)
+ initsO+ (monad.map ! (expression archive) initsS+)
+ bodyO (/////generation.with_anchor @loop
+ (expression archive bodyS))]
(wrap (|> (_.return bodyO)
(_.lambda (#.Some @loop)
(|> initsS+
@@ -39,9 +48,9 @@
(list\map (|>> product.left (n.+ start) //case.register))))
(_.apply/* initsO+)))))
-(def: #export (recur generate archive argsS+)
+(def: #export (recur expression archive argsS+)
(Generator (List Synthesis))
(do {! ///////phase.monad}
[@scope /////generation.anchor
- argsO+ (monad.map ! (generate archive) argsS+)]
+ argsO+ (monad.map ! (expression archive) argsS+)]
(wrap (_.apply/* argsO+ @scope))))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/reference.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/reference.lux
index 936f9249e..1149b2e8d 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/reference.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/reference.lux
@@ -2,12 +2,11 @@
[lux #*
[target
["_" ruby (#+ Expression)]]]
- ["." /// #_
- ["#." reference]])
+ [///
+ [reference (#+ System)]])
-(def: #export system
- (let [constant (: (-> Text (Expression Any))
- _.global)
- variable (: (-> Text (Expression Any))
- _.local)]
- (///reference.system constant variable)))
+(structure: #export system
+ (System Expression)
+
+ (def: constant _.global)
+ (def: variable _.local))
diff --git a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux
index 221442863..76460e39a 100644
--- a/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux
+++ b/stdlib/source/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux
@@ -1,36 +1,45 @@
(.module:
[lux (#- inc)
+ ["." meta]
[abstract
- [monad (#+ do)]]
+ ["." monad (#+ do)]]
[control
["." function]
- ["p" parser
- ["s" code]]]
+ ["<>" parser
+ ["<.>" code]]]
[data
- [number (#+ hex)
- ["." i64]]
- ["." text
- ["%" format (#+ format)]]
+ ["." product]
+ ["." text ("#\." hash)
+ ["%" format (#+ format)]
+ ["." encoding]]
[collection
- ["." list ("#\." functor)]]]
+ ["." list ("#\." functor)]
+ ["." row]]]
["." macro
- ["." code]
- [syntax (#+ syntax:)]]
- [target
+ [syntax (#+ syntax:)]
+ ["." code]]
+ [math
+ [number (#+ hex)
+ ["." i64]]]
+ ["@" target
["_" ruby (#+ Expression LVar Computation Literal Statement)]]]
["." /// #_
["#." reference]
["//#" /// #_
- ["#." synthesis]
- ["#." generation (#+ Buffer)]
- ["//#" /// #_
+ ["$" version]
+ ["#." synthesis (#+ Synthesis)]
+ ["#." generation]
+ ["//#" ///
["#." phase]
+ [reference
+ [variable (#+ Register)]]
[meta
- [archive (#+ Archive)]]]]])
+ [archive (#+ Output Archive)
+ ["." artifact (#+ Registry)]]]]]])
(template [<name> <base>]
[(type: #export <name>
- (<base> LVar (Expression Any) (Statement Any)))]
+ (<base> LVar Expression Statement))]
[Operation /////generation.Operation]
[Phase /////generation.Phase]
@@ -39,163 +48,172 @@
)
(type: #export (Generator i)
- (-> Phase Archive i (Operation (Expression Any))))
+ (-> Phase Archive i (Operation Expression)))
+
+(type: #export Phase!
+ (-> Phase Archive Synthesis (Operation (Statement Any))))
+
+(type: #export (Generator! i)
+ (-> Phase! Phase Archive i (Operation (Statement Any))))
(def: prefix Text "LuxRuntime")
-(def: #export unit (_.string /////synthesis.unit))
+(def: #export unit
+ (_.string /////synthesis.unit))
(def: (flag value)
(-> Bit Literal)
(if value
- (_.string "")
+ ..unit
_.nil))
-(def: #export variant-tag-field "_lux_tag")
-(def: #export variant-flag-field "_lux_flag")
-(def: #export variant-value-field "_lux_value")
+(def: #export variant_tag_field "_lux_tag")
+(def: #export variant_flag_field "_lux_flag")
+(def: #export variant_value_field "_lux_value")
(def: (variant' tag last? value)
- (-> (Expression Any) (Expression Any) (Expression Any) Literal)
- (_.hash (list [(_.string ..variant-tag-field) tag]
- [(_.string ..variant-flag-field) last?]
- [(_.string ..variant-value-field) value])))
+ (-> Expression Expression Expression Literal)
+ (_.hash (list [(_.string ..variant_tag_field) tag]
+ [(_.string ..variant_flag_field) last?]
+ [(_.string ..variant_value_field) value])))
(def: #export (variant tag last? value)
- (-> Nat Bit (Expression Any) Literal)
+ (-> Nat Bit Expression Literal)
(variant' (_.int (.int tag)) (..flag last?) value))
(def: #export none
Literal
- (variant 0 #0 unit))
+ (..variant 0 #0 ..unit))
(def: #export some
- (-> (Expression Any) Literal)
- (variant 1 #1))
+ (-> Expression Literal)
+ (..variant 1 #1))
(def: #export left
- (-> (Expression Any) Literal)
- (variant 0 #0))
+ (-> Expression Literal)
+ (..variant 0 #0))
(def: #export right
- (-> (Expression Any) Literal)
- (variant 1 #1))
-
-(def: runtime-name
- (-> Text LVar)
- (|>> ///reference.sanitize
- (format ..prefix "_")
- _.local))
+ (-> Expression Literal)
+ (..variant 1 #1))
(def: (feature name definition)
- (-> LVar (-> LVar (Statement Any)) (Statement Any))
+ (-> LVar (-> LVar Statement) Statement)
(definition name))
-(syntax: #export (with-vars {vars (s.tuple (p.some s.local-identifier))}
+(syntax: #export (with_vars {vars (<code>.tuple (<>.some <code>.local_identifier))}
body)
- (wrap (list (` (let [(~+ (|> vars
- (list\map (function (_ var)
- (list (code.local-identifier var)
- (` (_.local (~ (code.text (///reference.sanitize var))))))))
- list.concat))]
- (~ body))))))
-
-(syntax: (runtime: {declaration (p.or s.local-identifier
- (s.form (p.and s.local-identifier
- (p.some s.local-identifier))))}
+ (do {! meta.monad}
+ [ids (monad.seq ! (list.repeat (list.size vars) meta.count))]
+ (wrap (list (` (let [(~+ (|> vars
+ (list.zip/2 ids)
+ (list\map (function (_ [id var])
+ (list (code.local_identifier var)
+ (` (_.local (~ (code.text (format "v" (%.nat id)))))))))
+ list.concat))]
+ (~ body)))))))
+
+(def: module_id
+ 0)
+
+(syntax: (runtime: {declaration (<>.or <code>.local_identifier
+ (<code>.form (<>.and <code>.local_identifier
+ (<>.some <code>.local_identifier))))}
code)
- (case declaration
- (#.Left name)
- (macro.with-gensyms [g!_]
- (let [nameC (code.local-identifier name)
- code-nameC (code.local-identifier (format "@" name))
- runtime-nameC (` (runtime-name (~ (code.text name))))]
- (wrap (list (` (def: #export (~ nameC) LVar (~ runtime-nameC)))
- (` (def: (~ code-nameC)
- (Statement Any)
- (..feature (~ runtime-nameC)
- (function ((~ g!_) (~ nameC))
- (~ code)))))))))
-
- (#.Right [name inputs])
- (macro.with-gensyms [g!_]
- (let [nameC (code.local-identifier name)
- code-nameC (code.local-identifier (format "@" name))
- runtime-nameC (` (runtime-name (~ (code.text name))))
- inputsC (list\map code.local-identifier inputs)
- inputs-typesC (list\map (function.constant (` (_.Expression Any)))
- inputs)]
- (wrap (list (` (def: #export ((~ nameC) (~+ inputsC))
- (-> (~+ inputs-typesC) (Computation Any))
- (_.apply/* (list (~+ inputsC)) (~ runtime-nameC))))
- (` (def: (~ code-nameC)
- (Statement Any)
- (..feature (~ runtime-nameC)
- (function ((~ g!_) (~ g!_))
- (..with-vars [(~+ inputsC)]
- (_.function (~ g!_) (list (~+ inputsC))
- (~ code)))))))))))))
-
-(def: tuple-size
+ (do meta.monad
+ [runtime_id meta.count]
+ (macro.with_gensyms [g!_]
+ (let [runtime (code.local_identifier (///reference.artifact [..module_id runtime_id]))
+ runtime_name (` (_.local (~ (code.text (%.code runtime)))))]
+ (case declaration
+ (#.Left name)
+ (macro.with_gensyms [g!_]
+ (let [g!name (code.local_identifier name)]
+ (wrap (list (` (def: #export (~ g!name) LVar (~ runtime_name)))
+ (` (def: (~ (code.local_identifier (format "@" name)))
+ Statement
+ (..feature (~ runtime_name)
+ (function ((~ g!_) (~ g!name))
+ (_.set (list (~ g!name)) (~ code))))))))))
+
+ (#.Right [name inputs])
+ (macro.with_gensyms [g!_]
+ (let [g!name (code.local_identifier name)
+ inputsC (list\map code.local_identifier inputs)
+ inputs_typesC (list\map (function.constant (` _.Expression))
+ inputs)]
+ (wrap (list (` (def: #export ((~ g!name) (~+ inputsC))
+ (-> (~+ inputs_typesC) Computation)
+ (_.apply/* (list (~+ inputsC)) (~ runtime_name))))
+
+ (` (def: (~ (code.local_identifier (format "@" name)))
+ Statement
+ (..feature (~ runtime_name)
+ (function ((~ g!_) (~ g!_))
+ (..with_vars [(~+ inputsC)]
+ (_.function (~ g!_) (list (~+ inputsC))
+ (~ code))))))))))))))))
+
+(def: tuple_size
(_.the "length"))
-(def: last-index
- (|>> ..tuple-size (_.- (_.int +1))))
+(def: last_index
+ (|>> ..tuple_size (_.- (_.int +1))))
-(with-expansions [<recur> (as-is ($_ _.then
- (_.set (list lefts) (_.- last-index-right lefts))
- (_.set (list tuple) (_.nth last-index-right tuple))))]
+(with_expansions [<recur> (as_is ($_ _.then
+ (_.set (list lefts) (_.- last_index_right lefts))
+ (_.set (list tuple) (_.nth last_index_right tuple))))]
(runtime: (tuple//left lefts tuple)
- (with-vars [last-index-right]
+ (with_vars [last_index_right]
(<| (_.while (_.bool true))
($_ _.then
- (_.set (list last-index-right) (..last-index tuple))
- (_.if (_.> lefts last-index-right)
+ (_.set (list last_index_right) (..last_index tuple))
+ (_.if (_.> lefts last_index_right)
## No need for recursion
(_.return (_.nth lefts tuple))
## Needs recursion
<recur>)))))
(runtime: (tuple//right lefts tuple)
- (with-vars [last-index-right right-index]
+ (with_vars [last_index_right right_index]
(<| (_.while (_.bool true))
($_ _.then
- (_.set (list last-index-right) (..last-index tuple))
- (_.set (list right-index) (_.+ (_.int +1) lefts))
- (_.cond (list [(_.= last-index-right right-index)
- (_.return (_.nth right-index tuple))]
- [(_.> last-index-right right-index)
+ (_.set (list last_index_right) (..last_index tuple))
+ (_.set (list right_index) (_.+ (_.int +1) lefts))
+ (_.cond (list [(_.= last_index_right right_index)
+ (_.return (_.nth right_index tuple))]
+ [(_.> last_index_right right_index)
## Needs recursion.
<recur>])
- (_.return (_.array-range right-index (..tuple-size tuple) tuple)))
+ (_.return (_.array_range right_index (..tuple_size tuple) tuple)))
)))))
(runtime: (sum//get sum wantsLast wantedTag)
- (let [no-match! (_.return _.nil)
- sum-tag (_.nth (_.string ..variant-tag-field) sum)
- sum-flag (_.nth (_.string ..variant-flag-field) sum)
- sum-value (_.nth (_.string ..variant-value-field) sum)
- is-last? (_.= (_.string "") sum-flag)
- test-recursion! (_.if is-last?
+ (let [no_match! (_.return _.nil)
+ sum_tag (_.nth (_.string ..variant_tag_field) sum)
+ sum_flag (_.nth (_.string ..variant_flag_field) sum)
+ sum_value (_.nth (_.string ..variant_value_field) sum)
+ is_last? (_.= ..unit sum_flag)
+ test_recursion! (_.if is_last?
## Must recurse.
- (_.return (sum//get sum-value wantsLast (_.- sum-tag wantedTag)))
- no-match!)]
- (_.cond (list [(_.= sum-tag wantedTag)
- (_.if (_.= wantsLast sum-flag)
- (_.return sum-value)
- test-recursion!)]
+ (_.return (sum//get sum_value wantsLast (_.- sum_tag wantedTag)))
+ no_match!)]
+ (_.cond (list [(_.= sum_tag wantedTag)
+ (_.if (_.= wantsLast sum_flag)
+ (_.return sum_value)
+ test_recursion!)]
- [(_.> sum-tag wantedTag)
- test-recursion!]
+ [(_.> sum_tag wantedTag)
+ test_recursion!]
- [(_.and (_.< sum-tag wantedTag)
- (_.= (_.string "") wantsLast))
- (_.return (variant' (_.- wantedTag sum-tag) sum-flag sum-value))])
+ [(_.and (_.< sum_tag wantedTag)
+ (_.= ..unit wantsLast))
+ (_.return (variant' (_.- wantedTag sum_tag) sum_flag sum_value))])
- no-match!)))
+ no_match!)))
(def: runtime//adt
- (Statement Any)
+ Statement
($_ _.then
@tuple//left
@tuple//right
@@ -203,44 +221,44 @@
))
(runtime: (lux//try risky)
- (with-vars [error value]
+ (with_vars [error value]
(_.begin ($_ _.then
(_.set (list value) (_.do "call" (list ..unit) risky))
(_.return (..right value)))
(list [(list) error
(_.return (..left (_.the "message" error)))]))))
-(runtime: (lux//program-args raw)
- (with-vars [tail head]
+(runtime: (lux//program_args raw)
+ (with_vars [tail head]
($_ _.then
(_.set (list tail) ..none)
- (<| (_.for-in head raw)
+ (<| (_.for_in head raw)
(_.set (list tail) (..some (_.array (list head tail)))))
(_.return tail))))
(def: runtime//lux
- (Statement Any)
+ Statement
($_ _.then
@lux//try
- @lux//program-args
+ @lux//program_args
))
-(runtime: (i64//logic-right-shift param subject)
+(runtime: (i64//logic_right_shift param subject)
(let [mask (|> (_.int +1)
- (_.bit-shl (_.- param (_.int +64)))
+ (_.bit_shl (_.- param (_.int +64)))
(_.- (_.int +1)))]
(_.return (|> subject
- (_.bit-shr param)
- (_.bit-and mask)))))
+ (_.bit_shr param)
+ (_.bit_and mask)))))
(def: runtime//i64
- (Statement Any)
+ Statement
($_ _.then
- @i64//logic-right-shift
+ @i64//logic_right_shift
))
(runtime: (f64//decode inputG)
- (with-vars [@input @temp]
+ (with_vars [@input @temp]
($_ _.then
(_.set (list @input) inputG)
(_.set (list @temp) (_.do "to_f" (list) @input))
@@ -253,13 +271,13 @@
(_.return ..none)))))
(def: runtime//f64
- (Statement Any)
+ Statement
($_ _.then
@f64//decode
))
(runtime: (text//index subject param start)
- (with-vars [idx]
+ (with_vars [idx]
($_ _.then
(_.set (list idx) (|> subject (_.do "index" (list param start))))
(_.if (_.= _.nil idx)
@@ -267,20 +285,20 @@
(_.return (..some idx))))))
(def: (within? top value)
- (-> (Expression Any) (Expression Any) (Computation Any))
+ (-> Expression Expression Computation)
(_.and (|> value (_.>= (_.int +0)))
(|> value (_.< top))))
(runtime: (text//clip @text @from @to)
- (_.return (|> @text (_.array-range @from @to))))
+ (_.return (|> @text (_.array_range @from @to))))
(runtime: (text//char idx text)
(_.if (|> idx (within? (_.the "length" text)))
- (_.return (..some (|> text (_.array-range idx idx) (_.do "ord" (list)))))
+ (_.return (..some (|> text (_.array_range idx idx) (_.do "ord" (list)))))
(_.return ..none)))
(def: runtime//text
- (Statement Any)
+ Statement
($_ _.then
@text//index
@text//clip
@@ -288,7 +306,7 @@
))
(def: runtime
- (Statement Any)
+ Statement
($_ _.then
runtime//adt
runtime//lux
@@ -301,9 +319,14 @@
..prefix)
(def: #export generate
- (Operation (Buffer (Statement Any)))
- (/////generation.with-buffer
- (do ///////phase.monad
- [_ (/////generation.execute! ..runtime)
- _ (/////generation.save! ..prefix ..runtime)]
- /////generation.buffer)))
+ (Operation [Registry Output])
+ (do ///////phase.monad
+ [_ (/////generation.execute! ..runtime)
+ _ (/////generation.save! (%.nat ..module_id) ..runtime)]
+ (wrap [(|> artifact.empty
+ artifact.resource
+ product.right)
+ (row.row [(%.nat ..module_id)
+ (|> ..runtime
+ _.code
+ (\ encoding.utf8 encode))])])))