1 / 18

Implementing Cut Elimination: A case study of simulating dependent types in Haskell

Implementing Cut Elimination: A case study of simulating dependent types in Haskell. Chiyan Chen Dengping Zhu Hongwei Xi Boston University. Types. Very helpful in programming practice: Document programmers’ intentions. Statically assure program invariants and catch program errors.

odessa
Download Presentation

Implementing Cut Elimination: A case study of simulating dependent types in Haskell

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Implementing Cut Elimination:A case study of simulating dependent types in Haskell Chiyan Chen Dengping Zhu Hongwei Xi Boston University PADL 04

  2. Types • Very helpful in programming practice: • Document programmers’ intentions. • Statically assure program invariants and catch program errors. • Two directions of evolution: • Assign more refined types to programs: from simple types to dependent types. • Type more programs: from simple types to polymorphic types. PADL 04

  3. Polymorphic Types vs. Dependent Types • Polymorphic types are more widely used than dependent types in practice: • Facilitated by Hindley-Milner style type inference. • Languages with parametric polymorphism: ML, Haskell • Languages with dependent types: Dependent ML (DML), Cayenne. PADL 04

  4. Haskell • A versatile language with a variety of advanced type features: • Polymorphic recursion. • Higher ranked polymorphic types. • Existential types. • Type classes. • … … • Pure type inference is no longer supported. PADL 04

  5. Simulating Dependent Types in Haskell • Types for type index expressions. • Explicit equality on types for implicit equality on index expressions. • Existential datatypes for dependent datatypes. • Polymorphic recursion for polymorphism over index expressions. PADL 04

  6. What Is This Paper About? • A large variety of “cute” examples exist in the literature that make use of similar techniques to simulate dependent types • However, we have strong doubts about the viability of this practice, and the paper uses an interesting example to provide a critique. PADL 04

  7. Define Type Equality in Haskell data EQ a b = EQcon (a -> b) (b -> a) reflexivity idEQ :: EQ a a symEQ :: EQ a b -> EQ b a transEQ :: EQ a b -> EQ b c -> EQ a c pairEQ :: EQ a1 b1 -> EQ a2 b2 -> EQ (a1, a2) (b1, b2) symmetry transitivity constructor introduction fstEQ :: EQ (a1, a2) (b1, b2) -> EQ a1 b1 fstEQ (EQcon to from) = let bot = bot in EQcon (\x -> fst (to (x, bot))) (\x -> fst (from (x, bot))) sndEQ :: EQ (a1, a2) (b1, b2) -> EQ a2 b2 constructor elimination PADL 04

  8. Constructor Elimination Is Not Always Implementable Can be implemented data T a b = T a fstTEQ :: EQ (T a1 a2) (T b1 b2) -> EQ a1 b1 sndTEQ :: EQ (T a1 a2) (T b1 b2) -> EQ a2 b2 Cannot be implemented PADL 04

  9. Constructor Elimination Is Not Always Implementable Cannot be implemented data T a b = T (a -> b) fstTEQ :: EQ (T a1 a2) (T b1 b2) -> EQ a1 b1 sndTEQ :: EQ (T a1 a2) (T b1 b2) ->EQ a2 b2 Can be implemented PADL 04

  10. Use Type Equality toEQ :: EQ a b a -> b toEQ (EQcon to from) = to fromEQ :: EQ a b -> b -> a fromEQ (EQcon to from) = from PADL 04

  11. Intuitionistic Propositional Logic (IPL) PADL 04

  12. Sequent Calculus for IPL PADL 04

  13. Sequent Calculus for IPL PADL 04

  14. Cut Elimination PADL 04

  15. Type Equality on Constructors PADL 04

  16. EQ g2 (g’, a1) EQ (g’, a1) (g’, a2) EQ g2 g1 EQ g1 (g’, a1) IN a1 g1 EQ g1 g2 EQ a1 a2 IN a2 g2 EQ g2 (g’, a2) Explicit Proofs for Type Equalities to (INone pf) = INone (transEQ (transEQ (symEQ pf2) pf) (pairEQ idEQ pf1)) PADL 04

  17. Type Equality on Constructors PADL 04

  18. Conclusion • Simulate a restricted form of dependent types • Type equality for constructor elimination is not always implementable. • Practicality • Cannot simulate sorts in dependent type systems. • It is expected that only identity function can inhabit a type of the form EQ a b (although this cannot be guaranteed by the type system of Haskell). Why bother to define them? • Constructing explicit proofs for type equalities in programs is exceedingly tedious. • Small changes to a program may result in the need for global reconstruction of proofs for type equalities. type EQ a b =  f. f a -> f b (Baars and Swierstra 02) EQ Int Bool PADL 04

More Related