Closures and streams
This presentation is the property of its rightful owner.
Sponsored Links
1 / 28

Closures and Streams PowerPoint PPT Presentation


  • 106 Views
  • Uploaded on
  • Presentation posted in: General

Closures and Streams. Contemporary Interest in Closures. The concept of closures was developed in the 1960s and was first fully implemented in 1975 as a language feature in the Scheme programming language to support lexically scoped first-class functions.

Download Presentation

Closures and Streams

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


Closures and streams

Closures and Streams

L11Clos


Contemporary interest in closures

Contemporary Interest in Closures

  • The concept of closures was developed in the 1960s and was first fully implemented in 1975 as a language feature in the Scheme programming language to support lexically scoped first-class functions.

  • Project Lambda makes it easier to write code for multi-core processors by adding closures to the Java language and extending the Java API to support parallelizable operations upon streamed data.

  • Rick Hickey’s Clojure (a dialect of LISP for Java platform) is a pure functional language with support for rich set of data structures, and constructs for concurrent programming.

L11Clos


Models of evaluation

Models of Evaluation

Substitution-based

(define (square x) (* x x))

((lambda (xy)

(+ (square x) (square y)))

(- 5 3)5)

  • (+ (square 2) (square 5))

  • (+ (* 2 2) (* 5 5))

  • (+ 4 25)

  • 29

L11Clos


Expression evaluation options

Expression Evaluation Options

To evaluate: (operator operand1 operand2 operand3 ...)

  • Applicative-Order Evaluation (call by value)

    • evaluate each of the sub-expressions.

    • apply the leftmost result to the rest.

  • Normal-Order Evaluation (call by name)

    • apply the leftmost (lambda) sub-expression to the rest and expand. (Argument sub-expressions get evaluated when necessary.)

L11Clos


Models of evaluation1

Models of Evaluation

Environment-based

((lambda (xy)

(+ (square x) (square y)))

(- 5 3)5)

  • (+ (square x)(square y)) x=2,y=5

  • (+ (* x x)x=2,y=5

    (* x x) ) x=5,y=5

  • (+ 4 25)

  • 29

L11Clos


An extended example

An extended example

(define square (lambda (x) (* x x)))

(define sum-of-squares

(lambda (x y)

(+ (square x) (square y))))

(define f (lambda (a)

(sum-of-squares (+ a 1) (* a 2))))

L11Clos


Initial global environment

Initial Global Environment

L11Clos


Executing f 5 and sum of squares 6 10

Executing (f 5) and (sum-of-squares 6 10)

L11Clos


Closures and streams

Delayed Evaluation : THUNKS

(define x

(* 5 5))

x

25

(define y

(lambda ()

(* 5 5))

(y)

25

Partial Evaluation : CURRYING

(define add

(lambda (x)

(lambda (y)

(+ x y)))

(define ad4

(add 4))

(ad4 8)

12

L11Clos


Closure and models

Substitution

(lambda (y)

(+ 4 y)

)

Substitution model is inadequate for mutable data structures.

Environment

< (lambda (y)

(+ x y)) ,

[x <- 4] >

Need to distinguish location and contents of the location.

Closure and Models

L11Clos


Modular designs with lists

Modular Designs with Lists

L11Clos


Higher order functions and lists

Higher-order functions and lists

  • Use of lists and generic higher-order functions enable abstraction and reuse

    • Can replace customized recursive definitions with more readable definitions built using “library” functions

    • The HOF approach may be less efficient.

    • Promotes MODULAR DESIGNS – improves programmer productivity

L11Clos


Closures and streams

(define (even-fibs n)

(define (next k)

(if (> k n) ’()

(let ((f (fib k)))

(if (even? f)

(cons f (next (+ k 1)))

(next (+ k 1)) )) ))

(next 0))

  • Take a number n and construct a list of first n even Fibonacci numbers.

L11Clos


Abstract description

enumerate integers from 0 to n

compute the Fibonacci number for each integer

filter them, selecting even ones

accumulate the results using cons, starting with ()

Abstract Description

L11Clos


Closures and streams

(define (filter pred seq)

(cond ((null? seq) ’())

((pred (car seq))

(cons (car seq) (filter pred (cdr seq))))

(else (filter pred (cdr seq)))

))

(define (accumulate op init seq)

(if (null? seq) init

(op (car seq) (accumulate op init (cdr seq)))

))

L11Clos


Closures and streams

(define (enum-interval low high)

(if (> low high) ’()

(cons low (enum-interval (+ low 1) high)) ))

(define (even-fibs n)

(accumulate cons ’()

(filter even?

(map fib

(enum-interval 0 n)))))

L11Clos


Streams motivation

Streams: Motivation

L11Clos


Closures and streams

  • Modeling real-world objects (with state) and real-world phenomena

    • Use computational objects with local variables and implement time variation of states using assignments

    • Alternatively, use sequences to model time histories of the states of the objects.

  • Possible Implementations of Sequences

    • Using Lists

    • Using Streams

      • Delayed evaluation (demand-based evaluation) useful (necessary) when large (infinite) sequences are considered.

L11Clos


Streams equational reasoning

Streams : Equational Reasoning

(define s (cons 0 s))

  • Illegal. (Solution: infinite sequence of 0’s.)

    (0 . (0. (0. (0. … ))))

    • (cf. Ada, Pascal,…)

      type s = record

      car : integer;

      cdr : s

      end;

  • How do we represent potentially infinite structures?

L11Clos


Closures and streams

(0.(0.(0. … )))

(0. Function which when

executed generates

an infinite structure)

Recursive winding and unwinding

(0. )

(0. )

(0. . . . )

L11Clos


Closures and streams

>(define stream-car car)

>(define (stream-cdr s)

( (cadr s) ) )

  • Unwrap by executing the second.

    >(define stream-zeros

    (cons 0 (lambda()

    stream-zeros) ) )

  • Wrap by forming closure (thunk).

L11Clos


Closures and streams

>(stream-car

(stream-cdr stream-zeros) )

>(define (numbers-from n)

(cons n

(lambda ()

(numbers-from (+ 1 n))

)))

>(define stream-numbers

(numbers-from 0)

)

L11Clos


Recapitulating stream primitives

Recapitulating Stream Primitives

(define stream-car car)

(define (stream-cdr s)

( (cdr s) ) )

(define (stream-cons x s)

(cons x ( lambda ( ) s) ) )

(define the-empty-stream () )

(define stream-null? null?)

L11Clos


Closures and streams

(define (stream-filter p s)

(cond ((stream-null? s) the-empty-stream)

((p (stream-car s))

(stream-cons (stream-car s)

(stream-filter p (stream-cdr s))))

(else (stream-filter p (stream-cdr s)))

))

(define (stream-enum-interval low high)

(if (> low high) the-empty-stream

(stream-cons low

(stream-enum-interval (+ 1 low) high))))

L11Clos


Closures and streams

(stream-car

(stream-cdr

(stream-filter prime?

(stream-enum-interval 100 1000))))

(define (fibgen f1 f2)

(cons f1 (lambda () (fibgen f2 (+ f1 f2)))

))

(define fibs (fibgen 0 1))

L11Clos


Factorial revisited

Factorial Revisited

(define (trfac n)

(letrec

( (iter (lambda (i a)

(if (zero? i) a

(iter (- i 1) (* a i)))))

)

(iter n 1)

)

)

L11Clos


Closures and streams

(define (ifac n)

(let (( i n ) ( a 1 ))

(letrec

( (iter (lambda ()

(if (zero? i) a

(begin

(set! a (* a i))

(set! i (- i 1))

(iter)

))

)

)

)

(iter)

)

))

L11Clos


Factorial stream

Factorial Stream

(define (str n r)

(cons r (lambda ()

(str (+ n 1) (* n r))

)

)

)

(define sfac (str 1 1))

(car ((cdr ((cdr ((cdr sfac)) )) )) )

… (stream-cdr … )

  • Demand driven generation of list elements.

  • Caching/Memoing necessary for efficiency.

  • Avoids assignment.

L11Clos


  • Login