author Chris Thu, 26 Feb 2015 18:24:58 +0000 (13:24 -0500) committer Chris Thu, 26 Feb 2015 18:24:58 +0000 (13:24 -0500)

index 4bde11e..4517509 100644 (file)
@@ -51,16 +51,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
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
-(&alpha;, &beta;, 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 (&alpha;, &beta;, 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 `&alpha;`.  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

In the definition of the expressions, we have variables "`x`" as usual.
Abstracts "`λx:τ.e`" are similar to abstracts in the simply-typed lambda
@@ -79,24 +79,19 @@ variables.  So in the expression
<code>&Lambda; α (&lambda; x:α. x)</code>

the <code>&Lambda;</code> binds the type variable `α` that occurs in
<code>&Lambda; α (&lambda; x:α. x)</code>

the <code>&Lambda;</code> binds the type variable `α` that occurs in
-the <code>&lambda;</code> 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 <code>&lambda;</code> 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:

<code>(&Lambda; α (&lambda; x:α. x)) [t]</code>

This type application (where `t` is a type constant for Boolean truth
values) specifies the value of the type variable `α`.  Not

<code>(&Lambda; α (&lambda; x:α. x)) [t]</code>

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:

<code>((&Lambda;α (&lambda; x:α . x)) [t]): (b->b)</code>

<code>((&Lambda;α (&lambda; x:α . x)) [t]): (b->b)</code>

@@ -111,20 +106,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

of type `α`.  In general, then, the type of the uninstantiated
(polymorphic) identity function is

-<code>(&Lambda;α (&lambda;x:α . x)): (&forall;α. α-α)</code>
+<code>(&Lambda;α (&lambda;x:α . x)): (&forall;α. α->α)</code>

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,

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

let zero = Λα. λs:α->α. λz:α. z in
let fst = λx:N. λy:N. x in
@@ -136,12 +128,14 @@ relevant evaluator is called "fullpoly"):

pre (suc (suc (suc zero)));

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

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