| « Back to James's CS61A page. | CS61A: Spring 2000 |
This week we learned that we can use procedures as data. This is a big difference between Scheme and other, more conventional programming languages. This ability gives Scheme a lot of expressive power and is the primary reason why Scheme is one of my favorite languages.
In Scheme, lambda expressions create procedures. Technically, a lambda itself is not a procedure.
What do I mean by "creating" a procedure? A Scheme procedure is data; it's a thing. Just as sentence creates a sentence out of words, lambda creates procedural data objects.
Since procedures are data, we can pass them as arguments to other procedures. Procedures that take procedures as arguments are known as higher-order procedures.
Higher-order procedures allow us to generalize and to abstract operations. For example, here's the squares procedure from HW1:
(define (squares sent)
(if (empty? sent)
'()
(sentence (square (first sent))
(squares (butfirst sent))) ))
We can generalize this to:
(define (map proc sent)
(if (empty? sent)
'()
(sentence (proc (first sent))
(map proc (butfirst sent))) ))
(define (squares sent)
(define (square x) (* x x))
(map square sent))
As we can see, using this construct, constructing a sentence of cubes, etc. is now fairly trivial.
The syntax for let:
(let ((<variable1> <value1>) ;; these are the
(<variable2> <value2>) ;; bindings of a let
.
.
.
(<variablen> <valuen>))
<body>)
Let's look at the problem from this week's lab:
(define a 7)
(let ((a 3)
(b (+ a 2))) ;; b is 9, NOT 5
(- (* a b) a))
The important thing to know is that with let, the local variables bindings apply only to the body of the let. They do not apply to the other bindings in the let.
Why does let behave his way? let is actually syntactic sugar for a lambda expression:
((lambda (<variable1> <variable2> ... <variablen>)
<body>)
<value1> <value2> ... <valuen>)
We use a lambda to create a procedure which we then invoke. The local variables of the let are actually parameters of the procedure; the values are the arguments we pass. Applying this to the example from the lab:
((lambda (a b) (- (* a b) a))
3
(+ a 2))
We see that
Understanding the let as a lambda expression isn't too important now, but it will be in several weeks when we cover environment diagramming.
| « Week 1 | Week 3 » |
| « Back to James's CS61A page. | CS61A: Spring 2000 |
Last Modified: Tuesday, 30-Dec-2014 11:58:34 PST