Suppose I have one piece of code like this:

class Result r e | r -> e where   failure :: e -> r a     success :: a -> r a

at :: Result r String => [a] -> Int -> r a at xs i = if i >= 0 && i < length xs             then success (xs !! i)             else failure "Wrong index"

Either instance of Result is quite straightforward:

instance Result (Either e) e where     failure e = Left e     success x = Right x

Maybe instance is discarding failure information:

instance Result Maybe e where     failure _ = Nothing     success x = Just x

Some tests it in ghci: ghci> let xs = [0,1,2] ghci> at xs 2 :: Either String Integer Right 2 ghci> at xs 3 :: Either String Integer Left "Wrong index" ghci> at xs 2 :: Maybe Integer Just 2 ghci> at xs 3 :: Maybe Integer Nothing I'd like to replace functional dependencies with type families (associated types in my case):

class Result r where   type Failure   failure :: Failure r -> r a   success :: a -> r a

Either instance is ok:

instance Result (Either e) where   type Failure (Either e) = e   failure e = Left e   success x = Right x

But what to do with Maybe?

instance Result Maybe where   type Failure Maybe = forall e. e -- can't do this   failure _ = Nothing   success x = Just x