If you say who you are in this way, we'll be able to acknowledge your help in a revised version of the paper.

Patryk Zadarnowski offered the following during an email discussion:

> Are overlapping and undecidable instances different things?

Yep, quite different. Both try to add general programming to the type
level.
Overlapping instances do that by allowing things like:

instance Foo (a,Int)where...instance Foo (a, b)where...

and devising rules fo choosing (1) over (2) whenever possible. Right
now,
this is very, very clunky, under-specified and likely to go away once
Manuel
finishes his associated data types implementation. :) For example,
what is
GHC supposed to do with:

instance Foo (a,Int)where...instance Foo (Int, b)where...

Undecidable instances basically means that general recursion is allowed
at the type level. So the above will be accepted (I think) and, more
likely
than not, result in GHC's typechecker spinning into an infinite loop
when
it tries to resolve all these instance declarations. Hence the name; if
the instance declarations are allowed to express any patterns, they
provide
a Turing complete language, and if they provide a Turing complete
language,
than it's impossible to decide whether any given type-level program will
terminate (i.e. is OK) or not. If you're using
-fallow-undecidable-instances
than yes, your haskell type system is Turing-complete :)

BTW, the way GHC solves this is by declaring a fixed-depth stack for
"evaluation" of instance declarations. It's something small like 5-deep
by default. If it gets exceeded, GHC will bail out with an error
message.
You can increase the stack depth using some other -f on the command
line :)