Do-it-yourself dictionaries in Haskell 1

Do-it-yourself dictionaries in Haskell

Ingmar Brouns & Lukas Spee

Do-it-yourself dictionaries in Haskell 2

Introduction

• Extending the Haskell class system• Allowing multiple implementations for one

instance of a class declaration

Do-it-yourself dictionaries in Haskell 3

Introduction – examples (1)

• An example from the Java world:Equality: based on reference equivalence or member field value equivalence?

Do-it-yourself dictionaries in Haskell 4

Introduction – example (2)

• In Haskell: Ordering on Strings with the (>) operator:

based on alfabetical order (standard) or on length?

• Filename organizer vs Pretty printer: lexicographical equality vs length equality

Do-it-yourself dictionaries in Haskell 5

Issues

• Not sufficient for examples• We need to extend the class system• How does the current system work ?• What different syntaxes will be an option

(describing with intuitive semantics)• How does the new syntax reflect on the

semantics ?

Do-it-yourself dictionaries in Haskell 6

Current Class System

• Define class & instance declarations• Translation, to a core-Haskell variant

without overloading, by preprocessor• How does this translation work ?

Do-it-yourself dictionaries in Haskell 7

Translation to core-Haskell

• Class declarations are translated to dictionary data type declarations

• Instance declarations are translated to instances of the corresponding dictionary data type

Do-it-yourself dictionaries in Haskell 8

Translation - exampleclass Eq a => Ord a where

(>) :: a -> a -> Bool

data OrdDict a= OrdDict {

gt’ :: a -> a -> Bool,

…}

will be translated to:

Do-it-yourself dictionaries in Haskell 9

Translation - example

instance Ord Char where(>) = primitiveGT

ordDictChar :: OrdDict CharordDictChar = OrdDict {

gt’ = primitiveGT,…}

will be translated to:

Do-it-yourself dictionaries in Haskell 10

Translation - example

foo :: Ord a => a -> a -> Boolfoo = \x y -> x > y

foo :: OrdDict a -> a -> a -> Boolfoo = \ordDict x y ->

gt’ ordDict x y

So, in fact, dictionaries are implicit parameters that ‘control’ the overloading

will be translated to:

Do-it-yourself dictionaries in Haskell 11

Translation - exampleWhich instance of OrdDict a is used for the application of foo depends on the types of the parameters, thus:foo ‘a’ ‘b’

will be translated to:

foo ordDictChar ‘a’ ‘b’

Do-it-yourself dictionaries in Haskell 12

Back to our example

• We now have an instance of Ord for Char• We need an instance of Ord for String

([Char])• Can we construct it from our Ord Char

instance ?

Do-it-yourself dictionaries in Haskell 13

Back to our exampleYes, but we need an instance of Ord [a] for this:instance Ord a => Ord [a] where

(>) [] _ = False(>) _ [] = True(>) (x:xs) (y:ys) = (x > y) &&

(xs > ys)

Do-it-yourself dictionaries in Haskell 14

A dictionary for Ord [a]ordDictList :: OrdDict a -> OrdDict [a]ordDictList ordD = OrdDict (ordList ordD)

ordList :: OrdDict a -> [a] -> [a] -> BoolordList ordDict (x:xs) [] = TrueordList ordDict [] (y:ys) = FalseordList ordDict (x:xs) (y:ys) =

gt’ ordDict x y && gt’ (ord ordDict) xs ys

Please remember this for one more slide

Do-it-yourself dictionaries in Haskell 15

A dictionary for Ord [Char]Now we can easily combine the two to create the dictionary for Ord String:ordDictString = ordDictList ordDictChar

That’s nice, but how is it going to solve our problem?

Do-it-yourself dictionaries in Haskell 16

Dictionaries are the answer!

• If we want a new implementation for (>) on String, we’ll make it and put it in our own dictionary

• Wherever we want to use this dictionary instead of the implicitly passed default dictionary, we make this explicit

Do-it-yourself dictionaries in Haskell 17

Back to our example

getMaximumSize :: String -> String -> Int

getMaximumSize {impl2} = \x y -> if x > y then (length x) else (length y)

(>) :: String -> String -> Bool

(>) = \x y -> (length x) > (length y)

Suppose we have our own dictionary for Ord [Char] called ‘impl2’ which defines (>) as:

We can now explicitly pass this dictionary to a function:

Do-it-yourself dictionaries in Haskell 18

Extending the syntax

• Several attempts• What are the drawbacks ?• How can they be avoided ?

Do-it-yourself dictionaries in Haskell 19

Attempt 1Allow users to define dictionaries explicitlyinstance Ord [Char] where

(>) [] _ = False(>) _ [] = True(>) (x:xs) (y:ys) = (x > y) &&

(xs > ys)...

ordDictString’ = OrdDict { gt’ = (\a b -> compare (length a)

(length b) == GT),...}

Do-it-yourself dictionaries in Haskell 20

Attempt 1

• Drawbacks:• User has to be familiar dictionaries as used

in core-Haskell• Dictionary is copied so user must use

implementations of overloaded functions in definition

• Implementation is no longer hidden

Do-it-yourself dictionaries in Haskell 21

Attempt 2• Define extra implementation within

instance declaration• Tag the extra implementation

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

(xs > ys)(>) a b = length a > length b {impl2}

Do-it-yourself dictionaries in Haskell 22

Attempt 2

• Good things:– Implementation not visible to user– Consistent with existing syntax

• Drawbacks– Unhandy when using modules

Do-it-yourself dictionaries in Haskell 23

Attempt 3 Name the instance declaration

impl2 = instance Ord [Char] where(>) a b = length a > length b

Capable of modifying instances in other modules

Do-it-yourself dictionaries in Haskell 24

Attempt 4 Which instance declaration do we want to override ?

Impl2 overrides impl = instance Ord [Char]where(>) a b = length a > length b

When no overrides statement -> defaultOnly one default allowed, explicit or implicitly defined

Do-it-yourself dictionaries in Haskell 25

Type Checking

Where do we need to do new checks ?• Type checks:

– Type of new implementation should correspond to type of overridden implementation

– explicit dictionary usage should have same type as declared in explicit type

Do-it-yourself dictionaries in Haskell 26

Formal typing / translation rules

Do-it-yourself dictionaries in Haskell 27

Formal typing / translation rules

• Now:– gt :: Ord a => a -> a -> Bool

• Will be written as– gt :: forall a. (ord :: Ord a) . a -> a ->

Bool

• Eq a is an abbrevation for (a -> a -> Bool)• But now the important part !!!

Do-it-yourself dictionaries in Haskell 28

Typing / translation rules

• Translation is controlled by typing

A,(ord :: Ord Char \ ordDictChar) |- e :: p \ ē

A |- e :: (ord :: Ord Char).p \ (\ ordDictChar. ē)

• In the current system, there can only be one instance with a certain type

• In our system this is not the case

Do-it-yourself dictionaries in Haskell 29

Typing / translation rules

• Result:• Translation is no longer only type driven• Now also name driven• For example not passing a list of

dictionaries, but a list of (name, dictionary) tuples.

Do-it-yourself dictionaries in Haskell 30

Implementation issues for UHC

• Preprocessor has to be adjusted– Overriding dictionary should have same type as

overridden dictionary– Named dictionaries have to be generated– So the context for passing dictionaries will have

to be adjusted– User defined dictionary usage has to be type

checked

Do-it-yourself dictionaries in Haskell 31

Conclusion

• Allowing users to define alternative implementations of class instances, gives them more freedom.

• Formal typing rules do not change, only the translation is now also dependent of names

• Some extra type checks will be needed• It is possible to implement this in UHC

Do-it-yourself dictionaries in Haskell 32

Questions

1. Now it is the case that the translation is purely type driven. What is the case with our extension, and explain why it is like that ?

2. How does this affect the existing typing rules ?

3. Explain the use of our overrides statement.