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

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)

CS784(pm)

Scoping and Binding

• references– (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 rulesCS784(pm) 4

Kinds of Scope

• Static or Lexical 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) 5

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 = 200in 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)

Example Calc w/ Spec 1

CS784(pm) 10

Example Calc w/ Spec 2

CS784(pm) 11

Example Calc w/ Spec 3

CS784(pm) 12

Example Calc w/ Spec 4

CS784(pm) 13

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) 14

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-procedureCS784(pm) 15

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) 16

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) 17

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

CS784(pm) 18

the data type expval is now …

(define-datatype expval expval?

(num-val

(num number?))

(bool-val

(bool boolean?))

(proc-val

(proc proc?)))

CS784(pm) 19

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) 20

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)

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) 22

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 loopCS784(pm) 23

24

Lexical Analysis

(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)

SLLGEN Scanner Spec

Scanner-spec ::=({Regexp-and-action}∗)

Regexp-and-action ::= (Name ({Regexp}∗) Action)

Name ::= SymbolRegexp::= 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) 25

26

The SLLGEN Parsing System(define the-grammar '((program (expression) a-program)

(expression (number) const-exp) (expression ("-" "(" expression "," expression ")") diff-exp) (expression ("zero?" "(" expression ")") zero?-exp)

(expression ("if" expression "then" expression "else" expression) if-exp)

(expression (identifier) var-exp)

(expression ("let" identifier "=" expression "in" expression) let-exp)

(expression ("proc" "(" identifier ")" expression) proc-exp)

(expression ("(" 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 ::= SymbolRitem ::= 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)

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)))))))

• http://www.cs.wright.edu/~pmateti/Courses/784/Top/784-HW2.html

• 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) 28