fix typo, thanks Kyle

[lambda.git] / topics / week1_advanced_notes.mdwn

diff --git a/topics/week1_advanced_notes.mdwn b/topics/week1_advanced_notes.mdwn
index 1974565..8b6289a 100644 (file)
--- a/topics/week1_advanced_notes.mdwn
+++ b/topics/week1_advanced_notes.mdwn
@@ -102,7 +102,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
 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;
                      x & xs then ...;
                      ...
                    end;


@@ -112,7 +112,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
 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 ...;
       ...
                          ys match x & xs
                        in ...;
       ...


@@ -121,7 +121,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
 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
 
       ...
     end
 


@@ -197,18 +197,18 @@ All of this only works with infix operators like `-`, `&` and `+`. You can't wri
 Can you guess what our shortcut for the last function will be? It's `( + )`. That
 expresses a function that takes two arguments `(x, y)` and evaluates to `x + y`.
 
 Can you guess what our shortcut for the last function will be? It's `( + )`. That
 expresses a function that takes two arguments `(x, y)` and evaluates to `x + y`.
 

-Wait a second, you say. Isn't that just what `+` does *already*? Why am I making a distinction between `+` and `(+)`? The difference is that bare `+` without any parentheses is an *infix* operator that comes between its arguments. Whereas when we wrap it with parentheses, it loses its special infix syntax and then just behaves like a plain variable denoting a function, like `swap`. Thus whereas we write:
+Wait a second, you say. Isn't that just what `+` does *already*? Why am I making a distinction between `+` and `( + )`? The difference is that bare `+` without any parentheses is an *infix* operator that comes between its arguments. Whereas when we wrap it with parentheses, it loses its special infix syntax and then just behaves like a plain variable denoting a function, like `swap`. Thus whereas we write:

 
     x + y
 
 if we want to use `( + )`, we have to instead write:
 
 
     x + y
 
 if we want to use `( + )`, we have to instead write:
 

-    (+) (x, y)
+    ( + ) (x, y)

 
 It may not be obvious now why this would ever be useful, but sometimes it will be.
 
 All of these shorthands `(10 - )`, `( & ys)` and `( + )` are called "sections". I don't know exactly why.
 
 
 It may not be obvious now why this would ever be useful, but sometimes it will be.
 
 All of these shorthands `(10 - )`, `( & ys)` and `( + )` are called "sections". I don't know exactly why.
 

-Confession: actually, what I described here diverges *a bit* from how OCaml and Haskell treat `( + )`. They wouldn't really write `(+) (x, y)` like I did. Instead they'd write `(+) x y`. We will look at the difference between these next week.
+Confession: actually, what I described here diverges *a bit* from how OCaml and Haskell treat `( + )`. They wouldn't really write `( + ) (x, y)` like I did. Instead they'd write `( + ) x y`. We will look at the difference between these next week.