X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=week6.mdwn;h=2a4586a01c9b36c546e3aeacbb599a14c3e581d8;hp=e244af75eaf6a74feebf26a26c96c07c9537e8f0;hb=8fa88810958724fdd34b39f978adfd733c58ca44;hpb=93d67277339f0aed8184a14bbc35ec5060a0c031

diff --git a/week6.mdwn b/week6.mdwn
index e244af75..2a4586a0 100644
--- a/week6.mdwn
+++ b/week6.mdwn
@@ -1,7 +1,36 @@
 [[!toc]]
 
-Types, OCaml
-------------
+Polymorphic Types and System F
+------------------------------
+
+[Notes still to be added. Hope you paid attention during seminar.]
+
+<!--
+
+8.	The simply-typed lambda calculus<p>
+9.	Parametric polymorphism, System F, "type inference"<p>
+
+1.	Product or record types, e.g. pairs and triples
+2.	Sum or variant types; tagged or "disjoint" unions
+3.	Maybe/option types; representing "out-of-band" values
+10.	[Phil/ling application] inner/outer domain semantics for positive free logic
+	<http://philosophy.ucdavis.edu/antonelli/papers/pegasus-JPL.pdf>
+11.	[Phil/ling application] King vs Schiffer in King 2007, pp 103ff. [which paper?](http://rci.rutgers.edu/~jeffreck/pub.php)
+12. [Phil/ling application] King and Pryor on that clauses, predicates vs singular property-designators
+	Russell On Denoting / Kaplan on plexy
+13.	Possible excursion: [Frege's "On Concept and Object"](http://www.persiangig.com/pages/download/?dl=http://sahmir.persiangig.com/document/Frege%27s%20Articles/On%20Concept%20And%20object%20%28Jstore%29.pdf)<p>
+
+6.	Inductive types (numbers, lists)
+
+5.	Unit type
+4.	Zero/bottom types
+7.	"Pattern-matching" or type unpacking<p>
+
+-->
+
+
+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 +73,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 +239,8 @@ Now consider the following variations in behavior:
     # 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:
@@ -249,6 +278,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
 
 
@@ -268,5 +299,5 @@ diverge. As we consider richer languages, thunks will become more useful.
 Towards Monads
 --------------
 
-This has now been moved to [its own page](/towards_monads).
+This has now been moved to the start of [[week7]].