1. EOPL3: Section 3.3 PROC and App B: SLLGEN
Procedures
EOPL3: Section 3.3 PROC and App B: SLLGEN

2. The PROC language Expression ::= proc (Identifier) Expression
AST: proc-exp (var body)
Expression ::= (Expression Expression)
AST: call-exp (rator rand)
PROC includes all of LET language
Anonymous procedure
One parameter always
one arg only
CS784(pm)

3. Semantics of Procedures
(This slide is for procedures in general.)
Procedure Definition
Store formal parameters and body
Procedure Invocation
Evaluate body in an environment that binds formals to actual argument values
Interpretation of free-variables: Two methods
Use env at proc definition (lexical/static scoping)
Use env at proc call (dynamic scoping)
Overloading : Static binding – Dynamic binding :: association of code to function call
(cf. deep and shallow binding in the realm of dynamic scoping)
(cf. static typing vs dynamic typing)
CS784(pm)

4. Scoping and Binding references declarations lexical scoping rules
(f x y)
f, x, and y
declarations
(lambda (x) (+ x 3))
(let ((x (+ y 7))) (+ x 3))
y, and second/right x are refs
first/left x is a declaration
lexical scoping rules
CS784(pm)

5. Kinds of Scope Static or Lexical scope Dynamic scope Global Scope
determined by structure of program
Scheme, C++, Java, and many compiled languages
Dynamic scope
determined by path of execution
Lisp dialects, Perl, and many interpreted languages
Global Scope
File scope
Local Scope
Block
Body of a procedure
Body of a loop
Scope alters the meaning
CS784(pm)

6. Example-1 of PROC let f = proc (x) --(x,11) in (f (f 77))
Defines an anonymous procedure with one formal parameter named x.
Body of the procedure: --(x,11)
Binds the name f to this procedure.
Invokes f with actual argument 77.
Invokes f again with the result of above.
(will use two -- just for visibility)
CS784(pm)

7. Example-2 of PROC (proc (f) (f (f 77)) proc (x) --(x,11))
This example is derived from the production
Expression ::= (Expression Expression)
so is (f (f 77))
so is (f 77)
proc (f) (f (f 77)) is the rator.
It defines an anonymous procedure with one formal parameter named f.
proc (x) --(x,11)) is the rand.
It also defines an anonymous procedure with one formal parameter named x.
CS784(pm)

8. Example-3 of PROC
let x = 200 in let f = proc (z) --(z, x) in let x = 100 in let g = proc (z) --(z, x) in --((f 1), (g 1))
Illustrates scope issues
x and z appear four times each.
Lexical scoping
In --((f 1), (g 1)), the bodies of f and g must be evaluated in the env they were defined.
In f, x is bound to 200
In g, x is bound to 100
CS784(pm)

9. Example Programs of PROC
Example-1 and -2 produce same result, but different mechanisms.
Previous two slides gave semantics informally
Watch out: a very seductive approach
Next few slides: interpreter based
CS784(pm)

10. Example Calc w/ Spec 1
CS784(pm)

11. Example Calc w/ Spec 2
CS784(pm)

12. Example Calc w/ Spec 3
CS784(pm)

13. Example Calc w/ Spec 4
CS784(pm)

14. Recall value-of value-of is an operator with two operands
an AST
an environment
(value-of ast env)
PROC = LET + two more productions
Bring in all value-of specs from LET
Additions are shown on next few slides …
CS784(pm)

15. additional value-of specs
(value-of (proc-exp var body) ρ)
= (proc-val (procedure var body ρ))
(value-of (call-exp rator rand) ρ)
= (let ( (proc (expval->proc (value-of rator ρ)))
(arg (value-of rand ρ)))
(apply-procedure proc arg))
To be defined: proc-val, apply-procedure
CS784(pm)

16. Spec of apply-procedure
(apply-procedure (procedure var body ρ) val) = (value-of body [var=val]ρ )
apply-procedure takes two arguments:
an AST of a procedure definition
an argument for the parameter of the procedure
yields an expressed value
CS784(pm)

17. Impl of apply-procedure
(define proc?
(lambda (pc)
(procedure? pc)))
(define procedure
(lambda (var body env)
(lambda (val)
(value-of body
(extend-env var val env)))))
(define apply-procedure
(lambda (pc val) (pc val)))
procedure?  provided from r5rs
Names being bound:
proc?
procedure
apply-procedure
env is an environment
ASTs: body, pc, val, var
Use of procedure? is too liberal.
procedure is not self-contained; takes three arguments:
param name var
body AST
environment
CS784(pm)

18. Alternate impl called Closures
(define-datatype proc proc? (procedure (var identifier?) (body expression?) (saved-env environment?))) (define apply-procedure (lambda (pc val) (cases proc pc (procedure (var body saved-env) (value-of body (extend-env var val saved-env))))))
Defining a new data type called “proc”
Has only one variant
procedure
That has three parts
var
which must be an id
body
an expression
saved-env
an environment
apply-procedure takes pc and val.
“cases proc pc”
pc is expected to be of type proc
code for each variant of proc
only one variant “procedure” here
These data structures are often called closures, because they are self-
contained: they contain everything the procedure needs in order to be
applied. We sometimes say the procedure is closed over or closed in its creation
environment.
CS784(pm)

19. the data type expval is now …
(define-datatype expval expval? (num-val (num number?)) (bool-val (bool boolean?)) (proc-val (proc proc?)))
CS784(pm)

20. value-of: two new clauses
(proc-exp (var body) (proc-val (procedure var body env))) (call-exp (rator rand) (let ( (proc (expval->proc (value-of rator env))) (arg (value-of rand env))) (apply-procedure proc arg)))
CS784(pm)

21. Curried procedures
In PROC, procedures with multiple arguments can be had as in:
let f = proc (x) proc (y) ... in ((f 3) 4)
proc (x) … yields a procedure
Named after Haskell Brooks Curry (1900 – 1982), a combinatory logician.
CS784(pm)

22. chapter3/proc-lang/ Two subdirectories
chapter3/proc-lang/proc-rep: procedural implementation
chapter3/proc-lang/ds-rep: data type based (i.e., closure)
Both directories have the following files
data-structures.scm
drscheme-init.scm
environments.scm
interp.scm
lang.scm
tests.scm
top.scm
CS784(pm)

23. EOPL3 Appendix B SLLGEN
(define scanner-spec-1 ...) (define grammar-1 ...) (sllgen:make-define-datatypes scanner-spec-1 grammar-1) (define list-the-datatypes (lambda () (sllgen:list-define-datatypes scanner-spec-1 grammar-1))) (define just-scan (sllgen:make-string-scanner scanner-spec-1 grammar-1)) (define scan&parse (sllgen:make-string-parser scanner-spec-1 grammar-1)) (define read-eval-print (sllgen:make-rep-loop "--> " value-of--program (sllgen:make-stream-parser scanner-spec-1 grammar-1)))
sllgen:make-define-datatypes: generates a define-datatype for each production of the grammar, for use by cases.
sllgen:make-string-scanner takes a scanner spec and a grammar and generates a scanning procedure
read-eval-print loop
CS784(pm)

24. Lexical Analysis the-lexical-spec from chapter3/ proc-lang/*/lang.scm
(define the-lexical-spec '((whitespace (whitespace) skip) (comment ("%" (arbno (not #\newline))) skip) (identifier (letter (arbno (or letter digit "_" "-" "?"))) symbol) (number (digit (arbno digit)) number) (number ("-" digit (arbno digit)) number) ))
the-lexical-spec
from chapter3/ proc-lang/*/lang.scm
scanners are specified by reg exp – next slide
All our languages use this lexical analysis.
CS784(pm)

25. SLLGEN Scanner Spec
Scanner-spec ::= ({Regexp-and-action}∗) Regexp-and-action ::= (Name ({Regexp}∗) Action) Name ::= Symbol Regexp ::= String | letter | digit| whitespace|any ::= (not Character) | (or {Regexp}∗) ::= (arbno Regexp) | (concat {Regexp}∗) Action ::= skip | symbol | number | string
A scanner specification in SLLGEN is a list that satisfies the grammar at left
CS784(pm)

26. The SLLGEN Parsing System
(define the-grammar '((program (expression) a-program) (expression (number) const-exp) (expression ("-" "(" expression "," expression ")") diff-exp) ("zero?" "(" expression ")") zero?-exp) ("if" expression "then" expression "else" expression) if-exp) (expression (identifier) var-exp) ("let" identifier "=" expression "in" expression) let-exp) ("proc" "(" identifier ")" expression) proc-exp) ("(" expression expression ")") call-exp) ))
the-grammar of PROC
from chapter3/ proc-lang/*/lang.scm
Double-quoted items are terminals/tokens.
CS784(pm)

27. Specifying Grammars
Grammar ::= ({Production}∗) Production ::= (Lhs ({Ritem}∗) Prod-name) Lhs ::= Symbol Ritem ::= Symbol | String ::= (arbno {Ritem}∗) ::= (separated-list {Ritem}∗ String) Prod-name ::= Symbol
A grammar in SLLGEN is a list described by the grammar at left
CS784(pm)

28. HW2 Problem
(define closure (lambda (ids body env) (let ((freevars (set-diff (free-vars body) ids))) (let ((saved-env (extend-env freevars (map (lambda (v) (apply-env env v)) freevars) (empty-env)))) (lambda (args) (eval-expression body (extend-env ids args saved-env)))))))
In our data-structure representation of procedures, we have kept the entire environment in the closure. But of course all we need are the bindings for the free variables.
Modify the representation of procedures to retain only the free variables.
flat closure rep shown left
consists of exactly one rib of free variables and their values.
free-vars: ykwim ;-)
set-diff:  difference of two sets
map  provided from r5rs
CS784(pm)