Lecture 2026-01-29

Accumulators

int f (int c, int acc){
if(cont(c)){
body(c);
return f(update1(c), update2(acc,c));
}
return g(acc)
}
f(c,acc,0)

This implies,

int acc = acc0;
while (cont(c)){
body(c);
acc= update2(acc,c);
c=update1(c);
}
acc= g(acc);

For example:

int getIntHelper(int acc){
char c = getchar();
if(isdigit(c)){
return getIntHelper(10*acc + c - '0');
}
return acc;
}
int getInt(){
return getIntHelper(0);
}
=>
int acc=0;
char c = getchar();
while(isdigit(c)){
acc = 10* acc + c -'0';
c=getchar();
}

Common emerges ( initalize variables )

e.g.

while (condition){
(body)
(update varaibles)
}

Alternate Format

for (init; condition; update){
body
}

or e.g.

int acc = 0;
char c;
for(c=getchar(); isdigit(c); c= getchar(){
acc= 10 * acc+c-'0';
}

or even,

int acc=0;
for ( char c =  getchar(); isdigit(c); c=getchar()){
acc = 10* acc + c -'0';
}

Or even,

int acc = 0;
for(char c = getchar(); isdigit(c); acc = 10* acc + c -'0', c = getchar());

You don't have to have a block inside for a for loop

Peekchar version:

int acc=0;
for(char c = peekchar();isdigit(c); acc = 10 * acc + getchar()-'0';, c= peekchar()); 

or

for ( char c = peekchar(); isdigit(c); c= (getchar(), peekchar())){
    acc = 10* acc + c '0';
}

Updating Counters

c = c+1;
c = c-2;
c = 10* c;
c = c/2;
c = c+d; 

Very common patterns one might do in a loop.

Specialized Syntax

c += 1;
c -= 2;
c *= 10;
c /= 2;
c += d;

equivalent to previous

Incrementing decreasing by 1.

++c; //increment c
--i; //decrement i

These are expressions - have a value as well as an effect

++c increments c c + produces the value of c

--i decrements i + produces the value of i.

But an unintuitive leading question would be: Which Value?

• Which value of c , or i?

• The old value or the new one?

To find out:

int c = 1;
printf("%d\n", ++c);
2 - the new value

There are also postfix versions: c++, i--

• Give value before effect.

• Increment/decrement i, but produces the old value of i.

  • But this implies that the old vale must be remembered or recomputed?

    • This is some weird behaviour !

If you use increment/decrement, perfer the prefix version.

More on Global Data:

• global variables:

int i=0; //Avoid where possible - creates hidden dependencies.

Global Constants are still useful !

• Can force a variable to remain contant in C.

e.g.

const int passingGrade = 50; //cannot be mutated!

Intermediate Mutation ( Racket )

• What if we want to work with multiple address books?

#lang racket
(define work '(("Managers" 12345) ("Director" 234567)))
(define home '())

(define (add-entry abook name number)
  (set! abook (cons '(name number) abook)))
(add-entry home "poop" 32332)
home

• No Change is Made to Home.

  • Code doesn't work,

  • Not Clear how to make it work.

    • Why?

Substitution Model

(add-entry home "Neighbour 34567)
~> (add-entry '()) "Neighbour" 34567)
-> (set! '() (cons (list 'Neighbour" 34567) '()))

Do you see how this doesn't work? The home address-book is lost !

To make this work...

• Recall from CS145 (??)

  • simulation of structs using lambda

• Do the same thing to create a structure with one field - called a box.

  • Two operations

    • get the value in the box.

    • set the value to a new value.

e.g.

(define (make-box v)
   (lambda (msg)
   (cond
   [(equal? msg 'get) v]))

(define (get b) (b 'get))
(define b1 (make-box 7)) (get b 1)
=> (define b1 (lambda (msg) (cond [(equal? msg 'get) 7]))) (get b1)
=> (get (lambda (msg) (cond [(equals? msg 'get) 7])))
=> ((lambda (msg) (cond [(equal? msg 'get) 7])) 'get)
=> (cond [(equals? 'get 'get) 7])
=>  7

• The box is not v itself, its an agent that can, on demand, produce v or 7.

To support set

• We must introduce a local copy of v ( why? )

(define (make-box v)
(local [(define val v)]
(lambda (msg)
(cond
[(equals? msg 'get) val]))))
(define (get b) (b 'get))
(define b1 (make-box 7))
(get b1)
=> (define b1 (local
          [(define val 7)]
  (lambda (msg)
   (cond
   [(equals? msg 'get)val] 
)))) (get b1)
=> (define val_1 7)
   (define b1 (lambda(msg)
   (cond
   [(equals? msg 'get) val_1]
)))
(get b1)
=> ...
=> 7

Adding set requires an extra parameter

• Achieve by having the box return a function

(define (make-box v)
(local [(define val v)]
(lambda (msg)
(cond
[(equals? msg 'get) val]
[(equals? msg 'set) 
 (lambda (newv) (set! val newv))
]))))
(define (get b) (b 'get))
(define (set b v) ((b 'set) v))

The box is not a value, its the in between agent that gets the value.

• Next steps, using stepping rules to ensure the value actually sets the value.

(define b1 (make-box 7))
(set b1 4)
=> (define b1 (local
[(define val 7)]
(lambda (msg)...)))
(set b1 4)
=> (define val_1 7)
   (define b1 (lambda (msg)
             (cond [(equal? msg 'get) val_1]
                   [(equal? msg 'set)
                     (lambda (newv) (set! val_1 newv))])))
(set b1 4)