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=197456578e4d5920ef03a545558f9edcc155f4cc;hb=a4c6be4f4d84375904d19a74b7a781f7b204e7f2;hpb=bd4b9f540acc1988d66420c3bce6e02687b31660

diff --git a/topics/week1_advanced_notes.mdwn b/topics/week1_advanced_notes.mdwn
index 19745657..c5e589f2 100644
--- a/topics/week1_advanced_notes.mdwn
+++ b/topics/week1_advanced_notes.mdwn
@@ -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`.
 
-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)
+    ( + ) (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.
+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.