Tand a type variable
a, and means that
acan only be instantiated to a type whose members support the overloaded operations associated with
Type classes first appeared in the Haskell programming language, and were originally conceived as a way of implementing overloaded arithmetic and equality operators in a principled fashion. In contrast with the "eqtypes" of Standard ML, overloading the equality operator through the use of type classes in Haskell does not require extensive modification of the compiler frontend or the underlying type system.
Since their creation, many other applications of type classes have been discovered.
Eqintended to contain types that admit equality would be declared in the following way:
class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
This declaration may be read as stating "a type
a belongs to class
Eq if there are functions named
(/=), of the appropriate types, defined on it." A programmer could then define a function
member in the following way:
member :: (Eq a) => a -> [a] -> Bool
member y  = False
member y (x:xs) = (x == y) || member y xs
member has the type
a -> [a] -> Bool with the context
(Eq a), which limits the types
a can range over to those belonging to the
A programmer can make any type
t a member of a given class
C by using an instance declaration that defines implementations of all of
C's methods for the particular type
t. For instance, if a programmer defines a new data type
t, she may then make this new type an instance of
Eq by providing an equality function over values of type
t in whatever way she sees fit. Once she has done this, she may use the function
member on lists of elements of type
Note that type classes are different from classes in object-oriented programming languages. In particular,
Eq is not a type: there is no such thing as a value of type
Type classes are closely related to parametric polymorphism. For example, note that the type of
member as specified above would be the parametrically polymorphic type
a -> [a] -> Bool were it not for the type class constraint "
(Eq a) =>").
class Monad m where
(>>=) :: m a -> (a -> m b) -> m b
return :: a -> m aThe fact that m is applied to a type variable indicates that it has kind * -> *, i.e. it takes a type and returns a type.
IArrayexpresses a general immutable array interface. In this class, the type class constraint
IArray a emeans that
ais an array type that contains elements of type
e. (This restriction on polymorphism is used to implement unboxed array types, for example.)
Not only do type classes permit multiple type parameters, they also permit functional dependencies between those type parameters. That is, the programmer can assert that a given assignment of some subset of the type parameters uniquely determines the remaining type parameters. For example, general monads
m which carry a state parameter of type
s satisfy the type class constraint
MonadState s m. In this constraint, there is a functional dependency
m -> s. This means that for a given monad, the state type accessible from this interface is uniquely determined. This aids the compiler in type inference, as well as aiding the programmer in type-directed programming.
Haskell code that uses multi-parameter type classes is not portable, as this feature is not part of the Haskell 98 standard. The popular Haskell implementations GHC and Hugs support multi-parameter type classes.
Eq, but all equality operators are derived automatically by the compiler. The programmer's control of the process is limited to designating which type components in a structure are equality types and which type variables in a polymorphic type range over equality types.
SML's modules and functors can play a role similar to that of Haskell's type classes, the principal difference being the role of type inference, which makes type classes suitable for ad hoc polymorphism.
Monadis an example of a type class)