aboutsummaryrefslogtreecommitdiff
path: root/new-luxc/source/luxc/lang/host
diff options
context:
space:
mode:
Diffstat (limited to 'new-luxc/source/luxc/lang/host')
-rw-r--r--new-luxc/source/luxc/lang/host/python.lux340
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)))
+ )
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-27 15:10:14 +0000