add #sections anchor
[lambda.git] / topics / week1_advanced_notes.mdwn
index c5e589f..51da501 100644 (file)
@@ -1,5 +1,6 @@
 These are some advanced notes extending the material presented this week. Don't worry about mastering this stuff now if you're already feeling saturated. But you will need to learn these things in the near future, so tackle them as soon as you're ready.
 
+[[!toc]]
 
 ### More on multivalues ###
 
@@ -102,7 +103,7 @@ If we get to the `y & ys` line in the pattern list, and the pattern-match succee
 Sometimes it's useful to bind variables against overlapping parts of a structure. For instance, suppose I'm writing a pattern that is to be matched against multivalues like `([10, 20], 'true)`. And suppose I want to end up with `ys` bound to `[10, 20]`, `x` bound to `10`, and `xs` bound to `[20]`. Using the techniques introduced so far, I have two options. First, I could bind `ys` against `[10, 20]`, and then initiate a second pattern-match to break that up into `10` and `[20]`. Like this:
 
     case ([10, 20], 'true) of
-      [ys, _] then case ys of
+      (ys, _) then case ys of
                      x & xs then ...;
                      ...
                    end;
@@ -112,7 +113,7 @@ Sometimes it's useful to bind variables against overlapping parts of a structure
 Alternatively, I could directly bind `x` against `10` and `xs` against `[20]`. But then I would have to re-cons them together again to get `ys`. Like this:
 
     case ([10, 20], 'true) of
-      [x & xs, _] then let
+      (x & xs, _) then let
                          ys match x & xs
                        in ...;
       ...
@@ -121,7 +122,7 @@ Alternatively, I could directly bind `x` against `10` and `xs` against `[20]`. B
 Both of these strategies work. But they are a bit inefficient. I said you didn't really need to worry about efficiency in this seminar. But these are also a bit cumbersome to write. There's a special syntax that enables us to bind all three of `ys`, `x`, and `xs` in the desired way, despite the fact that they will be matching against overlapping, rather than discrete, parts of the value `[10, 20]`. The special syntax looks like this:
 
     case ([10, 20], 'true) of
-      [(x & xs) as ys, _] then ...
+      ((x & xs) as ys, _) then ...
       ...
     end
 
@@ -176,6 +177,7 @@ These functions can be defined like this:
     in (fst, snd, swap, dup)
 
 
+<a id=sections></a>
 ### Sections ###
 
 OCaml and Haskell have a convenient bit of syntax for the common case where you want a function like this: