Type-indexed functions in Generic Haskell

Transcription

1 Type-indexed functions in Generic Haskell Johan Jeuring September 15, 2004

2 Introduction Today I will talk about: a Types of polymorphism. b Type-indexed functions. c Dependencies. Read about b, and c in Exploring Generic haskell, Sections and Chapter 5. 2 / 33

3 Types of polymorphism Most modern programming languages support one or more forms of polymorphism: parametric polymorphism, ad hoc polymorphism or overloading, subtype polymorphism, generic polymorphism or polytypism. Some, such as Generic Java, C++, Haskell, support more than one. 3 / 33

4 Parametric polymorphism Parametric polymorphic functions work on any type in a uniform (parametric) manner for each type. flatten :: a.[[a]] [a] id :: a.a a map :: a b.(a b) [a] [b] foldl :: a b.(a b a) a [b] a 4 / 33

5 Ad hoc polymorphism or Overloading Haskell uses type classes for ad hoc polymorphism. You can write both and class Num a where (+) :: a a a... There is not necessarily any relationship between the different instances of the type class, hence the name ad hoc. Java s overloading is another example: same method name, but different argument types. Ad hoc polymorphism is statically resolved. 5 / 33

6 Subtype Polymorphism Dynamic dispatch in, for example, Java: Calling the draw method on a variable of type Shape will work for objects from type Circle, Square, etc. Objects to which the method can apply are related by subtyping (often by subclassing also). Multimethods extend Java overloading dispatch is dynamically resolved. Implemented in Multijava, Cecil. Thus subtype polymorphism (in OO) can be seen as the dynamic version of overloading. 6 / 33

7 Generic polymorphism or polytypism Some functions do essentially the same thing for different data types, but you still have to write instances on the data types. An example is the equality function. Often the behaviour depends upon the structure of type of the input. Since we are dealing with Haskell, we focus only on parametric polymorphism with an aim to extending it with generic polymorphism. 7 / 33

8 Parametricity Function length is parametrically polymorphic. Its operation is insensitive to the list s element type: the list elements are not inspected. length :: a.[a] Int length [ ] = 0 length (x : xs) = 1 + length xs 8 / 33

9 Parametric polymorphism: limitations Polymorphic type systems are less flexible than desired. If eq has the following type: equal :: a.a a Bool -- doesn t work then equal must be constant the arguments cannot be inspected. A programmer has to write an instance of equal for each type. With the help of class system: equal :: a.(eq a) a a Bool But this does not work for some (higher-order) data types. Generic Haskell aims to get around these problems. 9 / 33

10 Generic programming Many programs work in essentially the same way on different data types: Summing all integers, or collecting all values in a data structure. Printing and parsing values. Map. A generic program is written once, but works for many different data types maybe even of all kinds. Generic programming adds considerable expressive power to a polymorphic type system. 10 / 33

11 Type-indexed functions Our approach: a type-indexed function takes a type as argument, and can be defined inductively on the structure of the type. In ordinary programming we define values depending on values (called functions), and types depending (parametrically) on types (called type constructors). Generic programming adds the possibility of defining values depending on types (called type-indexed values), and types depending on kinds (called kind-indexed types). Type safety is not compromised. 11 / 33

12 Function add Lets define an addition function for some useful types. add Bool = ( ) add Int = (+) add Char x y = chr (ord x + ord y) The type of add is a :: a a a Or, to emphasize that add is a type-indexed function: add a :: :: a a a 12 / 33

13 Calling function add The type of add says that the function can be called by providing three arguments: a type, and two arguments of that type. Indeed, the calls add Bool False True add Int 2 7 add Char A would evaluate to True, 9, and a respectively. 13 / 33

14 What about generic programming? Being able to define functions on types is basically the same as defining instances of a class. So why not use classes? Advantages of classes: you can always add new instances, and you don t have to provide a type argument when calling a class method. And what is the relation with generic programming? In the next lecture we will show how any data type can be translated to a small set of data types. If we then define a type-indexed function on the elements of this small set of data types, it can automatically be used on any other data type. 14 / 33

15 Data types and kinds Consider the following data types: data Bool = True False data Nat = Zero Succ Nat data IntList = INil ICons Int IntList These types are basic types of kind. The following types have kind : data List a = Nil Cons a (List a) data [a] = [ ] a : [a] data Maybe a = Nothing Just a 15 / 33

16 Kinds The type of a data type is given by a kind. Kinds have two forms: κ ::= -- the kind of types κ ν -- function kind Here are some data types with more advanced kinds: data Rose a = Node a [Rose a] ex :: Rose String ex = Node "A" [Node "rose" [ ], Node "is" [ ],...] data GRose f a = GNode a (f (GRose f a)) ex :: GRose [ ] Int ex = GNode 3 [GNode 10 [ ], GNode 2 [ ],...] 16 / 33

17 Question What is the kind of Sum? data Sum a b = Inl a Inr b a b ( ) c ( ) ( ) ( ) d 17 / 33

18 Question What is the kind of Fix? data Fix f = In (f (Fix f)) a b ( ) c ( ) d 18 / 33

19 add on Maybe A problem with the definition of add is that it can only be applied to types of kind, but we also want it to work for on types of kinds other than. Given that we know how to add two values of some type t, we can also add two values of type Maybe t, by treating Nothing as exceptional value: add Maybe α Nothing = Nothing add Maybe α Nothing = Nothing add Maybe α (Just x) (Just y) = Just (add α x y) The knowledge of how to add two values of the argument type of Maybe is hidden in the reference to add α in the final case, and we still have to make sure that we get access to that information somehow. 19 / 33

20 add on types of other kinds We could also extend the function add to lists as pointwise addition: add [α ] x y length x length y = map (uncurry (add α )) (zip x y) otherwise = error "args must have same length" We do not even have to restrict ourselves to kind and data types. We can do pointwise addition for pairs, too: add (α, β) (x1, x2) (y1, y2) = (add α x1 y1, add β x2 y2) Now our function add has arms which involve type constructors of kinds,, and, all at the same time. 20 / 33

21 Requirements To be able to implement add as above, we need (at least) two extensions of the current situation: Type patterns must become more general. Instead of just named types of kind, we will admit named types of arbitrary kind, applied to type variables in such a way that the resulting type is of kind again. We need to introduce the notion of dependencies between type-indexed functions. A dependency arises if in the definition of one type-indexed function, another type-indexed function (including the function itself) is called, with a variable type as type argument. 21 / 33

22 Parameterized type patterns We now allow patterns such as [α ] or Either α β in the definitions of type-indexed functions. A pattern must be of kind, and of the form that a named type constructor is applied to variables to satisfy the type constructor. For example. Either α is not allowed because Either is only partially applied. All type variables in type patterns have to be distinct, just as we require variables in ordinary patterns to be distinct. A pattern such as (α,α) is illegal. We do not allow nested type patterns: [Int] is forbidden, and so is Either α Char. The top-level type constructor is the only named type occurring in a type pattern, the rest are all type variables. This restriction on type patterns is not essential. 22 / 33

23 Dependencies Consider the definition of add on lists again: add [α ] x y length x length y = map (uncurry (add α )) (zip x y) otherwise = error "args must have same length" We only know what type α is when add is called on a type somewhere. We say that the function add is a dependency of add. A dependency makes explicit that information is missing. Dependencies of type-indexed functions are reflected in their type signatures. Previously, add had the type add a :: :: a a a This type is no longer adequate we use a new syntax, add a :: :: (add) a a a 23 / 33

24 Type instances of function add I Now, let us look at some example types for specific applications of add: for a constant type argument such as Int, or [Char], the dependencies are ignored, and the types are simply add Int :: Int Int Int add [Char] :: [Char] [Char] [Char] These types are for specific instances of the type-indexed functions, and they can be derived automatically from above type signature. In general, for any type argument A that is dependency-variable free, we have add A :: A A A 24 / 33

25 Type instances of function add II Dependencies have an impact on the type of a generic application once variables occur in the type argument. For instance, if the type argument is [α ], the resulting type is add [α ] :: a ::. (add α :: a a a) [a] [a] [a] We call the part in the parentheses to the left of the double arrow a dependency constraint. In this case, add α :: a a a is a dependency constraint. 25 / 33

26 Type instances of function add III add A :: :: A A A add A (α :: ) :: :: a ::. (add α :: a a a) A a A a A a add A (α :: ) (β :: ) :: :: (a :: ) (b :: ). (add α :: a a a, add β :: b b b) A a b A a b A a b add A (α :: ) :: :: a ::. (add α (γ :: ) :: c ::. (add γ :: c c c) a c a c a c) A a A a A a 26 / 33

27 A function with no dependencies Function size, defined by size [α ] x = length x size Maybe α Nothing = 0 size Maybe α (Just ) = 1 size Tree α Leaf = 0 size Tree α (Node l x r) = size Tree α l size Tree α r where data Tree a = Leaf Node (Tree a) a (Tree a) has no dependencies: size a :: :: a Int 27 / 33

28 A function with different dependencies data CprResult = Less More EqualC NotComparable cpr [α ] x y size [α ] x == size [α ] y = if size [α ] x == 0 then EqualC else let p = zipwith (cpr α ) x y in if allequal [ CprResult] p then head p else NotComparable otherwise = NotComparable cpr (α, β) (x1, x2) (y1, y2) equal α x1 y1 = cpr β x2 y2 otherwise = NotComparable We assume that the type signatures for equal and allequal are as follows: equal a :: :: (equal) a a Bool allequal a :: :: (equal) a Bool 28 / 33

29 Question What is the type of function cpr? a cpr a :: :: (cpr, equal, size, allequal) a a CprResult b cpr a :: :: (cpr, equal, size) a a CprResult c cpr a :: :: (cpr, equal) a a CprResult d cpr a :: :: (cpr) a a CprResult 29 / 33

30 Type instances of function cpr I The type signature is not as fine-grained as one might expect: a dependency is a global property of a type-indexed function, not attached to some arm. Although the arm for lists does not depend on equal, the type for cpr [α ] that is derived from the above type signature exhibits the dependency: cpr [α ] :: a ::. (equal α :: a a Bool, cpr α :: a a CprResult) [a] [a] CprResult 30 / 33

31 Type instances of function cpr II Also, there is no distinction between different dependency variables. The arm for pairs does only depend on cpr for the second component. Nevertheless, the type for cpr α, β contains the dependency on cpr for both components: cpr (α, β) :: a :: (b :: ). (equal α :: a a Bool, cpr α :: a a CprResult, equal β :: b b Bool, cpr β :: b b CprResult) (a, b) (a, b) CprResult 31 / 33

32 Dependencies and classes Dependencies are similar to class constraints in classes. For example, for function add we might define class Add a where add :: a a a An instance of the class for lists would look as follows: instance Add a Add [a] where add x y length x == length y = map (uncurry add) (zip x y) otherwise = error "args must have same length" 32 / 33

33 Conclusions and next lecture Today you have seen: Various forms of polymorphism. Data types and kinds. Type-indexed functions. Types of type-indexed functions. Dependencies between type-indexed functions. In the next lecture I will show how we can use type-indexed functions to obtain generic functions. Furthermore, I will give many examples of generic functions. 33 / 33