星星魔法

(define rember*
  (lambda (a l)
    (cond
      ((null? l)(quote()))
      ((atom?(car l))
       (cond
         ((eq?(car l) a)
          (rember* a (cdr l)))
         (else(cons (car l)
                    (rember* a(cdr l))))))
      (else(cons(rember* a (car l))
                 (rember* a (cdr l)))))))
;上下两个函数都是不仅要递归列表的cdr，还要递归列表的car
(define insertR*
  (lambda(new old l)
    (cond
      ((null? l)(quote()))
      ((atom? (car l))
       (cond
         ((eq? (car l) old)
          (cons old
                (cons new
                      (insertR* new old
                               (cdr l)))))
         (else (cons (car l)
                     (insertR* new old
                              (cdr l))))))
      (else (cons(insertR* new old
                          (car l))
                 (insertR* new old
                          (cdr l)))))))
(define occur*
  (lambda(a l)
    (cond
      ((null? l)0)
      ((atom?(car l))
       (cond
         ((eq?(car l)a)
          (add1(occur* a(cdr l))))
         (else(occur* a (cdr l)))))
      (else(sum(occur* a(car l))
               (occur* a(cdr l)))))))

(define subst*
  (lambda(new old l)
    (cond
      ((null? l)(quote()))
      ((atom? (car l))
       (cond
         ((eq? (car l)old)
          (cons new
               (subst* new old (cdr l))))
         (else (cons(car l)
                    (subst* new old
                            (cdr l))))))
      (else(cons(subst* new old (car l))
                (subst* new old (cdr l)))))))

(define insertL*
  (lambda(new old l)
    (cond
      ((null? l)(quote()))
      ((atom? (car l))
              (cond
                ((eq? (car l)old)
                 (cons new
                       (cons old
                             (insertL* new old
                                      (cdr l)))))
              (else(cons(car l)
                        (insertL* new old
                                  (cdr l))))))
      (else(cons(insertL* new old
                          (car l))
                (insertL* new old
                         (cdr l)))))))

(define member*
  (lambda (a l)
    (cond
      ((null? l) #f)
      ((atom? (car l))
       (or (eq?(car l)a)
           (member* a (cdr l))))
      (else(or(member* a (car l))
              (member* a (cdr l)))))))

(define leftmost
        (lambda(l)
          (cond
            ((atom? (car l))(car l))
            (else(leftmost (car l))))))

(define eqlist?
  (lambda (l1 l2)
    (cond
      ((and (null? l1)(null? l2))#t)
      ((and (null? l1)(atom? (car l2)))
       #f)
      ((null? l1)#f)
      ((and(atom?(car l1))(null? l2))
       #f)
      ((and(atom?(car l1))
           (atom?(car l2)))
       (and(eqan?(car l1)(car l2))
           (eqlist?(cdr l1)(cdr l2))))
      ((atom?(car l1))#f)
      ((null? l2)#f)
      ((atom?(car l2))#f)
      (else
       (and(eqlist?(car l1)(car l2))
           (eqlist? (cdr l1)(cdr l2)))))))
;接下里重写eqlist?
(define eqlist*
  (lambda(l1 l2)
    (cond
      ((and(null? l1)(null? l2))#t)
      ((or(null? l1)(null? l2))#f)
      (else
       (and(equal?(car l1)(car l2))
           (eqlist?(cdr l1)(cdr l2)))))))

;重写rember函数，这里的版本移除S-表达式列表l中第一个匹配的
;S-表达式s的元素，而之前的版本仅移除原子列表lat第一个匹配原子a的元素
(define rember
  (lambda(s l)
   (cond
    ((null? l)(quote()))
    ((equal?(car l)s)(cdr l))
    (else(cons(car l)
              (rember s (cdr l)))))))