This document summarizes the changes made to support different parameter passing conventions in a programming language called AF. AF now supports call-by-value, call-by-reference, and call-by-need. The type of calling is specified in procedure declarations using annotations. The semantics and interpreter were updated to handle evaluating procedure arguments based on the calling convention. New test cases were added to validate the changes and ensure the different conventions work as expected.

1. Assignment #7
CSCE 550
“Parameter passing convention”
Georgiana Tache
gxt6286

2. Statement of the problem
● A new language AF (Annot-Formal) which extends Mutable
Pairs (chapter 4)
● AF supports:
– Call-by-value
– Call-by-reference
– Call-by-need
● The type of calling is established at the point of procedure
declaration
● New test cases are added to support the differences between the
types of calling

3. Convention
● The type of calling is distinguished using the following
annotations in front of the procedure argument:
– value
– ref
– lenes - for lazy evaluation
● There is no implicit annotation
● All proc declarations are required to specify the convention
let p = proc (value x) x
in (p 10)

4. Changes in the lexical spec &
grammar
● Lexical spec supports 3 annotations:
(annot ("lenes") symbol)
(annot ("value") symbol)
(annot ("ref") symbol)
● The grammar for proc is changed to require the type of
parameter passing in the procedure declaration
(expression
("proc" "(" annot identifier ")" expression)
proc-exp)

5. Abstract Data Types
● ExpVal = Num + Bool + Proc + Reference + Mutpair + Thunk
● Thunk = (Expression, Environment)
● Thunk is used to store the information for evaluating an
expression within an environment. Its evaluation is delayed until
the last moment.

6. Semantics of the changed expressions
● I keep in the store a global variable mode, which will
save the annotation
● I update its value once the procedure is declared
● I use mode in call-exp, var-exp and apply-procedure
interp.scm
(define mode "")
(define value-of-program
(lambda (pgm)
(initialize-store!)
(set! mode (newref 'unspecified))
(…... ))))))
interp.scm
(proc-exp (annot var body)
(begin
(setref! mode annot)
(proc-val (procedure var body env))
))

7. Semantics of the changed expressions
interp.scm
(call-exp (rator rand)
(let ((proc (expval->proc (value-of rator env)))
(arg (if (equal? (deref mode) 'value)
(value-of rand env)
(value-of-operand rand env))))
(apply-procedure proc arg)))
In call-exp, the argument of
the function is evaluated with
value-of only if we have call
by value.
In case of call by reference
and call by need, the expression is evaluated with value-of-
operand:
If the operand is a variable then
get its value from the environment.
If it's an expression not bound to a
variable, evaluate it only if we don't
have call by need, and also create
a new reference for it.
(define value-of-operand
(lambda (exp env)
(cases expression exp
(var-exp (var) (apply-env env var))
(else
(newref (if (equal? (deref mode) 'lenes)
(a-thunk exp env)
(value-of exp env)))))))

8. Semantics of the changed expressions
● A change in apply-procedure
● If call by value – create a new reference, otherwise
use the same reference (which is either bound before
in value-of-operand or bound at the creation of the
variable)
(define apply-procedure
(lambda (proc1 arg)
(cases proc proc1
(procedure (var body saved-env)
(let ((r (if (equal? (deref mode) 'value) (newref arg) arg)))
(let ((new-env (extend-env var r saved-env)))
(value-of body new-env)))))))

9. Semantics of the changed expressions
Call by need implementation
● A lazy reference evaluation
(define value-of-operand
(lambda (exp env)
(cases expression exp
(var-exp (var) (apply-env env var))
(else
(newref (if (equal? (deref mode) 'lenes)
(a-thunk exp env)
(value-of exp env)))))))
(define-datatype thunk thunk?
(a-thunk
(exp1 expression?)
(env environment?)))
A thunk has an (unevaluated)
expression and an environment
attached.

10. Semantics of the changed expressions
Call by need implementation
● Modification in var-exp:
interp.scm
(var-exp (var)
(if (not (equal? (deref mode) 'lenes))
(deref (apply-env env var))
; else, lazy evaluation:
(let ((ref1 (apply-env env var)))
(let ((w (deref ref1)))
(if (expval? w) w
(let ((v1 (value-of-thunk w)))
(begin
(setref! ref1 v1)
v1)))))))
If non-lazy evaluation or lazy evaluation of
an expval → get the value of the variable
from the environment
If lazy evaluation of a thunk → evaluate it
using value-of-thunk
data-structures.scm
(define value-of-thunk
(lambda (th)
(cases thunk th
(a-thunk (exp1 saved-env)
(value-of exp1 saved-env)))))
The procedure's argument stays as a thunk until it's
needed in the body and will be evaluated as a var-exp.

11. Examples of test cases
test1.scm
"newpair (let p = proc(value x)
set x = 4
in let a = 3
in begin
(p a);
a
end, 3)"
test2.scm
"newpair (let p = proc(ref x)
set x = 4
in let a = 3
in begin
(p a);
a
end, 4)"
test4.scm
"newpair (let swap = proc (ref x)
proc (value y)
let temp = x
in begin
set x = y;
set y = temp
end
in let a = 33
in let b = 44
in begin
((swap a) b);
-(a,b)
end , 0)"
Each test file has a tuple:
“newpair (AF-lang-code, expected value)”

12. Examples of test cases
test6.scm
"newpair (let p = proc(value f) proc(value x)
-(((f f) -(x,1)), -(0,x))
in let newp = proc(lenes n) 25
in (newp ((p p) 5))
, 25)"
Using value or ref instead of lenes → the
program doesn't terminate
> (run-all)
Runs all previous test cases from
tests.scm, where I have modified
the syntax of proc
> (run-all-files)
Runs all additional tests defined in
new files, folder tests
> (run-everything)
Runs both of the above
In top.scm – 2 new functions:
run-file: reading and interpreting one test file
run-all-files: comparing the expected output with
the actual output, for all test files

13. Questions?