add anchor for #lightweight
[lambda.git] / topics / week1_advanced_notes.mdwn
index 325b14d..2137d11 100644 (file)
@@ -2,6 +2,7 @@ These are some advanced notes extending the material presented this week. Don't
 
 [[!toc]]
 
+<a id=multivalues></a>
 ### More on multivalues ###
 
 A multivalue is a series of *zero or more* values. They are the result of evaluating expressions that consist of *zero or more* expressions, separated by commas, and enclosed in parentheses. So these expressions evaluate to multivalues:
@@ -47,7 +48,7 @@ In OCaml, there are no until-the-end-of-the-line comments. The only comments sta
 
 I agree it's annoying that these conventions are so diverse. There are plenty other commenting conventions out there, too.
 
-
+<a id=funct-declarations></a>
 ### Matching function values ###
 
 A function value doesn't have any structure---at least none that's visible to the pattern-matching system. You can only match against simple patterns like `_` or the variable `f`.
@@ -71,6 +72,7 @@ This is one of the few places where I'll indulge in the use of single `=`. Note
 This special syntax is only permitted in `let`- and `letrec`-constructions, not in `case`-constructions.
 
 
+<a id=guards></a>
 ### Pattern guards ###
 
 In `case` contructions, it's sometimes useful to check not only whether a certain pattern matches, but also whether a certain boolean expression is true, typically where we want some variables in that expression to be bound by the relevant pattern. Thus, for example, if we wanted to count the number of odd numbers in a sequence, we could do this:
@@ -98,6 +100,7 @@ It's a bit cumbersome, though, to have the doubly-embedded `case`-constructions.
 If we get to the `y & ys` line in the pattern list, and the pattern-match succeeds, then we check the guard expression `odd? y`, with `y` bound to whatever part of `xs` matched the corresponding part of the pattern `y & ys`. If that boolean expression is `'true`, then we continue to the right-hand side, after the `then`, just as usual. But if the boolean expression is `'false`, then we treat the whole line as a failed match, and proceed on to the next line in the binding list, if any.
 
 
+<a id=as-patterns></a>
 ### As-patterns ###
 
 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:
@@ -127,6 +130,7 @@ Both of these strategies work. But they are a bit inefficient. I said you didn't
     end
 
 
+<a id=dollar></a>
 ### $ Syntax ###
 
 Haskell has a useful bit of syntax that we will adopt. They use `$` as an infix operator that has the same kind of effect as Russell &amp; Whitehead's period. It is semantically inert, and only affects grouping. It enables you to avoid some parentheses in lots of situations. For example, if you want to check that a sequence `xs` is not empty, you'd express that like this:
@@ -177,6 +181,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: