Fleshing out my &quot;other point&quot;:<p>&quot;Passing the dictionary as a record&quot; is a pretty common alternative to typeclasses.  The way it works is if you have a typeclass:<p><pre><code>    class Foo a where
        foo :: ...
        bar :: ...
</code></pre>
you instead make a record that looks like:<p><pre><code>    data Foo = Foo { foo :: ..., bar :: ... }
</code></pre>
This works great for a lot of things, and is often preferable to typeclasses when all you&#x27;re doing is defining an interface.  One objection is that things look slightly less tidy, but the main problem with it (where it&#x27;s a problem at all) is that there&#x27;s no way of identifying individual implementors of an interface by type anymore.  An example where this relevant is Set.  We could define the Set operations to take a comparison function, but we couldn&#x27;t be sure that all comparison functions agree across all interactions with a particular set.<p>What I mean by &quot;reifying the instance&quot; is indexing typeclasses with a (single constructor) type that identifies the instance, and then passing that around to let us select which instance we care about, even for the same underlying type.<p>For example:<p><pre><code>    {-# LANGUAGE FunctionalDependencies #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE FlexibleInstances #-}

    import Data.Function (on)

    class ParamOrd o a | o -&gt; a where
        pcompare :: o -&gt; a -&gt; a -&gt; Ordering

    data StringsOverLength = StringsOverLength
    data StringsLexicographically = StringsLexicographically

    data IntegersInOrder = IntegersInOrder
    data IntegersReversed = IntegersReversed

    data ReversedOrdering r = ReversedOrdering r

    instance ParamOrd IntegersInOrder Integer where
        pcompare _ = compare

    instance ParamOrd (ReversedOrdering r) Integer where
        pcompare o = flip (pcompare o)

    instance ParamOrd StringsOverLength String where
        pcompare _ = compare `on` length

    instance ParamOrd StringsLexicographically String where
        pcompare _ = compare
</code></pre>
Now we could write a new version of Set, `ParamSet o a` such that we can still enforce agreement while choosing our orderings with an argument rather than a newtype.