(hash-set macs ‘if (fn args

(cond args
      (cond (cdr args)
            (cond (cddr args)
                  `(cond ,(car args) ,(cadr args) (if ,@(cddr args)))
                  `(cond ,(car args) ,(cadr args)))
            (car args))
      nil)))

(def map-helper-0 (f things lc)

(loop (pair? things)
      ((fn nil
           (assign lc (cdr-set lc (cons (f (car things)))))
           (assign things (cdr things)))))
(if things
    (cdr-set lc (f things))))

(def map-helper-1 (f things acc)

(map-helper-0 f things acc)
(cdr acc))

;; transforms the list ‘things by applying ’f to each item, returns the resulting list ;; conceptually, does the following: ;; ;; (if (pair? things) ;; (cons (f (car things)) (map f (cdr things))) ;; things ;; (f things)) ;; ;; however the actual version is more complicated to allow for TCO (“modulo-cons” issue) (def map (f things)

(map-helper-1 f things (cons)))

;; push ‘v onto the value for ’k in ‘h ;; the hash-values of h will all be lists, in reverse order of consing (def hash-cons (h k v)

(hash-set h k (cons v (hash-get h k))))

;; ‘things - the list to be reversed ;; ’last-cdr - (normally nil) - an item (atom, list, nil, anything) to be consed to the end of the reversed list. (def rev (things last-cdr)

(loop (pair? things)
      ((fn nil
           (assign last-cdr (cons (car things) last-cdr))
           (assign things (cdr things)))))
last-cdr)