Recent changes to this wiki:

diff --git index.mdwn
similarity index 100%
rename from index.mdwn
rename to

mechanical attempt at inline
diff --git chap07.mod chap07.mod
index 8e6c50e..199438d 100644
--- chap07.mod
+++ chap07.mod
@@ -14,2141 +14,8 @@ functions instead of on data values.  Some of these take data
 arguments and manufacture functions to order; others, like the F<imap>
 function of X<imap|chapter>, transform one function into another one.
-=section Currying
-We have seen several times so far how to use callbacks to parametrize
-the behavior of a function so that it can serve many purposes.  For
-example, in R<dir_walk_callbacks|section> we saw how a generic
-directory-walking function could be used to print a list of dangling
-symbolic links, to return a list of interesting files, or to copy an
-entire directory.
-Callbacks are a way to make functions more general by supplying other
-functions to them as arguments.  We saw how to write functions that
-used closures to generate other functions as return values.  The
-I<currying> technique we'll see combines closures and callbacks,
-turning an ordinary function into a factory that manufactures
-functions on demand.
-Recall our F<walk_html> function from R<walk_html|chapter>.  Its
-arguments were an HTML tree and a pair of callbacks, one to handle
-plain text and one to handle tagged text.  We had found a way to use
-this to extract all the text that was enclosed in T<h1> tags:
-=inline extract_headers
-We then observed that it would make sense to abstract the T<h1> out of
-F<promote_if_h1tag>, to make it more general:
-=inline promote_if
-The second callback in F<walk_html> is rather peculiar.  It's an
-anonymous function that we manufactured solely to call F<promote_if>
-with the right arguments.  The previous version of the code was
-tidier.  What we need is a way to get F<promote_if> to I<manufacture>
-the F<promote_if_h1tag> function we need.  This seems like it should
-be possible, since after all F<promote_if> already knows how to
-perform the task that we want F<promote_if_h1tag> to perform.  All
-that we need to do is to have F<promote_if> wrap up that behavior into
-a new function:
-=startlisting promote_if_curried        
-        sub promote_if {
-          my $is_interesting = shift;          
-*         return sub {
-            my $element = shift;
-            if ($is_interesting->($element->{_tag}) {
-              return ['keeper', join '', map {$_->[1]} @_];
-            } else {
-              return @_;
-            }
-*         }
-        }
-=contlisting promote_if_curried        
-Instead of accepting both arguments right away, F<promote_if> now gets
-the C<$is_interesting> callback only, and manufactures a new function
-that, given an HTML element, promotes it if it's considered
-interesting.  Making this change to F<promote_if>, to turn it from a
-function of two arguments into a function of one argument that returns
-a function of one argument, is called X<currying|d> it, and the
-version of F<promote_if> immediately above is the X<curried|d> version
-of F<promote_if>.N<Currying is so-named because it was popularized by
-Haskell B. Curry in 1930, although it had been discovered by Gottlob
-Frege in 1893 and rediscovered by Moses M<Schoenfinkel> in 1924.
-X<Frege, Gottlob|i> X<Curry, Haskell B.|i> X<M<Schoenfinkel>,
-The happy outcome is that the call to F<walk_html> is now much simpler:
-          my @tagged_texts = walk_html($tree, 
-                                       sub { ['maybe', $_[0]] }, 
-                                       promote_if('h1'),
-                                       });
-Once you get used to the idea of currying, you start to see
-opportunities to do it all over.  Recall our functions from R<power
-series|chapter> for adding and multiplying two streams together
-element-by-element: F<add2> and F<mul2>.
-        sub add2 {
-          my ($s, $t) = @_;
-          return unless $s && $t;
-          node(head($s) + head($t),
-                       promise { add2(tail($s), tail($t)) });
-        }
-        sub mul2 {
-          my ($s, $t) = @_;
-          return unless $s && $t;
-          node(head($s) * head($t),
-                       promise { mul2(tail($s), tail($t)) });
-        }
-These functions are almost identical.  We saw in R<callback|chapter>
-that two functions with similar code can often be combined into a
-single function that accepts a callback parameter.  In this case, the
-callback, C<$op>, specifies the operation to use to combine
-C<head($s)> and C<head($t)>:
-        sub combine2 {
-          my ($s, $t, $op) = @_;
-          return unless $s && $t;
-          node($op->(head($s), head($t)),
-               promise { combine2(tail($s), tail($t), $op) });
-        }
-Now we can build F<add2> and F<mul2> from F<combine2>:
-        sub add2 { combine2(@_, sub { $_[0] + $_[1] }) }
-        sub mul2 { combine2(@_, sub { $_[0] * $_[1] }) }
-Since a major use of F<combine2> is to manufacture such functions, it
-would be more convenient for F<combine2> to do what we wanted in the
-first place.  We can turn F<combine2> into a factory that manufactures
-stream-combining functions by currying it:
-=startlisting combine2
-        sub combine2 {
-*         my $op = shift;
-*         return sub {
-*           my ($s, $t) = @_;
-            return unless $s && $t;
-            node($op->(head($s), head($t)),
-*                promise { combine2($op)->(tail($s), tail($t)) });
-*         };        
-        }
-=endlisting combine2
-Now we simply have
-        $add2 = combine2(sub { $_[0] + $_[1] });
-        $mul2 = combine2(sub { $_[0] * $_[1] });
-This may also be fractionally more efficient, since we won't have to do
-an extra function call every time we call F<add2> or F<mul2>.  F<add2>
-is the function to add the two streams, rather than a function that
-re-invokes F<combine2> in a way that adds two streams.
-If we want these functions to stick around, we can give them names, as
-above; alternatively, we can use them anonymously:
-        my $catstrs = combine2(sub { "$_[0]$_[1]" })->($s, $t);
-=test catstrs
-    use Stream qw(:all);
-    do 'combine2';
-    my $s = upto(1,4);
-    my $t = upto(5,9);
-    my $catstrs = combine2(sub { "$_[0]$_[1]" })->($s, $t);
-    for my $want (qw(15 26 37 48)) {
-        is(head($catstrs),$want);
-        $catstrs = tail($catstrs);
-    }   
-    is($catstrs,undef);
-Instead of the F<scale> function we saw earlier, we might prefer this
-curried version:
-        sub scale {
-          my $s = shift;
-          return sub {
-            my $c = shift;
-            return if $c == 0;
-            transform { $_[0] * $c } $s;
-          }
-        }
-F<scale> is now a function factory.  Instead of taking a stream and a
-number and returning a new stream, it takes a stream and manufactures
-a function that produces new streams.  C<$scale_s = scale($s)> returns
-a function for scaling C<$s>; given a numeric argument, say C<$n>,
-C<$scale_s> produces a stream that has the elements of C<$s> scaled
-by C<$n>.  For example C<$scale_s-\>(2)> returns a stream whose every
-element is twice C<$s>'s, and C<$scale_s-\>(3)> returns a stream whose
-every element is three times C<$s>'s.  If we're planning to scale the
-same stream by several different factors, it might make sense to have
-a single scale function to generate all the outputs.
-Depending on how we're using it, we might have preferred to curry the
-function arguments in the other order:
-=listing scale

(Diff truncated)
diff --git index.mdwn index.mdwn
index 2820c95..6d3eaa2 100644
--- index.mdwn
+++ index.mdwn
@@ -1 +1,5 @@
 [[!map pages="chap*"]]
+_Generated with [[ikiwiki]] and [a very simple MOD plugin](

Added a comment: I can't edit, only comment
diff --git chap02/comment_1_4bcee6d3d974bbff7578ad4184eef6c7._comment chap02/comment_1_4bcee6d3d974bbff7578ad4184eef6c7._comment
new file mode 100644
index 0000000..b4ade9d
--- /dev/null
+++ chap02/comment_1_4bcee6d3d974bbff7578ad4184eef6c7._comment
@@ -0,0 +1,8 @@
+[[!comment format=mdwn
+ username="schmonz"
+ ip=""
+ subject="I can't edit, only comment"
+ date="2013-07-07T18:25:10Z"
+ content="""
+I'm not `mjd` so I'll have to make do.

blah blah
diff --git chap03.mod chap03.mod
index 5a5a23d..3786028 100644
--- chap03.mod
+++ chap03.mod
@@ -1,5 +1,4 @@
 =note You forgot to use the word 'stub'.
       This will make many paragraphs clearer.
@@ -210,6 +209,9 @@ we try to compute C<fib(17)> three times or C<fib(16)> five times
 because the work will only be done once, and the cached results will
 be retrieved quickly when they are needed again.
+M<x^2 + x + 1 = 0>
 =section Inline Caching
 The most straightforward way to add caching to a function is to give

an example web edit
diff --git chap01.mod chap01.mod
index f0346cb..d229815 100644
--- chap01.mod
+++ chap01.mod
@@ -1,5 +1,4 @@
 =chapter Recursion and Callbacks
@@ -8,7 +7,7 @@ X<Recursion|d> is a method of solving a problem by reducing it to a
 simpler problem of the same type.
 Unlike most of the techniques in this book, recursion is already
-well-known and widely-understood.  But it will underlie several of the
+well known and widely understood.  But it will underlie several of the
 later techniques, and so we need to have a good understanding of its
 fine points.

initial commit
diff --git .gitignore .gitignore
new file mode 100644
index 0000000..eecda60
--- /dev/null
+++ .gitignore
@@ -0,0 +1 @@
diff --git chap01.mod chap01.mod
new file mode 100644
index 0000000..f0346cb
--- /dev/null
+++ chap01.mod
@@ -0,0 +1,2368 @@
+=chapter Recursion and Callbacks
+The first `advanced' technique we'll see is X<recursion>.
+X<Recursion|d> is a method of solving a problem by reducing it to a
+simpler problem of the same type.
+Unlike most of the techniques in this book, recursion is already
+well-known and widely-understood.  But it will underlie several of the
+later techniques, and so we need to have a good understanding of its
+fine points.
+=section Decimal to Binary Conversion
+Until the release of Perl 5.6.0, there was no good way to generate a
+binary numeral in Perl.  Starting in 5.6.0, you can use
+C<sprintf("%b", $dec)>, but before that the question of how to do this
+was Frequently Asked.
+Any whole number has the form M<2k+b>, where V<k> is some smaller
+whole number and V<b> is either 0 or 1.  V<b> is the final bit of the
+binary expansion.  It's easy to see whether this final bit is 0 or 1;
+just look to see whether the input number is even or odd.  The rest of
+the number is M<2k>, whose binary expansion is the same as for V<k>,
+but shifted left one place.  For example, the number M<37 = 2 * 18 +
+1>; here V<k> is 18 and V<b> is 1, so the binary expansion of 37
+(100101) is the same as that for 18 (10010), but with an extra 1 on
+the end.
+How did I compute the expansion for 37?  It is odd, so the final bit
+must be 1; the rest of the expansion will be the same as the expansion
+for 18.  How can I compute the expansion for 18?  18 is even, so its
+final bit is 0, and the rest of the expansion is the same as the
+expansion for 9.  What is the binary expansion for 9?  9 is odd, so
+its final bit is 1, and the rest of its binary expansion is the same
+as the binary expansion of 4.  We can continue in this way, until
+finally we ask about the binary expansion of 1, which of course is 1.
+This procedure will work for any number at all. To compute the binary
+expansion of a number V<n> we proceed as follows:
+=item If V<n> is 1, its binary expansion is 1,  and we may ignore the
+      rest of the procedure.  Similarly, if V<n> is 0, the expansion
+      is simply 0.
+      Otherwise:
+=item Compute V<k> and V<b> so that M<n = 2k + b> and M<b = 0 {\rm or} 1>.
+      To do this, simply divide V<n> by 2; V<k> is the quotient, and M<b>
+      is the remainder, 0 if V<n> was even, and 1 if V<n> was odd.
+=item Compute the binary expansion for V<k>, using this same method.
+      Call the result V<E>. 
+=item The binary expansion for V<n> is M<Eb>.
+Let's build a function called F<binary> that does this.    Here
+is the preamble, and step 1:
+=listing binary
+        sub binary {
+          my ($n) = @_;
+          return $n if $n == 0 || $n == 1; 
+Here is step 2:
+          my $k = int($n/2);
+          my $b = $n % 2;
+For the third step, we need to compute the binary expansion of V<k>.
+How can we do that?  It's easy, because we have a handy function for
+computing binary expansions, called F<binary>---or we will once we're
+finished writing it.  We'll call F<binary> with V<k> as its argument:
+          my $E = binary($k);
+Now the final step is a string concatenation:
+          return $E . $b;
+        }
+=endlisting binary
+=test binary 51
+        eval { require 'binary' };
+        for (0..50) {
+          my $bin = sprintf "%b", $_;
+          my $b2 = binary($_);
+          is($b2, $bin, "$_ => binary");
+        }
+This works.  For example, if you invoke C<binary(37)> you get the
+string C<100101>.
+The essential technique here was to I<reduce the problem to a
+simpler case.> We were supposed to find the binary expansion of a
+number V<n>; we discovered that this binary expansion was the
+concatenation of the binary expansion of a smaller number V<k> and a
+single bit V<b>.  Then to solve the simpler case of the same problem,
+we used the function F<binary> in its own definition.  When we
+invoke F<binary> with some number as an argument, it needs to
+compute F<binary> for a different, smaller argument, which in turn
+computes F<binary> for an even smaller argument. Eventually, the
+argument becomes 1, and F<binary> computes the trivial binary
+representation of 1 directly.   
+This final step, called the X<base case|d> of the recursion, is
+important.  If we don't consider it, our function might never
+terminate.  If, in the definition of F<binary> above, we had omitted
+the line
+          return $n if $n == 0 || $n == 1; 
+then F<binary> would have computed forever, and would never have
+produced an answer for any argument.
+=section Factorial
+Suppose you have a list of V<n> different items.  For concreteness,
+we'll suppose that these items are letters.  How
+many different orders are there for such a list?  Obviously, the
+answer depends on V<n>, so it is a function of V<n>.  This function is
+called the X<factorial function|d>.  The factorial of V<n>
+is the number of different orders for a list of V<n> different items.
+Mathematicians usually write it as a postfix M<!> mark, so that the
+factorial of V<n> is M<n!>.  They also call the different orders
+X<permutations|d> .  
+Let's compute some factorials.  Evidently, there's only one way to
+order a list of 1 item, so M<1! = 1>.  There are two permutations of a
+list of two items: C<A-B> and C<B-A>, so M<2!=2>.  A little
+pencil work will reveal that there are six permutations of three
+        C  AB        C  BA
+        A C B        B C A
+        AB  C        BA  C
+How can we be sure we didn't omit anything from the list?  It's not
+hard to come up with a method that constructs every possible ordering,
+and in R<permutations|chapter> we will see a program to list them all.
+Here is one way to do it.  We can make any list of three items by
+adding a new item to a list of two items.  We have two choices for the
+two-item list we start with: C<AB> and C<BA>.  In each case, we have
+three choices about where to put the C<C>: at the beginning, in the
+middle, or at the end. There are M<2\cdot3=6> ways to make the choices
+together, and since each choice leads to a different list of three
+items, there must be six such lists.  The left column above shows all
+the lists we got by inserting the C<C> into C<AB>, and the right
+column shows the lists we got by inserting the C<C> into C<BA>, so the
+display above is complete.
+Similarly, if we want to know how many permutations there are of four
+items, we can figure it out the same way.  There are six different
+lists of three items, and there are four positions that we could
+insert the fourth item into each of the lists, for a total of
+M<6\cdot4=24> total orders:
+        D  ABC    D  ACB    D  BAC    D  BCA    D  CAB    D  CBA
+        A D BC    A D CB    B D AC    B D CA    C D AB    C D BA
+        AB D C    AC D B    BA D C    BC D A    CA D B    CB D A
+        ABC  D    ACB  D    BAC  D    BCA  D    CAB  D    CBA  D
+Now we'll write a function to compute, for any V<n>, how many
+permutations there are of a list of V<n> elements. 
+%%  Why would we care?
+%% Because lists are fundamental to computer programming and we need to
+%% know many basic facts about them.  
+%% Analogy with sin() and cos()
+We've just seen that if we know the number of possible permutations of
+M<n-1> things, we can compute the number of permutations of V<n>
+things.  To make a list of V<n> things, we take one of the M<(n-1)!>

(Diff truncated)