User-Defined Algebraic Data Types

Transcription

1 72 Static Semantics User-Defined Types User-Defined Algebraic Data Types An algebraic data type declaration has the general form: data cx T α 1... α k = K 1 τ τ 1k1... K n τ n1... τ nkn introduces new type constructor T of kind κ 1... κ k, where α i :: κ i introduces data constructors K i :: cx i τ i1... τ iki T α 1... α k where cx i cx contains only constraints on τ ij Example: data Ord a Tree a = E N a (T a) (T a) N :: Ord a a Tree a Tree a Tree a E :: Tree a (not: Ord a Tree a)

2 73 Static Semantics User-Defined Types Type Synonyms general form of type synonyms type T α 1... α k = τ introduces new type constructor T of kind κ 1... κ k κ, where τ :: κ and α i :: κ i T τ 1... τ k is operationally equivalent to τ[τ 1 /α 1,..., τ k /α k ] only difference: synonyms cannot be used in instance declarations Example: type TripleInt = (,,) Int of kind TripleInt [Bool] [Bool] equivalent to (Int, [Bool], [Bool]) not: instance Eq (TripleInt Int Int)

3 Static Semantics Type Classes Type Classes disciplined way to handle ad-hoc polymorphism (overloading) one function, many implementations Examples: numeric literals 1 :: Int, 1 :: Float, (++), (==) type class: collection of methods that are applicable to all instances of the class compare to Java interfaces provide only type signatures, fixities, and default values for each class method Example: class Eq a where class name (==) :: a a Bool type signatures (/=) :: a a Bool (/=) = \x y not (x==y) default methods (==) = \x y not (x/=y)

4 75 Static Semantics Type Classes Instances type t may be declared an instance of class C instance C t where d d defines overloaded methods (overriding default ones) potentially restricted by contexts instance Eq α Eq (Tree α) t must be type constructor followed by type variables no type synonyms not t 1 t 2 tuples and lists are allowed Examples (in hugs): six tuples with equality bounded functions with equality

5 76 Static Semantics Type Classes Superclasses class inherits methods from a superclass example: ordered types inherit from equality types class Eq a Ord a where compare :: a a Ordering super class instance of a class must also be instance of all superclasses smallest contexts suffice: Ord a instead of (Eq a, Ord a)

6 Static Semantics Type Classes Built-in Classes

7 78 Static Semantics Type Classes Numbers important type class Num and its subclasses e.g. (+) Num α α α α easily allows for ambiguities provides many conversions frominteger :: Num α Integer α fromrational :: Fractional α Rational α Beware: average xs = sum xs / length xs

8 79 Static Semantics Type Classes Ambiguous Types type (C 1 α 1,..., C k α k ) t is ambiguous if any of the α i does not occur in t example: (show. read) 42 :: (Read α, Show α) [Char] system does not know which implementation to use in Hugs: unresolved type variable α defaults according to default declaration (:s +T) only if α occurs in one of Num α, Eq α, Show α show [] in Hugs: [] (default: [Int]) but show ([]::[Char]) is different x = show [] in module: type error

9 80 Static Semantics Type Classes Monomorphism Restriction An identifier bound in a simple pattern binding on top-level can only be fully polymorphic if required by explicit type signature. summ = foldl (+) 0 : type error function bindings are ok: summ xs = foldl (+) 0 xs non-simple bindings are always monomorphic

10 81 Static Semantics Type Classes Type Constructor Classes in class definition class C a, a can have any kind in particular: not kind * built-in example Functor types that can be mapped over class Functor a where fmap :: (b c) a b a c typical instances (see code) Tree tuples of equal types polygons with area, circumference

11 82 Static Semantics Type Classes Derived Instances data Tree a = E N a (Tree a) (Tree a) deriving Eq, Ord, Show, Read makes Tree a a standard instance of the derived classes works only for the classes Eq Ord Bounded Enum Show Read

12 Experiment: design a type class Set and compare it to the module 83 Static Semantics Type Classes Discussion... taken from the Gentle Introduction Haskell Classes Haskell: definition of type (data) and operations (methods) are separated Java, C++: a class defines both data and methods actually closer to Java interfaces: a protocol how to use data no overloading the same name with different number or types of parameters (as in C++) no Object class; no coercion no access control: use modules no data abstraction: use modules

13 84 Static Semantics Modules Modules a module defines a collection of values types classes and instances in an environment created by imports a module exports a list of entities modules may be mutually recursive Purpose name-space control data abstraction not first class values

14 85 Static Semantics Modules Modules Haskell program: set of modules one module Main that exports a value main in a file, if no module is given, default is module Main(main) where... Multi-module program can always be transformed into single-module program by giving unique names to entities!

15 86 Static Semantics Modules Data Abstraction Data Abstraction Separation between abstract properties of data and their concrete implementation. abstract properties are the same regardless of implementation interface to the client implementation may change standard example: abstract data type set, implemented as list, tree, hash table,... In Haskell, modules are the proper way to provide data abstractions.

16 Static Semantics Modules A Set Module module Set (singleton, union, intersection, elem) where import List type Set a = [a] singleton x = [x] export list: names made visible to client modules can be values, types, type synonyms, classes, or modules an abstract data type data T a = K a... can be exported in three ways: just T: only the type constructor exported T(..): type and all data constructors exported T(K): type and only data constructor K exported import of modules use specified module import List (nub): bring only nub into scope import List hiding (nub): bring everyting except nub into 87