System F:
---------
- types τ ::= c | α | τ1 -> τ2 | ∀'a. τ
- expressions e ::= x | λx:τ. e | e1 e2 | Λα. e | e [τ]
+ types τ ::= c | α | τ1 -> τ2 | ∀α.τ
+ expressions e ::= x | λx:τ.e | e1 e2 | Λα.e | e [τ]
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
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
+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
+`'a`. 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.
type. Applications "`e1 e2`" are just like in the simply-typed lambda calculus.
In addition to variables, abstracts, and applications, we have two
-additional ways of forming expressions: "`Λα. e`" is called a *type
+additional ways of forming expressions: "`Λα.e`" is called a *type
abstraction*, and "`e [τ]`" is called a *type application*. The idea
is that <code>Λ</code> is a capital <code>λ</code>: just
like the lower-case <code>λ</code>, <code>Λ</code> binds
<code>Λ</code> binds type variables instead of expression
variables. So in the expression
-<code>Λ α (λ x:α . x)</code>
+<code>Λ α (λ x:α. x)</code>
the <code>Λ</code> binds the type variable `α` that occurs in
the <code>λ</code> abstract. Of course, as long as type
ready to apply this identity function to, say, a variable of type
boolean, just do this:
-<code>(Λ α (λ x:α . x)) [t]</code>
+<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:
-<code>((Λ α (λ x:α . x)) [t]): (b -> b)</code>
+<code>((Λα (λ x:α . x)) [t]): (b->b)</code>
Likewise, if we had instantiated the type variable as an entity (base
type `e`), the resulting identity function would have been a function
of type `e -> e`:
-<code>((Λ α (λ x:α . x)) [e]): (e -> e)</code>
+<code>((Λα (λ x:α. x)) [e]): (e->e)</code>
Clearly, for any choice of a type `α`, the identity function can be
instantiated as a function from expresions of type `α` to expressions
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
----------------
System F|http://www.cis.upenn.edu/~bcpierce/tapl/index.html]] (the
relevant evaluator is called "fullpoly"):
- N = ∀ α . (α->α)->α->α;
- Pair = (N -> N -> N) -> N;
- let zero = lambda α . lambda s:α->α . lambda z:α. z in
- let fst = lambda x:N . lambda y:N . x in
- let snd = lambda x:N . lambda y:N . y in
- let pair = lambda x:N . lambda y:N . lambda z:N->N->N . z x y in
- let suc = lambda n:N . lambda α . lambda s:α->α . lambda z:α . s (n [α] s z) in
- let shift = lambda p:Pair . pair (suc (p fst)) (p fst) in
- let pre = lambda n:N . n [Pair] shift (pair zero zero) snd in
+ N = ∀α. (α->α)->α->α;
+ Pair = (N->N->N) -> N;
+ let zero = α . λs:α->α . λz:α. z in
+ let fst = λx:N . λy:N . x in
+ let snd = λx:N . λy:N . y in
+ let pair = λx:N . λy:N . λz:N->N->N . z x y in
+ let suc = λn:N . λα . λlambda s:α->α . λz:α . s (n [α] s z) in
+ let shift = λp:Pair . pair (suc (p fst)) (p fst) in
+ let pre = λn:N . n [Pair] shift (pair zero zero) snd in
pre (suc (suc (suc zero)));