Lecture 16: Programming The Polymorphic Lambda Calculus

Booleans

      type bool = ALL a. a -> a -> a 
      val tt = /\a. \x:a. \y:a. x 
      val ff = /\a. \x:a. \y:a. x 
      val if e (e1: t) (e2: t) = e[t] e1 e2
    

Natural Numbers

      type nat = ALL a. (a -> a) -> a -> a 
      val z = /\a. \m:a -> a. \n:a. n 
      val one = /\a. \m:a -> a. \n:a. m n 
      val two = /\a. \m:a -> a. \n:a. m (m n) 
      val three = /\a. \m:a -> a. \n:a. m (m (m n)) 
    

Pairs

      type pair t1 t2 = ALL a. (t1 -> t2 -> a) -> a
      val tuple (e1: t1) (e2: t2) = /\a. \f: t1 -> t2 -> a. f e1 e2
      val letpair (e: pair t1 t2) (e2: t1 -> t2 -> t) = e[t] e2
      val pi1 (e: pair t1 t2) = letpair e (\x:t1. \y:t2. x)
      val pi2 (e: pair t1 t2) = letpair e (\x:t1. \y:t2. y)
    

Sums

      type sum t1 t2 = ALL a. (t1 -> a) -> (t2 -> a) -> a
      val inl[t1][t2] e = /\a. \f:t1 -> a. \g:t2 -> a. f e
      val inr[t1][t2] e = /\a. \f:t1 -> a. \g:t2 -> a. g e
      val case e (e1 : t1 -> t) (e2 : t2 -> t) = e[t] e1 e2
    

Lists

      type list t = ALL a. (t -> a -> a) -> a -> a
      val nil[t] = /\a. \c: t -> a -> a. \n: a. n
      val l1 (e: t) = /\a. \c: t -> a -> a \n: a. c e n
      val l2 (e1: t) (e2: t) = /\a. \c: t -> a -> a. \n: a. c e1 (c e2 n)
      val foldr (f : t -> b -> b) (n: b) (l: list t) = l[b] c n