From 8a7f214bdd5696c0cc2fd9f0926aeae0a6bbbcfb Mon Sep 17 00:00:00 2001 From: Jim Pryor Date: Mon, 1 Nov 2010 02:13:21 -0400 Subject: [PATCH] week6 tweaks Signed-off-by: Jim Pryor --- week6.mdwn | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/week6.mdwn b/week6.mdwn index e244af75..f1f5b42a 100644 --- a/week6.mdwn +++ b/week6.mdwn @@ -1,7 +1,13 @@ [[!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. @@ -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, -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 -are identical. (That question is not Turing computable.) +are equivalent. (That question is not Turing computable.) # (f) == (fun x -> x + 3);; - : bool = false @@ -210,8 +216,8 @@ Now consider the following variations in behavior: # test ();; -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: @@ -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);; +By the way, what's the type of this: + let rec blackhole (x:'a) : 'a = blackhole x in blackhole -- 2.11.0