X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=topics%2F_week5_system_F.mdwn;h=539017ea0d35488b5810cdb19d4fa667cecedd5a;hp=a7b4bb912333577b0afea0cb4f5ec855da96d566;hb=ff8ade136061e84890099464dc05206a8ecaeb98;hpb=c98d4e2d9d0c85b16ac707323031114f2a3db1aa
diff --git a/topics/_week5_system_F.mdwn b/topics/_week5_system_F.mdwn
index a7b4bb91..539017ea 100644
--- a/topics/_week5_system_F.mdwn
+++ b/topics/_week5_system_F.mdwn
@@ -1,23 +1,13 @@
[[!toc levels=2]]
-# System F and recursive types
+# System F: the polymorphic lambda calculus
-In the simply-typed lambda calculus, we write types like σ
--> τ
. This looks like logical implication. We'll take
-that resemblance seriously when we discuss the Curry-Howard
-correspondence. In the meantime, note that types respect modus
-ponens:
-
-
-Expression Type Implication ------------------------------------ -fn α -> β α ⊃ β -arg α α ------- ------ -------- -(fn arg) β β -- -The implication in the right-hand column is modus ponens, of course. +The simply-typed lambda calculus is beautifully simple, but it can't +even express the predecessor function, let alone full recursion. And +we'll see shortly that there is good reason to be unsatisfied with the +simply-typed lambda calculus as a way of expressing natural language +meaning. So we will need to get more sophisticated about types. The +next step in that journey will be to consider System F. System F was discovered by Girard (the same guy who invented Linear Logic), but it was independently proposed around the same time by @@ -44,16 +34,16 @@ Then System F can be specified as follows: In the definition of the types, "`c`" is a type constant. Type constants play the role in System F that base types play in the simply-typed lambda calculus. So in a lingusitics context, type -constants might include `e` and `t`. "α" is a type variable. The -tick mark just indicates that the variable ranges over types rather -than over values; in various discussion below and later, type variables -can be distinguished by using letters from the greek alphabet -(α, β, etc.), or by using capital roman letters (X, Y, -etc.). "`Ï1 -> Ï2`" is the type of a function from expressions of -type `Ï1` to expressions of type `Ï2`. And "`âα.Ï`" is called a -universal type, since it universally quantifies over the type variable -`'a`. You can expect that in `âα.Ï`, the type `Ï` will usually -have at least one free occurrence of `α` somewhere inside of it. +constants might include `e` and `t`. "α" is a type variable. In +various discussions, type variables are distinguished by using letters +from the greek alphabet (α, β, etc.), as we do here, or by +using capital roman letters (X, Y, etc.), or by adding a tick mark +(`'a`, `'b`, etc.), as in OCaml. "`Ï1 -> Ï2`" is the type of a +function from expressions of type `Ï1` to expressions of type `Ï2`. +And "`âα.Ï`" is called a universal type, since it universally +quantifies over the type variable `α`. You can expect that in +`âα.Ï`, the type `Ï` will usually have at least one free occurrence of +`α` somewhere inside of it. In the definition of the expressions, we have variables "`x`" as usual. Abstracts "`λx:Ï.e`" are similar to abstracts in the simply-typed lambda @@ -72,24 +62,19 @@ variables. So in the expression
Λ Î± (λ x:α. x)
the Λ
binds the type variable `α` that occurs in
-the λ
abstract. Of course, as long as type
-variables are carefully distinguished from expression variables (by
-tick marks, Grecification, or capitalization), there is no need to
-distinguish expression abstraction from type abstraction by also
-changing the shape of the lambda.
-
-The expression immediately below is a polymorphic version of the
-identity function. It defines one general identity function that can
-be adapted for use with expressions of any type. In order to get it
-ready to apply this identity function to, say, a variable of type
-boolean, just do this:
+the λ
abstract.
+
+This expression is a polymorphic version of the identity function. It
+defines one general identity function that can be adapted for use with
+expressions of any type. In order to get it ready to apply this
+identity function to, say, a variable of type boolean, just do this:
(Λ Î± (λ x:α. x)) [t]
This type application (where `t` is a type constant for Boolean truth
values) specifies the value of the type variable `α`. Not
-surprisingly, the type of this type application is a function from
-Booleans to Booleans:
+surprisingly, the type of the expression that results from this type
+application is a function from Booleans to Booleans:
((Λα (λ x:α . x)) [t]): (b->b)
@@ -104,20 +89,17 @@ instantiated as a function from expresions of type `α` to expressions
of type `α`. In general, then, the type of the uninstantiated
(polymorphic) identity function is
-(Λα (λx:α . x)): (∀α. α-α)
+(Λα (λx:α . x)): (∀α. α->α)
Pred in System F
----------------
We saw that the predecessor function couldn't be expressed in the
simply-typed lambda calculus. It *can* be expressed in System F,
-however. Here is one way, coded in
-[[Benjamin Pierce's type-checker and evaluator for
-System F|http://www.cis.upenn.edu/~bcpierce/tapl/index.html]] (the
-relevant evaluator is called "fullpoly"):
+however. Here is one way:
- N = âα.(α->α)->α->α;
- Pair = (N->N->N)->N;
+ let N = âα.(α->α)->α->α in
+ let Pair = (N->N->N)->N in
let zero = Îα. λs:α->α. λz:α. z in
let fst = λx:N. λy:N. x in
@@ -129,12 +111,14 @@ relevant evaluator is called "fullpoly"):
pre (suc (suc (suc zero)));
-We've truncated the names of "suc(c)" and "pre(d)", since those are
-reserved words in Pierce's system. Note that in this code, there is
-no typographic distinction between ordinary lambda and type-level
-lambda, though the difference is encoded in whether the variables are
-lower case (for ordinary lambda) or upper case (for type-level
-lambda).
+[If you want to run this code in
+[[Benjamin Pierce's type-checker and evaluator for
+System F|http://www.cis.upenn.edu/~bcpierce/tapl/index.html]], the
+relevant evaluator is called "fullpoly", and you'll need to
+truncate the names of "suc(c)" and "pre(d)", since those are
+reserved words in Pierce's system.]
+
+Exercise: convince yourself that `zero` has type `N`.
The key to the extra expressive power provided by System F is evident
in the typing imposed by the definition of `pre`. The variable `n` is