Dopo aver esaminato i calcoli di lambda-conversione di Alonzo Church, e pensando un po 'ai sistemi di riscrittura, alle diverse definizioni di algoritmi e al Lisp, sono giunto per lo più d'accordo con risposta di John Clements" : che lo stato di un programma Scheme è un programma Schema "ridotto".
Vorrei tuttavia formulare la mia versione di esso (che posso modificare o migliorare se imparo di più).
Secondo me, uno stato di un programma Scheme può essere visto come una sorta di programma Scheme, dove invece di costanti letterali , i dati costanti arbitrari valori sono consentiti (devono essere consentiti perché non sono sicuro che, ad esempio, un valore float arbitrario possa essere scritto come valore letterale float).
Ad esempio, un programma può essere eseguito come segue (la sequenza di stati):
Il programma:
(define x 0)
(set! x (lambda (x) (+ x 1)))
(define y 2)
(x y)
Stato del programma dopo il punto 1:
(define x (lambda (x) (+ x 1)))
(define y 2)
(x y)
Stato del programma dopo il passaggio 2:
(define y 2)
((lambda (x) (+ x 1)) y)
Stato del programma dopo il passaggio 3:
((lambda (x) (+ x 1)) 2)
Stato del programma dopo il punto 4:
(+ 2 1)
Stato del programma dopo il passaggio 5:
3
Aggiorna . Per confermare questo punto di vista, ecco le citazioni dal riferimento :
1.1 Evaluation Model
Racket evaluation can be viewed as the simplification of expressions to obtain values. For example, just as an elementary-school student simplifies
1 + 1 = 2
Racket evaluation simplifies
(+ 1 1) → 2
The arrow → above replaces the more traditional = to emphasize that evaluation proceeds in a particular direction towards simpler expressions. In particular, a value is an expression that evaluation simplifies no further, such as the number 2.
[...]
1.1.4 Top-Level Variables
Given
x = 10
then an algebra student simplifies x + 1 as follows:
x + 1 = 10 + 1 = 11
Racket works much the same way, in that a set of top-level variables are available for substitutions on demand during evaluation. [...]
Each evaluation step, then, takes the current set of definitions and program to a new set of definitions and program. Before a define can be moved into the set of definitions, its right-hand expression must be reduced to a value.
defined:
evaluate: (begin (define x (+ 9 1)) (+ x 1))
→ defined:
evaluate: (begin (define x 10) (+ x 1))
→ defined: (define x 10)
evaluate: (begin (void) (+ x 1))
→ defined: (define x 10)
evaluate: (+ x 1)
→ defined: (define x 10)
evaluate: (+ 10 1)
→ defined: (define x 10)
evaluate: 11
Using set!, a program can change the value associated with an existing top-level variable:
defined: (define x 10)
evaluate: (begin (set! x 8) x)
→ defined: (define x 8)
evaluate: (begin (void) x)
→ defined: (define x 8)
evaluate: x
→ defined: (define x 8)
evaluate: 8
Ho letto anche la macchina SECD , le chiusure e gli ambienti, ma mi sembrano solo un metodo di implementazione particolare.