diff options
author | Eduardo Julian | 2018-04-04 00:56:16 -0400 |
---|---|---|
committer | Eduardo Julian | 2018-04-04 00:56:16 -0400 |
commit | 787fc34a8f7c66746046a8ce0c16403cf6c2bf6c (patch) | |
tree | 31c054f4a61e784875b7d66642558e9357d91493 /new-luxc/source/luxc/lang/host/python.lux | |
parent | b14f95ca68887d9e6cea211b47e04e5ec00c05fa (diff) |
- Initial Python back-end implementation.
Diffstat (limited to '')
-rw-r--r-- | new-luxc/source/luxc/lang/host/python.lux | 340 |
1 files changed, 340 insertions, 0 deletions
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))) + ) |