#12700: Don't warn about redundant constraints for type equalities -------------------------------------+------------------------------------- Reporter: crockeea | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: Type of failure: Incorrect | Unknown/Multiple warning at compile-time | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by crockeea): Sorry if I was unclear, Simon. GHC says the constraint `b ~ Foo a` is redundant. To me, this warning means that GHC is suggesting it would be better to write `foo :: (RealFrac a, Integral b) => a -> b`. I disagree with GHC's suggestion: I meant to write the original signature (which is equivalent to the one which requires `FlexibleContexts`), because it is more specific and can help with type inference elsewhere in my program. Moreover, if I wrote the original signature in a different form (the `FlexibleContexts` version), GHC does ''not'' suggest it would be better to write `foo :: (RealFrac a, Integral b) => a -> b`. In that case it notices that the type restriction is meaningful. What I'm getting at here is: if A and B are equivalent (as my two signatures are), then GHC should have the same behavior when I do either one. Maybe it's difficult for GHC to realize that my particular A and B are equivalent, and I suppose that would be a valid reason to close the ticket. As to why I chose to write the signature I did instead of the `FlexibleContexts` version, it can be save some space in type signatures when some type variables are equivalent to long expressions. I don't give a whit about using `FlexibleContexts`, in fact it is enabled almost everywhere in my code already. As to whether putting type equalities in contexts should require `FlexibleContexts`: that misses the point, since I get the same warning with the original signature when the extension is enabled. GHC still behaves differently on equivalent inputs. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12700#comment:2 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12700: Don't warn about redundant constraints for type equalities -------------------------------------+------------------------------------- Reporter: crockeea | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: Type of failure: Incorrect | Unknown/Multiple warning at compile-time | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by hsyl20): Could we allow local type alias declarations into contexts? E.g., {{{ foo :: (RealFrac a, Integral b, let b ~ Foo a) => a -> b }}} This would be equivalent to: {{{ foo :: forall a. (RealFrac a, Integral b, let b ~ Foo a) => a -> b }}} i.e., b doesn't leak and isn't reported as redundant. Still ideally "b" should be accessible in the function code (with ScopedTypeVariable, TypeApplications, etc.). It would be useful to me to avoid redundancy into contexts such as the following where "zs" is the type alias: {{{ xxx :: forall x xs ys zs m. ( Monad m , zs ~ Union (Filter x xs) ys , Catchable x xs , Liftable (Filter x xs) zs , Liftable ys zs ) => Variant xs -> (x -> Flow m ys) -> Flow m zs }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12700#comment:4 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12700: Don't warn about redundant constraints for type equalities -------------------------------------+------------------------------------- Reporter: crockeea | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: Type of failure: Incorrect | Unknown/Multiple warning at compile-time | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by crockeea): I'm not sure why the extra syntax is needed, i.e. how is `let b ~ Foo a` different from `b ~ Foo a`? I'm intending, as hsyl20 indicated, to do the former, but apparently using the `b ~ Foo a` implies, and is more general than, `let b ~ Foo a`. Is there no way for GHC to turn the signature `forall a b . (b ~ Foo a) => a -> b` into `forall a . (let b ~ Foo a) => a -> b` or even `forall a . a -> Foo a`? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12700#comment:6 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler