From b32978921e06dfeae7807a2aa8a968647de9e113 Mon Sep 17 00:00:00 2001 From: Jim Pryor Date: Tue, 30 Nov 2010 14:57:07 -0500 Subject: [PATCH] week11: add exceptions Signed-off-by: Jim Pryor --- week11.mdwn | 186 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 185 insertions(+), 1 deletion(-) diff --git a/week11.mdwn b/week11.mdwn index fb6cf1f8..9fc1d424 100644 --- a/week11.mdwn +++ b/week11.mdwn @@ -250,7 +250,8 @@ We haven't given you a real implementation of the tree zipper, but only a sugges * Huet, Gerard. ["Functional Pearl: The Zipper"](http://www.st.cs.uni-sb.de/edu/seminare/2005/advanced-fp/docs/huet-zipper.pdf) Journal of Functional Programming 7 (5): 549-554, September 1997. * As always, [Oleg](http://okmij.org/ftp/continuations/Continuations.html#zipper) takes this a few steps deeper. -##Same-fringe using a tree zipper## + +##Same-fringe using a zipper-based coroutine## Recall back in [[Assignment4]], we asked you to enumerate the "fringe" of a leaf-labeled tree. Both of these trees (here I *am* drawing the labels in the diagram): @@ -469,6 +470,189 @@ If you want to read more about these kinds of threads, here are some links: The way we built cooperative threads here crucially relied on two heavyweight tools. First, it relied on our having a data structure (the tree zipper) capable of being a static snapshot of where we left off in the tree whose fringe we're enumerating. Second, it relied on our using mutable reference cells so that we could update what the current snapshot (that is, tree zipper) was, so that the next invocation of the `next_leaf` function could start up again where the previous invocation left off. +It's possible to build cooperative threads without using those tools, however. Some languages have a native syntax for them. Here's how we'd write the same-fringe solution above using native coroutines in the language Lua: + + > function fringe_enumerator (tree) + if tree.leaf then + coroutine.yield (tree.leaf) + else + fringe_enumerator (tree.left) + fringe_enumerator (tree.right) + end + end + + > function same_fringe (tree1, tree2) + local next1 = coroutine.wrap (fringe_enumerator) + local next2 = coroutine.wrap (fringe_enumerator) + local function loop (leaf1, leaf2) + if leaf1 or leaf2 then + return leaf1 == leaf2 and loop( next1(), next2() ) + elseif not leaf1 and not leaf2 then + return true + else + return false + end + end + return loop (next1(tree1), next2(tree2)) + end + + > return same_fringe ( {leaf=1}, {leaf=2}) + false + + > return same_fringe ( {leaf=1}, {leaf=1}) + true + + > return same_fringe ( {left = {leaf=1}, right = {left = {leaf=2}, right = {leaf=3}}}, + {left = {left = {leaf=1}, right = {leaf=2}}, right = {leaf=3}} ) + true + +We're going to think about the underlying principles to this execution pattern, and instead learn how to implement it from scratch---without necessarily having zippers to rely on. + + +##Exceptions and Aborts## + +To get a better understanding of how that execution patter works, we'll add yet a second execution pattern to our plate, and then think about what they have in common. + +While writing OCaml code, you've probably come across errors. In fact, you've probably come across errors of two sorts. One sort of error comes about when you've got syntax errors or type errors and the OCaml interpreter isn't even able to understand your code: + + # let lst = [1; 2] in + "a" :: lst;; + Error: This expression has type int list + but an expression was expected of type string list + +But you may also have encountered other kinds of error, that arise while your program is running. For example: + + # 1/0;; + Exception: Division_by_zero. + # List.nth [1;2] 10;; + Exception: Failure "nth". + +These "Exceptions" are **run-time errors**. OCaml will automatically detect some of them, like when you attempt to divide by zero. Other exceptions are *raised* by code. For instance, here is the implementation of `List.nth`: + + let nth l n = + if n < 0 then invalid_arg "List.nth" else + let rec nth_aux l n = + match l with + | [] -> failwith "nth" + | a::l -> if n = 0 then a else nth_aux l (n-1) + in nth_aux l n + +Notice the two clauses `invalid_arg "List.nth"` and `failwith "nth"`. These are two helper functions which are shorthand for: + + raise (Invalid_argument "List.nth");; + raise (Failure "nth");; + +where `Invalid_argument "List.nth"` is a value of type `exn`, and so too `Failure "nth"`. When you have some value `ex` of type `exn` and evaluate the expression: + + raise ex + +the effect is for the program to immediately stop without evaluating any further code: + + # let xcell = ref 0;; + val xcell : int ref = {contents = 0} + # let ex = Failure "test" + in let _ = raise ex + in xcell := 1;; + Exception: Failure "test". + # !xcell;; + - : int = 0 + +Notice that the line `xcell := 1` was never evaluated, so the contents of `xcell` are still `0`. + +I said when you evaluate the expression: + + raise ex + +the effect is for the program to immediately stop. That's not exactly true. You can also programmatically arrange to *catch* errors, without the program necessarily stopping. In OCaml we do that with a `try ... with PATTERN -> ...` construct, analogous to the `match ... with PATTERN -> ...` construct: + + # let foo x = + try + if x = 1 then 10 + else if x = 2 then raise (Failure "two") + else raise (Failure "three") + with Failure "two" -> 20 + ;; + val foo : int -> int = + # foo 1;; + - : int = 10 + # foo 2;; + - : int = 20 + # foo 3;; + Exception: Failure "three". + +Notice what happens here. If we call `foo 1`, then the code between `try` and `with` evaluates to `10`, with no exceptions being raised. That then is what the entire `try ... with ...` block evaluates to; and so too what `foo 1` evaluates to. If we call `foo 2`, then the code between `try` and `with` raises an exception `Failure "two"`. The pattern in the `with` clause matches that exception, so we get instead `20`. If we call `foo 3`, we again raise an exception. This exception isn't matched by the `with` block, so it percolates up to the top of the program, and then the program immediately stops. + +So what I should have said is that when you evaluate the expression: + + raise ex + +*and that exception is never caught*, then the effect is for the program to immediately stop. + +Of course, it's possible to handle errors in other ways too. There's no reason why the implementation of `List.nth` *had* to do things this way. They might instead have returned `Some a` when the list had an nth member `a`, and `None` when it does not. But it's pedagogically useful for us to think about this pattern now. + +When an exception is raised, it percolates up through the code that called it, until it finds a surrounding `try ... with ...` that matches it. That might not be the first `try ... with ...` that it encounters. For example: + + # try + try + raise (Failure "blah") + with Failure "fooey" -> 10 + with Failure "blah" -> 20;; + - : int = 20 + +The matching `try ... with ...` block need not *lexically surround* the site where the error was raised: + + # let foo b x = + try + b x + with Failure "blah" -> 20 + in let bar x = + raise (Failure "blah") + in foo bar 0;; + - : int = 20 + +Here we call `foo bar 0`, and `foo` in turn calls `bar 0`, and `bar` raises the exception. Since there's no matching `try ... with ...` block in `bar`, we percolate back up the history of *who called this function?* and find a matching `try ... with ...` block in `foo`. This catches the error and so then the `try ... with ...` block in `foo` that called `bar` in the first place will evaluate to `20`. + +OK, now this exception-handling apparatus does exemplify the second execution pattern we want to focus on. But it may bring it into clearer focus if we simplify the pattern even more. Imagine we could write code like this instead: + + # let foo x = + try + (if x = 1 then 10 + else abort 20) + 1 + end + ;; + +then if we called `foo 1`, we'd get the result `11`. If we called `foo 2`, on the other hand, we'd get `20` (note, not `21`). This exemplifies the same interesting "jump out of this part of the code" behavior that the `try ... raise ... with ...` code does, but without the details of matching which exception was raised, and handling the exception to produce a new result. + +Many programming languages have this simplified exceution pattern, either instead of or alongside a `try ... with ...`-like pattern. In Lua and many other languages, `abort` is instead called `return`. The preceding example would be written: + + > function foo(x) + local value + if (x == 1) then + value = 10 + else + return 20 + end + return value + 1 + end + + > return foo(1) + 11 + + > return foo(2) + 20 + +Okay, so that's our second execution pattern. + +##What do these have in common?## + + + + + + + +-------------------------------------- + In coming weeks, we'll learn about a different way to create threads, that relies on **continuations** rather than on those two tools. All of these tools are inter-related. As Oleg says, "Zipper can be viewed as a delimited continuation reified as a data structure." These different tools are also inter-related with monads. Many of these tools can be used to define the others. We'll explore some of the connections between them in the remaining weeks, but we encourage you to explore more. -- 2.11.0