X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=topics%2Fweek1_advanced_notes.mdwn;h=c5e589f23c678f7f54173ec964d7d641ae4aafdf;hp=9bac7eb64fbec8625f85a055d59b1bac6d52067a;hb=54c413718dba4d80448dfb652f84ad344f0b860b;hpb=d7dd23c2ace59bf557f247e57fe75190a4d1e798
diff --git a/topics/week1_advanced_notes.mdwn b/topics/week1_advanced_notes.mdwn
index 9bac7eb6..c5e589f2 100644
--- a/topics/week1_advanced_notes.mdwn
+++ b/topics/week1_advanced_notes.mdwn
@@ -176,3 +176,39 @@ These functions can be defined like this:
in (fst, snd, swap, dup)
+### Sections ###
+
+OCaml and Haskell have a convenient bit of syntax for the common case where you want a function like this:
+
+ lambda x. 10 - x
+
+or like this:
+
+ lambda x. x & ys
+
+or like this:
+
+ lambda (x, y). x + y
+
+They permit you to appreviate the first λ-expression as simply `(10 - )`. We know there's an argument missing, because the infix operator `-` demands two arguments, but we've only supplied one. So `(10 - )` expresses a function that takes an argument `x` and evaluates to `10 - x`. In other words, it expresses λ`x. 10 - x`. Similarly, `( & ys)` expresses a function that takes an argument `x` and evaluates to `x & ys`.
+
+All of this only works with infix operators like `-`, `&` and `+`. You can't write `(1 swap)` or `(swap 1)` to mean λ`x. swap (1, x)`.
+
+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:
+
+ x + y
+
+if we want to use `( + )`, we have to instead write:
+
+ ( + ) (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.
+
+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.
+
+