Overloading Functions

Defined functions should have different names within the same scope and name space. So sometimes it is convenient to overload certain functions in order to use identical names for different function (over different types).

A naive implementation by records (“dictionaries”):

data Equals a = Equals
  { equals    :: a -> a -> Bool
  , notEquals :: a -> a -> Bool
  }

where there is a separate dictionary defined for Bool:

eqBool = Equals { equals = boolEquals, notEquals = boolNotEquals }
  where
    boolEquals True  True  = True
    boolEquals False False = True
    boolEquals _     _     = False

    boolNotEquals x y = not (boolEquals x y)

as well as for Int:

eqInt = Equals { equals = (==), notEquals = (/=) } :: Equals Int

The dictionaries could be then used in function definitions as follows.

compareList :: Equals a -> [a] -> [a] -> Bool
compareList _  []     []     = True
compareList eq (x:xs) (y:ys) = (equals eq) x y && compareList eq xs ys
compareList _  _      _      = False

And those functions are invoked like that.

Type Class Definition

Type classes are set of overloaded functions, called members or methods. Type classes have variables that indicate how the different instantiations vary.

Example:

class Eq a where
     (==) :: a -> a -> Bool

• Eq is the type class constructor
• a is a type class variable
• (==) is a method

Type of the method:

Note that the a type variable. There is an additional restriction, called a class context, imposed. Class context is a form of bounded (parametric) polymorphism. Such contexts can be inferred automatically.

findWithDefault :: (Eq a, Default b) => a -> [(a,b)] -> b

Type Instance Definition

With an instance declaration an instance of a class can be defined.

Example:

data Dir = L | R

instance Eq Dir where
     L == L   = True
     R == R   = True
     _ == _   = False

• Type classes are open, that is, they may have unlimited number of instances.
• Instances can be added in any module where the class definition is available.
• All methods have to be defined.

data P = P Int Int

data Nat
   = Zero
   | Succ Nat

Default Methods

Instance definitions can also be defined in terms of other overloaded functions. In result, not every method has to be specified by the user when defining on a new instance.

Example:

class Eq a where
     (==) :: a -> a -> Bool
     a == b  =  not (a /= b)
 
     (/=) :: a -> a -> Bool
     a /= b  =  not (a == b)

Subclasses

A class definition can optionally refer to other, already defined, classes. Cyclic dependencies are forbidden, though. The classes to include are specified as context for the overloaded type variable.

It is not needed (but allowed) to define new methods.

Example:

class Eq a => Ord a where
     (<), (<=), (>=), (>) :: a -> a -> Bool
     
     x <= y   =  x < y || x == y
     x <  y   =  not (x >= y)
     x >= y   =  x > y || x == y
     x >  y   =  not (x <= y)

Usage:

member :: Ord a => a -> T a -> Bool
member a E = False
member a (N l b r)
    | a <  b  =  member a l
    | a == b  =  True           
    | a >  b  =  member a r

data T a = E | N (T a) a (T a) deriving (Eq, Ord, Show)

Deriving Instances

In Haskell, data and newtype declarations may contain an optional deriving clause to enable automatical generation of instances. When deriving a class for a tpye, instances for all superclasses must exist, either via an explicit declaration or using the deriving clause.

data Maybe a 
     = Nothing 
     | Just a
         deriving (Eq, Ord, Show, Read)

The only classes in the Prelude for which derived instances are allowed are Eq, Ord, Enum, Bounded, Show, and Read.

• deriving Eq: structural equality
• deriving Ord: lexicographical ordering
• deriving Enum: mapping to natural numbers
• deriving Show: conversion to String
• deriving Read: parsing from String

When the deriving clause is omitted, no insance declarations are derived.

Ambiguous Overloading

Overloaded functions may be ambiguous sometimes. As an example for this, consider the read function.

    No instance for (Read a0) arising from a use of `read'
    The type variable `a0' is ambiguous
    Possible fix: add a type signature that fixes these type variable(s)
    Note: there are several potential instances:
      instance Read () -- Defined in `GHC.Read'
      instance (Read a, Read b) => Read (a, b) -- Defined in `GHC.Read'
      instance (Read a, Read b, Read c) => Read (a, b, c)
        -- Defined in `GHC.Read'
      ...plus 25 others
    In the expression: read "True"
    In an equation for `it': it = read "True"

That is because it is not known what a is, so the corresponding implementation cannot be chosen.

(Note that the web site here will not display the error message above as it always tries to find some value for a. But it still finds the “wrong” type so the value cannot be eventually parsed.)

The ambiguity can be solved by giving an explicit type.

Laws

• Eq instances should be equivalence relations
• Ord instances should be orderings
• ∀a: read (show a) == a
• …

The Num Type Class

class (Eq a, Show a) => Num a where
    (+), (-), (*)    :: a -> a -> a
    negate           :: a -> a
    abs, signum      :: a -> a
    fromInteger      :: Integer -> a
 
    x - y            =  x + negate y
    negate x         =  0 - x

Overlapping Instances

A single type class instance is allowed for each type. However, an instance may cover multiple types at once. Consider the following type class:

class C a where
  f :: a -> String

and the following instances:

instance C Char where
  f _ = "Char"

instance C a => C [a] where
  f (x:_) = "List of " ++ f x

Invoking f on values of the Char and Char types will work like that.

But adding the following instance

instance C [Char] where
  f _ = "String"

will make the compiler complain:

    Illegal instance declaration for `C [Char]'
      (All instance types must be of the form (T a1 ... an)
       where a1 ... an are *distinct type variables*,
       and each type variable appears at most once in the instance head.
       Use -XFlexibleInstances if you want to disable this.)
    In the instance declaration for `C [Char]'

By the Haskell 98 standard, it is not allowed to bound the value of the type variable, such as setting a to Char. As the message above suggests, the FlexibleInstances extension of GHC can disable this. But this gives rise to another problem when f is invoked.

Overlapping instances for C [Char] arising from a use of `f'
Matching instances:
  instance C a => C [a] -- Defined in `main'
  instance C [Char] -- Defined in `main'

Another extension, called OverlappingInstances, may be used to fix the problem. By enabling this extension, the compiler will choose the most specific instantiation.

None of these extensions are required, though. The programmer may control this manually by creating a new type alias for each of the cases.

newtype NString = S [Char]

instance C NString where
  f (S _) = "String"

It works perfectly and incurs no performance overhead.