(.require
 [library
  [lux (.except Location Code static int if function or and not comment local global symbol the)
   [abstract
    [equivalence (.only Equivalence)]
    [hash (.only Hash)]
    ["[0]" enum]]
   [control
    ["[0]" pipe]]
   [data
    ["[0]" text (.only)
     ["%" \\format (.only format)]]
    [collection
     ["[0]" list (.use "[1]#[0]" functor mix)]]]
   [math
    [number
     ["n" nat]
     ["f" frac]]]
   [meta
    ["@" target]
    ["[0]" code (.only)
     ["<[1]>" \\parser]]
    [macro
     [syntax (.only syntax)]
     ["[0]" template]]
    [type
     [primitive (.except)]]]]])

(def input_separator ", ")
(def statement_suffix ";")

... Added the carriage return for better Windows compatibility.
(def \n+
  Text
  (format text.carriage_return text.new_line))

(def nested
  (-> Text Text)
  (.let [nested_new_line (format text.new_line text.tab)]
    (|>> (format \n+)
         (text.replaced text.new_line nested_new_line))))

(primitive .public (Code brand)
  Text

  (def .public equivalence
    (All (_ brand) (Equivalence (Code brand)))
    (implementation
     (def (= reference subject)
       (at text.equivalence = (representation reference) (representation subject)))))

  (def .public manual
    (-> Text Code)
    (|>> abstraction))

  (def .public code
    (-> (Code Any) Text)
    (|>> representation))

  (with_template [<type> <super>+]
    [(with_expansions [<brand> (template.symbol [<type> "'"])]
       (primitive (<brand> brand) Any)
       (`` (type .public <type> (|> Any <brand> (,, (template.spliced <super>+))))))]
    
    [Expression [Code]]
    [Computation [Expression' Code]]
    [Location [Computation' Expression' Code]]
    [Var [Location' Computation' Expression' Code]]
    [LVar [Var' Location' Computation' Expression' Code]]
    [Statement [Code]]
    )

  (with_template [<type> <super>+]
    [(with_expansions [<brand> (template.symbol [<type> "'"])]
       (primitive <brand> Any)
       (`` (type .public <type> (|> <brand> (,, (template.spliced <super>+))))))]

    [Literal [Computation' Expression' Code]]
    [Access [Location' Computation' Expression' Code]]
    [CVar [Var' Location' Computation' Expression' Code]]
    [GVar [Var' Location' Computation' Expression' Code]]
    [IVar [Var' Location' Computation' Expression' Code]]
    [SVar [Var' Location' Computation' Expression' Code]]
    [LVar* [LVar' Var' Location' Computation' Expression' Code]]
    [LVar** [LVar' Var' Location' Computation' Expression' Code]]
    )

  (with_template [<var> <prefix> <constructor>]
    [(def .public <constructor>
       (-> Text <var>)
       (|>> (format <prefix>) abstraction))]

    [LVar "l_" local]
    [CVar "C_" constant]
    [GVar "$"  global]
    [IVar "@"  instance]
    [SVar "@@" static]
    )

  (with_template [<var> <prefix> <modifier> <unpacker>]
    [(with_template [<name> <input> <output>]
       [(def .public <name>
          (-> <input> <output>)
          (|>> representation (format <prefix>) abstraction))]

       [<modifier> LVar <var>]
       [<unpacker> Expression Computation]
       )]

    [LVar*  "*"  variadic    splat]
    [LVar** "**" variadic_kv double_splat]
    )

  (with_template [<ruby_name> <lux_name>]
    [(def .public <lux_name>
       GVar
       (..global <ruby_name>))]

    ["!" latest_error_message]
    ["@" latest_error_location]
    ["_" last_string_read]
    ["." last_line_number_read]
    ["&" last_string_matched]
    ["~" last_regexp_match]
    ["=" case_insensitivity_flag]
    ["/" input_record_separator]
    ["\" output_record_separator]
    ["0" script_name]
    ["$" process_id]
    ["?" exit_status]

    ["stdout" stdout]
    ["stdin" stdin]
    )

  (with_template [<ruby_name> <lux_name>]
    [(def .public <lux_name>
       CVar
       (..manual <ruby_name>))]

    ["ARGV" command_line_arguments]
    )

  (def .public multi
    (-> (List Expression) Expression)
    (|>> (list#each ..code)
         (text.interposed ..input_separator)
         abstraction))

  (def .public nil
    Literal
    (abstraction "nil"))

  (def .public bool
    (-> Bit Literal)
    (|>> (pipe.case
           #0 "false"
           #1 "true")
         abstraction))

  (def safe
    (-> Text Text)
    (`` (|>> (,, (with_template [<find> <replace>]
                   [(text.replaced <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)]
                   ))
             )))

  (with_template [<format> <name> <type> <prep>]
    [(def .public <name>
       (-> <type> Literal)
       (|>> <prep> <format> abstraction))]

    [%.int  int    Int  (<|)]
    [%.text string Text ..safe]
    [(<|)   symbol Text (format ":")]
    )

  (def .public float
    (-> Frac Literal)
    (|>> (pipe.cond [(f.= f.positive_infinity)]
                    [(pipe.new "(+1.0/0.0)" [])]
                    
                    [(f.= f.negative_infinity)]
                    [(pipe.new "(-1.0/0.0)" [])]
                    
                    [(f.= f.not_a_number)]
                    [(pipe.new "(+0.0/-0.0)" [])]

                    ... else
                    [%.frac])
         abstraction))

  (def .public (array_range from to array)
    (-> Expression Expression Expression Computation)
    (|> (format (representation from) ".." (representation to))
        (text.enclosed ["[" "]"])
        (format (representation array))
        abstraction))

  (def .public array
    (-> (List Expression) Computation)
    (|>> (list#each (|>> representation (text.suffix ..input_separator)))
         text.together
         (text.enclosed ["[" "]"])
         abstraction))

  (def .public hash
    (-> (List [Expression Expression]) Computation)
    (|>> (list#each (.function (_ [k v])
                      (format (representation k) " => " (representation v) ..input_separator)))
         text.together
         (text.enclosed ["{" "}"])
         abstraction))

  (def (control_structure content)
    (-> Text Text)
    (format content
            \n+ "end" ..statement_suffix))

  (type .public Block
    (Record
     [#parameters (List Var)
      #body Statement]))

  (def (block it)
    (-> Block Text)
    (|> (format (|> (.the #parameters it)
                    (list#each (|>> representation))
                    (text.interposed ..input_separator)
                    (text.enclosed' "|"))
                (..nested (representation (.the #body it))))
        (text.enclosed ["{" "}"])))

  (def .public (apply arguments block func)
    (-> (List Expression) (Maybe Block) Expression Computation)
    (let [arguments (|> arguments
                        (list#each (|>> representation))
                        (text.interposed ..input_separator)
                        (text.enclosed ["(" ")"]))
          block (case block
                  {.#None}
                  ""
                  
                  {.#Some [inputs block]}
                  (|> block
                      representation
                      nested
                      control_structure
                      (format " do "
                              (|> inputs
                                  (list#each (|>> representation))
                                  (text.interposed ..input_separator)
                                  (text.enclosed' "|")))))]
      (abstraction (format (representation func) arguments block))))

  (def .public (the field object)
    (-> Text Expression Access)
    (abstraction (format (representation object) "." field)))

  (def .public (item idx array)
    (-> Expression Expression Access)
    (|> (representation idx)
        (text.enclosed ["[" "]"])
        (format (representation array))
        abstraction))

  (def .public (? test then else)
    (-> Expression Expression Expression Computation)
    (|> (format (representation test) " ? "
                (representation then) " : "
                (representation else))
        (text.enclosed ["(" ")"])
        abstraction))

  (def .public statement
    (-> Expression Statement)
    (|>> representation
         (text.suffix ..statement_suffix)
         abstraction))

  (def .public (then pre! post!)
    (-> Statement Statement Statement)
    (abstraction
     (format (representation pre!)
             \n+
             (representation post!))))

  (def .public (set vars value)
    (-> (List Location) Expression Statement)
    (abstraction
     (format (|> vars
                 (list#each (|>> representation))
                 (text.interposed ..input_separator))
             " = " (representation value) ..statement_suffix)))

  (def .public (if test then! else!)
    (-> Expression Statement Statement Statement)
    (<| abstraction
        ..control_structure
        (format "if " (representation test)
                (..nested (representation then!))
                \n+ "else"
                (..nested (representation else!)))))

  (with_template [<name> <control_structure>]
    [(def .public (<name> test then!)
       (-> Expression Statement Statement)
       (<| abstraction
           ..control_structure
           (format <control_structure> " " (representation test)
                   (..nested (representation then!)))))]

    [when "if"]
    [while "while"]
    )

  (def .public (for_in var array iteration!)
    (-> LVar Expression Statement Statement)
    (<| abstraction
        ..control_structure
        (format "for " (representation var)
                " in " (representation array)
                " do "
                (..nested (representation iteration!)))))

  (type .public Rescue
    (Record
     [#classes (List Text)
      #exception LVar
      #rescue Statement]))

  (def .public (begin body! rescues)
    (-> Statement (List Rescue) Statement)
    (<| abstraction
        ..control_structure
        (format "begin" (..nested (representation body!))
                (|> rescues
                    (list#each (.function (_ [classes exception rescue])
                                 (format \n+ "rescue " (text.interposed ..input_separator classes)
                                         " => " (representation exception)
                                         (..nested (representation rescue)))))
                    (text.interposed \n+)))))

  (def .public (catch expectation block)
    (-> Expression Block Expression)
    (<| abstraction
        (format "catch(" (representation expectation) ") "
                (..block block))))

  (def .public (return value)
    (-> Expression Statement)
    (abstraction (format "return " (representation value) ..statement_suffix)))

  (def .public (raise message)
    (-> Expression Expression)
    (abstraction (format "raise " (representation message))))

  (with_template [<name> <keyword>]
    [(def .public <name>
       Statement
       (|> <keyword>
           (text.suffix ..statement_suffix)
           abstraction))]

    [next "next"]
    [redo "redo"]
    [break "break"]
    )

  (def .public initialize
    LVar
    (..manual "initialize"))

  (def .public (function name args body!)
    (-> LVar (List LVar) Statement Statement)
    (<| abstraction
        ..control_structure
        (format "def " (representation name)
                (|> args
                    (list#each (|>> representation))
                    (text.interposed ..input_separator)
                    (text.enclosed ["(" ")"]))
                (..nested (representation body!)))))

  (def .public (lambda name block)
    (-> (Maybe LVar) Block Literal)
    (let [proc (format "lambda " (..block block))]
      (|> (case name
            {.#None}
            proc
            
            {.#Some name}
            (format (representation name) " = " proc))
          (text.enclosed ["(" ")"])
          abstraction)))

  (with_template [<op> <name>]
    [(def .public (<name> parameter subject)
       (-> Expression Expression Computation)
       (abstraction (format "(" (representation subject) " " <op> " " (representation parameter) ")")))]

    ["==" =]
    [ "<" <]
    ["<=" <=]
    [ ">" >]
    [">=" >=]

    [ "+" +]
    [ "-" -]
    [ "*" *]
    [ "/" /]
    [ "%" %]
    ["**" pow]

    ["||" or]
    ["&&" and]
    [ "|" bit_or]
    [ "&" bit_and]
    [ "^" bit_xor]

    ["<<" bit_shl]
    [">>" bit_shr]
    )

  (with_template [<unary> <name>]
    [(def .public (<name> subject)
       (-> Expression Computation)
       (abstraction (format "(" <unary> (representation subject) ")")))]

    ["!" not]
    ["~" bit_not]
    ["-" opposite]
    )

  (def .public (comment commentary on)
    (All (_ brand) (-> Text (Code brand) (Code brand)))
    (abstraction (format "# "  (..safe commentary) \n+
                         (representation on))))

  (with_template [<name>]
    [(`` (def .public ((,, (template.symbol [<name> "/*"])) attributes)
           (-> (List Text) Statement)
           (..statement
            (..apply (list#each ..string attributes) {.#None} (..manual <name>)))))]

    ["attr_reader"]
    ["attr_writer"]
    ["attr_accessor"])
  )

(def .public (do method arguments block object)
  (-> Text (List Expression) (Maybe Block) Expression Computation)
  (|> object (..the method) (..apply arguments block)))

(def .public new
  (-> (List Expression) (Maybe Block) Expression Computation)
  (..do "new"))

(def .public (class definition)
  (-> Block Computation)
  (|> (..manual "Class")
      (..new (list) {.#Some definition})))

(def .public (module definition)
  (-> Block Computation)
  (|> (..manual "Module")
      (..new (list) {.#Some definition})))

(def .public (apply_lambda args lambda)
  (-> (List Expression) Expression Computation)
  (|> lambda
      (..do "call" args {.#None})))

(def arity_inputs
  (syntax (_ [arity <code>.nat])
    (in (case arity
          0 (.list)
          _ (|> (-- arity)
                (enum.range n.enum 0)
                (list#each (|>> %.nat code.local)))))))

(def arity_types
  (syntax (_ [arity <code>.nat])
    (in (list.repeated arity (` ..Expression)))))

(with_template [<arity> <function>+]
  [(with_expansions [<apply> (template.symbol ["apply/" <arity>])
                     <inputs> (arity_inputs <arity>)
                     <types> (arity_types <arity>)
                     <definitions> (template.spliced <function>+)]
     (with_template [<function>]
       [(`` (def .public ((,, (template.symbol [<function> "/" <arity>])) <inputs>)
              (-> <types> Computation)
              (..apply (.list <inputs>) {.#None} (..manual <function>))))]

       <definitions>))]

  [0
   [["gets"]]]

  [1
   [["print"]
    ["include"]
    ["extend"]
    ["require"]
    ["defined?"]]]

  [2
   [["print"]
    ["alias_method"]]]
  )

(def .public (throw/1 error)
  (-> Expression Statement)
  (..statement (..apply (list error) {.#None} (..manual "throw"))))

(def .public (throw/2 tag value)
  (-> Expression Expression Statement)
  (..statement (..apply (list tag value) {.#None} (..manual "throw"))))

(def .public (class_variable_set var value object)
  (-> SVar Expression Expression Computation)
  (..do "class_variable_set" (list (..string (..code var)) value) {.#None} object))

(def .public (class_variable_get var object)
  (-> SVar Expression Computation)
  (..do "class_variable_get" (list (..string (..code var))) {.#None} object))