Lecture 2026-02-03

(( fun

Recall:

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

Assignment coming up that relies on tutorials.

(define b1 (make-box 7)
(set b1 4 )
=> (define val_1 7)
...
((b1 'set) 4)
=> (define val1 7)
...
((lambda ( new v ) (set! val1 newv)) 4 )

Questions of the day:

1. How is this related to our original address book problem.

2. Why does it fix it?

How are we going to achieve it?

Stepping

set, as a mutation returns (void)

(define val_1 7)
...
(set! val_1 4)
=> (define val_1 4 )
...
(void)

How does this fix the problem?

before:

(define home '())
(add home __ __)
=> (add '() __ __ )  ;; value of home is substiuted 
=> (set '() __ __ ) ;; we can't update home 

now:

(define home (make-box'()))
       (define (add abook name phone)
              (set abook (cons (list name phone))
                          (get abook))))

abook is not a list, it's a box, which is a function that can access the data for me, thus, we need to use get.

(add home __ __ ) ;; function taht can update the created variable

Boxes are built into racket

Syntax: Expr = ....

| (box expr)

| (unbox epr)

| (set-box! expr expr ) ;; note the first expression doesn't have to be an id !

e.g.

(define home (box '( ("Neighbour") 34567 ))))
(define work (box '(( "Manager" 1245 ) ( "Director" 23456))))

(set-box! home 

Semantics:

Convention: When we write an underscore before a variable name, it means the var's value is not looke dup during expression evaluation, unless (unbox __ ) is called on it.

(box v ) ... ( r a value ) 
=> (define _u v ) ( u a fresh name)
                  (then (box v) becomes _u)
(unbox _n) ;; finds (define _n v )
=> v

(set-box! _n v) ;; finds (define _n ___) replace with (define _n v)
=> (void )

e.g. Stepping row

(define box1 (box 4)) ;; to be evaluated next
(unbox box1)
(set-box! box1 true)
(unbox box1)

(define  _u1 4)
(define box1 _u1)
(unbox box1) ;; to be evaluated next
(set-box! box1 true)
(unbox box1)

(define _u1 4 )
(define box1 _u1)
(unbox _u1) ;; to be evaluated next.
(set-box! box1 true)
(unbox box1)

(define u1 4)
(define box1 u1)
4
(set-box! box1 true) ;; to be evaluated next
(unbox box1)

...
(set-box! u1 true)
(unbox box1)

(define u1 true)
(define box1 u1)
4
(void)
(unbox box1)

(define u1 true)
(define box1 u1)
4
(void)
(unbox u1)

(define u1 true)
(define box1 u1)
4 
(void)
true

In essence, a little bit messy, but substitution model had to be adapted.

The same problem in C

• Suppose we want to write a function:

void inc (int x) {
    x = x+1;
}
int main(void){
int x =1;
inc(x);
printf("%d\n", x);
}
// We want/expected to get: 2
// But we got: 1

Notice how this is the same problem in Racket.

• Racket solution: put the variables in a box.

• What is a C equivalent?

  • One-field structure

• Structure in C:

  • struct Posn { int x; int y;};

i.e.

struct posn{
int x;
int y;
} p1,p2,p3;

Often times where you define the type of the variable, verses defining where the variable are in different locations. So it is not used often, but is a common source of error and bugs !

e.g.

int main(void){
struct Posn P;
p.x = 3;
p.y = 4;
printf("p= (%d, %d)\n", p.x, p.y);
}

Alternate e.g.

LEGAL

int main(){
struct Posn p = {3,4};
...
}

NOT LEGAL

int main(void){
    struct Posn p;
    p = {3,4};
    ....
}

• Can these structs replace and emulate the functionality of boxes?

Code returns "p = (3,4)" Thus Doesn't swap in C, but it would have swapped in Racket.

void swap (struct Posn p){
int temp = p.x;
p.x = p.y;
p.y = temp;
}
int main(void){
struct Posn p = {3,4};
swap(p);
printf("p=(%d,%d)\n", p.x, p.y);
}

The problem:

• C ( and also racket ) passes arguments via a mechanism called "pass-by-value".

  • The function operates on a COPY of the value, not the value itself.

Note that the Racket substitution model naturally implements pass-by-value

(define x 3)
(f x) => (f 3)  ;; the value of  , not x itself.

Consider

void inc(int x){
++x;
}

x here really gets mutated, but its a copy of x, not the original from the called, original remains the same.

Similarily:

` void swap (struct Postn p) {//entire structure is copiped into the function
                             //original does not change.    

So there is something special about boxes.

• not equal to the value they hold

• but they know how to find the value

  • unbox = find the value.

Finding the value - where is it located?

• In memory ( RAM)

• every value in memory has an address

• given the address, can "find" the value.

So addresses could function as boxes

• instead of passing a value to a function, pass an address:

int main(){
   int x =1;
   inc(&x); 
   printf("%d\n", x);
}

& is called the address operator.

• Passes x's address, not it's value..

Thus recall:

void inc (int x ){
x = x+1;   
}

Thus, assuming we pass in the address, the above is still wrong, we didn't get an int; we got an address !

• Maybe: void inc(address x) {...} (wrong)

  • Need more info - what type of data is stored at that address?

void inc (int *x){ // x is a pointer to an int ( essentially though it's the address of the int )
x= x+1; 
}
x=x+1; //also wrong because we don't want to add to the address, we want to add1 
// to the value stored at the address !

thus we write:

void inc(int & x){
*x = *x+1;
}

* is called the deference operator = fetch the value stored at that address.

LHS of assign ** behaves differently from RHS!

e.g.

** = expr;
//stores the value of expression at address x.

Alternatives:

void inc(int *x ){
*x+=1;
}

OR

void inc ( int *x){
++*x;
}

OR?

void inc (int *x){
*x++; //Wrong Why?
}

*x++ - which happens first

• the * or the ++ ?

  • The answer is the ++