Today, we're going to do something horrible: we're going to add an assignment statement.

New features should provide new means of decomposition. So far, all of the programs have been functional; they have encoded mathamatical truths. Processes evolved by such programs can be understood by substitution.

<before>
(set! <var> <value>)
<after>

Note: Similar to how ? denotes predicate procedure, ! denotes assignment-like things.

By introducing assignment, time is now introduced. var has a different state before and after.

(define count 1)
(define (demo x)
  (set! count (1+ count))
  (+ x count))
(demo 3)

5

(demo 3)

6

To show the difference between functional and imperative, let's see how the factorial procedures differ.

Functional version:

(define (fact n)
  (define (iter m i)
    (cond ((> i n) m)
          (else (iter (* i m) (+ i 1)))))
  (iter 1 1))

Imperative version:

(define (fact n)
  (let ((i 1) (m 1))
    (define (loop)
      (cond ((> 1 n) m)
            (else
             (set! m (* i m))
             (set! i (+ i 1))
             (loop))))
    (loop)))

Note that define ≠ let ≠ set!. Two define​s are illegal, and let sets up a scope.

The following two statements are equivalent.

(let ((var1 e1) (var2 e2))
  e3)

((lambda (var1 var2)
   e3)
 e1
 e2)

The substitution model is dead. Long live the environment model.

Assignment allows us to create separate objects.

(define make-counter
  (lambda (n)
    (lambda ()
      (set! n (1+ n))
      n)))
(define c1 (make-counter 0))
(define c2(make-counter 10))
(c1)

1

(c2)

11

(c1)

2

(c2)

12

By introducing assignment and objects, we have opened ourselves up to all of the horrible questions of philosophy that have been plaguing philosophers for some thousands of years.

Don't use assignment when it can be avoided - it's the wrong way to think.

$$\text{Prob}(\text{gcd}(n1,n2)=1)=\frac{6}{\pi^{2}}$$

The proof can be found here.

(define (estimate-pi n)
  (sqrt (/ 6 (monte-carlo n cesaro))))
(define (cesaro)
  (= (gcd (rand) (rand)) 1 ))
(define (monte-carlo trials experiment)
  (define (iter remaining passed)
    (cond ((= remaining 0)
           (/ passed trials))
          ((experiment)
           (iter (-1+ remaining)
                 (1+ passed)))
          (else
           (iter (-1+ remaining)
                 passed))))
  (iter trials 0))
(define rand
  (let ((x random-init))
    (lambda ()
      (set! x (rand-update x))
      x)))

rand-update is a screwy function, details of which can be found in Knuth's books.

If assignment isn't available, the procedure is a lot worse: it's monolithic.

(define (estimate-pi n)
  (sqrt (/ 6 (random-gcd-test n))))
(define (random-gcd-test trials)
  (define (iter remaining passed x)
    (let ((x1 (rand-update x)))
      (let ((x2 (rand-update x1)))
        (cond ((= remaining 0)
               (/ passed trials))
              ((= (gcd x1 x2) 1)
               (iter (-1+ remaining)
                     (1+ passed)
                     x2))
              (else
               (iter (-1+ remaining)
                     passed
                     x2))))))
  (iter trials 0 random-seed))

The state of the random number generator is no longer confined to the inside of the random number generator - it has leaked out. Leaked out into cesaro, and then into monte-carlo, meaning none of the functions ca be written generally. The assignment version is evidently vastly superior.

Plus ça change, plus c'est la même chose.

Things are seldom what they seem
Skim milk masquerades as cream…