Are there any language extensions or language descendants of Haskell, that favor expressiveness, particularly in instance handling?

Question

At times, I run into the "feature" that Haskell only matches instance heads, namely,

instance (a ~ NewDataTyp b) => C a

will now match any type whatsoever, i.e. writing another instance declaration of C in your program will is an error, even if it cannot possibly conflict due to the context a ~ NewDataTyp b. At times, it takes a lot of effort to overcome; I've had to restructure hundreds of lines of code to avoid this limitation.

Are there any language extensions, or descendant languages (Curry? Agda?) that are designed with a higher priority for expressiveness? This could possibly sacrifice (a) openness of the typeclass world (b) polynomial time typechecking.

edit -- for those interested in the question, this page might also be of interest: http://www.haskell.org/haskellwiki/Future_of_Haskell

Selffertilization

Removing the open world assumption leads to more problems than you might expect. As far as I know, the only way to recover from that problem is to add full dependent types, and include the Ord instance being used in the Set's type. – Throughcomposed

Haskell type checking is not polynomial, since HM type checking is (doubly) exponential. – Dunlin

I'm not sure if Chameleon had such an extension. It requires the constraint solver to do backtracking, but I don't see any reason it shouldn't work. – Dunlin

@augustss, that sounds more like what I was looking for... will tell you when I have time to look – Selffertilization

Agda may be more "expressive" in that the definition will be more concise in a case such as this where you would use GADTs. – Ploughboy

If you what you want is default base case plus extensible type based cases I'd go with SYB3 (i.e. SYB-with-class). Trying to achieve this with "OverreachingInstances" is an anti-pattern. – District

Answer 1

For what it's worth, Scala accepts the more-or-less literal translation of what you just wrote. I'm not sure how useful it is.

trait C[T]
case class NewDataType[T]()

implicit def letItBeInjectiveWhyNot[K[_],T]: K[T] =:= K[T]

implicit def cIsh[A,S](implicit ev: A =:= NewDataType[S]): C[A]
implicit def another: C[Int]

implicitly[C[NewDataType[String]]]
implicitly[C[Int]]

Will