N = ∀α.(α->α)->α->α;
Pair = (N->N->N)->N;
- let zero = Λα.λs:α->α.λz:α. z in
+ 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
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
-typed as a Church number, i.e., as `∀ α . (α->α)->α->α`. The type
+typed as a Church number, i.e., as `∀α.(α->α)->α->α`. The type
application `n [Pair]` instantiates `n` in a way that allows it to
manipulate ordered pairs: `n [Pair]: (Pair->Pair)->Pair->Pair`. In
other words, the instantiation turns a Church number into a
In fact, unlike in the simply-typed lambda calculus,
it is even possible to give a type for ω in System F.
-<code>ω = λlambda x:(∀ α. α->α) . x [∀ α . α->α] x</code>
+<code>ω = λx:(∀α.α->α).x [∀α.α->α] x</code>
In order to see how this works, we'll apply ω to the identity
function.
<code>ω id ==</code>
- (λx:(∀α. α->α) . x [∀α.α->α] x) (Λα.λx:α. x)
+ (λx:(∀α.α->α). x [∀α.α->α] x) (Λα.λx:α.x)
Since the type of the identity function is `∀α.α->α`, it's the
right type to serve as the argument to ω. The definition of