X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=topics%2F_week5_system_F.mdwn;h=4517509b28236e8cab4d3c4123b4e03c5be348c5;hp=5b2e297c7a8929e9193c36d36375dbc59343bd36;hb=293b63f453994f8c3c458ca264ef0fb04b79e1fb;hpb=2e1217b17ae7e408c89f52c4f6b43ce69284a342 diff --git a/topics/_week5_system_F.mdwn b/topics/_week5_system_F.mdwn index 5b2e297c..4517509b 100644 --- a/topics/_week5_system_F.mdwn +++ b/topics/_week5_system_F.mdwn @@ -1,6 +1,13 @@ [[!toc levels=2]] -# System F and recursive types +# System F: the polymorphic lambda calculus + +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. In the simply-typed lambda calculus, we write types like σ -> τ. This looks like logical implication. We'll take @@ -44,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 -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 +79,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,36 +106,36 @@ 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"): - - 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.Λα.λ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 +however. Here is one way: + + 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 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. Λα. λ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))); -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 @@ -164,7 +166,7 @@ Typing ω In fact, unlike in the simply-typed lambda calculus, it is even possible to give a type for ω in System F. -ω = λx:(∀α.α->α).x [∀α.α->α] x +ω = λx:(∀α.α->α). x [∀α.α->α] x In order to see how this works, we'll apply ω to the identity function.