1 Advantages of TypeFamilies

1.1 Speed

For what I did the type families solution was considerably faster
than the functional dependencies code at least in GHC-7.4.1.
Thus the bug in ticket 5970 does no longer hurt me.
(In GHC-6.12.3 the conversion to type families made the compilation even slower.)

1.2 Anonymous type function values

One of the most annoying type classes of the llvm package was the IsSized class:

class(LLVM.IsType a, IsPositive size)=> IsSized a size | a -> size

where size is a type-level decimal natural number.

Many llvm functions require that an LLVM type has a size
where the particular size is not important.
However, I always have to name the size type.
I also cannot get rid of it using a subclass, like

class(IsSized a size)=> IsAnonymouslySized a where

The

size

type is somehow sticky.

The conversion of this type class to type families is straightforward:

Thus summarized: Type families may replace several other type extensions.
If I ignore the associated type functions
then many classes become Haskell 98 with Haskell 98 instances.
This is good because those instances prevent instance conflicts with other non-orphan instances.

2 Disadvantage of TypeFamilies

2.1 Redundant instance arguments

I have to write the type arguments both in the instance head
and in the function argument.
This is especially annoying in the presence of multi-parameter type classes
with bidirectional dependencies.
E.g.