récemment, commencer à apprendre Scheme (a été une semaineavec mon attention), alors tout est vraiment déroutant et mélangé dans ma tête. Je viens de me rendre compte que l’expression "évaluation" est l’axe principal du schéma. comparez avec d’autres langages de "langage procédural", Scheme est un monde différent (oui, "langage fonctionnel").
commence à connaître un nouveau langage, "retour aux sources". J'en ai lu d'autres questions et réponds mais ce n’est pas exactement ce que je veux savoir ou ce qui m’embrouille (pour le moment ... peut-être plus tard, peut-être mieux ..)
Question 1. Quoi exactement "évaluation" signifie dans Scheme? et Scheme utilisant également "evaluation of environment" = mise en pile ?? assigner la mémoire ???. en quoi diffère de l'exécution?
Question 2. Est environnement définition similaire à "accord" paramètres"dans une fonction?
Question 3. "valeur initiale" dans Schemeet "valeur initiale" autre procédureprogrammation (c / c ++) ont le même sens? généralement la valeur initiale en langage procédural est la valeur que vous devez attribuer avant l'exécution du programme ... généralement 0, null, ... l'adresse de début de la mémoire ... etc ... mais mon impression dans la valeur initiale de Scheme "s" "est un peu différent. Scheme" valeur initiale "= la fonction elle-même (du moins en récursion) ... Quelqu'un peut-il expliquer cela clairement avec une expression très simple (pas de mots" buzz Scheme ") ???
Question 4 alors, il semble que vous puissiez expliquer la différence entre let, letrec, let * avec évaluation. (pas encore sûr). quelque chose comme ça (peut être complètement faux ...),
4-1) ["Quand un" laisser "normal est évalué, les expressions de valeur initiales sont évaluées avant la liaison. "] signifie? = (avec mes mots) quand let est exécuté?? et je ne "comprends pas ... cela" les expressions de valeur initiale sont évaluées avant que la liaison ne soit faite. " Comment il peut évaluer avant que la liaison soit faite ... ?? qu'est-ce que cela signifie exactement "la liaison est faite" ???
4-2) ["let *": quand une commande est importante, évalue l'environnement (paramètre?) pas à pas avec les lignes du programme de commande (???)] par cette explication, pour moi, évalue = exécute .... => (mon interprétation, "laissez *" attribue la mémoire et s'exécute pour chaque paramètre, étape par étape avec l'ordre de la ligne de programme ???
4-3) "letrec": ["letrec nous laisse créer un environnement avant d'évaluer la valeur initiale(??) expressions, de sorte que la valeur initiale les calculs s'exécutent dans le nouvel environnement(mon interprétation cela sonne pour la récursion de la queue)]. "=> crée un environnement avant d'évaluer la valeur initiale, comment?
Question 5 Il n'y a pas d'initialisation, déclaration ... dans Scheme?
Désolé pour une longue question et peut-être trop basique pour d'autres. mais cela m'aidera à clarifier les choses dans Scheme.
Réponses:
1 pour la réponse № 1L’évaluation est le processus qui consiste à exécuter un peu de code sur son résultat. (+ 1 2) ;==> 3. Dans cet exemple particulier + est une variable libre qui doit être dans l'environnement. Il pourrait évaluer à la prcedure globale + ou il se peut qu’il s’agisse d’une variable lexicale issue du code exécuté auparavant.
2 environnement
L'environnement est les variables accessibles à un moment donné. par exemple.
(define x 10)
(define f1 (lambda (y) (+ x y))
(define f2 (let ((x 5))
(lamdba (y) (+ x y))))
Les formes lambda qui cerate f1 et f2 sont égaux dans le sens où ils font exactement la même chose. La différence dans l'environnement.
(f1 3) ; ==> 13
(f2 3) ; ==> 8
La portée de f2"s x n’est plus mais c’est référencé dans la procedure et accessible lors de l'exécution, mais pas à partir d'un autre endroit. Un évalué lambda forme (c'est-à-dire une procédure) est également appelée fermeture, car les variables accessibles au point d'évaluation sont accessibles lors de l'application du résultat de cette forme lambda (la procédure).
3 valeur initiale
Lorsque vous démarrez un programme Scheme, vous disposez d'un environnement global initial. des variables comme + et cons sont définis. Je ne suis pas sûr que c’est ce que vous vouliez. Peut-être devriez-vous donner un exemple de ce que vous pensiez?
4 let, let*, letrec, et lambda
Vous avez ceci dans tous les exemples:
(define x 10)
(define f (lambda (x) x)
Chacun d'entre eux devient anonyme lambda appels de fonction. Je ferai juste un niveau, mais puisque vous pouvez transformer let* dans let et let dans lambda vous pouvez transformer chacun d'eux en beaucoup de lambda formes. Voici comment:
(let ((a 1) (b 2) ...) body ...) est le même que ((lambda (a b ..) body ...) 1 2 ...) c'est donc vrai:
(let ((x 5) (y (+ x 1)) (f (lambda (x) (if (< 5 x) (f (- x 1)) x))))
(list x y (f 10))) ; ==> (5 11 9)
(let ((a 1) (b 2)) body ...) est le même que (let ((a 1)) (let ((b 2)) body ...) c'est donc vrai:
(let* ((x 5) (y (+ x 1)) (f (lambda (x) (if (< 5 x) (f (- x 1)) x))))
(list x y (f 10))) ; ==> (5 6 9)
(letrec ((a 1) (b 2)) body ...) est le même que (let ((a "undef) (b "undef)) (let ((tmpa 1) (tmpb 2)) (set! a tmpa) (set! b tmpb)) body ...) c'est donc vrai:
(letrec ((x 5) (y (list x 1)) (f (lambda (x) (if (< 5 x) (f (- x 1)) x))))
(list x y (f 10))) ; ==> (5 (undef 1) 5)
Note j'ai changé + à list depuis (+ "undef 1) ne fonctionnera pas. Votre implémentation Scheme pourra utiliser n'importe quelle valeur à la place de undef. Quand utiliser quoi? Utilisez `` letrecand namedlaisserfor procedures that you need to recurse, uselaisser*for variables where you rely on a previous calculation (it keeps you from writing nestedlaisserforms and uselaissez autant que vous le pouvez.
Alors, imaginez que vous ayez une procédure non récursive, une variable et une variable que vous dérivez, vous pouvez utiliser let*:
(let* ((sq (lambda (x) (* x x))) ; given this is a top level it will have global environment
(x (sq 5))
(y (sq 10))
(res (+ x y)) ; here I"m using both x and y
(do-something res))
5 déclarations
Il y a. Si je veux créer des variables globales, je le fais comme ceci:
(define test 55)
(define fun (lambda (x) (+ test x))