+means the same as:
+
+ lambda (x, y). (lambda z. result)
+
+The parentheses could have been omitted around `lambda z. result`; they're just there to focus your attention.
+
+Haskell and OCaml are very similar to this, they just use some slightly different notation. In Haskell you'd write:
+
+ -- Haskell
+ \(x, y) z -> result
+
+and in OCaml you'd write:
+
+ (* OCaml *)
+ fun (x, y) z -> result
+
+You may sometimes see λ expressions in OCaml written using `function` instead of `fun`. These overlap somewhat in their usage. The difference is that `function` only allocates a position for *one* argument pattern, so can't straightforwardly define curried functions. (You can however embed `function` expressions inside other `function` expressions.) On the other hand, `function` can take multiple *variant* patterns for that single position. Thus with `function` you can say:
+
+ (* OCaml *)
+ function [] -> result1 |
+ x::xs -> result2
+
+whereas with `fun` you'd have to write:
+
+ (* OCaml *)
+ fun ys -> match ys with
+ [] -> result1 |
+ x::xs -> result2
+
+In Scheme, lambda expressions are written like this:
+
+ ; Scheme
+ (lambda (vars...) body-expressions...)
+
+Scheme only permits simple variables as its argument patterns, and the lambda expression can be defined to take zero or more arguments:
+
+ ; Scheme
+ (lambda () ...)
+ (lambda (x) ...)
+ (lambda (x y) ...)
+ (lambda (x y z) ...)
+
+As I said before, we will discuss functions that "take zero arguments" a few weeks into the seminar.
+
+There is special syntax for defining functions that may take *varying* numbers of arguments (recall `and` and `+`), where Scheme binds a single variable to a list containing all of the received arguments (or all of the arguments after the *n*th...). I won't explain that syntax here.
+
+
+
+
+### Let, Letrec, and Define
+
+Kapulet has the syntax:
+
+ # Kapulet
+ let
+ pat1 match expr1;
+ pat2 match expr2;
+ pat3 match expr3
+ in result
+
+which is equivalent to:
+
+ # Kapulet
+ let
+ pat1 match expr1
+ in let
+ pat2 match expr2
+ in let
+ pat3 match expr3
+ in result
+
+There is also a corresponding `letrec` form. In `let`, the bindings in `pat1` are in effect for the evaluation of all of `expr2`, `expr3`, and `result` (but not any further, if this is part of a more complex expression); similarly for the bindings in `pat2` and `pat3`. In `letrec`, all of the bindings on the left-hand side are in effect for all of the right-hand side expressions, as well as for the result.
+
+OCaml only has the second, more verbose form of this, and writes it a bit differently:
+
+ (* OCaml *)
+ let
+ pat1 = expr1
+ in let
+ pat2 = expr2
+ in let
+ pat3 = expr3
+ in result
+
+If you want to define some mutually recursive functions with `letrec`, OCaml uses a special syntax for that, using `letrec ...` <code><em>and</em></code> `... in ...`:
+
+ (* OCaml *)
+ letrec
+ even = fun x -> if x = 0 then true else odd x
+ and
+ odd = fun x -> if x = 0 then false else even x
+ in ...
+
+Haskell has both of the syntactic forms that Kapulet does, though like OCaml, it uses `=` rather than `match`. And it wraps all the binding clauses with `{ ... }` (see [[earlier remarks|rosetta1#haskell-whitespace]] about Haskell and whitespace/indentation):
+
+ -- Haskell
+ let {
+ pat1 = expr1;
+ pat2 = expr2;
+ pat3 = expr3
+ } in result
+
+Also, in Haskell `let` always means `letrec`. There is no term in Haskell that means what simple `let` does in Kapulet and OCaml.
+
+Haskell also has another form, roughly synonymous with its `let ... in ...`. It looks like this:
+
+ -- Haskell
+ result where {
+ pat1 = expr1;
+ pat2 = expr2;
+ pat3 = expr3
+ }
+
+Here all the new bindings introduced for the variables in the `pat`s are in effect for the evaluation of the `expr`s (this works like `letrec` too), and also for the evaluation of `result`.
+
+There are a few places where you can use `let ... in ...` but not `... where ...`, and a few places where the inverse is true.
+
+<!-- (1) `let pat = expr` has a use inside do-blocks and guards; (2) `let ... in ...` is an expression, and so can occur within other expressions; (3) `where` can bind multiple guard-clauses in a `case` block: in `case expr of { pat | g1 -> e1 | g2 -> e2 where { ... }; another_pat -> ... }`, the `where` bindings govern free variables in all of `g1`, `e1`, `g2`, `e2`. -->
+
+
+<a id=five-lets></a>
+Scheme has *four (or five)* syntactic forms here, including `let`, `let*`, `letrec`, and `letrec*`. The difference between the last two [is subtle](http://stackoverflow.com/questions/13078165) and only arises in the presence of continuations; you can just use `letrec` for ordinary purposes. I won't try to explain the difference between `let` and `let*` here, except to say this:
+
+1. When there's only a single pattern-binding clause, as in `(let ((var expression)) result)`, `let` and `let*` work the same.
+2. When there are multiple pattern-binding clauses, as in `(let ((var1 expression1) (var2 expression2)) result)`, then they work somewhat differently and `let*` is probably the one that works like you're expecting.
+
+The `let*` form is the one that corresponds to `let` in Kapulet. I recommend you get in the habit of just always using `let*` (or `letrec`) in Scheme, instead of `let`.
+
+When you're at the "toplevel" of your program, or of a library/module/compilation-unit (the terminology differs), there is also another syntactic form possible. In Kapulet, you'd write:
+
+ # Kapulet
+ let
+ pat1 match expr1;
+ ...
+ end
+ ... # rest of program or library
+
+Notice that this form ends with `end`, not with `in result`. The above is roughly equivalent to:
+
+ # Kapulet
+ let
+ pat1 match expr1;
+ ...
+ in ... # rest of program or library
+
+That is, the bindings initiated by the clauses of the `let` construction remain in effect until the end of the program or library. They can of course be "hidden" by subsequent bindings to new variables spelled the same way. The program:
+
+ # Kapulet
+ let
+ x match 0
+ end
+ let
+ x match 1
+ end
+ x
+
+evaluates to `1`, just like:
+
+ # Kapulet
+ let
+ x match 0
+ in let
+ x match 1
+ in x
+
+does. There's a similar form for `letrec`.
+
+OCaml can do the same:
+
+ let
+ x = 0 ;;
+ let
+ x = 1 ;;
+ x
+
+The double-semicolons are hints to OCaml's "toplevel interpreter" that a syntactic unit has finished. In some contexts they're not needed, but it does no harm to include them if you're not sure.
+
+Haskell's "toplevel interpreter" (ghci) permits a syntactic form that looks superficially quite like these:
+
+ let x = 2
+ x
+
+but under the covers something quite different is happening. (Specifically, you're working "inside the IO Monad", except that in this special context, expressions like `x` that don't evaluate to monadic values are permitted and evaluated. We don't expect that you will understand yet what any of this means.) If you're writing *in a file* that you want Haskell to interpret or compile, on the other hand, you have to do something a bit different (which you can't easily also do at the toplevel in ghci). [[Recall|topics/week1_advanced_notes#funct-declarations]] the shortcut by which we permitted:
+
+ # Kapulet
+ let
+ f match lambda pat1. body1;
+ g match lambda pat2 pat3. body2
+ in ...
+
+to be written more concisely as:
+
+ # Kapulet
+ let
+ f pat1 = body1;
+ g pat2 pat3 = body2
+ in ...
+
+OCaml and Haskell permit that same shorthand. And Haskell additionally permits the bare binding clauses of such expressions (that is, without the surrounding `let` and `in`) to occur at the toplevel of files. In other words, a Haskell file can look like this:
+
+ -- Haskell file.hs
+ f pat1 = body1
+
+ g pat2 pat3 = body2
+ ...
+
+Note there are no semicolons here. These are called "toplevel declarations" of the functions `f` and `g`. A single function name can have multiple declarations (within a single scoping context), using different patterns:
+
+ -- Haskell file.hs
+ f [] = 0
+ f (x:xs) = 1 + f xs
+
+defines `f` as a function that returns the length of a single List argument. (You can also do that *inside* Haskell's `let` constructions, too.) This is what corresponds *in Haskell files* to `let ... end` in Kapulet.
+
+Haskell also permits multiple declarations of this sort inside its `let` and `where` constructs, too. Moreover, these declarations can also have [[pattern guards|rosetta1#haskell-guards]], as in:
+
+ -- Haskell file.fs
+ f [] = 0
+ f (x:xs) | odd x = 1 + f xs
+ | otherwise = f xs
+
+<a id=define></a>
+Scheme has a version of `letrec ... end`, which it writes as `define`. Thus in Scheme this:
+
+ ; Scheme
+ (define var1 expr1)
+ ... ; rest of program
+
+evaluates the same as this:
+
+ ; Scheme
+ (letrec ((var1 expr1))
+ ... ; rest of program
+ )
+
+This is what we can call Scheme's [[fifth|rosetta1#five-lets]] form of the `let` family.
+
+Some versions of Scheme permit you also to include `define` inside some (but not all) complex expressions. Thus you can write:
+
+ (lambda (x)
+ (define var1 expr1)
+ ...)
+
+instead of:
+
+ (lambda (x)
+ (letrec ((var1 expr1))
+ ...))
+
+There is no analogue to this in the other languages.
+
+
+
+
+### Further Installments ...
+
+We will expand these comparisons (on separate web pages) as we introduce additional ideas in the course, such as types and monads and continuations.
+
+
+
+
+## Offsite Readings comparing Scheme, OCaml, and Haskell ##