Presentation on theme: "PADL 041 Implementing Cut Elimination: A case study of simulating dependent types in Haskell Chiyan Chen Dengping Zhu Hongwei Xi Boston University."— Presentation transcript:
PADL 041 Implementing Cut Elimination: A case study of simulating dependent types in Haskell Chiyan Chen Dengping Zhu Hongwei Xi Boston University
PADL 042 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 043 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 044 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 045 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 046 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 047 Define Type Equality in Haskell data EQ a b = EQcon (a -> b) (b -> a) 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 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) reflexivity symmetry transitivity constructor introduction constructor elimination
PADL 048 Constructor Elimination Is Not Always Implementable 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 Can be implemented Cannot be implemented
PADL 049 Constructor Elimination Is Not Always Implementable 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 Cannot be implemented Can be implemented
PADL 0410 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 0418 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. EQ Int Bool type EQ a b = f. f a -> f b (Baars and Swierstra 02)