[Haskell-cafe] Avoiding undecidables

[Michael Snoyman]

Hi all,

Well, I've got two problems which both want to be solved with undecidable
and overlapping instances. Obviously, I'd like to try and avoid them. For
the record, the problems have to do with the control-monad-failure and
convertible packages. The code below *should* make clear what I'm trying to
accomplish:

-- failure should not be limited to just monads, so...
class Failure e f where
    failure :: e -> f v
class (Functor f, Failure e f) => FunctorFailure e f
instance (Functor f, Failure e f) => FunctorFailure e f -- undecidable,
overlaps
class (Applicative f, Failure e f) => ApplicativeFailure e f
instance (Applicative f, Failure e f) => ApplicativeFailure e f --
undecidable, overlaps
class (Monad f, Failure e f) => MonadFailure e f
instance (Monad f, Failure e f) => MonadFailure e f -- undecidable, overlaps

And now the convertible issue. I want two type classes: Convert for anything
which *might* be convertible, but might not. For example, sometimes a String
can be converted to an Int (like the string "5"), but sometimes it will fail
(like "five"). TotalConvert is when something *is* convertible, such as Int
to String (simply the show function). Thus the following:

class Convert x y where
    convert :: x -> Maybe y
class Convert x y => TotalConvert x y where
    totalConvert :: x -> y
instance TotalConvert x y => Convert x y where -- Boom!
    convert = Just . totalConvert

Any ideas are most welcome. Both of these seem like cases where the compiler
could do some DWIMery, but isn't.

Michael
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org/pipermail/haskell-cafe/attachments/20091205/46f1b654/attachment.html