Dependent Polymorphism. Makoto Hamana

Transcription

1 1 Dependent Polymorphism Makoto Hamana Department of Computer Science, Gunma University, Japan hamana/

2 This Talk 2 [I] A semantics for dependently-typed programming [II] A kind of polymorphism from semantics dependent polymorphism

3 This Talk 3 [I] A semantics for dependently-typed programming [II] A kind of polymorphism from semantics dependent polymorphism

4 4 Dependent type

5 Dependently-typed Programming, Now! 5 (i) Agda [Chalmers 07-,AIST] (ii) Coq with program/equations tactic [Sozeau ICFP 07,ITP 10] (iii) Epigram [McBride,McKinna 04-] (iv) Haskell with type classes/gadts [McBride JFP 02, Hinze 03] Origin Dependently Typed Functional Programs and Their Proofs Conor McBride, Ph.D thesis, University of Edinburgh, 1999.

6 How to Use Dependent Types in Programming? 6 data Nat : Set where zero : Nat suc : Nat -> Nat data Vec : Nat -> Set where -- an inductive family [] : Vec zero _::_ : {n : Nat} -> (a : A) -> Vec n -> Vec (suc n) Vec type of length-indexed lists [] : Vec zero a1 :: [] : Vec (suc zero) a2 :: a1 :: [] : Vec (suc (suc zero))

7 How to Use Dependent Types in Programming? 7 Safe head head : {n : Nat} -> Vec (suc n) -> A head (x :: xs) = x Never fails

8 Typical Example: append 8 _++_ : {m n : Nat} -> Vec m -> Vec n -> Vec (m + n) [] ++ ys = ys (x :: xs) ++ ys = x :: (xs ++ ys) The index of result type precisely specifies the resulting list Is it always possible?

9 More Example: filter 9 Agda filter : {n : Nat} -> (Nat -> Bool) -> Vec n -> Vec (?) filter p [] = [] filter p (x :: xs) with p x... False = filter p xs... True = x :: filter p xs

10 More Example: filter 10 Agda: first attempt filter : {n : Nat} -> (p : Nat -> Bool) -> (xs : Vec n) -> Vec (length (filter p xs)) filter p [] = [] filter p (x :: xs) with p x... False = filter p xs... True = x :: filter p xs

11 More Example: filter 11 Agda: correct code len-filter : {n : Nat} -> (Nat -> Bool) -> Vec n -> Nat len-filter p [] = 0 len-filter p (x :: xs) with p x... False = len-filter p xs... True = suc (len-filter p xs) filter : {n : Nat} -> (p : Nat -> Bool) -> (xs : Vec n) -> Vec (len-filter p xs) filter p [] = [] filter p (x :: xs) with p x... False = filter p xs... True = x :: filter p xs

12 More Example: filter 12 Agda: correct code len-filter : {n : Nat} -> (Nat -> Bool) -> Vec n -> Nat len-filter p [] = 0 len-filter p (x :: xs) with p x... False = len-filter p xs... True = suc (len-filter p xs) filter : {n : Nat} -> (p : Nat -> Bool) -> (xs : Vec n) -> Vec (len-filter p xs) filter p [] = [] Dependent polymorphism helps filter p (x :: xs) with p x... False = filter p xs... True = x :: filter p xs

13 Classification of Polymorphism 13 Straychey [1967], Reynolds [1983] Ad-hoc Int Int + Int Int Real Real + Real Real Parametric Int Int Int R R R Real Real Real fst Int Int R fst Real Real Dependent V ec V ec V ec + V ec dependency Nat Nat Nat Nat +

14 This Talk 14 [I] A semantics for dependently-typed programming [II] A kind of polymorphism from semantics

15 New Semantics of Inductive Families 15 1) Simplified version of semantics of dependently-sorted abstract syntax [Fiore LICS 08] 2) Dependency category S of sorts 3) The category of discourse is Set S

16 Dependency Category S 16 data N at : Set where zero : Nat suc : Nat Nat data Vec : Nat Set where nil : Vec Zero cons : (n : Nat) (a : A) Vec n Vec (suc n) Dependency category S of sorts skeletal, DAG N len V Objects: sorts Arrows : sort dependencies

17 Semantic Construction of Models 17 data Nat : Set where zero : Nat suc : Nat Nat data Vec : Nat Set where nil : Vec Zero cons : (n : Nat) (a : A) Vec n Vec (suc n) Functor F : Set S Set S modelling an inductive family Initial F -algebra

18 Why Interesting? Programming Viewpoint 18 The category of discourse Set S A natural transformation f : A B in Set S is a family of functions {f s : A s B s s S} satisfying naturality polymorphism? s A s f s B s d s A(d) As f s B s B(d) in S in Set

19 Sort Dependency in Models 19 Term model T Set S T N = {zero} {suc(n) n T N } T V = {nil} {cons(n, b, y) n T N, b T B, y T V, T (len)(y) = n} Functoriality of T : S Set N len V in S T T N T (len) T V in Set

20 Sort Dependency in Model 20 Term model T Set S T N = {zero} {suc(n) n T N } T V = {nil} {cons(n, b, y) n T N, b T B, y T V, T (len)(y) = n} Functoriality of T : S Set N len V in S T T N T (len) length T V in Set 0 nil suc(n) cons(n, a, y) term level dependency

21 Dependent Polymorphism : V ec(m) V ec(n) V ec(m + n) + : Nat Nat nil ++ ys = ys zero + y = y (x : xs) ++ ys = x : (xs ++ ys) suc(n) + y = suc(n + y) V T V T V + T V

22 Dependent Polymorphism : V ec(m) V ec(n) V ec(m + n) + : Nat Nat nil ++ ys = ys zero + y = y (x : xs) ++ ys = x : (xs ++ ys) suc(n) + y = suc(n + y) V T V T V + T V len N T len T len T N T N + T T N len in S in Set

23 Dependent Polymorphism : V ec(m) V ec(n) V ec(m + n) + : Nat Nat nil ++ ys = ys zero + y = y (x :: xs) ++ ys = x :: (xs ++ ys) suc(n) + y = suc(n + y) V T V T V + T V len N T len T len T N T N + T T N len in S in Set T T Schematic definition z y = y c(n) y = c(n y) T in Set S is dependently polymorphic

24 Conclusion: What types admit this reading? When indices are the shapes of data in a type (i) Vectors a2 :: (a1 :: []) : Vec (suc (suc zero)) (ii) Shape indexed type of trees [Hamana LMCS 10] e.g. bin( lf(3), lf(5) ) : Tree (B(L,L)) 2. When indices are calculated by fold Theoretical basis of code reuse in dependently-typed programming