Normalized the hierarchy of the standard library modules.

1 files changed, 501 insertions, 0 deletions

diff --git a/stdlib/source/library/lux/target/python.lux b/stdlib/source/library/lux/target/python.lux
new file mode 100644
index 000000000..49c3d8612
--- /dev/null
+++ b/stdlib/source/library/lux/target/python.lux
@@ -0,0 +1,501 @@
+(.module:
+  [library
+   [lux (#- Location Code not or and list if cond int comment exec try)
+    ["@" target]
+    ["." ffi]
+    [abstract
+     [equivalence (#+ Equivalence)]
+     [hash (#+ Hash)]
+     ["." enum]]
+    [control
+     [pipe (#+ new> case> cond>)]
+     [parser
+      ["<.>" code]]]
+    [data
+     ["." text
+      ["%" format (#+ format)]]
+     [collection
+      ["." list ("#\." functor fold)]]]
+    [macro
+     [syntax (#+ syntax:)]
+     ["." template]
+     ["." code]]
+    [math
+     [number
+      ["n" nat]
+      ["f" frac]]]
+    [type
+     abstract]]])
+
+(def: expression
+  (-> Text Text)
+  (text.enclose ["(" ")"]))
+
+(for {@.old (as_is (ffi.import: java/lang/CharSequence)
+                   (ffi.import: java/lang/String
+                     ["#::."
+                      (replace [java/lang/CharSequence java/lang/CharSequence] java/lang/String)]))}
+     (as_is))
+
+(def: nest
+  (-> Text Text)
+  (.let [nested_new_line (format text.new_line text.tab)]
+    (for {@.old (|>> (format text.new_line)
+                     (:as java/lang/String)
+                     (java/lang/String::replace (:as java/lang/CharSequence text.new_line)
+                                                (:as java/lang/CharSequence nested_new_line)))}
+         (|>> (format text.new_line)
+              (text.replace_all text.new_line nested_new_line)))))
+
+(abstract: #export (Code brand)
+  Text
+
+  (implementation: #export equivalence
+    (All [brand] (Equivalence (Code brand)))
+
+    (def: (= reference subject)
+      (\ text.equivalence = (:representation reference) (:representation subject))))
+
+  (implementation: #export hash
+    (All [brand] (Hash (Code brand)))
+
+    (def: &equivalence ..equivalence)
+    (def: hash (|>> :representation (\ text.hash hash))))
+
+  (def: #export manual
+    (-> Text Code)
+    (|>> :abstraction))
+
+  (def: #export code
+    (-> (Code Any) Text)
+    (|>> :representation))
+
+  (template [<type> <super>]
+    [(with_expansions [<brand> (template.identifier [<type> "'"])]
+       (`` (abstract: #export (<brand> brand) Any))
+       (`` (type: #export (<type> brand)
+             (<super> (<brand> brand)))))]
+    
+    [Expression Code]
+    [Computation Expression]
+    [Location Computation]
+    [Var Location]
+    [Statement Code]
+    )
+
+  (template [<type> <super>]
+    [(with_expansions [<brand> (template.identifier [<type> "'"])]
+       (`` (abstract: #export <brand> Any))
+       (`` (type: #export <type> (<super> <brand>))))]
+
+    [Literal Computation]
+    [Access Location]
+    [Loop Statement]
+    [Label Code]
+    )
+
+  (template [<var> <brand>]
+    [(abstract: #export <brand> Any)
+
+     (type: #export <var> (Var <brand>))]
+
+    [SVar Single]
+    [PVar Poly]
+    [KVar Keyword]
+    )
+
+  (def: #export var
+    (-> Text SVar)
+    (|>> :abstraction))
+
+  (template [<name> <brand> <prefix>]
+    [(def: #export <name>
+       (-> SVar (Var <brand>))
+       (|>> :representation (format <prefix>) :abstraction))]
+
+    [poly    Poly    "*"]
+    [keyword Keyword "**"]
+    )
+
+  (def: #export none
+    Literal
+    (:abstraction "None"))
+
+  (def: #export bool
+    (-> Bit Literal)
+    (|>> (case> #0 "False"
+                #1 "True")
+         :abstraction))
+
+  (def: #export int
+    (-> Int Literal)
+    (|>> %.int :abstraction))
+
+  (def: #export (long value)
+    (-> Int Literal)
+    (:abstraction (format (%.int value) "L")))
+
+  (def: #export float
+    (-> Frac Literal)
+    (`` (|>> (cond> (~~ (template [<test> <python>]
+                          [[<test>]
+                           [(new> (format "float(" text.double_quote <python> text.double_quote ")") [])]]
+
+                          [(f.= f.positive_infinity) "inf"]
+                          [(f.= f.negative_infinity) "-inf"]
+                          [f.not_a_number? "nan"]
+                          ))
+                    
+                    ## else
+                    [%.frac])
+             :abstraction)))
+
+  (def: sanitize
+    (-> Text Text)
+    (`` (|>> (~~ (template [<find> <replace>]
+                   [(text.replace_all <find> <replace>)]
+
+                   ["\" "\\"]
+                   [text.tab "\t"]
+                   [text.vertical_tab "\v"]
+                   [text.null "\0"]
+                   [text.back_space "\b"]
+                   [text.form_feed "\f"]
+                   [text.new_line "\n"]
+                   [text.carriage_return "\r"]
+                   [text.double_quote (format "\" text.double_quote)]
+                   ))
+             )))
+
+  (def: #export string
+    (-> Text Literal)
+    (|>> ..sanitize
+         (text.enclose [text.double_quote text.double_quote])
+         :abstraction))
+
+  (def: #export unicode
+    (-> Text Literal)
+    (|>> ..string
+         :representation
+         (format "u")
+         :abstraction))
+
+  (def: (composite_literal left_delimiter right_delimiter entry_serializer)
+    (All [a]
+      (-> Text Text (-> a Text)
+          (-> (List a) Literal)))
+    (function (_ entries)
+      (<| :abstraction
+          ## ..expression
+          (format left_delimiter
+                  (|> entries
+                      (list\map entry_serializer)
+                      (text.join_with ", "))
+                  right_delimiter))))
+
+  (template [<name> <pre> <post>]
+    [(def: #export <name>
+       (-> (List (Expression Any)) Literal)
+       (composite_literal <pre> <post> ..code))]
+
+    [tuple "(" ")"]
+    [list  "[" "]"]
+    )
+
+  (def: #export (slice from to list)
+    (-> (Expression Any) (Expression Any) (Expression Any) Access)
+    (<| :abstraction
+        ## ..expression
+        (format (:representation list) "[" (:representation from) ":" (:representation to) "]")))
+
+  (def: #export (slice_from from list)
+    (-> (Expression Any) (Expression Any) Access)
+    (<| :abstraction
+        ## ..expression
+        (format (:representation list) "[" (:representation from) ":]")))
+
+  (def: #export dict
+    (-> (List [(Expression Any) (Expression Any)]) (Computation Any))
+    (composite_literal "{" "}" (.function (_ [k v]) (format (:representation k) " : " (:representation v)))))
+
+  (def: #export (apply/* func args)
+    (-> (Expression Any) (List (Expression Any)) (Computation Any))
+    (<| :abstraction
+        ## ..expression
+        (format (:representation func) "(" (text.join_with ", " (list\map ..code args)) ")")))
+
+  (template [<name> <brand> <prefix>]
+    [(def: (<name> var)
+       (-> (Expression Any) Text)
+       (format <prefix> (:representation var)))]
+
+    [splat_poly    Poly    "*"]
+    [splat_keyword Keyword "**"]
+    )
+
+  (template [<name> <splat>]
+    [(def: #export (<name> args extra func)
+       (-> (List (Expression Any)) (Expression Any) (Expression Any) (Computation Any))
+       (<| :abstraction
+           ## ..expression
+           (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 (the name object)
+    (-> Text (Expression Any) (Computation Any))
+    (:abstraction (format (:representation object) "." name)))
+
+  (def: #export (do method args object)
+    (-> Text (List (Expression Any)) (Expression Any) (Computation Any))
+    (..apply/* (..the method object) args))
+
+  (template [<name> <apply>]
+    [(def: #export (<name> args extra method)
+       (-> (List (Expression Any)) (Expression Any) Text
+           (-> (Expression Any) (Computation Any)))
+       (|>> (..the method) (<apply> args extra)))]
+
+    [do_poly    apply_poly]
+    [do_keyword apply_keyword]
+    )
+
+  (def: #export (nth idx array)
+    (-> (Expression Any) (Expression Any) Location)
+    (:abstraction (format (:representation array) "[" (:representation idx) "]")))
+
+  (def: #export (? test then else)
+    (-> (Expression Any) (Expression Any) (Expression Any) (Computation Any))
+    (<| :abstraction
+        ..expression
+        (format (:representation then) " if " (:representation test) " else " (:representation else))))
+
+  (template [<name> <op>]
+    [(def: #export (<name> param subject)
+       (-> (Expression Any) (Expression Any) (Computation Any))
+       (<| :abstraction
+           ..expression
+           (format (:representation subject) " " <op> " " (:representation param))))]
+
+    [is      "is"]
+    [=       "=="]
+    [<       "<"]
+    [<=      "<="]
+    [>       ">"]
+    [>=      ">="]
+    [+       "+"]
+    [-       "-"]
+    [*       "*"]
+    [/       "/"]
+    [//      "//"]
+    [%       "%"]
+    [**      "**"]
+    [bit_or  "|"]
+    [bit_and "&"]
+    [bit_xor "^"]
+    [bit_shl "<<"]
+    [bit_shr ">>"]
+
+    [or      "or"]
+    [and     "and"]
+    )
+
+  (template [<name> <unary>]
+    [(def: #export (<name> subject)
+       (-> (Expression Any) (Computation Any))
+       (<| :abstraction
+           ## ..expression
+           (format <unary> " " (:representation subject))))]
+
+    [not "not"]
+    [negate "-"]
+    )
+
+  (def: #export (lambda arguments body)
+    (-> (List (Var Any)) (Expression Any) (Computation Any))
+    (<| :abstraction
+        ..expression
+        (format "lambda " (|> arguments (list\map ..code) (text.join_with ", ")) ": "
+                (:representation body))))
+
+  (def: #export (set vars value)
+    (-> (List (Location Any)) (Expression Any) (Statement Any))
+    (:abstraction
+     (format (|> vars (list\map ..code) (text.join_with ", "))
+             " = "
+             (:representation value))))
+
+  (def: #export (delete where)
+    (-> (Location Any) (Statement Any))
+    (:abstraction (format "del " (:representation where))))
+
+  (def: #export (if test then! else!)
+    (-> (Expression Any) (Statement Any) (Statement Any) (Statement Any))
+    (:abstraction
+     (format "if " (:representation test) ":"
+             (..nest (:representation then!))
+             text.new_line "else:"
+             (..nest (:representation else!)))))
+
+  (def: #export (when test then!)
+    (-> (Expression Any) (Statement Any) (Statement Any))
+    (:abstraction
+     (format "if " (:representation test) ":"
+             (..nest (:representation then!)))))
+
+  (def: #export (then pre! post!)
+    (-> (Statement Any) (Statement Any) (Statement Any))
+    (:abstraction
+     (format (:representation pre!)
+             text.new_line
+             (:representation post!))))
+
+  (template [<keyword> <0>]
+    [(def: #export <0>
+       (Statement Any)
+       (:abstraction <keyword>))]
+
+    ["break"    break]
+    ["continue" continue]
+    )
+
+  (def: #export (while test body! else!)
+    (-> (Expression Any) (Statement Any) (Maybe (Statement Any)) Loop)
+    (:abstraction
+     (format "while " (:representation test) ":"
+             (..nest (:representation body!))
+             (case else!
+               (#.Some else!)
+               (format text.new_line "else:"
+                       (..nest (:representation else!)))
+               
+               #.None
+               ""))))
+
+  (def: #export (for_in var inputs body!)
+    (-> SVar (Expression Any) (Statement Any) Loop)
+    (:abstraction
+     (format "for " (:representation var) " in " (:representation inputs) ":"
+             (..nest (:representation body!)))))
+
+  (def: #export statement
+    (-> (Expression Any) (Statement Any))
+    (|>> :transmutation))
+
+  (def: #export pass
+    (Statement Any)
+    (:abstraction "pass"))
+
+  (type: #export Except
+    {#classes (List SVar)
+     #exception SVar
+     #handler (Statement Any)})
+  
+  (def: #export (try body! excepts)
+    (-> (Statement Any) (List Except) (Statement Any))
+    (:abstraction
+     (format "try:"
+             (..nest (:representation body!))
+             (|> excepts
+                 (list\map (function (_ [classes exception catch!])
+                             (format text.new_line "except (" (text.join_with ", " (list\map ..code classes))
+                                     ") as " (:representation exception) ":"
+                                     (..nest (:representation catch!)))))
+                 (text.join_with "")))))
+
+  (template [<name> <keyword> <pre>]
+    [(def: #export (<name> value)
+       (-> (Expression Any) (Statement Any))
+       (:abstraction
+        (format <keyword> (<pre> (:representation value)))))]
+
+    [raise  "raise "  |>]
+    [return "return " |>]
+    [print  "print"   ..expression]
+    )
+
+  (def: #export (exec code globals)
+    (-> (Expression Any) (Maybe (Expression Any)) (Statement Any))
+    (let [extra (case globals
+                  (#.Some globals)
+                  (.list globals)
+
+                  #.None
+                  (.list))]
+      (:abstraction
+       (format "exec" (:representation (..tuple (list& code extra)))))))
+
+  (def: #export (def name args body)
+    (-> SVar (List (Ex [k] (Var k))) (Statement Any) (Statement Any))
+    (:abstraction
+     (format "def " (:representation name)
+             "(" (|> args (list\map ..code) (text.join_with ", ")) "):"
+             (..nest (:representation body)))))
+
+  (def: #export (import module_name)
+    (-> Text (Statement Any))
+    (:abstraction (format "import " module_name)))
+
+  (def: #export (comment commentary on)
+    (All [brand] (-> Text (Code brand) (Code brand)))
+    (:abstraction (format "# "  (..sanitize commentary) text.new_line
+                          (:representation on))))
+  )
+
+(def: #export (cond clauses else!)
+  (-> (List [(Expression Any) (Statement Any)]) (Statement Any) (Statement Any))
+  (list\fold (.function (_ [test then!] next!)
+               (..if test then! next!))
+             else!
+             (list.reverse clauses)))
+
+(syntax: (arity_inputs {arity <code>.nat})
+  (wrap (case arity
+          0 (.list)
+          _ (|> (dec arity)
+                (enum.range n.enum 0)
+                (list\map (|>> %.nat code.local_identifier))))))
+
+(syntax: (arity_types {arity <code>.nat})
+  (wrap (list.repeat arity (` (Expression Any)))))
+
+(template [<arity> <function>+]
+  [(with_expansions [<apply> (template.identifier ["apply/" <arity>])
+                     <inputs> (arity_inputs <arity>)
+                     <types> (arity_types <arity>)
+                     <definitions> (template.splice <function>+)]
+     (def: #export (<apply> function <inputs>)
+       (-> (Expression Any) <types> (Computation Any))
+       (..apply/* function (.list <inputs>)))
+
+     (template [<function>]
+       [(`` (def: #export (~~ (template.identifier [<function> "/" <arity>]))
+              (<apply> (..var <function>))))]
+
+       <definitions>))]
+
+  [1
+   [["str"]
+    ["ord"]
+    ["float"]
+    ["int"]
+    ["len"]
+    ["chr"]
+    ["unichr"]
+    ["unicode"]
+    ["repr"]
+    ["__import__"]
+    ["Exception"]]]
+
+  [2
+   []]
+
+  [3
+   []]
+  )