author Jim Mon, 2 Feb 2015 23:01:21 +0000 (18:01 -0500) committer Jim Mon, 2 Feb 2015 23:01:21 +0000 (18:01 -0500)

index 9bac7eb..8f0fb85 100644 (file)
@@ -176,3 +176,30 @@ 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 &lambda;-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 &lambda;`x. 10 - x`.Similarly, `( & ys)` expresses a function that takes an argument `x` and evaluates to `x & ys`. And --- can you guess what the last one will be? --- `( + )` expresses a function that takes two arguments `(x, y)` and evaluates to `x + y`.
+
+Wait a second, you might say. Isn't that last operation exactly 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 instead use `( + )`, we have to instead write:
+
+    (+) (x, y)
+
+Confession: actually, what I described here diverges a *tiny* bit from what OCaml and Haskell do. They wouldn't really write `(+) (x, y)` like I just did. Instead they'd write `(+) x y`. We will look at the difference between these next week.
+
+