meaning. So we will need to get more sophisticated about types. The
next step in that journey will be to consider System F.
-In the simply-typed lambda calculus, we write types like <code>σ
--> τ</code>. 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:
-
-<pre>
-Expression Type Implication
------------------------------------
-fn α -> β α ⊃ β
-arg α α
------- ------ --------
-(fn arg) β β
-</pre>
-
-The implication in the right-hand column is modus ponens, of course.
-
System F was discovered by Girard (the same guy who invented Linear
Logic), but it was independently proposed around the same time by
Reynolds, who called his version the *polymorphic lambda calculus*.
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
<code>Λ α (λ x:α. x)</code>
the <code>Λ</code> binds the type variable `α` that occurs in
- the <code>λ</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>λ</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>(Λ α (λ 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>((Λα (λ x:α . x)) [t]): (b->b)</code>
of type `α`. In general, then, the type of the uninstantiated
(polymorphic) identity function is
- <code>(Λα (λx:α . x)): (∀α. α-α)</code>
+ <code>(Λα (λx:α . x)): (∀α. α->α)</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,
- 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
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