Copyright (C) 2017, 2018, H. Conrad Cunningham

Acknowledgements: I originally created these slides in Fall 2017 to accompany what is now Chapter 22, Overloading and Type Classes, in the 2018 version of the textbook Exploring Languages with Interpreters and Functional Programming.

Browser Advisory: The HTML version of this document may require use of a browser that supports the display of MathML. A good choice as of November 2018 is a recent version of Firefox from Mozilla.

Source Code: The Haskell module for this chapter is in file TypeClassMod.hs.

Lecture Goals

• Motivate overloading and type classes

• Introduce type class laws

• Extend concepts to inheritance and multiple constraints

• Compare Haskell to other languages

Polymorphism in Haskell

1. Parametric polymorphism — same name, same function definition for all types of arguments/results — “polymorphism”

   length: [a] -> Int

2. Overloading — same name, same functionality, but different function definitions depending upon type

   (+) function takes two numbers of same type

Why Overloading?

elemBool :: Bool -> [Bool] -> Bool
elemBool x []     = False
elemBool x (y:ys) = eqBool x y || elemBool x ys

How can define eqBool?

eqBool :: Bool -> Bool -> Bool
eqBool True  False = False
eqBool False True  = False
eqBool _     _     = True

Not general!

Generalizing eqBool

elemGen :: (a -> a -> Bool) -> a -> [a] -> Bool
elemGen eqFun x []     = False
elemGen eqFun x (y:ys) = eqFun x y || elemGen eqFun x ys

elemBool :: Bool -> [Bool] -> Bool
elemBool = elemGen eqBool

• But elemGen too general! any a -> a -> Bool

• Equality meaningless for some types (functions?)

Solution?

• Overload == operator for set of types

• Restrict polymorphism in elem to types with (==) defined

• Introduce type class for equality, then constrain polymorphism to that context (used before)

  elem :: Eq a => a -> [a] -> Bool

Defining Equality Class

• Define class Eq as set of types with (==) defined

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

• Make type Bool instance of class (also others like Int, Char)

  instance Eq Bool where
      True  == True  = True
      False == False = True
      _     == _     = False

Instances

• Make list in Eq if element is also

  instance Eq a => Eq [a] where
      []     == []     =  True
      (x:xs) == (y:ys) =  x == y && xs == ys
       _     == _      =  False

• Left side of equation defined by right side

• Right side must be previously defined operation
  (e..g. x == y) or terminating recursion (e.g. xs == ys)

Classes with Default Methods

class Eq a where  -- from Prelude library
    (==), (/=) :: a -> a -> Bool
    -- Minimal complete definition: (==) or (/=)
    x /= y  = not (x == y)
    x == y  = not (x /= y)

• Must override (redefine) at least one to break cycle above

What is Equality?

• Equality is equivalence relation in math. For all x, y, and z in type’s set:

  • Reflexivity: x == x is True.
  • Symmetry: x == y if and only if y == x.
  • Transitivity: if x == y and y == z, then x == z.

• x /= y equivalent to not (x == y)

• Type class laws — must hold for all Eq instances

• Reality intervenes! x == x for infinite? floating?

Example Class Visible

class Visible a where
    toString :: a -> String
    size     :: a -> Int

instance Visible Char where
    toString ch  = [ch]
    size _       = 1

instance Visible Bool where
    toString True  = "True"
    toString False = "False"
    size _         = 1

instance Visible a => Visible [a] where
    toString = concat . map toString
    size     = foldr (+) 1 . map size

Class Laws for Visible

• No constraints on the conversion to strings

• size must return Int, finite and bounded

Class Extension (Inheritance)

• Ord is subclass of Eq

class Eq a => Ord a where -- from Prelude
    (<), (<=), (>), (>=) :: a -> a -> Bool
    max, min             :: a -> a -> a
    -- Minimal complete definition: (<) or (>)
    -- Must break circular definition
    x <= y                  = x < y || x == y
    x <  y                  = y > x
    x >= y                  = x > y || x == y
    x >  y                  = y < x
    max x y   | x >= y      = x
              | otherwise   = y
    min x y   | x <= y      = x
              | otherwise   = y

Class Laws for Ord

• For <= and all x, y,z in type’s set (total order)

  • Reflexivity: x <= x is True

  • Antisymmetry: x <= y and y <= x, then x == y

  • Transitivity: if x <= y and y <= z, then x <= z

  • Trichotomy (comparability, totality): x <= y or y <= x

• == (and /=) satisfy Eq type class laws

• <, >, >=, max, and min satisfy definition in declaration

Example Use isort

    isort' :: Ord a => [a] -> [a]
    isort' []     = []
    isort' (x:xs) = insert' x (isort' xs)

    insert' :: Ord a => a -> [a] -> [a]
    insert' x []    = [x]
    insert' x (y:ys)
        | x <= y    = x:y:ys   -- overloaded <=
        | otherwise = y : insert' x ys

Multiple Constraints on Functions

vSort :: (Ord a,Visible a) => [a] -> String
vSort = toString . isort' 

vLookupFirst :: (Eq a,Visible b) => [(a,b)] -> a -> String
vLookupFirst xs x = toString (lookupFirst xs x)

lookupFirst :: Eq a => [ (a,b) ] -> a -> [b]
lookupFirst ws x  = [ z | (y,z) <- ws, y == x ]

Multiple Constraints on instance

instance (Eq a, Eq b) => Eq (a,b) where
    (x,y) == (z,w) =  x == z && y == w 

• == overloaded from different instances

Multiple Constraints on class

class (Ord a,Visible a) => OrdVis a
    
vSort :: OrdVis a => [a] -> String

• OrdVis has multiple inheritance — reuse methods of both

• Must satisfy type class laws for Ord and Visible

Built-In Haskell Classes

• Prelude classes in Section 6.3 of the Haskell 2010 Language

• Typeclassopedia by Brent Yorgey

Comparison to Java (1)

• Haskell class is collection of types; Java class similar to type

• Haskell class similar to Java abstract class except Haskell has no data, Java only single inheritance

• Haskell class similar to Java interface except Haskell has default method definitions (in Java from Java 8)

• Haskell instance is type, not object — like concrete Java class that extends abstract classes or implements interface

Comparison to Java (2)

• Haskell separates type definition from method definition; Java mixes type and method definition

• Haskell class methods correspond to Java instance methods

  Each instance provides own definition for methods; class defaults correspond to default definitions in parent class

  Haskell has no receiver object or mutable fields

• Haskell class methods bound statically at compile time; Java bound dynamically at runtime

Comparison to Java (3)

• Java attaches identifying information to runtime object; Haskell only attaches logically

• Haskell does not support Java/C++ overloading where functions have different types, same name

• Haskell objects cannot be implicitly coerced, types have no default parent — Java has universal base class Object (reference types)

• Haskell class separates type from access control, uses modules for access control — Java mixes

Type Classes Spreading

First appeared in Haskell, but adopted in newer languages

• Rust supports traits, limited form of type classes

• Scala’s implicit classes/parameters enable similar type enrichment idiom

• PureScript supports Haskell-like type classes

• Idris supports interfaces, generalization of Haskell type classes

• JavaScript has functional libraries such as Ramda

Key Ideas

• Overloading function giving same name, “same functionality” but different definitions for different types

• Type classes and instances

• Type class laws to define “same functionality”

• Multiple constraints, inheritance

• Comparison to classes in other languages

Source Code

The Haskell code for this chapter is file TypeClassMod.hs.