(defun member. (x xs)
  (cond ((null xs) nil)
        ((eq x (car xs)) t)
        (t (member. x (cdr xs)))))
(defun member. (x xs)
  (when xs
    (if (eq x (car xs))
        t
      (member. x (cdr xs)))))

;; FIXME double recursive calls have to go
(defun intersection. (xs ys)
  (when xs
    (if (mem. (car xs) ys)
        (cons (car xs) (intersection. (cdr xs) ys))
      (intersection. (cdr xs) ys))))
(defun intersection. (xs ys)
  (cond ((null xs) nil)
        ((mem. (car xs) ys) (cons (car xs) (intersection. (cdr xs) ys)))
        (t (intersection. (cdr xs) ys))))

(defun map. (proc xs)
  (cond ((null xs) nil)
        (t (cons (proc (car xs)) (map. proc (cdr xs))))))

(defun fold. (init proc items)
  ;; see `reduce' in stdlib.jl
  ;; (fold. '+ 0 '(1 2 3 4 5)) => 15
  (if (null items)
      init
    (proc (car items) (fold. proc init (cdr items)))))

(defun sum. (items)
  (cond ((null items) 0)
        (t (+ (car items) (sum. (cdr items))))))

;; special let form for sum
(let loop ((rest '(1 2 3))
           (total 0))
     (if (null rest)
         total
       (loop (cdr rest) (+ total (car rest)))))

(defun product. (items)
  (cond ((null items) 1)
        (t (* (car items) (product. (cdr items))))))