X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=week7.mdwn;h=65d528c45b0f13bf068fc31df047c9578f75ee6d;hp=fe9bedb8aec9745285f783b97f438381de6a2015;hb=e8a135f7bc1a0aa4118703baa78ec8d2ea9db490;hpb=505704532a701f9e2ffad2ab7af9e028fdabef3f diff --git a/week7.mdwn b/week7.mdwn index fe9bedb8..65d528c4 100644 --- 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 - `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 @@ -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`. - 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 @@ -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 -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 -Theory](/advanced_notes/monads_in_category_theory). +Theory](/advanced_topics/monads_in_category_theory). See also . 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.--> -* [Daniel Friedman. A Schemer's View of Monads](/schemersviewofmonads.ps): from 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 -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. @@ -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. -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 = @@ -574,13 +575,13 @@ Monad outlook ------------- 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. -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]]##