path: root/stdlib/source/lux/target/python.lux

(.module:
  [lux (#- Location Code not or and list if cond int comment exec)
   ["@" target]
   ["." host]
   [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 (host.import: java/lang/CharSequence)
                   (host.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)
                     (:coerce java/lang/String)
                     (java/lang/String::replace (:coerce java/lang/CharSequence text.new_line)
                                                (:coerce java/lang/CharSequence nested_new_line)))}
         (|>> (format text.new_line)
              (text.replace_all text.new_line nested_new_line)))))

(abstract: #export (Code brand)
  Text

  (structure: #export equivalence
    (All [brand] (Equivalence (Code brand)))

    (def: (= reference subject)
      (\ text.equivalence = (:representation reference) (:representation subject))))

  (structure: #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 [<lux> <python>]
                          [[(f.= <lux>)]
                           [(new> (format "float(" text.double_quote <python> text.double_quote ")") [])]]

                          [f.positive_infinity "inf"]
                          [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
   []]
  )