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

(.using
 [library
  [lux (.except)
   [program (.only program:)]
   ["[0]" ffi (.only import)]
   ["[0]" debug]
   ["[0]" static]
   [abstract
    ["[0]" monad (.only do)]]
   [control
    ["[0]" pipe]
    ["[0]" maybe]
    ["[0]" try (.only Try) (.open: "[1]#[0]" monad)]
    ["[0]" exception (.only exception:)]
    ["[0]" io (.only IO io)]
    ["[0]" function]
    [concurrency
     ["[0]" async (.only Async)]]]
   [data
    ["[0]" text (.open: "[1]#[0]" hash)
     ["%" \\format (.only format)]
     [encoding
      ["[0]" utf8]]]
    [collection
     ["[0]" array (.only Array)]
     ["[0]" list (.open: "[1]#[0]" functor)]]]
   [macro
    ["^" pattern]
    ["[0]" template]
    ["[0]" code]]
   [math
    [number
     ["n" nat]
     ["[0]" i64]]]
   ["[0]" world
    ["[0]" file]
    ["[1]/[0]" program]]
   ["@" target (.only)
    ["_" python]]
   [tool
    ["[0]" compiler
     ["[0]" phase (.only Operation Phase) (.open: "[1]#[0]" monad)]
     [reference
      [variable (.only Register)]]
     [language
      [lux
       [program (.only Program)]
       [generation (.only Host)]
       ["[0]" synthesis]
       [analysis
        [macro (.only Expander)]]
       [phase
        ["[0]" extension (.only Extender Handler)
         ["[1]/[0]" bundle]
         ["[0]" analysis
          ["[1]" python]]
         ["[0]" generation
          ["[1]" python]]]
        [generation
         ["[0]" reference]
         ["[0]" python (.only)
          ["[0]" runtime]]]]]]
     [default
      ["[0]" platform (.only Platform)]]
     [meta
      ["[0]" context]
      ["[0]" cli]
      [archive (.only Archive)
       ["[0]" unit]]
      ["[0]" packager
       ["[1]" script]]]]]]]
 [program
  ["/" compositor]])

(with_expansions [<jvm> (these (import java/lang/String
                                 "[1]::[0]")
                               
                               (import (java/lang/Class a)
                                 "[1]::[0]"
                                 ("static" forName [java/lang/String] (java/lang/Class java/lang/Object))
                                 (getName [] java/lang/String))

                               (import java/lang/Object
                                 "[1]::[0]"
                                 (new [])
                                 (toString [] java/lang/String)
                                 (getClass [] (java/lang/Class java/lang/Object)))

                               (import org/python/core/PyNone
                                 "[1]::[0]")
                               
                               (import org/python/core/PyInteger
                                 "[1]::[0]")
                               
                               (import org/python/core/PyTuple
                                 "[1]::[0]")
                               
                               (import org/python/core/PyList
                                 "[1]::[0]")
                               
                               (import org/python/core/PyBoolean
                                 "[1]::[0]"
                                 (new [boolean]))
                               
                               (import org/python/core/PyLong
                                 "[1]::[0]"
                                 (new [long]))
                               
                               (import org/python/core/PyFloat
                                 "[1]::[0]"
                                 (new [double]))

                               (import org/python/core/PyString
                                 "[1]::[0]"
                                 (new [java/lang/String]))

                               (import org/python/core/PyObject
                                 "[1]::[0]"
                                 (asInt [] java/lang/Integer)
                                 (asLong [] long)
                                 (asDouble [] double)
                                 (asString [] java/lang/String)
                                 (__nonzero__ [] boolean)
                                 (__getitem__ [int] "try" org/python/core/PyObject)
                                 (__getitem__ "as" __getitem__dict [org/python/core/PyObject] "try" org/python/core/PyObject)
                                 (__len__ [] int))

                               (import org/python/core/PyFunction
                                 "[1]::[0]"
                                 (__call__ [[org/python/core/PyObject]] "try" org/python/core/PyObject))

                               (import org/python/core/ThreadState
                                 "[1]::[0]")

                               (import org/python/core/PyArray
                                 "[1]::[0]"
                                 (new [(java/lang/Class [? < java/lang/Object]) java/lang/Object])
                                 (getArray [] java/lang/Object))

                               (import org/python/util/PythonInterpreter
                                 "[1]::[0]"
                                 (new [])
                                 (exec [java/lang/String] "try" void)
                                 (eval [java/lang/String] "try" PyObject))

                               (type: Translator
                                 (-> org/python/core/PyObject (Try Any)))

                               (def: (read_tuple read host_object)
                                 (-> Translator Translator)
                                 (let [size (|> host_object org/python/core/PyObject::__len__ ffi.of_int .nat)]
                                   (loop (again [idx 0
                                                 output (as (Array Any)
                                                            (array.empty size))])
                                     (if (n.< size idx)
                                       (case (org/python/core/PyObject::__getitem__ (ffi.as_int (.int idx)) host_object)
                                         {try.#Success value}
                                         (case (read value)
                                           {try.#Success lux_value}
                                           (again (++ idx) (array.has! idx lux_value output))

                                           failure
                                           failure)

                                         failure
                                         failure)
                                       {try.#Success output}))))

                               (exception: (unknown_kind_of_object [object java/lang/Object])
                                 (exception.report
                                  "Object" (ffi.of_string (java/lang/Object::toString object))))

                               (def: (read_variant read host_object)
                                 (-> Translator Translator)
                                 (case [(org/python/core/PyObject::__getitem__ (ffi.as_int +0) host_object)
                                        (org/python/core/PyObject::__getitem__ (ffi.as_int +1) host_object)
                                        (org/python/core/PyObject::__getitem__ (ffi.as_int +2) host_object)]
                                   (^.or [{try.#Failure try} _ _]
                                         [_ {try.#Failure try} _]
                                         [_ _ {try.#Failure try}])
                                   {try.#Failure try}
                                   
                                   (^.multi [{try.#Success tag} {try.#Success flag} {try.#Success value}]
                                            [(read tag)
                                             {try.#Success tag}]
                                            [(read value)
                                             {try.#Success value}])
                                   {try.#Success [tag
                                                  (is Any
                                                      (case (ffi.as org/python/core/PyNone
                                                                    (as java/lang/Object flag))
                                                        {.#Some _}
                                                        (as Any (ffi.null))

                                                        {.#None}
                                                        (as Any synthesis.unit)))
                                                  value]}

                                   _
                                   (exception.except ..unknown_kind_of_object [(as java/lang/Object host_object)])))

                               (ffi.interface LuxValue
                                 (value [] java/lang/Object))

                               (import LuxValue
                                 "[1]::[0]"
                                 (value [] java/lang/Object))

                               (def: (read host_object)
                                 Translator
                                 (`` (<| (~~ (with_template [<class> <processing>]
                                               [(case (ffi.as <class> (as <class> host_object))
                                                  {.#Some host_object}
                                                  {try.#Success (`` (|> host_object (~~ (template.spliced <processing>))))}

                                                  _)]

                                               [LuxValue [LuxValue::value]]
                                               [org/python/core/PyNone [(pipe.new [] [])]]
                                               [org/python/core/PyBoolean [org/python/core/PyObject::__nonzero__]]
                                               ... [org/python/core/PyInteger [(ffi.is org/python/core/PyObject) org/python/core/PyObject::asInt]]
                                               [org/python/core/PyInteger [(ffi.is org/python/core/PyObject)
                                                                           ("jvm member invoke virtual" [] "org.python.core.PyObject" "asInt" [])
                                                                           "jvm object cast"
                                                                           (is (Primitive "java.lang.Integer"))]]
                                               [org/python/core/PyLong [org/python/core/PyObject::asLong]]
                                               [org/python/core/PyFloat [org/python/core/PyObject::asDouble]]
                                               [org/python/core/PyString [org/python/core/PyObject::asString]]
                                               [org/python/core/PyFunction []]
                                               [org/python/core/PyArray [org/python/core/PyArray::getArray]]
                                               [[java/lang/Object] [(|>)]]
                                               ))
                                         (~~ (with_template [<class> <processing>]
                                               [(case (ffi.as <class> host_object)
                                                  {.#Some host_object}
                                                  (<| <processing> (as org/python/core/PyObject) host_object)

                                                  _)]

                                               [org/python/core/PyTuple (..read_variant read)]
                                               [org/python/core/PyList (..read_tuple read)]
                                               ))
                                         ... (exception.except ..unknown_kind_of_object [(as java/lang/Object host_object)])
                                         {try.#Success host_object})))

                               (def: (function/? arity)
                                 (-> Nat Code)
                                 (` (.-> (~+ (list.repeated arity (` .Any))) .Any)))

                               (def: (inputs/? arity)
                                 (-> Nat (List Text))
                                 (|> (list.indices arity)
                                     (list#each (|>> %.nat (format "input/")))))

                               (def: (pseudo_function to_host it)
                                 (-> (-> Any org/python/core/PyObject) Any org/python/core/PyObject)
                                 (<| (as org/python/core/PyObject)
                                     (ffi.object [] org/python/core/PyObject [LuxValue]
                                       []
                                       ... Methods
                                       (LuxValue [] (value self []) java/lang/Object (as java/lang/Object it))
                                       
                                       (org/python/core/PyObject
                                        [] (__call__ self [inputs [org/python/core/PyObject]
                                                           keywords [java/lang/String]])
                                        org/python/core/PyObject
                                        (try.trusted
                                         (do [! try.monad]
                                           [inputs (monad.each ! ..read (array.list {.#None} inputs))]
                                           (in (loop (again [it it
                                                             inputs inputs])
                                                 (`` (`` (case inputs
                                                           (pattern (list))
                                                           (as org/python/core/PyObject self)

                                                           (~~ (with_template [<arity>]
                                                                 [(pattern (list (~~ (static.literals code.local (inputs/? <arity>)))))
                                                                  (to_host ((as (~~ (static.literal function.identity (function/? <arity>))) it)
                                                                            (~~ (static.literals code.local (inputs/? <arity>)))))]

                                                                 [1]
                                                                 [2]
                                                                 [3]
                                                                 [4]
                                                                 [5]
                                                                 [6]
                                                                 [7]
                                                                 [8]))

                                                           (pattern (list.partial (~~ (static.literals code.local (inputs/? 8)))
                                                                                  input/+))
                                                           (again ((as (~~ (static.literal function.identity (function/? 8))) it)
                                                                   (~~ (static.literals code.local (inputs/? 8))))
                                                                  input/+))))))))))))

                               (def: object_class
                                 (java/lang/Class java/lang/Object)
                                 (java/lang/Object::getClass (java/lang/Object::new)))

                               (import library/lux/Function
                                 "[1]::[0]")

                               (def: (to_host|array to_host it)
                                 (-> (-> Any org/python/core/PyObject) Any org/python/core/PyObject)
                                 (as org/python/core/PyObject
                                     (ffi.object [] org/python/core/PyArray [LuxValue]
                                       [(java/lang/Class java/lang/Object) ..object_class
                                        java/lang/Object (as java/lang/Object it)]
                                       ... Methods
                                       (LuxValue
                                        [] (value self [])
                                        java/lang/Object
                                        (as java/lang/Object it))
                                       
                                       (org/python/core/PyArray
                                        [] (pyget self [index' int])
                                        org/python/core/PyObject
                                        (case (|> it
                                                  (as (Array Any))
                                                  (array.item (|> index' ffi.int_to_long (as Nat))))
                                          {.#None}
                                          (pyget "super" [index'])

                                          {.#Some it}
                                          (<| (case (ffi.as [java/lang/Object] (as java/lang/Object it))
                                                {.#Some it}
                                                (to_host it)

                                                {.#None})
                                              (case (ffi.as library/lux/Function (as java/lang/Object it))
                                                {.#Some it}
                                                (pseudo_function to_host it)

                                                {.#None})
                                              (pyget "super" [index']))))
                                       )))

                               (def: (to_host it)
                                 (-> Any org/python/core/PyObject)
                                 (`` (<| (~~ (with_template [<jvm> <python>]
                                               [(case (ffi.as <jvm> (as java/lang/Object it))
                                                  {.#Some it}
                                                  (as org/python/core/PyObject
                                                      (<python> [it]))

                                                  {.#None})]

                                               [java/lang/Boolean org/python/core/PyBoolean::new]
                                               [java/lang/Long org/python/core/PyLong::new]
                                               [java/lang/Double org/python/core/PyFloat::new]
                                               [java/lang/String org/python/core/PyString::new]
                                               [library/lux/Function (pseudo_function to_host)]
                                               [[java/lang/Object] (to_host|array to_host)]
                                               ))
                                         (as org/python/core/PyObject it))))
                               )]
  (for @.old (these <jvm>)
       @.jvm (these <jvm>)
       @.python (these)))

(with_expansions [<jvm> (these (def: (call_macro inputs lux macro)
                                 (-> (List Code) Lux org/python/core/PyFunction (Try (Try [Lux (List Code)])))
                                 (|> macro
                                     (org/python/core/PyFunction::__call__ (|> (ffi.array org/python/core/PyObject 2)
                                                                               (ffi.write! 0 (..to_host inputs))
                                                                               (ffi.write! 1 (..to_host lux))))
                                     (try#each ..read)
                                     try#conjoint
                                     as_expected))

                               (def: python_function!
                                 (-> Any (Maybe org/python/core/PyFunction))
                                 (|>> (as java/lang/Object)
                                      (ffi.as org/python/core/PyFunction)))

                               (exception: (cannot_apply_a_non_function [object java/lang/Object])
                                 (exception.report
                                  "Object" (ffi.of_string (java/lang/Object::toString object))
                                  "Class" (ffi.of_string (java/lang/Class::getName (java/lang/Object::getClass object)))))

                               (def: (expander macro inputs lux)
                                 Expander
                                 (case (python_function! macro)
                                   {.#Some macro}
                                   (case (..call_macro inputs lux macro)
                                     {try.#Success output}
                                     (|> output
                                         (as org/python/core/PyObject)
                                         ..read
                                         (as (Try (Try [Lux (List Code)]))))

                                     {try.#Failure error}
                                     {try.#Failure error})

                                   {.#None}
                                   (exception.except ..cannot_apply_a_non_function [(as java/lang/Object macro)]))))]
  (for @.old (these <jvm>)
       @.jvm (these <jvm>)

       @.python
       (def: (expander macro inputs lux)
         Expander
         {try.#Success ((as Macro' macro) inputs lux)})))

(with_expansions [<jvm> (def: host
                          (IO (Host (_.Expression Any) (_.Statement Any)))
                          (io (let [interpreter (org/python/util/PythonInterpreter::new)
                                    evaluate! (is (-> unit.ID [(Maybe unit.ID) (_.Expression Any)] (Try Any))
                                                  (function (evaluate! context [_ input])
                                                    (do try.monad
                                                      [output (org/python/util/PythonInterpreter::eval (ffi.as_string (_.code input)) interpreter)]
                                                      (..read output))))
                                    execute! (is (-> (_.Statement Any) (Try Any))
                                                 (function (execute! input)
                                                   (case (org/python/util/PythonInterpreter::exec (ffi.as_string (_.code input)) interpreter)
                                                     {try.#Failure error}
                                                     (if (text.contains? "maximum recursion depth exceeded" error)
                                                       (execute! input)
                                                       {try.#Failure error})

                                                     output
                                                     output)))]
                                (is (Host (_.Expression Any) (_.Statement Any))
                                    (implementation
                                     (def: evaluate evaluate!)
                                     (def: execute execute!)
                                     (def: (define context custom [@def input])
                                       (let [global (maybe.else (reference.artifact context)
                                                                custom)
                                             @global (_.var global)]
                                         (do try.monad
                                           [.let [definition (_.set (list @global) input)]
                                            _ (execute! definition)
                                            value (evaluate! context [@def @global])]
                                           (in [global value definition]))))

                                     (def: (ingest context content)
                                       (|> content
                                           (at utf8.codec decoded)
                                           try.trusted
                                           (as (_.Statement Any))))

                                     (def: (re_learn context custom content)
                                       (execute! content))
                                     
                                     (def: (re_load context custom content)
                                       (do try.monad
                                         [_ (execute! content)]
                                         (evaluate! context [{.#None} (_.var (reference.artifact context))]))))))))]
  (for @.old <jvm>
       @.jvm <jvm>

       @.python
       (these (import (dict [] ffi.Dict))
              (import (eval [ffi.String ffi.Dict] "try" Any))

              (def: host
                (IO (Host (_.Expression Any) (_.Statement Any)))
                (io (is (Host (_.Expression Any) (_.Statement Any))
                        (let [globals (..dict [])
                              evaluate! (is (-> unit.ID (_.Expression Any) (Try Any))
                                            (function (evaluate! context input)
                                              (..eval [(_.code input) globals])))
                              execute! (is (-> (_.Statement Any) (Try Any))
                                           (function (execute! input)
                                             (ffi.try ("python exec" (_.code input) globals))))
                              define! (is (-> unit.ID (_.Expression Any) (Try [Text Any (_.Statement Any)]))
                                          (function (define! context input)
                                            (let [global (reference.artifact context)
                                                  @global (_.var global)]
                                              (do try.monad
                                                [.let [definition (_.set (list @global) input)]
                                                 _ (execute! definition)
                                                 value (evaluate! context @global)]
                                                (in [global value definition])))))]
                          (implementation
                           (def: evaluate! evaluate!)
                           (def: execute! execute!)
                           (def: define! define!)

                           (def: (ingest context content)
                             (|> content (at utf8.codec decoded) try.trusted (as (_.Statement Any))))

                           (def: (re_learn context content)
                             (execute! content))
                           
                           (def: (re_load context content)
                             (do try.monad
                               [_ (execute! content)]
                               (evaluate! context (_.var (reference.artifact context)))))))))))))

(with_expansions [<jvm> (these (def: (extender phase_wrapper)
                                 (-> phase.Wrapper Extender)
                                 ... TODO: Stop relying on coercions ASAP.
                                 (<| (as Extender)
                                     (function (_ handler))
                                     (as Handler)
                                     (function (_ name phase))
                                     (as Phase)
                                     (function (_ archive parameters))
                                     (as Operation)
                                     (function (_ state))
                                     (as Try)
                                     try.trusted
                                     (as Try)
                                     (do try.monad
                                       [handler (try.of_maybe (..python_function! handler))
                                        output (org/python/core/PyFunction::__call__ (|> (ffi.array org/python/core/PyObject 5)
                                                                                         (ffi.write! 0 (as org/python/core/PyObject (org/python/core/PyString::new (ffi.as_string name))))
                                                                                         (ffi.write! 1 (as org/python/core/PyObject (phase_wrapper phase)))
                                                                                         (ffi.write! 2 (..to_host archive))
                                                                                         (ffi.write! 3 (..to_host parameters))
                                                                                         (ffi.write! 4 (..to_host state)))
                                                                                     handler)]
                                       (..read output)))))]
  (for @.old (these <jvm>)
       @.jvm (these <jvm>)

       @.python
       (def: (extender phase_wrapper handler)
         (-> phase.Wrapper Extender)
         (as_expected handler))))

(def: (phase_wrapper archive)
  (-> Archive (runtime.Operation phase.Wrapper))
  (|> (..pseudo_function ..to_host)
      (as phase.Wrapper)
      phase#in))

(def: platform
  (IO (Platform Register (_.Expression Any) (_.Statement Any)))
  (do io.monad
    [host ..host]
    (in [platform.#file_system (file.async file.default)
         platform.#host host
         platform.#phase python.generate
         platform.#runtime runtime.generate
         platform.#phase_wrapper ..phase_wrapper
         platform.#write (|>> _.code (at utf8.codec encoded))])))

(def: (program context program)
  (Program (_.Expression Any) (_.Statement Any))
  (all _.then
       (_.import "sys")
       (_.when (_.= (_.string "__main__") (_.var "__name__"))
               (_.statement (_.apply (list (|> (_.var "sys") (_.the "argv")
                                               ... The first entry in the list will be the program.py file itself
                                               ... so, it must be removed so only the program's arguments are left.
                                               (_.slice_from (_.int +1))
                                               runtime.lux::program_args)
                                           _.none)
                                     program)))))

(def: (declare_success! _)
  (-> Any (Async Any))
  (async.future (at world/program.default exit +0)))

(def: (scope body)
  (-> (_.Statement Any) (_.Statement Any))
  (let [@program (_.var "lux_program")
        ; _.statement
        $sys (_.__import__/1 (_.unicode "sys"))
        ... $threading (_.__import__/1 (_.unicode "threading"))
        current_limit (_.do "getrecursionlimit" (list) $sys)
        old_limit current_limit
        new_limit (_.bit_shl (_.int +2) old_limit)]
    (<| (_.comment "-*- coding: utf-8 -*-")
        (all _.then
             (; (_.do "setrecursionlimit" (list new_limit) $sys))
             ... (; (_.do "stack_size" (list current_limit) $threading))
             (_.def @program (list) body)
             (; (_.apply (list) @program))
             ))))

(def: (lux_compiler it)
  (-> Any platform.Custom)
  (undefined))

(program: [service cli.service]
  (let [extension ".py"]
    (exec
      (do async.monad
        [_ (/.compiler ..lux_compiler
                       (context.python (cli.target service))
                       ..expander
                       analysis.bundle
                       ..platform
                       generation.bundle
                       (function.constant extension/bundle.empty)
                       ..program
                       [Register
                        (type (_.Expression Any))
                        (type (_.Statement Any))]
                       ..extender
                       service
                       [(packager.package (is (_.Statement Any) (_.manual ""))
                                          _.code
                                          _.then
                                          ..scope)
                        (format (cli.target service)
                                (at file.default separator)
                                "program"
                                extension)])]
        (..declare_success! []))
      (io.io []))))