| overlappable? In other words, does OVERLAPPABLE instruct the | type checker to expect overlapping instances even if none of | them are visible? No, not at the moment. Suppose we have class C a where op :: a -> String instance {-# OVERLAPPABLE #-} C a => C [a] where op x = "[a]" instance {-# OVERLAPPING #-} C [Int] where op x = "[Int]" foo :: C a => a -> String foo x = op [x] ++ "urk" Then we (rightly) get an overlapping instance error when we try to solve the (C [a]) constraint arising from op [a] in foo's RHS. But if we omit the type signature for foo, then GHC will (as before) not simplify the (C [a]) constraint, for the same reason, but because it's unsolved GHC will abstract over it to give the inferred type foo :: C [a] => a -> String But this only happens if the overlapping instance is visible here. If the C [Int] instance is in some other module, then GHC will infer foo :: C a => a -> String. Your point is that if the C [a] instance is marked OVERLAPPABLE, perhaps GHC should decline to simplify it, on the grounds that a more specific instance might appear. But then the (C [a]) instance would never, ever be used! (On the grounds that it might be overlapped by some as-yet-unseen instance. So I don't think this would work. In any case, if the current behaviour doesn't seem precisely defined by the user manual, could you suggest some words that would make it clearer? Simon | -----Original Message----- | From: Glasgow-haskell-users [mailto:glasgow-haskell-users- | bounces@haskell.org] On Behalf Of Bertram Felgenhauer | Sent: 07 August 2014 16:25 | To: glasgow-haskell-users@haskell.org | Subject: Re: Overlapping and incoherent instances | | Simon Peyton Jones wrote: | > | >>On a largely unrelated note, here's another thing I don't | > | >>understand: when is OVERLAPPABLE at one instance declaration | > | >>preferable to using only OVERLAPPING at the instance declarations | > | >>that overlap it? | > | > It's a user decision. GHC allows | > - OVERLAPPABLE at the instance that is being overlapped, or | > - OVERLAPPING at the instance that is doing the overlapping, or | > - both | | I'm curious how this affects simplification of contexts. If I have | | class Foo a | instance Foo a => Foo [a] | | then GHC will simplify | | foo :: Foo [a] => a -> () | | to | | foo :: Foo a => a -> () | | Would this be prevented by declaring the Foo [a] instance as | overlappable? In other words, does OVERLAPPABLE instruct the | type checker to expect overlapping instances even if none of | them are visible? | | Cheers, | | Bertram | _______________________________________________ | Glasgow-haskell-users mailing list | Glasgow-haskell-users@haskell.org | http://www.haskell.org/mailman/listinfo/glasgow-haskell-users