lambda终结者

;(define rember-f
 ; (lambda(test? a l)
  ;  (cond
   ;   ((null? l)(quote()))
    ;  (else(cond
     ;        ((test?(car l)a)(cdr l))
      ;       (else(cons(car l)
       ;                (rember-f test? a
        ;                         (cdr l)))))))))

(define rember-f
  (lambda(test? a l)
    (cond
      ((null? l)(quote()))
      ((test?(car l)a)(cdr l))
      (else(cons(car l)
                (rember-f test? a)
                (cdr l))))))

(define insertL-f
  (lambda(test?)
    (lambda(new old l)
      (cond
        ((null? l)(quote()))
        ((test?(car l)old)
         (cons new(cons old (cdr l))))
        (else(cons(car l)
                  ((insertL-f test?)new old
                                    (cdr l))))))))

(define insertR-f
  (lambda(test?)
    (lambda(new old l)
      (cond
        ((null? l)(quote()))
        ((test?(car l)old)
         (cons old(cons new (cdr l))))
        (else(cons(car l)
                  ((insertR-f test?)new old
                                    (cdr l))))))))

(define seqL
  (lambda(new old l)
    (cons new(cons old l))))

(define seqR
  (lambda(new old l)
    (cons old(cons new l))))

(define insert-g
  (lambda(seq)
    (lambda(new old l)
      (cond
        ((null? l)(quote()))
        ((eq?(car l)old)
         (seq new old (cdr l)))
        (else(cons(car l)
                  ((insert-g seq)new old
                                 (cdr l))))))))
;再次用insert-g来定义insertL,但这次不传递seqL参数
(define insertLc
  (insert-g
   (lambda(new old l)
     (cons new (cons old l)))))

;给subst定义一个函数
(define seqS
  (lambda(new old l)
    (cons new l)))

(define subst(insert-g seqS))

;curry value函数
(define atom-to-function
  (lambda(x)
    (cond
      ((eq? x(quote +))+)
      ((eq? x(quote *))*)
      (else →))))

(define valuec
  (lambda(nexp)
    (cond
      ((atom? nexp)nexp)
      (else
       ((atom-to-function
         (operator nexp))
        (valuec(1st-sub-exp nexp))
        (valuec(2nd-sub-exp nexp)))))))

(define multirember-f
  (lambda(test?)
    (lambda(a lat)
      (cond
        ((null? lat)(quote()))
        ((test? a(car lat))
         ((multirember-f test?)a
                               (cdr lat)))
        (else(cons(car lat)
                  ((multirember-f test?)a
                                        (cdr lat))))))))

(define multiremberT
  (lambda(test? lat)
    (cond
      ((null? lat)(quote()))
      ((test?(car lat))
       (multiremberT test?(cdr lat)))
      (else(cons(car lat)
                (multiremberT test?
                              (cdr lat)))))))
(define multirember&co
  (lambda(a lat col)
    (cond
      ((null? lat)
       (col(quote())(quote())))
      ((eq?(car lat)a)
       (multirember&co a
                       (cdr lat)
                       (lambda(newlat seen)
                         (col newlat
                              (cons(car lat)seen)))))
      (else
       (multirember&co a
                         (cdr lat)
                         (lambda(newlat seen)
                           (col(cons(car lat)newlat)
                               seen)))))))

(define a-friend
  (lambda(x y)
    (null? y)))

(define new-friend
  (lambda(newlat seen)
    (a-friend newlat
         (cons(quote tuna)seen))))

(define lastest-friend
  (lambda(newlat seen)
    (a-friend(cons(quote and)newlat))))

(define multiinsertLR
  (lambda(new oldL oldR lat)
    (cond
      ((null? lat)(quote()))
      ((eq?(car lat)oldL)
       (cons new
             (cons oldL
                   (multiinsertLR new oldL oldR
                                   (cdr lat)))))
      ((eq?(car lat)oldR)
       (cons oldR
             (cons new
                   (multiinsertLR new oldL oldR
                                  (cdr lat)))))
      (else
       (cons(car lat)
            (multiinsertLR new oldL oldR
                           (car lat)))))))

;实现一个函数evens-only*从一个嵌套列表的某个子列表中移除所有的奇数
(define even?
  (lambda(n)
    (=(*(/ n 2)2)n)))

(define evens-only*
  (lambda(l)
    (cond
      ((null? l)(quote()))
      ((atom?(car l)
             (cond
               ((even?(car l))
                (cons(car l)
                     (evens-only*(cdr l))))
               (else(evens-only*(cdr l))))))
      (else(cons(evens-only*(car l))
                (evens-only*(cdr l)))))))

(define the-last-friend
  (lambda(newl product sum)
    (cons sum
          (cons product
                newl))))