; rember (as on page 34)

(define rember
  (lambda (a lat)
    (cond ((null? lat) '())
          ((eq? (car lat) a) (rember a (cdr lat)))
          (else (cons (car lat) (rember a (cdr lat)))))))

; rember* (mostly as on page 81)

; remove all atoms a from recursive list l
(define rember*
  (lambda (a l)
    (cond ((null? l) '())
          ((list? (car l)) (cons (rember* a (car l))
                                 (rember* a (cdr l))))
          ((eq? (car l) a) (rember* a (cdr l)))
          (else (cons (car l) (rember* a (cdr l)))))))

; replace all atoms a with b from recursive list l
(define replace*
  (lambda (a b l)
    (cond ((null? l) '())
          ((list? (car l)) (cons (replace* a b (car l))
                                 (replace* a b (cdr l))))
          ((eq? (car l) a) (cons b (replace* a b (cdr l))))
          (else (cons (car l) (replace* a b (cdr l)))))))

; with cond's "exploded" and indented line in the book
(define rember*
  (lambda (a l)
    (cond 
      ((null? l) '())
      (else 
       (cond 
         ((list? (car l)) 
          (cons (rember* a (car l))
                (rember* a (cdr l))))
         (else (cond ((eq? (car l) a) 
                      (rember* a (cdr l)))
                     (else (cons (car l) 
                                 (rember* a (cdr l)))))))))))

(define ^ expt)

; simplified version of value on pp. 102ff

; a nexp is:
;   - a number, or
;   - a list of length 3:  (nexp1 operator nexp2)
;      where operator is +, *, ^

(define value
  (lambda (nexp)
    (cond ((number? nexp) nexp)
          (else (let ((value-nexp1 (value (car nexp)))
                      (value-nexp2 (value (caddr nexp)))
                      (operator (cadr nexp)))
                  (cond ((eq? operator '+) (+ value-nexp1 value-nexp2))
                        ((eq? operator '*) (* value-nexp1 value-nexp2))
                        ((eq? operator '^) (^ value-nexp1 value-nexp2))
                        (else 0)))))))


; using value and replace* to plug in 4 into 2(x+7x^2)
(value (replace* 'x 4 '(2 * (x + (7 * (x * x))))))
; or just use lambda in scheme...
((lambda (x) (* 2 (+ x (* 7 (* x x))))) 4)