procedures
Download
Skip this Video
Download Presentation
Procedures

Loading in 2 Seconds...

play fullscreen
1 / 17

Procedures - PowerPoint PPT Presentation


  • 152 Views
  • Uploaded on

Procedures. Primitive procedures +, -, *, etc User-defined procedures Naming a sequence of operations triple = proc (x) + (x, + (x,x)) Recursive definitions exp = proc (x, i) if (i = 0) then 1 else * (x, exp (x,i-1)). User-defined procedures. Concrete Syntax

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Procedures' - brandice


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide2
Primitive procedures
      • +, -, *, etc
  • User-defined procedures
    • Naming a sequence of operations
      • triple = proc (x) +(x,+(x,x))
    • Recursive definitions
      • exp = proc (x, i)

if (i = 0) then 1

else*(x,exp(x,i-1))

L8Proc

user defined procedures
User-defined procedures

Concrete Syntax

<expression> ::= … | ( <expression> +)

| proc <idlist> <expression>

<idlist> ::= ()

| ( <identifier> {, <identifier>}*)

Abstract Syntax

proc-exp (ids body)

app-exp (rator rands)

Examples

proc (y,z) *(y,5)

(f x 5)

L8Proc

scoping free non local variables
proc main();

int x := 5;

proc q();

{ x := x + 1;}

proc r();

{int x := 0;

q();

}

{ r();

print(x); }.

Static scoping

x -> x

output: 6

Dynamic scoping

x-> x

output: 5

Scoping : Free (non-local) Variables

L8Proc

slide5
letx = 15

in let f = proc () x

in

( letx = 8

in (f)

) + (f)

Static Scoping x -> x30

Dynamic Scoping x -> x23

x -> x

L8Proc

informal semantics of procedures
Informal Semantics of Procedures
  • 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
      • Use env. at proc. creation (static scoping)
      • Use env. at proc. call (dynamic scoping)

L8Proc

encoding procedures
Encoding Procedures
  • Static scoping

(define-datatype procval procval?

(closure

(ids (list-of symbol?)

(body expression?)

(env environment?)))

Closure retains the bindings of the free variables at procedure creation time.

  • Dynamic scoping

(define-datatype procval procval?

(procv

(ids (list-of symbol?)

(body expression?)))

L8Proc

processing procedure definitions
Processing Procedure Definitions
  • Static scoping

(define (eval-expression exp env)

(cases expression exp

( proc-exp (ids body)

(closure idsbodyenv)) ))

  • Dynamic scoping

(define (eval-expression exp env)

(cases expression exp

( proc-exp (ids body)

(procv idsbody)) ))

L8Proc

processing procedure invocations
Processing Procedure Invocations
  • Static scoping

(define (eval-expression exp env)

(cases expression exp

. . .

(app-exp (rator rands)

(let ((proc (eval-expression ratorenv))

(args (eval-rands randsenv)))

(if (procval? proc)

(apply-procval proc args)

(eopl:error \'eval-expression

“Applying non-procedure ~s" proc)

)

))

L8Proc

processing procedure invocations10
Processing Procedure Invocations
  • Dynamic scoping

(define (eval-expression exp env)

(cases expression exp

(app-exp (rator rands)

. . .

(let ((proc (eval-expression ratorenv))

(args (eval-rands randsenv)))

(if (procval? proc)

(apply-procval proc args env)

(eopl:error \'eval-expression

"Applying non-procedure ~s" proc)

)

))

L8Proc

processing procedure invocations11
Processing Procedure Invocations
  • Static scoping

(define (apply-procval proc args)

(cases procval proc

( closure (ids body s-env)

(eval-expression body

(extend-env ids argss-env)) )))

  • Dynamic scoping

(define (apply-procval proc args c-env)

(cases procval proc

( procv (ids body)

(eval-expression body

(extend-env idsargsc-env)) )))

L8Proc

processing procedure invocations12
Processing Procedure Invocations
  • Static scoping

>(run "let x = 1 in

let f = proc () x in (f)")

1

>(run "let x = 1 in

let f = proc (x) x in (f 2)")

2

>(run "let x = 1 in

let f = proc () x x = 5 in (f)")

1

  • Dynamic scoping

>(run "let x = 1 in

let f = proc () x x = 5 in (f)")

5

L8Proc

alternative description static scoping
Alternative Description: Static Scoping

(define (closure ids body env)

(lambda (args)

(eval-expression body

(extend-env ids argsenv))

)

)

(define (apply-procval procargs)

(procargs)

)

L8Proc

implementing dynamic scoping
Implementing Dynamic Scoping
  • The value of variable x is the last value bound to x. => stack discipline
    • Deep binding
      • Use a global stack for all variables
    • Shallow binding
      • Use a separate stack for each variable
  • Implementing recursion is trivial.
      • First LISP evaluator used dynamic scoping by accident!!
  • Meaning of a call depends on the context.

L8Proc

pros and cons of scoping rules
Pros and cons of scoping rules
  • It is easy to implement recursion in a dynamically scoped language. Historically, LISP uses dynamic scoping.
  • In dynamic scoping, the interpretation of a free variable in a function body can change based on the context (environment) of a call. Renaming a formal parameter in the caller can effect the semantics of a program, if renamed parameter now captures a free variable in the called function. (Locality of formals destroyed.)

L8Proc

application of dynamic scoping
Application of Dynamic Scoping
  • Exception Handling
    • provide a separate construct in statically scoped language
  • Setting Local Formatting Parameters
  • Input-Output Redirection
    • avoids passing parameters explicitly through “intermediate” procedures

L8Proc

difference between scheme and ml
> (define x 1)

> (define (f) x)

> (f)

1

> (define x 2)

> (f)

2

> (define (g) x)

> x

2

> (g)

2

- val x = 1;

- fun f () = x;

val f = fn : unit -> int

- f ();

val it = 1 : int

- val x = 2;

- f () ;

val it = 1 : int

- fun g () = x;

val g = fn : unit -> int

- g ();

val it = 2: int

Difference between Scheme and ML

L8Proc

ad