X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=topics%2Fweek9_monad_transformers.mdwn;h=c8133e2041d05ab7633843fa08bd705e664c351a;hp=6d8b5b74bc953aa7c0285d937e8b2d8158c058cf;hb=a0eb18e702862266fdc8a7d935d6cc33821fdf4a;hpb=b35732e3e34bb499d0b7775b81632d40d7e3876e

diff --git a/topics/week9_monad_transformers.mdwn b/topics/week9_monad_transformers.mdwn
index 6d8b5b74..c8133e20 100644
--- a/topics/week9_monad_transformers.mdwn
+++ b/topics/week9_monad_transformers.mdwn
@@ -155,24 +155,24 @@ Here's an example wrapping Option around List, and vice versa:
 
 	# module LO = Monad.List.T(Monad.Option);;
 	# module OL = Monad.Option.P(Monad.List);; (* we use the `.P` transformer to hoist List's ++ operation *)
-	# OL.(run (mzero ++ mid 20 >>= fun i -> mid (i+10)));;
+	# OL.(run (mzero ++ mid 20 >>= fun x -> mid (x+10) ));;
 	- : int OL.result = [Some 30]
 
 When List is on the inside, the failed results just got dropped and the computation proceeds without them.
 
-	# LO.(run (hoist Monad.Option.mzero ++ mid 20 >>= fun i -> mid (i+10)));;
+	# LO.(run (hoist Monad.Option.mzero ++ mid 20 >>= fun x -> mid (x+10) ));;
 	- : int LO.result = None
 
 On the other hand, when Option is on the inside, as in LO, failures (which we again represent by `mzero`s from the Option monad, not the List monad's own `mzero`; but here since it's the inner monad we need to `hoist Monad.Option.mzero`) abort the whole computation. (If you instead used the List monad's `mzero`, it'd be ignored by `++` and you'd end with just `Some [30]`.)
 
-This is fun. Notice the difference it makes whether the second `++` is native to the outer `Monad.List`, or whether it's the inner `Monad.List`'s `++` hoisted into the outer wrapper:
+This is fun. Here is a List around a List. Notice the difference it makes whether the second `++` is native to the outer `Monad.List`, or whether it's the inner `Monad.List`'s `++` hoisted into the outer wrapper:
 
 	# module LL = Monad.List.T(Monad.List);;
 
 	# LL.(run(mid 1 ++ mid 2 >>= fun x -> mid x ++ mid (10*x) ));;
 	- : int LL.result = \[[1; 10; 2; 20]]
-	#  LL.(run(mid 1 ++ mid 2 >>= fun x -> hoist Monad.List.(mid x ++ mid (10*x) )));;
-	- : int LL.result = \[[1; 2]; [1; 20]; [10; 2]; [10; 20]]
+	#  LL.(run(mid 1 ++ mid 2 >>= fun x -> hoist Monad.List.(mid x ++ mid (10*x)) ));;
+	- : int LL.result = [[1; 2]; [1; 20]; [10; 2]; [10; 20]]
 
 <!--
 	# EL.(run((++) (throw "bye") (mid 20) >>= fun i -> mid (i+10)));;
@@ -190,7 +190,8 @@ This is fun. Notice the difference it makes whether the second `++` is native to
 Further Reading
 ---------------
 
-*	This is excellent, everyone should read: [Monad Transformers Step by Step](http://www.grabmueller.de/martin/www/pub/Transformers.pdf)
+*	This is excellent, everyone should read: [Monad Transformers Step by Step](http://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf)
+<!-- also http://web.archive.org/web/20140711174905/http://www.grabmueller.de/martin/www/pub/Transformers.pdf -->
 
 *	Read Part III of [All About Monads](http://web.archive.org/web/20071106232016/haskell.org/all_about_monads/html/introIII.html). This link is to an archived version, the main link to haskell.org seems to be broken. Some but not all of this site has been [absorbed into the Haskell wikibook](http://en.wikibooks.org/wiki/Haskell/Monad_transformers).