various cleanup

[lambda.git] / week7.mdwn

diff --git a/week7.mdwn b/week7.mdwn
index fe9bedb..65d528c 100644 (file)
--- a/week7.mdwn
+++ b/week7.mdwn
@@ -378,7 +378,9 @@ them from hurting the people that use them or themselves.
        The parentheses is the magic for telling OCaml that the
        function to be defined (in this case, the name of the function
        is `>>=`, pronounced "bind") is an infix operator, so we write
        The parentheses is the magic for telling OCaml that the
        function to be defined (in this case, the name of the function
        is `>>=`, pronounced "bind") is an infix operator, so we write

-       `u >>= f` or equivalently `( >>= ) u f` instead of `>>= u f`. Now:
+       `u >>= f` or equivalently `( >>= ) u f` instead of `>>= u
+       f`. Now, for a less trivial instance of a function from `int`s
+       to `int option`s:

 
                # unit 2;;
                - : int option = Some 2
 
                # unit 2;;
                - : int option = Some 2


@@ -405,7 +407,9 @@ them from hurting the people that use them or themselves.
        If you don't understand why the lambda form is necessary (the "fun
        x" part), you need to look again at the type of `bind`.
 
        If you don't understand why the lambda form is necessary (the "fun
        x" part), you need to look again at the type of `bind`.
 

-       Some examples of associativity in the option monad:
+       Some examples of associativity in the option monad (bear in
+       mind that in the Ocaml implementation of integer division, 2/3
+       evaluates to zero, throwing away the remainder):

 
                # Some 3 >>= unit >>= unit;; 
                - : int option = Some 3
 
                # Some 3 >>= unit >>= unit;; 
                - : int option = Some 3


@@ -447,14 +451,13 @@ More details about monads
 If you studied algebra, you'll remember that a *monoid* is an
 associative operation with a left and right identity.  For instance,
 the natural numbers along with multiplication form a monoid with 1
 If you studied algebra, you'll remember that a *monoid* is an
 associative operation with a left and right identity.  For instance,
 the natural numbers along with multiplication form a monoid with 1

-serving as the left and right identity.  That is, temporarily using
-`*` to mean arithmetic multiplication, `1 * u == u == u * 1` for all
+serving as the left and right identity.  That is, `1 * u == u == u * 1` for all

 `u`, and `(u * v) * w == u * (v * w)` for all `u`, `v`, and `w`.  As
 presented here, a monad is not exactly a monoid, because (unlike the
 arguments of a monoid operation) the two arguments of the bind are of
 different types.  But it's possible to make the connection between
 monads and monoids much closer. This is discussed in [Monads in Category
 `u`, and `(u * v) * w == u * (v * w)` for all `u`, `v`, and `w`.  As
 presented here, a monad is not exactly a monoid, because (unlike the
 arguments of a monoid operation) the two arguments of the bind are of
 different types.  But it's possible to make the connection between
 monads and monoids much closer. This is discussed in [Monads in Category

-Theory](/advanced_notes/monads_in_category_theory).
+Theory](/advanced_topics/monads_in_category_theory).

 See also <http://www.haskell.org/haskellwiki/Monad_Laws>.
 
 Here are some papers that introduced monads into functional programming:
 See also <http://www.haskell.org/haskellwiki/Monad_Laws>.
 
 Here are some papers that introduced monads into functional programming:


@@ -476,12 +479,10 @@ invited talk, *19'th Symposium on Principles of Programming Languages*, ACM Pres
        Monads increase the ease with which programs may be modified. They can mimic the effect of impure features such as exceptions, state, and continuations; and also provide effects not easily achieved with such features. The types of a program reflect which effects occur.
        The first section is an extended example of the use of monads. A simple interpreter is modified to support various extra features: error messages, state, output, and non-deterministic choice. The second section describes the relation between monads and continuation-passing style. The third section sketches how monads are used in a compiler for Haskell that is written in Haskell.-->
 
        Monads increase the ease with which programs may be modified. They can mimic the effect of impure features such as exceptions, state, and continuations; and also provide effects not easily achieved with such features. The types of a program reflect which effects occur.
        The first section is an extended example of the use of monads. A simple interpreter is modified to support various extra features: error messages, state, output, and non-deterministic choice. The second section describes the relation between monads and continuation-passing style. The third section sketches how monads are used in a compiler for Haskell that is written in Haskell.-->
 

-*      [Daniel Friedman. A Schemer's View of Monads](/schemersviewofmonads.ps): from <https://www.cs.indiana.edu/cgi-pub/c311/doku.php?id=home> but the link above is to a local copy.
-
-There's a long list of monad tutorials on the [[Offsite Reading]] page. Skimming the titles makes me laugh.
+There's a long list of monad tutorials on the [[Offsite Reading]] page. (Skimming the titles is somewhat amusing.) If you are confused by monads, make use of these resources. Read around until you find a tutorial pitched at a level that's helpful for you.

 
 In the presentation we gave above---which follows the functional programming conventions---we took `unit`/return and `bind` as the primitive operations. From these a number of other general monad operations can be derived. It's also possible to take some of the others as primitive. The [Monads in Category
 
 In the presentation we gave above---which follows the functional programming conventions---we took `unit`/return and `bind` as the primitive operations. From these a number of other general monad operations can be derived. It's also possible to take some of the others as primitive. The [Monads in Category

-Theory](/advanced_notes/monads_in_category_theory) notes do so, for example.
+Theory](/advanced_topics/monads_in_category_theory) notes do so, for example.

 
 Here are some of the other general monad operations. You don't have to master these; they're collected here for your reference.
 
 
 Here are some of the other general monad operations. You don't have to master these; they're collected here for your reference.
 


@@ -499,7 +500,7 @@ that is:
 
 You could also do `bind u (fun x -> v)`; we use the `_` for the function argument to be explicit that that argument is never going to be used.
 
 
 You could also do `bind u (fun x -> v)`; we use the `_` for the function argument to be explicit that that argument is never going to be used.
 

-The `lift` operation we asked you to define for last week's homework is a common operation. The second argument to `bind` converts `'a` values into `'b m` values---that is, into instances of the monadic type. What if we instead had a function that merely converts `'a` values into `'b` values, and we want to use it with our monadic type. Then we "lift" that function into an operation on the monad. For example:
+The `lift` operation we asked you to define for last week's homework is a common operation. The second argument to `bind` converts `'a` values into `'b m` values---that is, into instances of the monadic type. What if we instead had a function that merely converts `'a` values into `'b` values, and we want to use it with our monadic type? Then we "lift" that function into an operation on the monad. For example:

 
        # let even x = (x mod 2 = 0);;
        val g : int -> bool = <fun>
 
        # let even x = (x mod 2 = 0);;
        val g : int -> bool = <fun>


@@ -574,13 +575,13 @@ Monad outlook
 -------------
 
 We're going to be using monads for a number of different things in the
 -------------
 
 We're going to be using monads for a number of different things in the

-weeks to come.  The first main application will be the State monad,
+weeks to come.  One major application will be the State monad,

 which will enable us to model mutation: variables whose values appear
 to change as the computation progresses.  Later, we will study the
 Continuation monad.
 
 which will enable us to model mutation: variables whose values appear
 to change as the computation progresses.  Later, we will study the
 Continuation monad.
 

-In the meantime, we'll look at several linguistic applications for monads, based
-on what's called the *reader monad*.
+But first, we'll look at several linguistic applications for monads, based
+on what's called the *Reader monad*.

 
 ##[[Reader monad]]##
 
 
 ##[[Reader monad]]##