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

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

(with_expansions [<jvm> (as_is (import: java/lang/String)
                               
                               (import: (java/lang/Class a))

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

                               (import: org/python/core/PyNone)
                               (import: org/python/core/PyBoolean)
                               (import: org/python/core/PyInteger)
                               (import: org/python/core/PyLong)
                               (import: org/python/core/PyFloat)
                               (import: org/python/core/PyTuple)
                               (import: org/python/core/PyList)

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

                               (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__ .nat)]
                                   (loop [idx 0
                                          output (:as (Array Any)
                                                      (array.empty size))]
                                     (if (n.< size idx)
                                       (case (org/python/core/PyObject::__getitem__ (.int idx) host_object)
                                         {try.#Failure try}
                                         {try.#Failure try}
                                         
                                         {try.#Success value}
                                         (case (read value)
                                           {try.#Failure try}
                                           {try.#Failure try}

                                           {try.#Success lux_value}
                                           (again (++ idx) (array.write! idx lux_value output))))
                                       {try.#Success output}))))

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

                               (def: (read_variant read host_object)
                                 (-> Translator Translator)
                                 (case [(org/python/core/PyObject::__getitem__ +0 host_object)
                                        (org/python/core/PyObject::__getitem__ +1 host_object)
                                        (org/python/core/PyObject::__getitem__ +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
                                                  (: Any
                                                     (case (ffi.check 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)])))

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

                                                  _)]

                                               [org/python/core/PyNone [(new> [] [])]]
                                               [org/python/core/PyBoolean [org/python/core/PyObject::__nonzero__]]
                                               ... [org/python/core/PyInteger [(ffi.:as org/python/core/PyObject) org/python/core/PyObject::asInt]]
                                               [org/python/core/PyInteger [(ffi.:as org/python/core/PyObject)
                                                                           ("jvm member invoke virtual" [] "org.python.core.PyObject" "asInt" [])
                                                                           "jvm object cast"
                                                                           (: (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] [(|>)]]
                                               ))
                                         (~~ (template [<class> <processing>]
                                               [(case (ffi.check <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})))

                               (exception: (cannot_apply_a_non_function [object java/lang/Object])
                                 (exception.report
                                  ["Non-function" (java/lang/Object::toString object)]))

                               (def: (ensure_macro macro)
                                 (-> Macro (Maybe org/python/core/PyFunction))
                                 (ffi.check org/python/core/PyFunction (:as java/lang/Object macro)))

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

                               (def: to_host
                                 (-> Any org/python/core/PyObject)
                                 (|>> (:as java/lang/Object)
                                      (org/python/core/PyArray::new ..object_class)
                                      (:as org/python/core/PyObject)))

                               (def: ensure_function
                                 (-> Any (Maybe org/python/core/PyFunction))
                                 (|>> (:as java/lang/Object)
                                      (ffi.check org/python/core/PyFunction)))
                               )]
  (for [@.old (as_is <jvm>)
        @.jvm (as_is <jvm>)
        @.python (as_is)]))

(with_expansions [<jvm> (as_is (def: (call_macro inputs lux macro)
                                 (-> (List Code) Lux org/python/core/PyFunction (Try (Try [Lux (List Code)])))
                                 (:expected
                                  (do try.monad
                                    [expansion (org/python/core/PyFunction::__call__ (|> (ffi.array org/python/core/PyObject 2)
                                                                                         (ffi.write! 0 (..to_host inputs))
                                                                                         (ffi.write! 1 (..to_host lux)))
                                                                                     macro)]
                                    (..read expansion))))

                               (def: (expander macro inputs lux)
                                 Expander
                                 (case (ensure_macro 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 (as_is <jvm>)
        @.jvm (as_is <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! (: (-> Context (_.Expression Any) (Try Any))
                                                 (function (evaluate! context input)
                                                   (do try.monad
                                                     [output (org/python/util/PythonInterpreter::eval (_.code input) interpreter)]
                                                     (..read output))))
                                    execute! (: (-> (_.Statement Any) (Try Any))
                                                (function (execute! input)
                                                  (case (org/python/util/PythonInterpreter::exec (_.code input) interpreter)
                                                    {try.#Failure error}
                                                    (if (text.contains? "maximum recursion depth exceeded" error)
                                                      (execute! input)
                                                      {try.#Failure error})

                                                    output
                                                    output)))]
                                (: (Host (_.Expression Any) (_.Statement Any))
                                   (implementation
                                    (def: evaluate evaluate!)
                                    (def: execute execute!)
                                    (def: (define context custom 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 @global)]
                                          (in [global value definition]))))

                                    (def: (ingest context content)
                                      (|> content
                                          (# 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 (_.var (reference.artifact context))))))))))]
  (for [@.old <jvm>
        @.jvm <jvm>

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

               (def: host
                 (IO (Host (_.Expression Any) (_.Statement Any)))
                 (io (: (Host (_.Expression Any) (_.Statement Any))
                        (let [globals (..dict [])
                              evaluate! (: (-> Context (_.Expression Any) (Try Any))
                                           (function (evaluate! context input)
                                             (..eval [(_.code input) globals])))
                              execute! (: (-> (_.Statement Any) (Try Any))
                                          (function (execute! input)
                                            (ffi.try ("python exec" (_.code input) globals))))
                              define! (: (-> Context (_.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 (# 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> (as_is (exception: .public (invaid_phase_application [partial_application (List Any)
                                                                              arity Nat])
                                 (exception.report
                                  ["Partial Application" (%.nat (list.size partial_application))]
                                  ["Arity" (%.nat arity)]))

                               (def: (host_phase partial_application phase)
                                 (All (_ s i o)
                                   (-> (List Any) (Phase [extension.Bundle s] i o)
                                       org/python/core/PyObject))
                                 (<| (:as org/python/core/PyObject)
                                     (ffi.object [] org/python/core/PyObject []
                                       []
                                       ... Methods
                                       (org/python/core/PyObject
                                        [] (__call__ self [inputs [org/python/core/PyObject]
                                                           keywords [java/lang/String]])
                                        org/python/core/PyObject
                                        (try.trusted
                                         (case (array.list {.#None} inputs)
                                           (^ (list))
                                           (# try.monad in (host_phase (list) phase))
                                           
                                           (^ (list input/0))
                                           (do try.monad
                                             [input/0 (..read input/0)]
                                             (case partial_application
                                               (^ (list partial/0 partial/1))
                                               (in (..to_host ((:as (-> Any Any Any Any) phase)
                                                               partial/0
                                                               partial/1
                                                               input/0)))

                                               (^ (list partial/0))
                                               (in (host_phase (list partial/0 input/0) phase))
                                               
                                               (^ (list))
                                               (in (host_phase (list input/0) phase))

                                               _
                                               (exception.except ..invaid_phase_application [partial_application (array.size inputs)])))
                                           
                                           (^ (list input/0 input/1))
                                           (do try.monad
                                             [input/0 (..read input/0)
                                              input/1 (..read input/1)]
                                             (case partial_application
                                               (^ (list partial/0))
                                               (in (..to_host ((:as (-> Any Any Any Any) phase)
                                                               partial/0
                                                               input/0
                                                               input/1)))
                                               
                                               (^ (list))
                                               (in (host_phase (list input/0 input/1) phase))

                                               _
                                               (exception.except ..invaid_phase_application [partial_application (array.size inputs)])))
                                           
                                           (^ (list input/0 input/1 input/2))
                                           (do try.monad
                                             [input/0 (..read input/0)
                                              input/1 (..read input/1)
                                              input/2 (..read input/2)]
                                             (case partial_application
                                               (^ (list))
                                               (in (..to_host ((:as (-> Any Any Any Any) phase)
                                                               input/0
                                                               input/1
                                                               input/2)))
                                               
                                               _
                                               (exception.except ..invaid_phase_application [partial_application (array.size inputs)])))

                                           _
                                           (exception.except ..invaid_phase_application [partial_application (array.size inputs)])))))))
                               
                               (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 (..ensure_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 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 (as_is <jvm>)
        @.jvm (as_is <jvm>)

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

(def: (phase_wrapper archive)
  (-> Archive (runtime.Operation phase.Wrapper))
  (do phase.monad
    []
    (in (:as phase.Wrapper
             (..host_phase (list))))))

(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 (# utf8.codec encoded))])))

(def: (program context program)
  (Program (_.Expression Any) (_.Statement Any))
  ($_ _.then
      (_.import "sys")
      (_.when (_.= (_.string "__main__") (_.var "__name__"))
              (_.statement (_.apply/2 program
                                      (|> (_.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)))))

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

(def: (scope body)
  (-> (_.Statement Any) (_.Statement Any))
  (let [@program (_.var "lux_program")
        max_recursion (|> (_.int +10) (_.** (_.int +6)))
        ; _.statement]
    (<| (_.comment "-*- coding: utf-8 -*-")
        ($_ _.then
            (; (|> (_.__import__/1 (_.unicode "sys"))
                   (_.do "setrecursionlimit" (list max_recursion))))
            (_.def @program (list) body)
            (; (_.apply/* @program (list)))
            ))))

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