week6 tweaks

[lambda.git] / week6.mdwn

diff --git a/week6.mdwn b/week6.mdwn
index e244af7..f1f5b42 100644 (file)
--- a/week6.mdwn
+++ b/week6.mdwn
@@ -1,7 +1,13 @@
 [[!toc]]
 
 [[!toc]]
 

-Types, OCaml
-------------
+Polymorphic Types and System F
+------------------------------
+
+[Notes still to be added. Hope you paid attention during seminar.]
+
+
+Types in OCaml
+--------------

 
 OCaml has type inference: the system can often infer what the type of
 an expression must be, based on the type of other known expressions.
 
 OCaml has type inference: the system can often infer what the type of
 an expression must be, based on the type of other known expressions.


@@ -44,9 +50,9 @@ Oh well.
 `==` operator instead of the `=` operator. Later when we discuss mutation,
 we'll discuss the difference between these two equality operations.
 Scheme has a similar pair, which they name `eq?` and `equal?`. In Python,
 `==` operator instead of the `=` operator. Later when we discuss mutation,
 we'll discuss the difference between these two equality operations.
 Scheme has a similar pair, which they name `eq?` and `equal?`. In Python,

-these are `is` and `==` respectively. It's unfortunate that OCaml uses `==` for the opposite operation that Python and many other languages use it for. In any case, OCaml will understand `(f) == f` even though it doesn't understand
+these are `is` and `==` respectively. It's unfortunate that OCaml uses `==` for the opposite operation that Python and many other languages use it for. In any case, OCaml will accept `(f) == f` even though it doesn't accept

 `(f) = f`. However, don't expect it to figure out in general when two functions
 `(f) = f`. However, don't expect it to figure out in general when two functions

-are identical. (That question is not Turing computable.)
+are equivalent. (That question is not Turing computable.)

 
        # (f) == (fun x -> x + 3);;
        - : bool = false
 
        # (f) == (fun x -> x + 3);;
        - : bool = false


@@ -210,8 +216,8 @@ Now consider the following variations in behavior:
     # test ();;
     <Infinite loop, need to control-c to interrupt>
 
     # test ();;
     <Infinite loop, need to control-c to interrupt>
 

-We can use functions that take arguments of type unit to control
-execution.  In Scheme parlance, functions on the unit type are called
+We can use functions that take arguments of type `unit` to control
+execution.  In Scheme parlance, functions on the `unit` type are called

 *thunks* (which I've always assumed was a blend of "think" and "chunk").
 
 Question: why do thunks work? We know that `blackhole ()` doesn't terminate, so why do expressions like:
 *thunks* (which I've always assumed was a blend of "think" and "chunk").
 
 Question: why do thunks work? We know that `blackhole ()` doesn't terminate, so why do expressions like:


@@ -249,6 +255,8 @@ Here are some exercises that may help better understand this. Figure out what is
 
        let rec blackhole x = blackhole x in 2 :: (blackhole 1);;
 
 
        let rec blackhole x = blackhole x in 2 :: (blackhole 1);;
 

+By the way, what's the type of this:
+

        let rec blackhole (x:'a) : 'a = blackhole x in blackhole
 
 
        let rec blackhole (x:'a) : 'a = blackhole x in blackhole