anchor.diff:              (,impl nil)]
          (set! ,impl (lambda (,ctr')
                        (cond
  -                       ((if (< 0 ,step) (<= ,ctr' ,end') (>= ,ctr' ,end'))
  -                         (let* ((,ctr ,ctr')) ,@body)
  -                         (,impl (+ ,ctr' ,step')))
  -                       (true))))
  +                       [(if (< 0 ,step) (<= ,ctr' ,end') (>= ,ctr' ,end'))
  +                        (let* ((,ctr ,ctr')) ,@body)
  +                        (,impl (+ ,ctr' ,step'))]
  +                       [true])))
          (,impl ,start))))
   
   (defmacro while (check &body)
  
positive.code:     (cond
        ;; If we've only got one entry in the body then use that: we don't want
        ;; to break functions which return a constant value
        ((= (get-idx body "n") 1)
          `(,@header (lambda ,args ,@body)))
        ;; If we've got a string literal then yoink it
        ((= (type# (car body)) "string")
          (copy-meta `(,@header ,(car body)) args (cdr body)))
        ;; If we've got a table then check if it is a string or key.
        ((= (type# (car body)) "table")
          (cond
            ((= (get-idx (car body) "tag") "string")
              (copy-meta `(,@header ,(car body)) args (cdr body)))
            ((= (get-idx (car body) "tag") "key")
              (copy-meta `(,@header ,(car body)) args (cdr body)))
            ;; Simply splice everything together into our final definition
            (true
              `(,@header (lambda ,args ,@body)))))
        (true
          `(,@header (lambda ,args ,@body))))))
  
  (define-macro defun
    "Define NAME to be the function given by (lambda ARGS @BODY), with
  
negative.code:   "Format VALUE as a valid Lisp expression which can be parsed."
    (with (ty (type# value))
      (cond
        [(= ty "table")
         (with (tag (get-idx value :tag))
           (cond
             [(= tag "list")
              (with (out '())
                    (for i 1 (# value) 1
                         (set-idx! out i (pretty (get-idx value i))))
                    (.. "(" (.. (concat out " ") ")")))]
             [(and (= (type# (getmetatable value)) "table")
                   (= (type# (get-idx (getmetatable value) :--pretty-print)) "function"))
              ((get-idx (getmetatable value) :--pretty-print) value)]
             [(= tag "list") (get-idx value :contents)]
             [(= tag "symbol") (get-idx value :contents)]
             [(= tag "key") (.. ":" (get-idx value :contents))]
             [(= tag "string") (string/format "%q" (get-idx value :value))]
             [(= tag "number") (tostring (get-idx value :value))]
             [true (tostring value)]))]
        [(= ty "string") (string/format "%q" value)]
        [true (tostring value)])))
  
  (define arg
    "The arguments passed to the currently executing program"
    (cond
      [(= nil arg#) '()]
      [true
        ;; Ensure we're got a list
        (set-idx! arg# :tag "list")
        (cond
          ((get-idx arg# :n))
          (true (set-idx! arg# :n (len# arg#))))
        arg#]))
  
  (defun const-val (val)
    "Get the actual value of VAL, an argument to a macro.
  