- Initial Python back-end implementation.

2 files changed, 341 insertions, 1 deletions

diff --git a/new-luxc/source/luxc/lang/host.jvm.lux b/new-luxc/source/luxc/lang/host.jvm.lux
index f22bf3302..58b79cfa4 100644
--- a/new-luxc/source/luxc/lang/host.jvm.lux
+++ b/new-luxc/source/luxc/lang/host.jvm.lux
@@ -183,4 +183,4 @@
 (def: #export runtime-class Text "LuxRuntime")
 (def: #export function-class Text "LuxFunction")
 (def: #export runnable-class Text "LuxRunnable")
-(def: #export unit Text "\u0000")
+(def: #export unit Text "")
diff --git a/new-luxc/source/luxc/lang/host/python.lux b/new-luxc/source/luxc/lang/host/python.lux
new file mode 100644
index 000000000..335d418a3
--- /dev/null
+++ b/new-luxc/source/luxc/lang/host/python.lux
@@ -0,0 +1,340 @@
+(.module:
+  [lux #- not or and list if is]
+  (lux (control pipe)
+       (data [text]
+             text/format
+             [number]
+             (coll [list "list/" Functor<List> Fold<List>]))
+       (type abstract)))
+
+(abstract: #export Single {} Unit)
+(abstract: #export Poly {} Unit)
+(abstract: #export Keyword {} Unit)
+
+(abstract: #export (Var kind)
+  {}
+
+  Text
+
+  (def: name (All [k] (-> (Var k) Text)) (|>> @representation))
+
+  (def: #export var (-> Text (Var Single)) (|>> @abstraction))
+
+  (do-template [<name> <kind> <prefix>]
+    [(def: #export <name>
+       (-> (Var Single) (Var <kind>))
+       (|>> @representation (format <prefix>) @abstraction))]
+
+    [poly    Poly    "*"]
+    [keyword Keyword "**"]
+    )
+  )
+
+(type: #export SVar (Var Single))
+(type: #export PVar (Var Poly))
+(type: #export KVar (Var Keyword))
+
+(abstract: #export Expression
+  {}
+  
+  Text
+
+  (def: #export expression (-> Expression Text) (|>> @representation))
+
+  (def: #export code (-> Text Expression) (|>> @abstraction))
+
+  (def: #export none
+    Expression
+    (@abstraction "None"))
+
+  (def: #export bool
+    (-> Bool Expression)
+    (|>> (case> true "True"
+                false "False")
+         @abstraction))
+
+  (def: #export int
+    (-> Int Expression)
+    (|>> %i @abstraction))
+
+  (def: #export float
+    (-> Frac Expression)
+    (|>> (cond> [(f/= number.positive-infinity)]
+                [(new> "float(\"inf\")")]
+                
+                [(f/= number.negative-infinity)]
+                [(new> "float(\"-inf\")")]
+                
+                [(f/= number.not-a-number)]
+                [(new> "float(\"nan\")")]
+                
+                ## else
+                [%f])
+         @abstraction))
+
+  (def: #export string
+    (-> Text Expression)
+    (|>> %t @abstraction))
+
+  (def: (composite-literal left-delimiter right-delimiter entry-serializer)
+    (All [a] (-> Text Text (-> a Text)
+                 (-> (List a) Expression)))
+    (function [entries]
+      (@abstraction (format "(" left-delimiter
+                            (|> entries (list/map entry-serializer) (text.join-with ","))
+                            right-delimiter ")"))))
+
+  (do-template [<name> <pre> <post>]
+    [(def: #export <name>
+       (-> (List Expression) Expression)
+       (composite-literal <pre> <post> expression))]
+
+    [tuple "(" ")"]
+    [list  "[" "]"]
+    )
+  
+  (def: #export (slice from to list)
+    (-> Expression Expression Expression Expression)
+    (@abstraction (format "(" (@representation list)
+                          "[" (@representation from) ":" (@representation to) "]"
+                          ")")))
+
+  (def: #export (slice-from from list)
+    (-> Expression Expression Expression)
+    (@abstraction (format "(" (@representation list)
+                          "[" (@representation from) ":]"
+                          ")")))
+
+  (def: #export dict
+    (-> (List [Expression Expression]) Expression)
+    (composite-literal "{" "}" (.function [[k v]] (format (@representation k) " : " (@representation v)))))
+
+  (def: #export (apply args func)
+    (-> (List Expression) Expression Expression)
+    (@abstraction (format "(" (@representation func)
+                          "(" (text.join-with "," (list/map expression args)) ")"
+                          ")")))
+
+  (do-template [<name> <kind> <prefix>]
+    [(def: (<name> var)
+       (-> Expression Text)
+       (format <prefix> (@representation var)))]
+
+    [splat-poly    Poly    "*"]
+    [splat-keyword Keyword "**"]
+    )
+
+  (do-template [<name> <splat>]
+    [(def: #export (<name> args extra func)
+       (-> (List Expression) Expression Expression Expression)
+       (@abstraction (format "(" (@representation func)
+                             (format "(" (|> args
+                                             (list/map (function [arg] (format (@representation arg) ", ")))
+                                             (text.join-with ""))
+                                     (<splat> extra) ")")
+                             ")")))]
+
+    [apply-poly    splat-poly]
+    [apply-keyword splat-keyword]
+    )
+
+  (def: #export (field name object)
+    (-> Text Expression Expression)
+    (@abstraction (format "(" (@representation object) "." name ")")))
+
+  (def: #export (send args method object)
+    (-> (List Expression) Text Expression Expression)
+    (|> object (field method) (apply args)))
+
+  (do-template [<name> <apply>]
+    [(def: #export (<name> args extra method)
+       (-> (List Expression) Expression Text
+           (-> Expression Expression))
+       (|>> (field method) (<apply> args extra)))]
+
+    [send-poly    apply-poly]
+    [send-keyword apply-keyword]
+    )
+
+  (def: #export (nth idx array)
+    (-> Expression Expression Expression)
+    (@abstraction (format "(" (@representation array) "[" (@representation idx) "])")))
+
+  (def: #export (if test then else)
+    (-> Expression Expression Expression Expression)
+    (@abstraction (format "(" (@representation then)
+                          " if " (@representation test)
+                          " else " (@representation else)
+                          ")")))
+
+  (do-template [<name> <op>]
+    [(def: #export (<name> param subject)
+       (-> Expression Expression Expression)
+       (@abstraction (format "(" (@representation subject)
+                             " " <op> " "
+                             (@representation param) ")")))]
+
+    [is      "is"]
+    [=       "=="]
+    [<       "<"]
+    [<=      "<="]
+    [>       ">"]
+    [>=      ">="]
+    [+       "+"]
+    [-       "-"]
+    [*       "*"]
+    [/       "/"]
+    [%       "%"]
+    [**      "**"]
+    [bit-or  "|"]
+    [bit-and "&"]
+    [bit-xor "^"]
+    [bit-shl "<<"]
+    [bit-shr ">>"]
+    )
+
+  (do-template [<name> <op>]
+    [(def: #export (<name> param subject)
+       (-> Expression Expression Expression)
+       (@abstraction (format "(" (@representation param)
+                             " " <op> " "
+                             (@representation subject) ")")))]
+
+    [or      "or"]
+    [and     "and"]
+    )
+
+  (def: #export (not subject)
+    (-> Expression Expression)
+    (@abstraction (format "(not " (@representation subject) ")")))
+
+  (def: #export (@@ var)
+    (All [k] (-> (Var k) Expression))
+    (@abstraction (format "(" (..name var) ")")))
+
+  (def: #export (lambda arguments body)
+    (-> (List (Ex [k] (Var k))) Expression Expression)
+    (@abstraction (format "(" "lambda " (|> arguments (list/map ..name) (text.join-with ", ")) ": "
+                          (@representation body) ")")))
+
+  (def: #export global
+    (-> Text Expression)
+    (|>> var @@))
+
+  (def: #export (length sequence)
+    (-> Expression Expression)
+    (apply (.list sequence) (global "len")))
+  )
+
+(abstract: #export Statement
+  {}
+  
+  Text
+
+  (def: #export statement (-> Statement Text) (|>> @representation))
+
+  (def: nest
+    (-> Statement Text)
+    (|>> @representation
+         (format "\n")
+         (text.replace-all "\n" "\n  ")))
+
+  (def: #export (set-nth! idx value array)
+    (-> Expression Expression Expression Statement)
+    (@abstraction (format (expression array) "[" (expression idx) "] = " (expression value))))
+
+  (def: #export (set! vars value)
+    (-> (List (Var Single)) Expression Statement)
+    (@abstraction
+     (format (|> vars (list/map ..name) (text.join-with ", "))
+             " = "
+             (expression value))))
+
+  (def: #export (if! test then! else!)
+    (-> Expression Statement Statement Statement)
+    (@abstraction
+     (format "if " (expression test) ":"
+             (nest then!)
+             "\n" "else:"
+             (nest else!))))
+
+  (def: #export (when! test then!)
+    (-> Expression Statement Statement)
+    (@abstraction
+     (format "if " (expression test) ":"
+             (nest then!))))
+
+  (def: #export (cond! clauses else!)
+    (-> (List [Expression Statement]) Statement Statement)
+    (list/fold (.function [[test then!] next!]
+                 (if! test then! next!))
+               else!
+               (list.reverse clauses)))
+
+  (def: #export (then! pre! post!)
+    (-> Statement Statement Statement)
+    (@abstraction
+     (format (@representation pre!)
+             "\n"
+             (@representation post!))))
+
+  (def: #export (while! test body!)
+    (-> Expression Statement Statement)
+    (@abstraction
+     (format "while " (expression test) ":"
+             (nest body!))))
+
+  (def: #export (for-in! var inputs body!)
+    (-> SVar Expression Statement Statement)
+    (@abstraction
+     (format "for " (..name var) " in " (expression inputs) ":"
+             (nest body!))))
+
+  (def: #export (do! expression)
+    (-> Expression Statement)
+    (@abstraction
+     (format (..expression expression) ";")))
+
+  (def: #export no-op!
+    Statement
+    (@abstraction "\n"))
+
+  (type: #export Except
+    {#classes (List Text)
+     #exception SVar
+     #handler Statement})
+  
+  (def: #export (try! body! excepts)
+    (-> Statement (List Except) Statement)
+    (@abstraction
+     (format "try:"
+             (nest body!)
+             (|> excepts
+                 (list/map (function [[classes exception catch!]]
+                             (format "\n" "except (" (text.join-with "," classes)
+                                     ") as " (..name exception) ":"
+                                     (nest catch!))))
+                 (text.join-with "")))))
+
+  (do-template [<name> <keyword>]
+    [(def: #export (<name> message)
+       (-> Expression Statement)
+       (@abstraction
+        (format <keyword> " " (expression message))))]
+
+    [raise!  "raise"]
+    [return! "return"]
+    [print!  "print"]
+    )
+  
+  (def: #export (def! name args body)
+    (-> (Var Single) (List (Ex [k] (Var k))) Statement Statement)
+    (@abstraction
+     (format "def " (..name name)
+             "(" (|> args (list/map ..name) (text.join-with ",")) "):"
+             (nest body))))
+
+  (def: #export (import! module-name)
+    (-> Text Statement)
+    (@abstraction (format "import " module-name)))
+  )