path: root/lux-ruby/source/program.lux

(.module:
  [lux #*
   [program (#+ program:)]
   ["." host (#+ import:)]
   ["." meta]
   [abstract
    ["." monad (#+ do)]]
   [control
    [pipe (#+ new>)]
    ["." try (#+ Try)]
    ["." exception (#+ exception:)]
    ["." io (#+ IO io)]
    [concurrency
     ["." promise (#+ Promise)]]
    ["<>" parser
     ["<.>" code]]]
   [data
    ["." maybe]
    ["." text ("#\." hash)
     ["%" format (#+ format)]
     ["." encoding]]
    [collection
     ["." array (#+ Array)]]]
   ["." macro
    [syntax (#+ syntax:)]
    ["." template]
    ["." code]]
   [math
    [number
     ["n" nat]
     ["." i64]]]
   ["." world #_
    ["." file]
    ["#/." program]]
   ["@" target
    ["_" ruby]]
   [tool
    [compiler
     [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)]]
     [meta
      ["." packager #_
       ["#" script]]]]]]
  [program
   ["/" compositor
    ["/." cli]
    ["/." static]]])

(import: java/lang/String)

(import: (java/lang/Class a))

(import: java/lang/Object
  ["#::."
   (toString [] java/lang/String)
   (getClass [] (java/lang/Class java/lang/Object))])

(import: java/lang/Integer)

(import: java/lang/Long
  ["#::."
   (intValue [] java/lang/Integer)])

(import: org/jruby/RubyArray
  ["#::."
   (getLength [] int)
   (get [int] #? Object)])

(import: org/jruby/RubyHash
  ["#::."
   (get [java/lang/Object] #? java/lang/Object)])

(import: org/jruby/Ruby
  ["#::."
   (getCurrentContext [] org/jruby/runtime/ThreadContext)])

(import: org/jruby/runtime/builtin/IRubyObject)

(import: org/jruby/runtime/ThreadContext)

(template [<name>]
  [(host.interface: <name>
     (getValue [] java/lang/Object))

   (`` (import: (~~ (template.identifier ["program/" <name>]))
         ["#::."
          (getValue [] java/lang/Object)]))]

  [StructureValue]
  )

(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: 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)
  (-> (Array java/lang/Object) org/jruby/runtime/builtin/IRubyObject)
  (with_expansions [<checkers> (template [<name>]
                                 [[<name> [] boolean]]

                                 [isNil] [isTaint] [isClass] [isFrozen]
                                 [isImmediate] [isModule] [isSpecialConst] [isTrue]
                                 [isUntrusted] [hasVariables])
                    <markers> (template [<name>]
                                [[<name> [boolean] void]]

                                [setFrozen] [setTaint] [setUntrusted])
                    <nullaries> (template [<name>]
                                  [[<name> [] org/jruby/runtime/builtin/IRubyObject]]

                                  [dup] [checkArrayType] [inspect] [checkStringType]
                                  [checkStringType19] [id] [rbClone] [anyToString])
                    <class> (template [<name>]
                              [[<name> [] org/jruby/RubyClass]]

                              [getMetaClass] [getType] [getSingletonClass])
                    <call> (template [<inputs>]
                             [[callMethod <inputs>
                               org/jruby/runtime/builtin/IRubyObject]]

                             [[org/jruby/runtime/ThreadContext int java/lang/String]]
                             [[org/jruby/runtime/ThreadContext int java/lang/String org/jruby/runtime/builtin/IRubyObject]]
                             [[org/jruby/runtime/ThreadContext java/lang/String]]
                             [[org/jruby/runtime/ThreadContext java/lang/String org/jruby/runtime/builtin/IRubyObject]]
                             ## [[org/jruby/runtime/ThreadContext java/lang/String [org/jruby/runtime/builtin/IRubyObject]]]
                             [[org/jruby/runtime/ThreadContext java/lang/String [org/jruby/runtime/builtin/IRubyObject] org/jruby/runtime/Block]]
                             )
                    <placeholders> (template [<name> <inputs> <output>]
                                     [(org/jruby/runtime/builtin/IRubyObject
                                       (<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]
                                     [convertToArray [] org/jruby/RubyArray]
                                     [convertToHash [] org/jruby/RubyHash]
                                     [convertToFloat [] org/jruby/RubyFloat]
                                     [convertToString [] org/jruby/RubyString]
                                     [asString [] org/jruby/RubyString]
                                     [respondsTo [java/lang/String] boolean]
                                     [respondsToMissing [java/lang/String] boolean]
                                     [respondsToMissing [java/lang/String boolean] boolean]
                                     [dataGetStruct [] java/lang/Object]
                                     [dataGetStructChecked [] java/lang/Object]
                                     [infectBy [org/jruby/runtime/builtin/IRubyObject] org/jruby/runtime/builtin/IRubyObject]
                                     [eql [org/jruby/runtime/builtin/IRubyObject] boolean]
                                     [toJava [(java/lang/Class java/lang/Object)] java/lang/Object]

                                     [op_eqq
                                      [org/jruby/runtime/ThreadContext
                                       org/jruby/runtime/builtin/IRubyObject]
                                      org/jruby/runtime/builtin/IRubyObject]
                                     
                                     [op_equal
                                      [org/jruby/runtime/ThreadContext
                                       org/jruby/runtime/builtin/IRubyObject]
                                      org/jruby/runtime/builtin/IRubyObject]
                                     
                                     [callSuper
                                      [org/jruby/runtime/ThreadContext
                                       [org/jruby/runtime/builtin/IRubyObject]
                                       org/jruby/runtime/Block]
                                      org/jruby/runtime/builtin/IRubyObject]
                                     
                                     [checkCallMethod
                                      [org/jruby/runtime/ThreadContext
                                       java/lang/String]
                                      org/jruby/runtime/builtin/IRubyObject]
                                     
                                     [checkCallMethod
                                      [org/jruby/runtime/ThreadContext
                                       org/jruby/runtime/JavaSites$CheckedSites]
                                      org/jruby/runtime/builtin/IRubyObject]

                                     <checkers>
                                     <markers>
                                     <nullaries>
                                     <class>
                                     <call>
                                     )]
    (`` (host.object [] [program/StructureValue
                         org/jruby/runtime/builtin/IRubyObject]
          []
          ## Methods
          (program/StructureValue
           [] (getValue self)
           java/lang/Object
           (:coerce (Array java/lang/Object) value))
          
          (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
             ("lux io log" (format "Was called: " (%.text member)))
             (error! "OOPS!")))

          <placeholders>
          ))))

(import: org/jruby/RubyProc
  ["#::."
   (call [org/jruby/runtime/ThreadContext [org/jruby/runtime/builtin/IRubyObject]]
         #try org/jruby/runtime/builtin/IRubyObject)])

(import: org/jruby/javasupport/JavaArray
  ["#::."
   (new [org/jruby/Ruby java/lang/Object])])

(type: Translator
  (-> java/lang/Object (Try Any)))

(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)
          #.None
          (recur (inc idx) output)
          
          (#.Some value)
          (case (read value)
            (#try.Failure error)
            (#try.Failure error)

            (#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.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 (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)])
    (#try.Success [(java/lang/Long::intValue (:coerce java/lang/Long tag))
                   (: Any (case ?flag
                            (#.Some _)
                            ""

                            #.None
                            (host.null)))
                   value])

    _
    (exception.throw ..unknown_kind_of_object host_object)))

(exception: #export nil_has_no_lux_representation)

(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>)

                   _)]

                [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: (cannot_apply_a_non_function {object java/lang/Object})
  (exception.report
   ["Non-function" (java/lang/Object::toString object)]))

(import: org/jruby/embed/internal/LocalContextProvider
  ["#::."
   (getRuntime [] org/jruby/Ruby)])

(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
  (-> Macro (Maybe org/jruby/RubyProc))
  (|>> (:coerce java/lang/Object) (host.check org/jruby/RubyProc)))

(template: (!ruby_runtime)
  (|> ..interpreter
      org/jruby/embed/ScriptingContainer::getProvider
      org/jruby/embed/internal/LocalContextProvider::getRuntime))

(template: (!ruby_thread_context)
  (|> (!ruby_runtime)
      org/jruby/Ruby::getCurrentContext))

(def: to_host
  (-> Any org/jruby/runtime/builtin/IRubyObject)
  (|>> (:coerce (Array java/lang/Object))
       ..lux_structure
       ## (org/jruby/javasupport/JavaArray::new (!ruby_runtime))
       ))

(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)
    (#.Some macro)
    (case (call_macro inputs lux macro)
      (#try.Success output)
      (|> output
          (:coerce java/lang/Object)
          ..read
          (:coerce (Try (Try [Lux (List Code)]))))

      (#try.Failure error)
      (#try.Failure error))

    #.None
    (exception.throw ..cannot_apply_a_non_function (:coerce java/lang/Object macro))))

(def: separator "___")

(def: host
  (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 _.Expression _.Statement)
           (structure
            (def: (evaluate! context code)
              (run! code))

            (def: execute! run!)

            (def: (define! context input)
              (let [global (reference.artifact context)
                    @global (_.global global)]
                (do try.monad
                  [#let [definition (_.set (list @global) input)]
                   _ (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 _.LVar _.Expression _.Statement))
  (do io.monad
    [host ..host]
    (wrap {#platform.&file_system (file.async file.default)
           #platform.host host
           #platform.phase ruby.generate
           #platform.runtime runtime.generate
           #platform.write (|>> _.code (\ encoding.utf8 encode))})))

(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}]
  (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 []))))