anchor.diff:  
      ### Example:
      ```cl
  -   > (nth (range 1 100) 10)
  +   > (nth (range :from 1 :to 100) 10)
      out = 10
      ```"
     (if (>= idx 0)
  
positive.code: 
     ### Example:
     ```cl
     > (init (range 1 10))
     out = '(1 2 3 4 5 6 7 8 9)
     ```"
    (assert-type! xs list)
  
negative.code:    ```"
    (foldl append '() xss))
  
  (defun range (&args)
    "Build a list from :FROM to :TO, optionally passing by :BY.
  
     ### Example:
     ```cl
     > (range :from 1 :to 10)
     out = (1 2 3 4 5 6 7 8 9 10)
     > (range :from 1 :to 10 :by 3)
     out = (1 3 5 7 9)
     ```"
    (let* [(x (let* [(out {})]
                (when (= (% (n args) 2) 1)
                  (error "Expected an even number of arguments to range" 2))
                (for i 1 (n args) 2
                  (set-idx! out (get-idx args i) (get-idx args (+ i 1))))
                out))
           (st (or (get-idx x :from) 1))
           (ed (or (get-idx x :to) huge))
           (inc (- (or (get-idx x :by) (+ 1 st)) st))
           (tst (if (>= st ed)
                  > <))]
      (let* [(c st)
             (out '())]
        (while (tst c ed)
          (push-cdr! out c)
          (set! c (+ c inc)))
        out)))
  
  
  (defun reverse (xs)
    "Reverse the list XS, using the accumulator ACC.
  
     ### Example:
     ```cl
     > (reverse (range :from 1 :to 10))
     out = (10 9 8 7 6 5 4 3 2 1)
     ```"
    (let* [(out '())]
  