sibilant-rails 0.0.1

data/lib/source/include/macros.sibilant

@@ -0,0 +1,411 @@
+(macro join (glue arr)
+  (concat "(" (translate arr) ").join(" (translate glue) ")"))
+
+
+(macro send (object method &rest args)
+  (concat (translate object) "." (translate method)
+	  "(" (join ", " (map args translate)) ")"))
+
+(macro apply (fn arglist)
+  (macros.send fn 'apply 'undefined arglist))
+
+(macro list (&rest args)
+  (concat "[ " (join ", " (map args translate)) " ]"))
+
+(macro cons (first rest)
+  (macros.send (macros.list first) 'concat rest))
+
+(macro append (list &rest additional)
+  (macros.send list 'concat (apply macros.list additional)))
+
+(macro get (obj &rest keys)
+  (concat "(" (translate obj) ")"
+    (join "" (map keys (lambda (key)
+                         (concat "[" (translate key) "]"))))))
+
+(macro +   (&rest args)
+  (concat "(" (join " + " (map args translate)) ")"))
+(macro -   (&rest args)
+  (concat "(" (join " - " (map args translate)) ")"))
+(macro *   (&rest args)
+  (concat "(" (join " * " (map args translate)) ")"))
+(macro /   (&rest args)
+  (concat "(" (join " / " (map args translate)) ")"))
+(macro or  (&rest args)
+  (concat "(" (join " || " (map args translate)) ")"))
+(macro and (&rest args)
+  (concat "(" (join " && " (map args translate)) ")"))
+(macro mod (&rest args)
+  (concat "(" (join " % " (map args translate)) ")"))
+
+(macro join (&optional glue arr) ;redefined because join and or are mutually dependent
+  (concat "(" (translate arr) ").join(" (or (translate glue) "\"\"") ")"))
+
+(macro infix-comparator (comparator args)
+  (concat "("
+          (join " && "
+                (map (args.slice 0 -1)
+                     (lambda (item index)
+                       (concat item
+                               " " comparator " "
+                               (get args (+ 1 index))))))
+          ")"))
+
+(macro >  (&rest args) (macros.infix-comparator  ">"  (map args translate)))
+(macro <  (&rest args) (macros.infix-comparator  "<"  (map args translate)))
+(macro <= (&rest args) (macros.infix-comparator "<="  (map args translate)))
+(macro >= (&rest args) (macros.infix-comparator ">="  (map args translate)))
+(macro != (&rest args) (macros.infix-comparator "!==" (map args translate)))
+
+(macro pow (base exponent)
+  (macros.call "Math.pow" base exponent))
+
+(macro incr-by (item increment)
+  (concat (translate item) " += " (translate increment)))
+
+(macro incr (item)
+  (concat "((" (translate item) ")++)"))
+
+(macro decr (item)
+  (concat "((" (translate item) ")--)"))
+
+(macro set (arr &rest kv-pairs)
+  (join "\n" (bulk-map kv-pairs
+		       (lambda (k v)
+			 (concat "(" (translate arr) ")"
+				 "[" (translate k) "] = " (translate v) ";")))))
+
+(macro new (&rest args)
+  (concat "(new " (apply macros.call args) ")"))
+
+(macro regex (string &optional glim)
+  (call (get macros 'new) 'RegExp string (or glim 'undefined)))
+
+(macro timestamp ()
+  (concat "\"" (send (new Date) to-string) "\""))
+
+(macro comment (&rest contents)
+  (map contents
+       (lambda (item)
+	 (join "\n" (map (send (translate item) split "\n")
+			 (lambda (line) (concat "// " line)))))))
+
+(macro meta (body)
+  (eval (translate body)))
+
+(macro zero? (item)
+  ((get macros "=") (translate item) 0))
+
+(macro empty? (arr)
+  (concat "((" (translate arr) ").length === 0)"))
+
+(macro odd? (number)
+  ((get macros "!=") 0
+   (macros.mod (translate number) 2)))
+
+(macro even? (number)
+  ((get macros "=") 0
+   (macros.mod (translate number) 2)))
+
+
+(macro typeof (thing) (+ "typeof " (translate thing)))
+
+(macro function? (thing)
+  ((get macros "=") (macros.typeof thing) "'function'"))
+
+(macro undefined? (thing)
+  ((get macros "=") (macros.typeof thing) "'undefined'"))
+
+(macro defined? (thing)
+  ((get macros "!=") (macros.typeof thing) "'undefined'"))
+
+(macro number? (thing)
+  ((get macros "=") (macros.typeof thing) "'number'"))
+
+(macro first (arr) (macros.get arr 0))
+(macro second (arr) (macros.get arr 1))
+(macro third (arr) (macros.get arr 2))
+(macro fourth (arr) (macros.get arr 3))
+(macro fifth (arr) (macros.get arr 4))
+(macro sixth (arr) (macros.get arr 5))
+(macro seventh (arr) (macros.get arr 6))
+(macro eighth (arr) (macros.get arr 7))
+(macro ninth (arr) (macros.get arr 8))
+
+(macro rest (arr)
+  (macros.send arr 'slice 1))
+
+(macro length (arr)
+  (macros.get arr "\"length\""))
+
+(macro last (arr)
+  (macros.get (macros.send arr 'slice -1) 0))
+
+(macro if (arg truebody falsebody)
+  (concat
+   "(function() {"
+   (indent (concat
+	    "if (" (translate arg) ") {"
+	    (indent (macros.progn truebody))
+	    "} else {"
+	    (indent (macros.progn falsebody))
+	    "}"))
+   "})()"))
+
+(macro defvar (&rest pairs)
+  (as-statement
+   (concat "var "
+           (join ",\n    "
+                 (bulk-map pairs
+                           (lambda (name value)
+                             (concat (translate name) " = "
+                                     (translate value)))))
+           ";")))
+
+(macro = (first-thing &rest other-things)
+  (defvar translated-first-thing (translate first-thing))
+  (concat "("
+          (join " &&\n "
+                (map other-things
+                     (lambda (thing)
+                       (concat translated-first-thing
+                               " === "
+                               (translate thing)))))
+          ")"))
+
+
+(macro string? (thing)
+  (concat "typeof(" (translate thing) ") === \"string\""))
+
+(macro list? (thing)
+  (defvar translated (concat "(" (translate thing) ")"))
+  (concat translated " && "
+	  translated ".constructor.name === \"Array\""))
+
+
+(macro when (arg &rest body)
+  (concat
+   "(function() {"
+   (indent (concat
+	    "if (" (translate arg) ") {"
+	    (indent (apply macros.progn body))
+	    "}"))
+   "})()"))
+
+(macro unless (condition &rest body)
+  (apply macros.when (cons ['not condition] body)))
+
+(macro not (exp)
+  (concat "(!" (translate exp) ")"))
+
+(macro slice (arr start &optional end)
+  (macros.send (translate arr) "slice" start end))
+
+(macro inspect (&rest args)
+  (join " + \"\\n\" + "
+        (map args
+             (lambda (arg)
+               (concat "\"" arg ":\" + " (translate arg))))))
+
+(macro each (item array &rest body)
+  (macros.send (translate array) 'for-each
+               (apply macros.lambda (cons item body))))
+
+
+(macro setf (&rest args)
+  (join "\n"
+	(bulk-map args (lambda (name value)
+			 (as-statement (concat (translate name) " = "
+				 (translate value)))))))
+
+
+(macro macro-list ()
+  (concat "["
+	  (indent (join ",\n"
+			(map (-object.keys macros)
+			     macros.quote)))
+	  "]"))
+
+(macro macroexpand (name)
+  (defvar macro (get macros (translate name)))
+  (if macro
+    (concat "// macro: " name "\n" (send macro to-string))
+    "undefined"))
+
+(macro throw (&rest string)
+  (concat "throw new Error (" (join " " (map string translate)) ")"))
+
+(macro as-boolean (expr)
+  (concat "(!!(" (translate expr) "))"))
+
+(macro chain (object &rest calls)
+  (if (= 0 calls.length) (translate object)
+      (if (= 1 calls.length) (apply macros.send (cons object (first calls)))
+        (concat (translate object)
+                (indent (join "\n"
+                              (map calls (lambda (call index)
+                                           (concat "." (translate (first call))
+                                                   "(" (join ", " (map (rest call) translate)) ")")))))))))
+
+(macro chainable (&rest names)
+  (each (name) names
+    (macros.macro name ['target "&rest" 'calls]
+                     ['apply 'macros.chain ['cons ['macros.call ['quote name] 'target] 'calls]])))
+
+(macro try (tryblock catchblock)
+  (concat
+   "(function() {"
+   (indent (concat
+	    "try {"
+	    (indent (macros.progn tryblock))
+	    "} catch (e) {"
+	    (indent (macros.progn catchblock))
+	    "}"))
+   "})()"))
+
+
+(macro while (condition &rest block)
+  (macros.scoped
+   (macros.defvar '**return-value**)
+   (concat "while (" (translate condition) ") {"
+           (indent (macros.setf '**return-value**
+                                (apply macros.scoped block))))
+   "}"
+   '**return-value**))
+
+(macro until (condition &rest block)
+  (apply (get macros 'while)
+         (cons ['not condition] block)))
+
+
+(macro thunk (&rest args)
+  (apply macros.lambda (cons [] args)))
+
+(macro keys (obj)
+  (macros.call "Object.keys" (translate obj)))
+
+(macro delete (&rest objects)
+  (join "\n" (map objects (lambda (obj)
+                            (concat "delete " (translate obj) ";")))))
+
+(macro delmacro (macro-name)
+  (delete (get macros (translate macro-name)))
+  "")
+
+(macro alias-macro (current-macro-name desired-macro-name)
+  (defvar current-macro-name (translate current-macro-name)
+          desired-macro-name (translate desired-macro-name))
+  (set macros desired-macro-name (get macros current-macro-name))
+  "")
+
+(macro rename-macro (current-macro-name desired-macro-name)
+  (macros.alias-macro current-macro-name desired-macro-name)
+  (macros.delmacro current-macro-name)
+  "")
+
+(macro defhash (name &rest pairs)
+  (macros.defvar name (apply macros.hash pairs)))
+
+(macro arguments ()
+  "(Array.prototype.slice.apply(arguments))")
+
+(macro scoped (&rest body)
+  (macros.call (apply macros.thunk body)))
+
+(macro each-key (as obj &rest body)
+  (concat "(function() {"
+	  (indent
+	   (concat "for (var " (translate as) " in " (translate obj) ") "
+		   (apply macros.scoped body)
+		   ";"))
+	  "})();"))
+
+(macro match? (regexp string)
+  (macros.send string 'match regexp))
+
+(macro switch (obj &rest cases)
+
+  ;; the complexity of this macro indicates there's a problem
+  ;; I'm not quite sure where to fix this, but it has to do with quoting.
+  (defvar lines (list (concat "switch(" (translate obj) ") {")))
+  (each (case-def) cases
+    (defvar case-name (first case-def))
+    (when (and (list? case-name)
+               (= (first case-name) 'quote))
+      (defvar second (second case-name))
+      (setf case-name (if (list? second)
+                        (map second macros.quote)
+                        (macros.quote second))))
+
+    (defvar case-string
+            (if (list? case-name)
+	      (join "\n" (map case-name (lambda (c)
+					  (concat "case " (translate c) ":"))))
+              (if (= 'default case-name) "default:"
+                  (concat "case " (translate case-name) ":"))))
+
+    (lines.push (concat case-string
+                        (indent (apply macros.progn (case-def.slice 1))))))
+
+  ;; the following two lines are to get the whitespace right
+  ;; this is necessary because switches are indented weird
+  (set lines (- lines.length 1)
+       (chain (get lines (- lines.length 1)) (concat "}")))
+
+  (concat "(function() {" (apply indent lines) "})()"))
+
+
+(macro if-else (&rest args)
+    (concat "(function() {"
+        (indent
+            (join " else "
+                (bulk-map args
+                    (lambda (cond val)
+                        (if (undefined? val)
+                            (concat "{" (indent (macros.progn cond)) "}")
+                            (concat "if (" (translate cond) ") {"
+                                (indent (macros.progn val))
+                                "}"))))))
+    "})()"))
+
+(macro let (args &optional body)
+  (concat "let (" (bulk-map args
+    (lambda (h k v)
+      (concat (translate k) " = " (translate v))))
+    (if (undefined? body) ");"
+        (concat ") {" (indent (translate body)) "}"))))
+
+(macro instance-of? (item type)
+  (concat "(" (translate item) " instanceof " (translate type) ")"))
+
+(macro slice (list &optional begin &optional end)
+  (concat "Array.prototype.slice.call(" (translate list)
+          ", " (or (translate begin) 0)
+          (if (defined? end) (concat ", " (translate end) ")") ")")))
+
+(macro ternary (cond if-true if-false)
+  (concat "(" (translate cond) ") ? "
+          (translate if-true) " : "
+          (translate if-false)))
+
+
+(macro includes? (list item)
+  (call (get macros "!=") -1 (macros.send list 'index-of item)))
+
+(macro excludes? (list item)
+  (call (get macros "=") -1 (macros.send list 'index-of item)))
+
+(macro exists? (thing)
+  (call (get macros "and")
+        (macros.defined? thing)
+        (call (get macros "!=") thing 'null)))
+
+;;new style
+(alias-macro lambda #)
+(alias-macro thunk #>)
+(alias-macro defvar var)
+(alias-macro progn do)
+(alias-macro setf assign)
+(alias-macro defun def)
+(alias-macro delmacro delete-macro)
+

data/lib/source/lib/browser.js

@@ -0,0 +1,644 @@
+(function(root) {
+  var sibilant = {  },
+      exports = {  };
+  var error = (function(str) {
+    throw new Error (str);
+  });
+  ;
+  var inspect = (function(item) {
+    return (function() {
+      if (item.toSource) {
+        return item.toSource();
+      } else {
+        return item.toString();
+      }
+    })();
+  });
+  ;
+  (root)["sibilant"] = sibilant;
+  var bulkMap = (function(arr, fn) {
+    var index = 0,
+        groupSize = fn.length,
+        retArr = [  ];
+    (function() {
+      var __returnValue__ = undefined;
+      while ((index < arr.length)) {
+        __returnValue__ = (function() {
+          retArr.push(fn.apply(undefined, arr.slice(index, (index + groupSize))));
+          return index += groupSize;
+        })();
+      };
+      return __returnValue__;
+    })();
+    return retArr;
+  });
+  
+  var inject = (function(start, items, fn) {
+    var value = start;
+    (function() {
+      if ((items) && (items).constructor.name === "Array") {
+        return items.forEach((function(item, index) {
+          return value = fn(value, item, index);
+        }));
+      }
+    })();
+    return value;
+  });
+  
+  var map = (function(items, fn) {
+    return inject([  ], items, (function(collector, item, index) {
+      collector.push(fn(item, index));
+      return collector;
+    }));
+  });
+  
+  var select = (function(items, fn) {
+    return inject([  ], items, (function(collector, item, index) {
+      (function() {
+        if (fn(item, index)) {
+          return collector.push(item);
+        }
+      })();
+      return collector;
+    }));
+  });
+  
+  var detect = (function(items, fn) {
+    var returnItem = undefined,
+        index = 0,
+        items = items;
+    return (function() {
+      var __returnValue__ = undefined;
+      while ((!((items.length === index) || returnItem))) {
+        __returnValue__ = (function() {
+          (function() {
+            if (fn((items)[index], index)) {
+              return returnItem = (items)[index];
+            }
+          })();
+          return ((index)++);
+        })();
+      };
+      return __returnValue__;
+    })();
+  });
+  
+  var reject = (function(items, fn) {
+    var args = [ items, fn ];
+    return select(items, (function() {
+      return (!fn.apply(undefined, arguments));
+    }));
+  });
+  
+  var compact = (function(arr) {
+    return select(arr, (function(item) {
+      return (!!(item));
+    }));
+  });
+  
+  var flatten = (function(items) {
+    var items = Array.prototype.slice.call(arguments, 0);
+    
+    return inject([  ], items, (function(collector, item) {
+      return collector.concat((function() {
+        if ((item) && (item).constructor.name === "Array") {
+          return flatten.apply(undefined, item);
+        } else {
+          return item;
+        }
+      })());
+    }));
+  });
+  
+  ;
+  (sibilant)["tokens"] = {  };
+  (sibilant.tokens)["regex"] = "(\\/(\\\\\\\/|[^\\/\\n])+\\/[glim]*)";
+  (sibilant.tokens)["comment"] = "(;.*)";
+  (sibilant.tokens)["string"] = "(\"(([^\"]|(\\\\\"))*[^\\\\])?\")";
+  (sibilant.tokens)["number"] = "(-?[0-9][0-9.,]*)";
+  (sibilant.tokens)["literal"] = "(-?[*.$a-zA-Z][*.a-zA-Z0-9-]*(\\?|!)?)";
+  (sibilant.tokens)["special"] = "([&']?)";
+  (sibilant.tokens)["otherChar"] = "([#><=!\\+\\/\\*-]+)";
+  (sibilant.tokens)["openParen"] = "(\\()";
+  (sibilant.tokens)["specialOpenParen"] = "('?\\()";
+  (sibilant.tokens)["closeParen"] = "(\\))";
+  (sibilant.tokens)["alternativeParens"] = "\\{|\\[|\\}|\\]";
+  (sibilant.tokens)["specialLiteral"] = (sibilant.tokens.special + sibilant.tokens.literal);
+  (sibilant)["tokenPrecedence"] = [ "regex", "comment", "string", "number", "specialLiteral", "otherChar", "specialOpenParen", "closeParen", "alternativeParens" ];
+  var tokenize = sibilant.tokenize = (function(string) {
+    var tokens = [  ],
+        parseStack = [ tokens ],
+        specials = [  ];
+    var acceptToken = (function(token) {
+      return (parseStack)[0].push(token);
+    });
+    ;
+    var increaseNesting = (function() {
+      var newArr = [  ];
+      acceptToken(newArr);
+      return parseStack.unshift(newArr);
+    });
+    ;
+    var decreaseNesting = (function() {
+      specials.shift();
+      parseStack.shift();
+      return (function() {
+        if ((parseStack.length === 0)) {
+          throw new Error (("unbalanced parens:\n" + inspect(parseStack)));
+        }
+      })();
+    });
+    ;
+    var handleToken = (function(token) {
+      var special = (token)[0],
+          token = token;
+      (function() {
+        if ((special === "'")) {
+          token = token.slice(1);
+          increaseNesting();
+          return acceptToken("quote");
+        } else {
+          return special = false;
+        }
+      })();
+      specials.unshift((!!(special)));
+      (function() {
+        switch(token) {
+        case "(":
+          return increaseNesting();
+        
+        case "]":
+        case "}":
+        case ")":
+          return decreaseNesting();
+        
+        case "{":
+          increaseNesting();
+          return acceptToken("hash");
+        
+        case "[":
+          increaseNesting();
+          return acceptToken("list");
+        
+        default:
+          return (function() {
+            if (token.match((new RegExp(("^" + sibilant.tokens.number + "$"), undefined)))) {
+              return acceptToken(parseFloat(token.replace((new RegExp(",", "g")), "")));
+            } else {
+              return acceptToken(token);
+            }
+          })();
+        }
+      })();
+      return (function() {
+        if (((token !== "(") && specials.shift())) {
+          return decreaseNesting();
+        }
+      })();
+    });
+    ;
+    var orderedRegexen = map(sibilant.tokenPrecedence, (function(x) {
+      return (sibilant.tokens)[x];
+    })),
+        masterRegex = (new RegExp((orderedRegexen).join("|"), "g"));
+    string
+      .match(masterRegex)
+      .forEach(handleToken)
+    ;
+    (function() {
+      if ((parseStack.length > 1)) {
+        return error("unexpected EOF, probably missing a )\n", inspect((parseStack)[0]));
+      }
+    })();
+    return tokens;
+  });
+  var indent = (function(args) {
+    var args = Array.prototype.slice.call(arguments, 0);
+    
+    return (compact(args)
+      .join("\n")
+      .replace(/^/, "\n")
+      .replace(/\n/g, "\n  ")
+     + "\n");
+  });
+  
+  var constructHash = (function(arrayOfArrays) {
+    return inject({  }, arrayOfArrays, (function(object, item) {
+      (object)[(item)[0]] = (object)[(item)[1]];
+      return object;
+    }));
+  });
+  
+  var macros = {  };
+  (sibilant)["macros"] = macros;
+  (macros)["return"] = (function(token) {
+    var defaultReturn = ("return " + translate(token));
+    return (function() {
+      if ((token) && (token).constructor.name === "Array") {
+        return (function() {
+          switch((token)[0]) {
+          case "return":
+          case "throw":
+          case "progn":
+          case "do":
+            return translate(token);
+          
+          case "delete":
+            var deleteMacro = (macros)["delete"];
+            return (function() {
+              if ((token.length < 3)) {
+                return defaultReturn;
+              } else {
+                return (deleteMacro.apply(undefined, token.slice(1, -1)) + "\nreturn " + deleteMacro((token.slice(-1))[0]));
+              }
+            })();
+          
+          case "setf":
+          case "assign":
+            return (function() {
+              if ((token.length < 4)) {
+                return defaultReturn;
+              } else {
+                return (macros.setf.apply(undefined, token.slice(1, (token.length - 2))) + "\nreturn " + macros.setf.apply(undefined, token.slice(-2)));
+              }
+            })();
+          
+          case "set":
+            return (function() {
+              if ((token.length < 5)) {
+                return defaultReturn;
+              } else {
+                var obj = (token)[1],
+                    nonReturnPart = token.slice(2, (token.length - 2)),
+                    returnPart = token.slice(-2);
+                nonReturnPart.unshift(obj);
+                returnPart.unshift(obj);
+                return (macros.set.apply(undefined, nonReturnPart) + "\nreturn " + macros.set.apply(undefined, returnPart));
+              }
+            })();
+          
+          default:
+            return defaultReturn;
+          }
+        })();
+      } else {
+        return defaultReturn;
+      }
+    })();
+  });
+  var asStatement = (function(string) {
+    return string
+      .toString()
+      .replace(/;*\s*$/, ";")
+    ;
+  });
+  
+  macros.statement = (function(args) {
+    var args = Array.prototype.slice.call(arguments, 0);
+    
+    return (macros.call.apply(undefined, args) + ";\n");
+  });
+  
+  macros.progn = (function(body) {
+    var body = Array.prototype.slice.call(arguments, 0);
+    
+    var lastIndex = Math.max(0, (body.length - 1));
+    (body)[lastIndex] = [ "return", (body)[lastIndex] ];
+    return (map(body, (function(arg) {
+      return (asStatement(translate(arg)));
+    }))).join("\n");
+  });
+  
+  macros.emptyList = (function() {
+    return "null";
+  });
+  
+  macros.call = (function(fnName, args) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    
+    return (translate(fnName) + "(" + (map(args, translate)).join(", ") + ")");
+  });
+  
+  macros.defun = (function(fnName, argsAndBody) {
+    var argsAndBody = Array.prototype.slice.call(arguments, 1);
+    
+    var fnNameTr = translate(fnName),
+        start = (function() {
+      if (fnNameTr.match(/\./)) {
+        return "";
+      } else {
+        return "var ";
+      }
+    })();
+    return (start + fnNameTr + " = " + macros.lambda.apply(undefined, argsAndBody) + ";\n");
+  });
+  
+  macros.defmacro = (function(name, argsAndBody) {
+    var argsAndBody = Array.prototype.slice.call(arguments, 1);
+    
+    var js = macros.lambda.apply(undefined, argsAndBody),
+        name = translate(name);
+    (function() {
+      try {
+        return (macros)[name] = eval(js);
+      } catch (e) {
+        return error(("error in parsing macro " + name + ":\n" + indent(js)));
+      }
+    })();
+    return undefined;
+  });
+  
+  (macros)["macro"] = macros.defmacro;
+  macros.concat = (function(args) {
+    var args = Array.prototype.slice.call(arguments, 0);
+    
+    return ("(" + (map(args, translate)).join(" + ") + ")");
+  });
+  
+  var transformArgs = (function(arglist) {
+    var last = undefined,
+        args = [  ];
+    arglist.forEach((function(arg) {
+      return (function() {
+        if (((arg)[0] === "&")) {
+          return last = arg.slice(1);
+        } else {
+          args.push([ (last || "required"), arg ]);
+          return last = null;
+        }
+      })();
+    }));
+    (function() {
+      if (last) {
+        return error(("unexpected argument modifier: " + last));
+      }
+    })();
+    return args;
+  });
+  
+  macros.reverse = (function(arr) {
+    var reversed = [  ];
+    arr.forEach((function(item) {
+      return reversed.unshift(item);
+    }));
+    return reversed;
+  });
+  
+  var reverse = macros.reverse;
+  var buildArgsString = (function(args, rest) {
+    var argsString = "",
+        optionalCount = 0;
+    args.forEach((function(arg, optionIndex) {
+      return (function() {
+        if (((arg)[0] === "optional")) {
+          argsString = (argsString + "if (arguments.length < " + (args.length - optionalCount) + ")" + indent(("var " + map(args.slice((optionIndex + 1)), (function(arg, argIndex) {
+            return (translate((arg)[1]) + " = " + translate(((args)[(optionIndex + argIndex)])[1]));
+          }))
+            .reverse()
+            .concat((translate((arg)[1]) + " = undefined"))
+            .join(", ")
+           + ";")));
+          return ((optionalCount)++);
+        }
+      })();
+    }));
+    return (function() {
+      if ((typeof rest !== 'undefined')) {
+        return (argsString + "var " + translate((rest)[1]) + " = Array.prototype.slice.call(arguments, " + args.length + ");\n");
+      } else {
+        return argsString;
+      }
+    })();
+  });
+  
+  macros.lambda = (function(arglist, body) {
+    var body = Array.prototype.slice.call(arguments, 1);
+    
+    var args = transformArgs(arglist),
+        rest = (select(args, (function(arg) {
+      return ("rest" === (arg)[0]);
+    })))[0],
+        docString = undefined;
+    (body)[(body.length - 1)] = [ "return", (body)[(body.length - 1)] ];
+    (function() {
+      if (((typeof (body)[0] === "string") && (body)[0].match(/^".*"$/))) {
+        return docString = ("/* " + eval(body.shift()) + " */\n");
+      }
+    })();
+    var noRestArgs = (function() {
+      if (rest) {
+        return args.slice(0, -1);
+      } else {
+        return args;
+      }
+    })(),
+        argsString = buildArgsString(noRestArgs, rest);
+    return ("(function(" + (map(args, (function(arg) {
+      return translate((arg)[1]);
+    }))).join(", ") + ") {" + indent(docString, argsString, (map(body, (function(stmt) {
+      var tstmt = translate(stmt);
+      return (tstmt + (function() {
+        if (((tstmt.slice(-1))[0] === ";")) {
+          return "";
+        } else {
+          return ";";
+        }
+      })());
+    }))).join("\n")) + "})");
+  });
+  
+  macros.quote = (function(item) {
+    return (function() {
+      if (("Array" === item.constructor.name)) {
+        return ("[ " + (map(item, macros.quote)).join(", ") + " ]");
+      } else {
+        return (function() {
+          if (("number" === typeof item)) {
+            return item;
+          } else {
+            return ("\"" + literal(item) + "\"");
+          }
+        })();
+      }
+    })();
+  });
+  
+  macros.hash = (function(pairs) {
+    var pairs = Array.prototype.slice.call(arguments, 0);
+    
+    (function() {
+      if ((0 !== (pairs.length % 2))) {
+        return error(("odd number of key-value pairs in hash: " + inspect(pairs)));
+      }
+    })();
+    var pairStrings = bulkMap(pairs, (function(key, value) {
+      return (translate(key) + ": " + translate(value));
+    }));
+    return (function() {
+      if ((1 >= pairStrings.length)) {
+        return ("{ " + (pairStrings).join(", ") + " }");
+      } else {
+        return ("{" + indent((pairStrings).join(",\n")) + "}");
+      }
+    })();
+  });
+  
+  var literal = (function(string) {
+    return inject(string
+      .replace(/\*/g, "_")
+      .replace(/\?$/, "__QUERY")
+      .replace(/!$/, "__BANG")
+    , string.match(/-(.)/g), (function(returnString, match) {
+      return returnString.replace(match, (match)[1].toUpperCase());
+    }));
+  });
+  
+  var translateListToken = (function(token, hint) {
+    return (function() {
+      if (((token).length === 0)) {
+        return macros.emptyList();
+      } else {
+        return (function() {
+          if ((typeof (macros)[translate((token)[0])] !== 'undefined')) {
+            return (macros)[translate((token)[0])].apply(undefined, token.slice(1));
+          } else {
+            return (macros)[(hint || "call")].apply(undefined, token);
+          }
+        })();
+      }
+    })();
+  });
+  
+  var translateStringToken = (function(token, hint) {
+    return (function() {
+      if (token.match((new RegExp(("^" + sibilant.tokens.literal + "$"), undefined)))) {
+        return literal(token);
+      } else {
+        return (function() {
+          if (token.match((new RegExp("^;", undefined)))) {
+            return token.replace((new RegExp("^;+", undefined)), "//");
+          } else {
+            return (function() {
+              if (("\"" === (token)[0] &&
+               "\"" === (token.slice(-1))[0])) {
+                return token
+                  .split("\n")
+                  .join("\\n\" +\n\"");
+              } else {
+                return token;
+              }
+            })();
+          }
+        })();
+      }
+    })();
+  });
+  
+  var translate = (function(token, hint) {
+    var hint = hint;
+    (function() {
+      if ((hint && (typeof (macros)[hint] === 'undefined'))) {
+        return hint = undefined;
+      }
+    })();
+    return (function() {
+      if ((typeof token !== 'undefined')) {
+        (function() {
+          if (typeof(token) === "string") {
+            return token = token.trim();
+          }
+        })();
+        return (function() {
+          try {
+            return (function() {
+              if ((token) && (token).constructor.name === "Array") {
+                return translateListToken(token, hint);
+              } else {
+                return (function() {
+                  if (typeof(token) === "string") {
+                    return translateStringToken(token, hint);
+                  } else {
+                    return token;
+                  }
+                })();
+              }
+            })();
+          } catch (e) {
+            return error((e.stack + "\n" + "Encountered when attempting to process:\n" + indent(inspect(token))));
+          }
+        })();
+      }
+    })();
+  });
+  
+  (sibilant)["translate"] = translate;
+  var translateAll = (function(contents) {
+    var buffer = "";
+    tokenize(contents).forEach((function(token) {
+      var line = translate(token, "statement");
+      return (function() {
+        if (line) {
+          return buffer = (buffer + line + "\n");
+        }
+      })();
+    }));
+    return buffer;
+  });
+  
+  (sibilant)["translateAll"] = translateAll;
+  ;
+  return (function() {
+    if ((typeof $ !== "undefined")) {
+      return $((function() {
+        var sibilant = root.sibilant,
+            scripts = [  ];
+        var evalWithTryCatch = (function(js) {
+          return (function() {
+            try {
+              return eval(js);
+            } catch (e) {
+              console.log(js);
+              throw new Error (e);
+            }
+          })();
+        });
+        ;
+        sibilant.scriptLoaded = (function() {
+          var lisp = null,
+              js = null;
+          return (function() {
+            if ((!sibilant.loadNextScript())) {
+              return $("script[type=\"text/sibilant\"]:not([src])").each((function() {
+                lisp = $(this)
+                  .text()
+                  .replace(/(^\s*\/\/\<!\[CDATA\[)|(\/\/\]\]>\s*$)/g, "");
+                js = sibilant.translateAll(lisp);
+                $(this).data("js", js);
+                return evalWithTryCatch(js);
+              }));
+            }
+          })();
+        });
+        ;
+        scripts = $.makeArray($("script[type=\"text/sibilant\"][src]").map((function() {
+          return this.src;
+        })));
+        sibilant.loadNextScript = (function() {
+          var nextScript = scripts.shift();
+          return (function() {
+            if ((typeof nextScript !== 'undefined')) {
+              $.get(nextScript, (function(data) {
+                evalWithTryCatch(sibilant.translateAll(data));
+                return sibilant.scriptLoaded();
+              }));
+              return true;
+            }
+          })();
+        });
+        ;
+        return sibilant.loadNextScript();
+      }));
+    }
+  })();
+})(this);
+