- Initial Ruby back-end implementation.

1 files changed, 219 insertions, 0 deletions

diff --git a/new-luxc/source/luxc/lang/host/ruby.lux b/new-luxc/source/luxc/lang/host/ruby.lux
new file mode 100644
index 000000000..3f179105d
--- /dev/null
+++ b/new-luxc/source/luxc/lang/host/ruby.lux
@@ -0,0 +1,219 @@
+(.module:
+  [lux #- not or and]
+  (lux (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
+  (-> Bool Expression)
+  %b)
+
+(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 ")"))