Closures and Streams

1
Closures and Streams
2
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 Hickeys 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.

3
Models of Evaluation

• Substitution-based
• (define (square x) ( x x))
• ((lambda (x y)
• ( (square x) (square y)))
• (- 5 3) 5)
• ( (square 2) (square 5))
• ( ( 2 2) ( 5 5))
• ( 4 25)
• 29

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

5
Models of Evaluation

• Environment-based
• ((lambda (x y)
• ( (square x) (square y)))
• (- 5 3) 5)
• ( (square x) (square y)) x2,y5
• ( ( x x) x2,y5
• ( x x) ) x5,y5
• ( 4 25)
• 29

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

7
Initial Global Environment
8
Executing (f 5) and (sum-of-squares 6 10)
9

• 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

10
Closure and Models

• Substitution
• (lambda (y)
• ( 4 y)
• )
• Substitution model is inadequate for mutable
  data structures.

• Environment
• lt (lambda (y)
• ( x y)) ,
• x lt- 4 gt
• Need to distinguish location and contents of
  the location.

11
Modular Designs with Lists
12
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

13

• (define (even-fibs n)
• (define (next k)
• (if (gt 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.

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

15

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

16

• (define (enum-interval low high)
• (if (gt low high) ()
• (cons low (enum-interval ( low 1) high))
  ))

(define (even-fibs n) (accumulate cons ()
(filter even? (map fib
(enum-interval 0 n)))))
17
Streams Motivation
18

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

19
Streams Equational Reasoning

• (define s (cons 0 s))
• Illegal. (Solution infinite sequence of 0s.)
• (0 . (0. (0. (0. ))))
• (cf. Ada, Pascal,)
• type s record
• car integer
• cdr s
• end
• How do we represent potentially infinite
  structures?

20

• (0.(0.(0. )))
• (0. Function which when
• executed generates
• an infinite structure )
• Recursive winding and unwinding
• (0. )
• (0. )
• (0. . . . )

21

• gt(define stream-car car)
• gt(define (stream-cdr s)
• ( (cdr s) ) )
• Unwrap by executing the second.
• gt(define stream-zeros
• (cons 0 (lambda()
• stream-zeros) ) )
• Wrap by forming closure (thunk).

22

• gt(define stream-car car)
• gt(define (stream-cdr s)
• ( (cadr s) ) )
• Unwrap by executing the second.
• gt(define stream-zeros
• (list 0 (lambda()
• stream-zeros) ) )
• Wrap by forming closure (thunk).

23

• gt(stream-car
• (stream-cdr stream-zeros) )
• gt(define (numbers-from n)
• (cons n
• (lambda ()
• (numbers-from ( 1 n))
• )))
• gt(define stream-numbers
• (numbers-from 0)
• )

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

25

• (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 (gt low high) the-empty-stream
• (stream-cons low
• (stream-enum-interval ( 1 low)
  high))))

26

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

27
Factorial Revisited

• (define (trfac n)
• (letrec
• ( (iter (lambda (i a)
• (if (zero? i) a
• (iter (- i 1) ( a i)))))
• )
• (iter n 1)
• )
• )

28

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

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