(.module:
  [lux #- not or and]
  (lux
   (control
    pipe)
   (data [text]
         text/format
         (coll [list "list/" Functor<List> Fold<List>]))))

(type: #export Ruby Text)

(type: #export Expression Ruby)

(type: #export Statement Ruby)

(def: #export nil
  Expression
  "nil")

(def: #export bool
  (-> Bit Expression)
  (|>> (case> true "true"
              false "false")))

(def: #export int
  (-> Int Expression)
  %i)

(def: #export float
  (-> Frac Expression)
  %f)

(def: #export (string value)
  (-> Text Expression)
  (%t value))

(def: #export splat
  (-> Expression Expression)
  (|>> (format "*")))

(def: #export (array-range from to array)
  (-> Expression Expression Expression Expression)
  (format "(" array "[" from ".." to "])"))

(def: #export (array elements)
  (-> (List Expression) Expression)
  (format "([" (text.join-with "," elements) "])"))

(def: #export (dictionary kvs)
  (-> (List [Expression Expression]) Expression)
  (format "({"
          (|> kvs
              (list/map (.function (_ [k v])
                          (format k " => " v)))
              (text.join-with ", "))
          "})"))

(def: #export (apply func args)
  (-> Expression (List Expression) Expression)
  (format "(" func "(" (text.join-with "," args) ")" ")"))

(def: #export (send method args object)
  (-> Text (List Expression) Expression Expression)
  (apply (format object "." method) args))

(def: #export call
  (-> (List Expression) Expression Expression)
  (send "call"))

(def: #export (nth idx array)
  (-> Expression Expression Expression)
  (format "(" array "[" idx "])"))

(def: #export (set-nth! idx value array)
  (-> Expression Expression Expression Statement)
  (format array "[" idx "] = " value ";"))

(def: #export (field name object)
  (-> Text Expression Expression)
  (format "(" object "." name ")"))

(def: #export (length array)
  (-> Expression Expression)
  (format "(" array ".length)"))

(def: #export (set! vars value)
  (-> (List Text) Expression Statement)
  (format (text.join-with ", " vars) " = " value ";"))

(def: #export (global var)
  (-> Text Expression)
  (format "$" var))

(def: #export (global! var value)
  (-> Text Expression Statement)
  (set! (list (global var)) value))

(def: #export (? test then! else!)
  (-> Expression Expression Expression Expression)
  (format "(" test " ? " then! " : " else! ")"))

(def: #export (if! test then! else!)
  (-> Expression Statement Statement Statement)
  (format "if " test
          "\n" then!
          "\n" "else"
          "\n" else!
          "\n" "end;"))

(def: #export (when! test then!)
  (-> Expression Statement Statement)
  (format "if " test
          "\n" then!
          "\n" "end;"))

(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 (block! statements)
  (-> (List Statement) Statement)
  (text.join-with " " statements))

(def: #export (statement expression)
  (-> Expression Statement)
  (format expression ";"))

(def: #export (while! test body)
  (-> Expression Statement Statement)
  (format "while " test
          "\n" body
          "\n" "end;"))

(def: #export (for-in! var array body)
  (-> Text Expression Statement Statement)
  (format "for " var " in " array "do" "\n"
          body "\n"
          "end;" "\n"))

(def: #export (begin! body rescues)
  (-> Statement (List [(List Text) Text Statement]) Statement)
  (format "begin"
          "\n" body "\n"
          (|> rescues
              (list/map (function (_ [ex-classes ex-value ex-handler])
                          (format "rescue " (text.join-with ", " ex-classes)
                                  (case ex-value
                                    "" ""
                                    _ (format " => " ex-value))
                                  "\n"
                                  ex-handler)))
              (text.join-with "\n"))
          "\n" "end;"))

(def: #export (raise message)
  (-> Expression Expression)
  (format "raise " message ";"))

(def: #export (return! value)
  (-> Expression Statement)
  (format "return " value ";"))

(def: #export (function! name args body)
  (-> Text (List Text) Statement Statement)
  (format "def " name "(" (text.join-with "," args) ")\n"
          body
          "\n" "end;"))

(def: #export (lambda name args body)
  (-> (Maybe Text) (List Text) Statement Expression)
  (let [proc (format "lambda {" (format "|" (text.join-with ", " args) "|") " " body "}")]
    (case name
      #.None
      (format "(" proc ")")
      
      (#.Some name)
      (format "(" name " = " proc ")"))))

(do-template [<name> <op>]
  [(def: #export (<name> param subject)
     (-> Expression Expression Expression)
     (format "(" subject " " <op> " " param ")"))]

  [=       "=="]
  [<       "<"]
  [<=      "<="]
  [>       ">"]
  [>=      ">="]
  [+       "+"]
  [-       "-"]
  [*       "*"]
  [/       "/"]
  [%       "%"]
  [pow     "**"]
  )

(do-template [<name> <op>]
  [(def: #export (<name> param subject)
     (-> Expression Expression Expression)
     (format "(" param " " <op> " " subject ")"))]

  [or      "||"]
  [and     "&&"]
  [bit-or  "|"]
  [bit-and "&"]
  [bit-xor "^"]
  )

(do-template [<name> <op>]
  [(def: #export (<name> param subject)
     (-> Expression Expression Expression)
     (format "(" subject " " <op> " " param ")"))]

  [bit-shl "<<"]
  [bit-shr ">>"]
  )

(def: #export (not subject)
  (-> Expression Expression)
  (format "(!" subject ")"))