Explication de l'évaluation de cette procédure de schéma en utilisant lambdas

Question

Je me demandais comment le code suivant évalue à 3.

(define (foo y) ((lambda (x) y) ((lambda (y)(* y y)) y))) 

(foo 3) 

J'ai regardé pendant un certain temps et ne peut pas sembler comprendre pourquoi l'évaluation ne se traduit pas 9. Est-ce que quelqu'un pourrait fournir une instruction détaillée étape par étape sur la façon dont cela évalue à 3?

Answer 1

le début Let par indenter le code d'une manière qu'il est plus facile à comprendre:

(define (foo y) 
    ((lambda (x) y) 
    ((lambda (y) (* y y)) 
    y))) 

Maintenant, nous allons l'évaluer, de l'intérieur vers l'extérieur:

(define (foo y) 
    ((lambda (x) y) 
    ((lambda (y) (* y y)) 
    3))) ; pass the parameter 

(define (foo y) 
    ((lambda (x) y) 
    (* 3 3))) ; evaluate innermost lambda 

(define (foo y) 
    ((lambda (x) y) 9)) ; pass the result of evaluation 

Aha! c'est là que nous obtenons le 3. Même si nous transmettons un 9 en tant que paramètre (lié à x), nous renvoyer la valeur du paramètre y plus à l'extérieur, ce qui était 3 tout le long:

=> 3 

Answer 2

Avec let ré-écriture,

(define (foo y) ((lambda (x) y) ((lambda (y)(* y y)) y))) 

(foo 3) 
= 
(let ([y 3])         ; by application 
    ((lambda (x) y) ((lambda (y)(* y y)) y))) 
= 
(let ([y 3]) 
    (let ([x ((lambda (y)(* y y)) y)])  ; by application 
    y)) 
= 
(let ([y 3]) 
    (let ([x ((lambda (z)(* z z)) y)])  ; by alpha-renaming 
    y)) 
= 
(let ([y 3]) 
    (let ([x (let ([z y])    ; by application 
       (* z z))]) 
    y)) 
= 
(let ([y 3]) 
    (let ([x (* y y)])    ; by let-elimination 
    y)) 
= 
(let ([y 3]) 
    (let ([x 9])      ; by expression evaluation 
    y)) 
= 
(let ([y 3]) 
    y )      ; by let-elimination 
= 
3        ; by let-elimination 

Comme vous pouvez le voir, le (lambda (y)(* y y)) imbriquée est situé dans un champ imbriqué, sans incidence sur la y qui est finalement retourné, mais seulement x, dont la valeur, , est évalué puis rejeté.