From: chris <chris@web>
Date: Thu, 26 Feb 2015 02:25:40 +0000 (-0500)
Subject: (no commit message)
X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=commitdiff_plain;h=1cbc7b6a7a1ec26412c8fb695e65ee03c7e4fff0

---

diff --git a/topics/_week5_system_F.mdwn b/topics/_week5_system_F.mdwn
index f7c38eb1..6b80c20a 100644
--- a/topics/_week5_system_F.mdwn
+++ b/topics/_week5_system_F.mdwn
@@ -39,8 +39,8 @@ match up with usage in O'Caml, whose type system is based on System F):
 
 	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
@@ -51,9 +51,9 @@ than over values; in various discussion below and later, type variable
 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
+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.
@@ -62,7 +62,7 @@ calculus, except that they have their shrug variable annotated with a
 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>&Lambda;</code> is a capital <code>&lambda;</code>: just
 like the lower-case <code>&lambda;</code>, <code>&Lambda;</code> binds
@@ -70,7 +70,7 @@ variables in its body, except that unlike <code>&lambda;</code>,
 <code>&Lambda;</code> binds type variables instead of expression
 variables.  So in the expression
 
-<code>&Lambda; α (&lambda; x:α . x)</code>
+<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
@@ -85,27 +85,27 @@ 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>    
+<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:
 
-<code>((&Lambda; α (&lambda; x:α . x)) [t]): (b -> b)</code>    
+<code>((&Lambda;α (&lambda; 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>((&Lambda; α (&lambda; x:α . x)) [e]): (e -> e)</code>    
+<code>((&Lambda;α (&lambda; 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>(&Lambda; α (&lambda; x:α . x)): (&forall; α . α -> α)</code>
+<code>(&Lambda;α (&lambda;x:α . x)): (&forall;α. α-α)</code>
 
 Pred in System F
 ----------------
@@ -117,15 +117,15 @@ however.  Here is one way, coded in
 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)));