#10532: Unnecessary constraints when using overlapping instances -------------------------------------+------------------------------------- Reporter: MikeIzbicki | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler (Type | Version: 7.10.1 checker) | Keywords: Resolution: | Architecture: Operating System: Unknown/Multiple | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Description changed by MikeIzbicki: Old description:

The following code compiles just fine:

{{{ class Foo a where foo :: a -> Int instance Foo a where foo _ = 5

f :: a -> Int f = foo }}}

But if we modify the code to use overlapping instances like so:

{{{ class Foo a where foo :: a -> Int instance {-# OVERLAPS #-} Foo Int where foo = id instance {-# OVERLAPPABLE #-} Foo a where foo _ = 5

f:: a -> Int f = foo }}}

We get the following compiler message: {{{ Overlapping instances for Foo a arising from a use of ‘foo’ Matching instances: instance [overlappable] Foo a -- Defined at ... instance [overlap ok] Foo Int -- Defined at ... (The choice depends on the instantiation of ‘a’ To pick the first instance above, use IncoherentInstances when compiling the other instance declarations) }}}

Including the constraint in the type signature makes the problem go away, but the constraint shouldn't be needed. In most use cases this wouldn't be a big deal, but it's making my type signatures much messier looking than they actually are.

Adding IncoherentInstances as the error message suggests gives the instance I don't want. Weirdly, I get different instances depending on whether the constraint is in the type signature or not.

New description: The following code compiles just fine: {{{ class Foo a where foo :: a -> Int instance Foo a where foo _ = 5 f :: a -> Int f = foo }}} But if we modify the code to use overlapping instances like so: {{{ class Foo a where foo :: a -> Int instance {-# OVERLAPS #-} Foo Int where foo = id instance {-# OVERLAPPABLE #-} Foo a where foo _ = 5 f:: a -> Int f = foo }}} We get the following error message: {{{ Overlapping instances for Foo a arising from a use of ‘foo’ Matching instances: instance [overlappable] Foo a -- Defined at ... instance [overlap ok] Foo Int -- Defined at ... (The choice depends on the instantiation of ‘a’ To pick the first instance above, use IncoherentInstances when compiling the other instance declarations) }}} Including the constraint in the type signature makes the problem go away, but the constraint shouldn't be needed. In most use cases this wouldn't be a big deal, but it's making my type signatures much messier looking than they actually are. Adding IncoherentInstances as the error message suggests gives the instance I don't want. Weirdly, I get different instances depending on whether the constraint is in the type signature or not. -- -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10532#comment:1> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10532: Unnecessary constraints when using overlapping instances -------------------------------------+------------------------------------- Reporter: MikeIzbicki | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler (Type | Version: 7.10.1 checker) | Keywords: Resolution: | Architecture: Operating System: Unknown/Multiple | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Comment (by MikeIzbicki): I don't understand why this would be expected behavior. GHC lets me remove the constraint when overlapping instances are not involved, but requires the constraint when overlapping instances are involved. Why should there be a difference when overlapping instances gets involved? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10532#comment:3> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10532: Unnecessary constraints when using overlapping instances -------------------------------------+------------------------------------- Reporter: MikeIzbicki | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler (Type | Version: 7.10.1 checker) | Keywords: Resolution: | Architecture: Operating System: Unknown/Multiple | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Comment (by rwbarton): In any event, what you seem to want is impossible: `f :: a -> Int` can never dispatch on the type of `a`, even with IncoherentInstances or any other language extension. You really must have the constraint if you want to use it! -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10532#comment:5> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10532: Unnecessary constraints when using overlapping instances -------------------------------------+------------------------------------- Reporter: MikeIzbicki | Owner: Type: bug | Status: closed Priority: normal | Milestone: Component: Compiler (Type | Version: 7.10.1 checker) | Keywords: Resolution: invalid | Architecture: Operating System: Unknown/Multiple | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Changes (by simonpj): * status: new => closed * resolution: => invalid Comment: Consider what happens, in your modified code with overlapping instances, when you call `f` thus: `f (4::Int)`. What result do you expect? You might say: 1. The instance `Foo Int` clearly says that `foo` is the identity function on `Int`. I'm giving it an `Int` so `f 4` should return `4`. 2. Or you might say: when I compiled the code for `f`, GHC had to choose which instance to use, of the two available. Since the constraint is `Foo a`, and GHC knows nothing about `a` it must choose the `Foo a` instance. Result, `f 4` returns 5. This incoherence is what GHC is complaining about. If it can't make a unique choice, it decides not to decide, and rejects the program instead. If it silently chose (2), which I think you intend, then if you replaced the call `(f 4)` with the result of inlining `f`, thus `(foo 4)`, the result of the program would change. This has been GHC's behaviour (and Hugs) ever since we introduced overlapping instances. The flag `-XIncoherentInstances` switches off this behaviour, and does (2). Simon -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10532#comment:7> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10532: Unnecessary constraints when using overlapping instances -------------------------------------+------------------------------------- Reporter: MikeIzbicki | Owner: Type: bug | Status: closed Priority: normal | Milestone: Component: Compiler (Type | Version: 7.10.1 checker) | Keywords: Resolution: invalid | Architecture: Operating System: Unknown/Multiple | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Comment (by goldfire): What would you like to happen when GHC sees `(f (3 :: Int))`? My guess is that you expect GHC to notice that there is an instance for `Foo Int` around and to use it. But if `f` had the type `a -> Int`, then there is nothing to tell GHC to go out and look for the instance. When we have `f :: Foo a => a -> Int`, it tells GHC to look for a `Foo` instance at call sites. If, on the other hand, you want `f` always to use the `Foo a` instance, then `IncoherentInstances` is the way to go. I don't see this as an issue of parametricity, but just one of a misunderstanding about what the type signature means. As for what happens when you omit the signature: You're hitting the monomorphism restriction. When I load this into GHCi: {{{ {-# LANGUAGE FlexibleInstances, NoMonomorphismRestriction #-} class Foo a where foo :: a -> Int instance {-# OVERLAPS #-} Foo Int where foo = id instance {-# OVERLAPPABLE #-} Foo a where foo _ = 5 f = foo }}} I get an inferred type for `f` of `Foo a => a -> Int`. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10532#comment:9> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler