XGitUrl: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=week1.mdwn;h=b1df1ad5523599929a4241489ab9260cb49fa256;hp=bfcf91d728463effd6ba5509d91906a79e56097d;hb=fcaf8b03257c825dcacad9882a695560273f5812;hpb=d5523cc6cf13375f7b1da8ef3f4a10b7ed422891
diff git a/week1.mdwn b/week1.mdwn
index bfcf91d7..b1df1ad5 100644
 a/week1.mdwn
+++ b/week1.mdwn
@@ 14,6 +14,7 @@ See also:
* [Chris Barker's Lambda Tutorial](http://homepages.nyu.edu/~cb125/Lambda)
* [Lambda Animator](http://thyer.name/lambdaanimator/)
+* [Penn lambda calculator](http://www.ling.upenn.edu/lambda/) Pedagogical software developed by Lucas Champollion, Josh Tauberer and Maribel Romero. Linguistically oriented.
* MORE
The lambda calculus we'll be focusing on for the first part of the course has no types. (Some prefer to say it instead has a single typebut if you say that, you have to say that functions from this type to this type also belong to this type. Which is weird.)
@@ 36,7 +37,6 @@ We'll tend to write (λa M)
as just `(\a M)`, so we don't hav
Application: (M N)
Some authors reserve the term "term" for just variables and abstracts. We'll probably just say "term" and "expression" indiscriminately for expressions of any of these three forms.
Examples of expressions:
@@ 78,6 +78,10 @@ For instance:
The first occurrence of `x` in T is free. The `\x` we won't regard as containing an occurrence of `x`. The next occurrence of `x` occurs within a form that begins with `\x`, so it is bound as well. The occurrence of `y` is bound; and the occurrence of `z` is free.
+To read further:
+
+* [[!wikipedia Free variables and bound variables]]
+
Here's an example of betareduction:
((\x (y x)) z)
@@ 126,7 +130,7 @@ because here the second occurrence of `y` is no longer free.
There is plenty of discussion of this, and the fine points of how substitution works, in Hankin and in various of the tutorials we've linked to about the lambda calculus. We expect you have a good intuitive understanding of what to do already, though, even if you're not able to articulate it rigorously.
* MORE
+* [More discussion in week 2 notes](/week2/#index1h1)
Shorthand
@@ 308,7 +312,7 @@ Finally, you'll see the term **dynamic** used in a variety of ways in the litera
* dynamic versus static typing
* dynamic versus lexical scoping
+* dynamic versus lexical [[!wikipedia Scope (programming) desc="scoping"]]
* dynamic versus static control operators
@@ 316,6 +320,16 @@ Finally, you'll see the term **dynamic** used in a variety of ways in the litera
For the most part, these uses are only loosely connected to each other. We'll tend to use "imperatival" to describe the kinds of semantic properties made available in dynamic semantics, languages which have robust notions of sequencing changes, and so on.
+To read further about the relation between declarative or functional programming, on the one hand, and imperatival programming on the other, you can begin here:
+
+* [[!wikipedia Declarative programming]]
+* [[!wikipedia Functional programming]]
+* [[!wikipedia Purely functional]]
+* [[!wikipedia Referential transparency (computer science)]]
+* [[!wikipedia Imperative programming]]
+* [[!wikipedia Side effect (computer science) desc="Side effects"]]
+
+
Map
===
@@ 342,6 +356,7 @@ combinatorial logic
+
Rosetta Stone
=============
@@ 351,6 +366,7 @@ The following site may be useful; it lets you run a Scheme interpreter inside yo
* [Try Scheme in your web browser](http://tryscheme.sourceforge.net/)
+
1. Function application and parentheses
@@ 378,8 +394,9 @@ The following site may be useful; it lets you run a Scheme interpreter inside yo
((foo 2) 3)
 These functions are "curried". MORE
 `foo 2` returns a `2`fooer, which waits for an argument like `3` and then foos `2` to it. `( + ) 2` returns a `2`adder, which waits for an argument like `3` and then adds `2` to it.
+ These functions are "curried". `foo 2` returns a `2`fooer, which waits for an argument like `3` and then foos `2` to it. `( + ) 2` returns a `2`adder, which waits for an argument like `3` and then adds `2` to it. For further reading:
+
+* [[!wikipedia Currying]]
In Scheme, on the other hand, there's a difference between `((foo 2) 3)` and `(foo 2 3)`. Scheme distinguishes between unary functions that return unary functions and binary functions. For our seminar purposes, it will be easiest if you confine yourself to unary functions in Scheme as much as possible.
@@ 393,10 +410,10 @@ The following site may be useful; it lets you run a Scheme interpreter inside yo
In Scheme:
(let* ((three 3))
 (let ((two 2))
+ (let* ((two 2))
(+ three two)))
Most of the parentheses in this construction *aren't* playing the role of applying a function to some argumentsonly the ones in `(+ three two)` are doing that.
+ Most of the parentheses in this construction *aren't* playing the role of applying a function to some argumentsonly the ones in `(+ three two)` are doing that.
In OCaml:
@@ 407,9 +424,9 @@ Most of the parentheses in this construction *aren't* playing the role of applyi
In the lambda calculus:
 > Here we're on our own, we don't have predefined constants like `+` and `3` and `2` to work with. We've got to build up everything from scratch. We'll be seeing how to do that over the next weeks.
+ Here we're on our own, we don't have predefined constants like `+` and `3` and `2` to work with. We've got to build up everything from scratch. We'll be seeing how to do that over the next weeks.
 > But supposing you had constructed appropriate values for `+` and `3` and `2`, you'd place them in the ellided positions in:
+ But supposing you had constructed appropriate values for `+` and `3` and `2`, you'd place them in the ellided positions in:
(((\three (\two ((... three) two))) ...) ...)
@@ 442,23 +459,27 @@ Most of the parentheses in this construction *aren't* playing the role of applyi
Of course you don't need to remember any of this syntax. We're just illustrating it so that you see that in Scheme and OCaml it looks somewhat different than we had above. The difference is much more obvious than it is in C.
 In the lambda calculus: sorry, you can't do mutation. At least, not natively. Later in the term we'll be learning how in fact, really, you can embed mutation inside the lambda calculus even though the lambda calculus has no primitive facilities for mutation.
+ In the lambda calculus:
+ Sorry, you can't do mutation. At least, not natively. Later in the term we'll be learning how in fact, really, you can embed mutation inside the lambda calculus even though the lambda calculus has no primitive facilities for mutation.
3. Anonymous functions
 Functions are "firstclass values" in the lambda calculus, in Scheme, and in OCaml. What that means is that they can be arguments to other functions. They can be the results of the application of other functions to some arguments. They can be stored in data structures. And so on.
+ Functions are "firstclass values" in the lambda calculus, in Scheme, and in OCaml. What that means is that they can be arguments to, and results of, other functions. They can be stored in data structures. And so on. To read further:
+
+ * [[!wikipedia Higherorder function]]
+ * [[!wikipedia Firstclass function]]
 First, we'll show what "anonymous" functions look like. These are functions that have not been bound as values to any variables. That is, there are no variables whose value they are.
+ We'll begin by looking at what "anonymous" functions look like. These are functions that have not been bound as values to any variables. That is, there are no variables whose value they are.
In the lambda calculus:
(\x M)
 is always anonymous! Here `M` stands for any expression of the language, simple or complex. It's only when you do
+ where `M` is any simple or complex expressionis anonymous. It's only when you do:
((\y N) (\x M))
@@ 468,28 +489,14 @@ Most of the parentheses in this construction *aren't* playing the role of applyi
(lambda (x) M)
 Not very different, right? For example, if `M` stands for `(+ 3 x)`, then this is an anonymous function that adds 3 to whatever argument it's given:
+ Not very different, right? For example, if `M` stands for `(+ 3 x)`, then here is an anonymous function that adds 3 to whatever argument it's given:
(lambda (x) (+ 3 x))

In OCaml, we write our anonymous function like this:
 fun x > (3 + x)

 or:

 fun x > (( + ) 3 x)

 In OCaml, parentheses only serve a grouping function and they often can be omitted. Or more could be added. For instance, we could equally well say:

fun x > ( + ) 3 x
 or:

 (fun x > (( + ) (3) (x)))

 As we saw above, parentheses can often be omitted in the lambda calculus too. But not in Scheme. Every parentheses has a specific role.
4. Supplying an argument to an anonymous function
@@ 497,7 +504,7 @@ Most of the parentheses in this construction *aren't* playing the role of applyi
((lambda (x) (+ 3 x)) 2)
 The outermost parentheses here mean "apply the function `(lambda (x) (+ 3 x))` to the argument `2`.
+ The outermost parentheses here mean "apply the function `(lambda (x) (+ 3 x))` to the argument `2`, or equivalently, "give the value `2` as an argument to the function `(lambda (x) (+ 3 x))`.
In OCaml:
@@ 509,7 +516,7 @@ Most of the parentheses in this construction *aren't* playing the role of applyi
Let's go back and reconsider this Scheme expression:
(let* ((three 3))
 (let ((two 2))
+ (let* ((two 2))
(+ three two)))
Scheme also has a simple `let` (without the ` *`), and it permits you to group several variable bindings together in a single `let` or `let*`statement, like this:
@@ 520,23 +527,23 @@ Most of the parentheses in this construction *aren't* playing the role of applyi
Often you'll get the same results whether you use `let*` or `let`. However, there are cases where it makes a difference, and in those cases, `let*` behaves more like you'd expect. So you should just get into the habit of consistently using that. It's also good discipline for this seminar, especially while you're learning, to write things out the longer way, like this:
(let* ((three 3))
 (let ((two 2))
+ (let* ((two 2))
(+ three two)))
However, here you've got the double parentheses in `(let* ((three 3)) ...)`. They're doubled because the syntax permits more assignments than just the assignment of the value `3` to the variable `three`. Myself I tend to use `[` and `]` for the outer of these parentheses: `(let* [(three 3)] ...)`. Scheme can be configured to parse `[...]` as if they're just more `(...)`.
 Someone asked in seminar if the `3` could be replaced by a more complex expression. The answer is "yes". You could also write:
+ It was asked in seminar if the `3` could be replaced by a more complex expression. The answer is "yes". You could also write:
(let* [(three (+ 1 2))]
 (let [(two 2)]
+ (let* [(two 2)]
(+ three two)))
 The question also came up whether the `(+ 1 2)` computation would be performed before or after it was bound to the variable `three`. That's a terrific question. Let's say this: both strategies could be reasonable designs for a language. We are going to discuss this carefully in coming weeks. In fact Scheme and OCaml make the same design choice. But you should think of the underlying form of the `let`statement as not settling this by itself.
+ It was also asked whether the `(+ 1 2)` computation would be performed before or after it was bound to the variable `three`. That's a terrific question. Let's say this: both strategies could be reasonable designs for a language. We are going to discuss this carefully in coming weeks. In fact Scheme and OCaml make the same design choice. But you should think of the underlying form of the `let`statement as not settling this by itself.
Repeating our starting point for reference:
(let* [(three 3)]
 (let [(two 2)]
+ (let* [(two 2)]
(+ three two)))
Recall in OCaml this same computation was written:
@@ 578,7 +585,7 @@ Most of the parentheses in this construction *aren't* playing the role of applyi
((lambda (bar) (bar A)) (lambda (x) B))
 which, as we'll see, is equivalent to:
+ which betareduces to:
((lambda (x) B) A)
@@ 623,7 +630,7 @@ Most of the parentheses in this construction *aren't* playing the role of applyi
let x = A;;
... rest of the file or interactive session ...
 It's easy to be lulled into thinking this is a kind of imperative construction. *But it's not!* It's really just a shorthand for the compound `let`expressions we've already been looking at, taking the maximum syntactically permissible scope. (Compare the "dot" convention in the lambda calculus, discussed above.)
+ It's easy to be lulled into thinking this is a kind of imperative construction. *But it's not!* It's really just a shorthand for the compound `let`expressions we've already been looking at, taking the maximum syntactically permissible scope. (Compare the "dot" convention in the lambda calculus, discussed above. I'm fudging a bit here, since in Scheme `(define ...)` is really shorthand for a `letrec` epression, which we'll come to in later classes.)
9. Some shorthand
@@ 700,11 +707,15 @@ Most of the parentheses in this construction *aren't* playing the role of applyi
When a previouslybound variable is rebound in the way we see here, that's called **shadowing**: the outer binding is shadowed during the scope of the inner binding.
+ See also:
+
+ * [[!wikipedia Variable shadowing]]
+
Some more comparisons between Scheme and OCaml

11. Simple predefined values
+* Simple predefined values
Numbers in Scheme: `2`, `3`
In OCaml: `2`, `3`
@@ 715,18 +726,18 @@ Some more comparisons between Scheme and OCaml
The eighth letter in the Latin alphabet, in Scheme: `#\h`
In OCaml: `'h'`
12. Compound values
+* Compound values
These are values which are built up out of (zero or more) simple values.
 Ordered pairs in Scheme: `'(2 . 3)`
+ Ordered pairs in Scheme: `'(2 . 3)` or `(cons 2 3)`
In OCaml: `(2, 3)`
 Lists in Scheme: `'(2 3)`
+ Lists in Scheme: `'(2 3)` or `(list 2 3)`
In OCaml: `[2; 3]`
We'll be explaining the difference between pairs and lists next week.
 The empty list, in Scheme: `'()`
+ The empty list, in Scheme: `'()` or `(list)`
In OCaml: `[]`
The string consisting just of the eighth letter of the Latin alphabet, in Scheme: `"h"`