aboutsummaryrefslogtreecommitdiff
path: root/lux-ruby
diff options
context:
space:
mode:
Diffstat (limited to 'lux-ruby')
-rw-r--r--lux-ruby/project.clj2
-rw-r--r--lux-ruby/source/program.lux479
2 files changed, 305 insertions, 176 deletions
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 []))))