1 / 28

Procedures

Procedures. EOPL3: Section 3.3 PROC and App B: SLLGEN. 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

orien
Download Presentation

Procedures

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 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

  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)

  4. 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 rules

  5. 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

  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)

  7. Example-2 of PROC • (proc (f) (f (f 77))proc (x) --(x,11)) • This example is derived from the production • Expression ::= (ExpressionExpression) • so is (f(f 77)) • so is (f77) • 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.

  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

  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

  10. Example Calc w/ Spec 1

  11. Example Calc w/ Spec 2

  12. Example Calc w/ Spec 3

  13. Example Calc w/ Spec 4

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

  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

  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

  17. Impl of apply-procedure (define proc? (lambda (pc) (procedure? pc))) (define procedure (lambda (var body env) (lambda (val) (value-of body (extend-envvarvalenv))))) (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

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

  19. the data type expval is now … (define-datatypeexpvalexpval? (num-val (num number?)) (bool-val (boolboolean?)) (proc-val (proc proc?)))

  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 ratorenv))) (arg (value-of rand env))) (apply-procedure proc arg)))

  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.

  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

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

  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.

  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}∗) ::= (arbnoRegexp) | (concat {Regexp}∗) Action ::= skip | symbol | number | string A scanner specification in SLLGEN is a list that satisfies the grammar at left

  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.

  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

  28. HW2 Problem (define closure(lambda (ids body env) (let ((freevars (set-diff (free-vars body) ids))) (let ((saved-env (extend-envfreevars (map (lambda (v) (apply-envenvv))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

More Related