Lecture 6 (Pre-Recorded)

Lambda Abstraction

Rules of computation in ISL+

• If it’s a constant (a number or string)
• It’s its own value
• Return it

​

• If it’s a variable name (e.g. a word, hyphenated-phrase, or symbol like +)
• Look up its value in the dictionary
• Return (output) it

​

• If it has parens (i.e.(a b c …))
• Check if it’s a special case
• (define name value)�Update dictionary to list value as definition of name.
• (λ (input-names …) output-exp)�Makes a new function, whose inputs are called input-names and whose output is computed by output-exp.
• Otherwise, find the values of a, b, c, etc. using these same rules
• The value of a had better be a function
• Call it with the values of b, c, etc. as inputs
• Return its output

the substitution model

The substitution model

• The SICP book teaches a model of how function calls operate called the substitution model
• Based on algebraic simplification
• Calls to primitive functions work by replacing the call with the value of its output
• Calls to compound functions are computed by
• Replacing the call with the body of the function
• Replace the argument names with their values
• So ((λ (n) (+ n 1)) 5)
• (+ n 1), remembering n is 5
• (+ 5 1)

What is the value of this expression?

> ((λ (n) (+ n 1))

3)

​

• Find the values of the subexpressions
• λ expression is a function
• 3 is the number 3
• Call the function with 3 as its argument
• Substitute 3 for n in (+ n 1) to get (+ 3 1)
• Execute (+ 3 1)
• Output of λ expression is 4
• Value of the overall expression is 4

What is the value of this expression?

> ((λ (n) (+ n 1)) 3)

> 4

• The rules are very simple
• But interact in subtle ways

Making a�color gradient

Drawing a line

• How do we make a 100 pixel vertical line?

Drawing a line

• How do we make a 100 pixel vertical line?

​

(rectangle 1 100 "solid" "blue")

​

Drawing a line

• How do we make it two pixels wide?

​

(rectangle 1 100 "solid" "blue")

​

Drawing a line

• How do we make it two pixels wide?

​

(rectangle 2 100 "solid" "blue")

​

Drawing a line

• How do we make it three pixels wide?

​

(rectangle 2 100 "solid" "blue")

​

Drawing a line

• How do we make it three pixels wide?

​

(rectangle 3 100 "solid" "blue")

​

Drawing a line

• How do we make a function that creates lines of specified widths?

​

(rectangle 3 100 "solid" "blue")

​

Drawing lines "à la mode"

• How do we make a function that creates lines of specified widths?

​

(λ (width)

(rectangle width 100 "solid" "blue"))

​

Even more customization

• How can we modify the function to change the color based on the width?

​

(λ (width)

(rectangle width 100 "solid" "blue"))

​

Even more customization

• How can we modify the function to change the color based on the width?

​

(λ (width)

(rectangle width

100

"solid"

(color 0

0

(- 255

(* width 10)))))

MORE LINES

• How do we make a series of lines?

​

(λ (width)

(rectangle width

100

"solid"

(color 0

0

(- 255

(* width 10)))))

MORE LINES

• How do we make a series of lines?

​

(iterated-beside (λ (width)

(rectangle width

100

"solid"

(color 0

0

(- 255

(* width 10)))))

10)

Reading the Code

​

​

(iterated-beside (λ (width)

(rectangle width

100

"solid"

(color 0

0

(- 255

(* width 10)))))

10)

calls the line generator

repeatedly and collects the results

generates a single line

number of lines to make

Stretching

• How do we make the lines wider?

​

​

​

​

​

(iterated-beside (λ (width)

(rectangle width

100

“solid”

(color 0

0

(- 255

(* width 10)))))

10)

Stretching

• How do we make the lines wider?

​

​

​

​

​

(iterated-beside (λ (width)

(rectangle (* 10 width)

100

“solid”

(color 0

0

(- 255

(* width 10)))))

10)

Changing the Palette

• How do we make them shift from blue to green?

​

​

​

(iterated-beside (λ (width)

(rectangle (* 10 width)

100

“solid”

(color 0

0

(- 255

(* width 10)))))

10)

Changing the Palette

• How do we make them shift from blue to green?

​

​

​

(iterated-beside (λ (width)

(rectangle (* 10 width)

100

“solid”

(color 0

(* width 25)

(- 255

(* width 25)))))

10)

Lambda abstraction

Functional abstraction

“Variablizing” expressions to generalize them

• The expression (rectangle width 100 "solid" "blue") doesn’t express any particular line
• It expresses vertical 100 pixel blue lines
• Without specifying which vertical 100 pixel blue line we mean
• (i.e. which width we mean)

Abstracting expressions

• A good method for writing simple functions:
1. Think of what its output should be in some specific test case
2. Write an expression for it
3. Change the part(s) you want to vary to a variable
4. Wrap it with (λ (variable) … )
• This is called abstracting the expression
• Or, if you want to be fancy, you can call it λ-abstraction

(rectangle 1 100

"solid" "blue")

​

(rectangle width 100

"solid" "blue")

​

(λ (width)

(rectangle width

100

"solid"

"blue"))

​

Abstracting expressions

Alas, it’s often not that simple

• You may need to modify the input before it’s really in the form you want
• Or experiment with it a bit to make it work the way you really want

(rectangle 1 100

"solid" "blue")

​

(rectangle width 100

"solid" "blue")

​

(λ (width)

(rectangle width 100

"solid" "blue"))

​

(λ (width)

(rectangle (* 10 width)

100

"solid"

"blue"))

​

Making a rotary pattern

How do we make a pattern of rectangles rotating around a central point?

Start simple

How do we make one rectangle?

Start simple

How do we make one rectangle?

​

(rectangle 50 200

"solid" "red")

Get slightly closer

How do we rotate one rectangle?

​

(rectangle 50 200

"solid" "red")

Get slightly closer

How do we rotate one rectangle?

​

(rotate 30

(rectangle 50 200

"solid" "red"))

Get slightly closer

How do we rotate one rectangle by an arbitrary angle?

​

(rotate 30

(rectangle 50 200

"solid" "red"))

Get slightly closer

How do we rotate one rectangle by an arbitrary angle?

​

(rotate degrees

(rectangle 50 200

"solid" "red"))

Make a function to do it!

How do we make a function to create arbitrary rotated rectangles?

​

(rotate degrees

(rectangle 50 200

"solid" "red"))

Make a function to do it!

How do we make a function to create arbitrary rotated rectangles?

​

(λ (degrees)

(rotate degrees

(rectangle 50 200

"solid" "red")))

Use the function you made

How do we make many rotated rectangles?

​

(λ (degrees)

(rotate degrees

(rectangle 50 200

"solid" "red")))

Use the function you made

How do we make many rotated rectangles?

​

(iterated-overlay (λ (degrees)

(rotate degrees

(rectangle 50 200

"solid" "red")))

50)

​

Use the function you made

How do we separate them more?

​

(iterated-overlay (λ (degrees)

(rotate degrees

(rectangle 50 200

"solid" "red")))

50)

​

Use the function you made

How do we separate them more?

​

(iterated-overlay (λ (degrees)

(rotate (* 36 degrees)

(rectangle 50 200

"solid" "red")))

5)

​

Further Parameterize

How do we separate them more?

​

(iterated-overlay (λ (picture-num)

(rotate (* 36 picture-num)

(rectangle 50 200

"solid" "red")))

5)

​

Further Parameterize

How do we vary the color?

​

(iterated-overlay (λ (picture-num)

(rotate (* 36 picture-num)

(rectangle 50 200

"solid" "red")))

5)

​

Further Parameterize

How do we vary the color?

​

(iterated-overlay (λ (picture-num)

(rotate (* 36 picture-num)

(rectangle 50 200

"solid"

(color (- 200 (* picture-num 50))

(* picture-num 50)

0))))

5)

​

​

Make it into a Function

How do we functionalize it?

​

(iterated-overlay (λ (picture-num)

(rotate (* 36 picture-num)

(rectangle 50 200

"solid"

(color (- 200 (* picture-num 50))

(* picture-num 50)

0))))

5)

​

​

Make it into a function

How do we functionalize it?

​

​

(define rotary (λ (num-spokes)

(iterated-overlay

(λ (picture-num)

(rotate (* (quotient 360 (* 2 num-spokes)) picture-num)

(rectangle 50 200

"solid"

(color (- 255 (* picture-num (quotient 255 num-spokes)))

(* picture-num (quotient 255 num-spokes))

0))))

num-spokes)))

​

​

​

​

​

Local variables

Another abstraction tool

We keep dividing the same thing…

;; rotary: number -> image

;; creates a rotary image with rectangles that change color

(define rotary (λ (num-spokes)

(iterated-overlay

(λ (picture-num)

(rotate (* (quotient 360 (* 2 num-spokes)) picture-num)

(rectangle 50 200

"solid"

(color (- 255

(* picture-num

(quotient 255

num-spokes)))

(* picture-num

(quotient 255

num-spokes))

0))))

num-spokes)))

​

Local names in Racket

(local [(define name₁ value₁)

(define name₂ value₂)

…

(define name_n value_n)]�output-expression)

​

• Local names (also known as local variables or temporary variables) are names that are only in effect for a single expression
• Sort of like pronouns in English

Local names in Racket

(local [(define name₁ value₁)

(define name₂ value₂)

…

(define name_n value_n)]�output-expression)

​

• Computes all the values
• Substitutes them for their respective names in output-expression
• Runs output-expression and returns its value

Saving some redundant work

;; rotary: number -> image

;; creates a rotary image with rectangles that change color

(define rotary-2 (λ (num-spokes)

(iterated-overlay

(λ (picture-num)

(local [(define q (quotient 250 num-spokes))]

(rotate (* (quotient 360 (* 2 num-spokes)) picture-num)

(rectangle 50 200

"solid"

(color (- 255

(* picture-num

q))

(* picture-num

q)

0)))))

num-spokes)))

Rules of computation in ISL+

Look at the expression

• If it’s a constant (i.e. a number or string), it’s its own value
• If it’s a variable name (i.e. a word, hyphenated phrase, etc.), look its value up in the dictionary
• Parentheses? (Check if it’s one of the special cases from the next slide)
• Otherwise it’s a function call
• (func-expression arg-expression₁ … arg-expression_n)
• Execute all the subexpressions�(func-expression and arg-expression₁ through arg-expression_n)
• Call the value of func-expression, passing it the values of arg-expression₁ through arg-expression_n as inputs
• Use its output as the value of the expression

Special cases: Rules of computation in ISL+

If it starts with define

(define name value-expression)

• Run value-expression
• Assign its value to name�in the dictionary

If it starts with λ or lambda:

(λ (name₁ … name_last) result-expression)

• Make a function
• That names its inputs�name₁ … name_last
• And returns the value�of result-expression�(presumably using those names)

If it starts with the the word local

(local [(define name₁ value₁) � …� (define name_last value_last)]� result-expression)

• Run the value expressions
• Substitutes their values for their respective�names in result-expression
• Runs the substituted result-expression
• Returns its value

​

Grids revisited

How do we make a row of items?

​

​

​

​

​

​

​

• How do we write a function that makes rows of items?

Making a row

;; row: image number -> image

;; Makes an row of copies of item

(define row (λ (item count)

(iterated-beside ;; number -> image

;; Just returns item

(λ (ignore) item)

count)))

Wait…can you do that?

;; row: image number -> image

;; Makes an row of copies of item

(define row (λ (item count)

(iterated-beside ;; number -> image

;; Just returns item

(λ (ignore) item)

count)))

​

• The inner function doesn’t use its argument
• It ignores it and always returns the same output
• That’s fine; it’s a common thing to do

But then why bother with a function (aka procedure)?

;; row: image number -> image

;; Makes an row of copies of item

(define row (λ (item count)

(iterated-beside item

count)))

​

• Couldn't we just do this?

​

That won’t work

​

​

​

​

• We'd be passing the square image itself to iterated-beside
• It needs its input to be a function
• But we’re passing it an image
• So it throws an argument type exception

How do we make a column?

Making a column

;; column: image number -> image

;; Makes an stack of copies of item

(define column (λ (item count)

(iterated-above (λ (ignore) item)

count))

How do we make a grid?

Making a grid

;; grid: image number number -> image

;; Makes an grid of copies of item

(define grid

(λ (item columns rows)

(column (row item columns)

rows)))

​

Take the item

;; grid: image number number -> image

;; Makes an grid of copies of item

(define grid

(λ (item columns rows)

(column (row item columns)

rows)))

​

Make a row of them

;; grid: image number number -> image

;; Makes an grid of copies of item

(define grid

(λ (item columns rows)

(column (row item columns)

rows)))

​

Make a stack of them

;; grid: image number number -> image

;; Makes an grid of copies of item

(define grid

(λ (item columns rows)

(column (row item columns)

rows)))

​

Make a function that does that

;; grid: image number number -> image

;; Makes an grid of copies of item

(define grid

(λ (item columns rows)

(column (row item columns)

rows)))

​

Name it grid

;; grid: image number number -> image

;; Makes an grid of copies of item

(define grid

(λ (item columns rows)

(column (row item columns)

rows)))

​