Yanında çalışıyorumKüçük DüzenbazDüzeni öğrenmek ve kullanarak PLT çevre Düzeni benim için.

Küçük Düzenbazama "toplayıcıları" ve bir bütün olarak işlev devamı. aramalar tanıtan bir kitabın bir bölümünü yolda kaldım beni özyineleme (benim için basit şimdi) ile son derece yardımcı oldu

Burada kullandıkları örnek kodu. Anlıyorum özyinelemeli elemanları ama kaldığım, özellikle üzerinde lambda fonksiyonları - aklımı alamıyorum yolunu izleyin ve nasıl argümanlar için lambda fonksiyonudur set (beri onların sadece çağrı için çağrı onları bir daha tekrarlama yok betonlar içinde işlev gövdesi).

Eğer biri daha fazla veya daha az lambda koleksiyoncular içine fonksiyon özyineleme ile hesaplama yoluna beni rahat bırak, olur, bana yardımcı olabilir.

;; Build a nested list of even numbers by removing the odd ones from its
;; argument and simultaneously multiply the even numbers and sum the odd
;; numbers that occur in its argument.
(define (even-only-collector l col)
  (cond
    ((null? l)
      (col (quote ()) 1 0))
    ((atom? (car l))
      (cond
        ((even? (car l))
          (even-only-collector (cdr l)
            (lambda (newl p s)
              (col (cons (car l) newl)
                (* (car l) p) s))))
         (else
           (even-only-collector (cdr l)
             (lambda (newl p s)
               (col newl
                 p (  (car l) s)))))))
    (else
      (even-only-collector (car l)
        (lambda (al ap as)
          (even-only-collector (cdr l)
            (lambda (dl dp ds)
              (col (cons al dl)
                (* ap dp)
                (  as ds)))))))))

;; The collector function
(define (collector newl product sum)
  (cons sum
    (cons product newl)))

Şimdiden teşekkürler!!

Daha basit bir şey bunun nasıl çalıştığını görmek için deneyin. Örneğin, burada devam argümanı sık sık k (çağrılan) alır list-sum bir fonksiyonun bir versiyonu:

(define (list-sum l k)
  (if (null? l)
    ???
    (list-sum (cdr l) ???)))

Temel desen yok, eksik parçalar ilginç şeylerin olduğu. Devamı tartışma sonucu eğer liste boş ise, o toplamıdır: 0, göndermesi gereken açık o yüzden -- almak için bekleyen bir fonksiyonudur

(define (list-sum l k)
  (if (null? l)
    (k 0)
    (list-sum (cdr l) ???)))

Liste boş değil, şimdi işlevi listenin kuyruk özyinelemeli olarak diyoruz (diğer bir deyişle, bu bir döngü, ama soru devamı ne olmalıdır. Bu işi yapmaya

(define (list-sum l k)
  (if (null? l)
    (k 0)
    (list-sum (cdr l) k)))

açıkça yanlış -- k sonunda l her yerine (cdr l) toplamı alacak demektir. Bunun yerine, l ilk eleman da birlikte aldığı değer ile özetlemek olacak: yeni bir işlevi var

(define (list-sum l k)
  (if (null? l)
    (k 0)
    (list-sum (cdr l) (lambda (sum) (  (car l) sum)))))

Bu daha yakın oluyor, ama yine de yanlış. Ama iyi bir noktaya düşün nasıl gidiyor çalışma ... arama list-sum ile devam edecek kendisi almak genel toplamı ekleyin ilk madde görüyoruz şimdi. Eksik parçası k görmezden geliyoruz aslında bellidir. İhtiyacımız olan şeyoluşturBu k aynı toplam işlemi yapıyoruz yani ... fonksiyonu k sonuç gönderin:

(define (list-sum l k)
  (if (null? l)
    (k 0)
    (list-sum (cdr l) (compose k (lambda (s) (  s (car l)))))))

nihayet çalışıyor. (BTW, bu lambda bu fonksiyonların her biri kendi var ""*.* 26) kopya unutma Bunu deneyebilirsiniz:

(list-sum '(1 2 3 4) (lambda (x) x))

Ve son olarak bu aynı .. not:

(define (list-sum l k)
  (if (null? l)
    (k 0)
    (list-sum (cdr l) (lambda (s) (k (  s (car l)))))))

kompozisyon açık yaparsanız.

(Ayrıca bu kodu Ara lambda öğrenci Dil ve tıklatın step düğmesi görmek nasıl değerlendirme gelirleri -- bu vakit alacak gidin, ama göreceksin nasıl devam işlevler iç içe geçmiş, her biri kendi görünüm listesi.)