ass5: prime lift,bind,add

[lambda.git] / assignment5.mdwn

diff --git a/assignment5.mdwn b/assignment5.mdwn
index 61096c4..5a2a488 100644 (file)
--- a/assignment5.mdwn
+++ b/assignment5.mdwn
@@ -35,38 +35,38 @@ Types and OCaml
 
 2.     Throughout this problem, assume that we have
 
-               let rec omega x = omega x;;
+               let rec blackhole x = blackhole x;;
 
        All of the following are well-typed.
        Which ones terminate?  What are the generalizations?
 
-               omega;;
+               blackhole;;
 
-               omega ();;
+               blackhole ();;
 
-               fun () -> omega ();;
+               fun () -> blackhole ();;
 
-               (fun () -> omega ()) ();;
+               (fun () -> blackhole ()) ();;
 
-               if true then omega else omega;;
+               if true then blackhole else blackhole;;
 
-               if false then omega else omega;;
+               if false then blackhole else blackhole;;
 
-               if true then omega else omega ();;
+               if true then blackhole else blackhole ();;
 
-               if false then omega else omega ();;
+               if false then blackhole else blackhole ();;
 
-               if true then omega () else omega;;
+               if true then blackhole () else blackhole;;
 
-               if false then omega () else omega;;
+               if false then blackhole () else blackhole;;
 
-               if true then omega () else omega ();;
+               if true then blackhole () else blackhole ();;
 
-               if false then omega () else omega ();;
+               if false then blackhole () else blackhole ();;
 
-               let _ = omega in 2;;
+               let _ = blackhole in 2;;
 
-               let _ = omega () in 2;;
+               let _ = blackhole () in 2;;
 
 3.     This problem is to begin thinking about controlling order of evaluation.
 The following expression is an attempt to make explicit the
@@ -104,15 +104,15 @@ and that "bool" is any boolean.  Then we can try the following:
 
        However,
 
-               let rec omega x = omega x in
-               if true then omega else omega ();;
+               let rec blackhole x = blackhole x in
+               if true then blackhole else blackhole ();;
 
        terminates, but
 
-               let rec omega x = omega x in
+               let rec blackhole x = blackhole x in
                let b = true in
-               let y = omega in
-               let n = omega () in
+               let y = blackhole in
+               let n = blackhole () in
                match b with true -> y | false -> n;;
 
        does not terminate.  Incidentally, `match bool with true -> yes |
@@ -127,19 +127,19 @@ Baby monads
 -----------
 
 Read the lecture notes for week 6, then write a
-function `lift` that generalized the correspondence between + and
-`add`: that is, `lift` takes any two-place operation on integers
+function `lift'` that generalized the correspondence between + and
+`add'`: that is, `lift'` takes any two-place operation on integers
 and returns a version that takes arguments of type `int option`
 instead, returning a result of `int option`.  In other words,
-`lift` will have type
+`lift'` will have type
 
        (int -> int -> int) -> (int option) -> (int option) -> (int option)
 
-so that `lift (+) (Some 3) (Some 4)` will evalute to `Some 7`.  
+so that `lift' (+) (Some 3) (Some 4)` will evalute to `Some 7`.  
 Don't worry about why you need to put `+` inside of parentheses.
-You should make use of `bind` in your definition of `lift`:
+You should make use of `bind'` in your definition of `lift'`:
 
-       let bind (x: int option) (f: int -> (int option)) =
+       let bind' (x: int option) (f: int -> (int option)) =
                match x with None -> None | Some n -> f n;;