anchor.diff:    (if (type# val)
       (with (tag (get-idx val :tag))
         (cond
  -        ((= tag "number") (get-idx val :value))
  -        ((= tag "string") (get-idx val :value))
  -        (true val)))
  +        [(= tag "number") (get-idx val :value)]
  +        [(= tag "string") (get-idx val :value)]
  +        [true val]))
       val))
  
positive.code:             (,impl nil)]
         (set! ,impl (lambda (,ctr')
                       (cond
                         ((if (< 0 ,step) (<= ,ctr' ,end') (>= ,ctr' ,end'))
                           (let* ((,ctr ,ctr')) ,@body)
                           (,impl (+ ,ctr' ,step')))
                         (true))))
         (,impl ,start))))
  
  (defmacro while (check &body)
  
negative.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
  