- ghc-tickets - Haskell.org

[GHC] #9611: Suggest the cause of "No instance" errors involving multiple versions of a package
by GHC 18 Feb '16

18 Feb '16

#9611: Suggest the cause of "No instance" errors involving multiple versions of a package -------------------------------------+------------------------------------- Reporter: rwbarton | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.3 Keywords: | Operating System: Architecture: Unknown/Multiple | Unknown/Multiple Difficulty: Unknown | Type of failure: Blocked By: | None/Unknown Related Tickets: | Test Case: | Blocking: | Differential Revisions: -------------------------------------+------------------------------------- Suppose I have packages A-1.0, A-1.1, and B-1.0 built against A-1.0, and A (both versions) defines a type T which B defines to be an instance of some class C. If I load A-1.1 and B-1.0 into ghci and try to use the C T instance I will get a "No instance for C T" error, because T refers to A-1.1:T and B only defines an instance for A-1.0:T. However, if I don't realize this is what's going on, the error will be quite confusing as B appears to define an instance C T. Or, A could define the class C, rather than the type T, with the same result. This is quite common nowadays because there is a newer version of transformers (0.4.1.0) than the one which ships with GHC (0.3.0.0) and it's easy to end up installing mtl or lens against 0.3.0.0, and then some other package which pulls in 0.4.1.0. It would be nice to give a hint about what is going on, like {{{ No instance for (MonadIO X) arising from a use of ‘liftIO’ In the expression: ... ... Note: there is an instance transformers-0.3.0.0:MonadIO X }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9611> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 8

[GHC] #11488: -dynamic-too is entirely undocumented
by GHC 18 Feb '16

18 Feb '16

#11488: -dynamic-too is entirely undocumented -------------------------------------+------------------------------------- Reporter: bgamari | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Documentation | Version: 7.10.3 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- It seems like there are precisely zero mentions of the `-dynamic-too` flag in our user documentation. This may not be a flag that users will use often but it still needs documentation -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11488> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #11541: Type errors sometimes has a lot of irrelevant information
by GHC 18 Feb '16

18 Feb '16

#11541: Type errors sometimes has a lot of irrelevant information -------------------------------------+------------------------------------- Reporter: augustss | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.3 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Here's an example. The essential part of the error message is {{{ Couldn't match type `DeclS IString TLoc' with `DeclHeadS IString l' }}} This is buried somewhere in the middle. Fixing this problem makes all the others go away. It seems ghc spits out constraints that it hasn't solved, but they are unsolved because there was a type error. Full message: {{{ Stem\Mu\Deriving.hs:214:93: No instance for (Integral b0) arising from a use of `constr' The type variable `b0' is ambiguous Note: there are several potential instances: instance Integral Int -- Defined in `GHC.Real' instance Integral Integer -- Defined in `GHC.Real' instance Integral GHC.Types.Word -- Defined in `GHC.Real' ...plus 8 others In the first argument of `zipWith', namely `constr' In the second argument of `($)', namely `zipWith constr qs [0 .. ]' In the expression: List () $ zipWith constr qs [0 .. ] Stem\Mu\Deriving.hs:214:103: No instance for (Enum b0) arising from the arithmetic sequence `0 .. ' The type variable `b0' is ambiguous Note: there are several potential instances: instance Enum GeneralCategory -- Defined in `Data.Char' instance Enum InlInfo -- Defined in `Cortex.Stem.Mu.Util' instance Enum Double -- Defined in `GHC.Float' ...plus 24 others In the third argument of `zipWith', namely `[0 .. ]' In the second argument of `($)', namely `zipWith constr qs [0 .. ]' In the expression: List () $ zipWith constr qs [0 .. ] Stem\Mu\Deriving.hs:214:104: No instance for (Num b0) arising from the literal `0' The type variable `b0' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the expression: 0 In the third argument of `zipWith', namely `[0 .. ]' In the second argument of `($)', namely `zipWith constr qs [0 .. ]' Stem\Mu\Deriving.hs:285:28: No instance for (Integral a0) arising from a use of `list' The type variable `a0' is ambiguous Note: there are several potential instances: instance Integral Int -- Defined in `GHC.Real' instance Integral Integer -- Defined in `GHC.Real' instance Integral GHC.Types.Word -- Defined in `GHC.Real' ...plus 8 others In the second argument of `($)', namely `list 10 (mkstr (nameString n) : map (ashow (mkInt () 11) . qvar) vs)' In the second argument of `($)', namely `shows $ list 10 (mkstr (nameString n) : map (ashow (mkInt () 11) . qvar) vs)' In the expression: method (PApp () (UnQual () $ dropAnn n) (map (PVar ()) vs)) $ shows $ list 10 (mkstr (nameString n) : map (ashow (mkInt () 11) . qvar) vs) Stem\Mu\Deriving.hs:285:33: No instance for (Num a0) arising from the literal `10' The type variable `a0' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the first argument of `list', namely `10' In the second argument of `($)', namely `list 10 (mkstr (nameString n) : map (ashow (mkInt () 11) . qvar) vs)' In the second argument of `($)', namely `shows $ list 10 (mkstr (nameString n) : map (ashow (mkInt () 11) . qvar) vs)' Stem\Mu\Deriving.hs:285:72: No instance for (Integral a1) arising from a use of `mkInt' The type variable `a1' is ambiguous Note: there are several potential instances: instance Integral Int -- Defined in `GHC.Real' instance Integral Integer -- Defined in `GHC.Real' instance Integral GHC.Types.Word -- Defined in `GHC.Real' ...plus 8 others In the first argument of `ashow', namely `(mkInt () 11)' In the first argument of `(.)', namely `ashow (mkInt () 11)' In the first argument of `map', namely `(ashow (mkInt () 11) . qvar)' Stem\Mu\Deriving.hs:285:81: No instance for (Num a1) arising from the literal `11' The type variable `a1' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the second argument of `mkInt', namely `11' In the first argument of `ashow', namely `(mkInt () 11)' In the first argument of `(.)', namely `ashow (mkInt () 11)' Stem\Mu\Deriving.hs:288:44: No instance for (Show a3) arising from a use of `var' The type variable `a3' is ambiguous Note: there are several potential instances: instance Show GeneralCategory -- Defined in `Data.Char' instance Show IString -- Defined in `Cortex.Utils.IString' instance Show a => Show (Cortex.Utils.List.Down a) -- Defined in `Cortex.Utils.List' ...plus 171 others In the second argument of `PVar', namely `(var 0)' In the second argument of `PInfixApp', namely `(PVar () (var 0))' In the first argument of `method', namely `(PInfixApp () (PVar () (var 0)) (UnQual () $ dropAnn n) (PVar () (var 1)))' Stem\Mu\Deriving.hs:288:48: No instance for (Num a3) arising from the literal `0' The type variable `a3' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the first argument of `var', namely `0' In the second argument of `PVar', namely `(var 0)' In the second argument of `PInfixApp', namely `(PVar () (var 0))' Stem\Mu\Deriving.hs:288:86: No instance for (Show a4) arising from a use of `var' The type variable `a4' is ambiguous Note: there are several potential instances: instance Show GeneralCategory -- Defined in `Data.Char' instance Show IString -- Defined in `Cortex.Utils.IString' instance Show a => Show (Cortex.Utils.List.Down a) -- Defined in `Cortex.Utils.List' ...plus 171 others In the second argument of `PVar', namely `(var 1)' In the fourth argument of `PInfixApp', namely `(PVar () (var 1))' In the first argument of `method', namely `(PInfixApp () (PVar () (var 0)) (UnQual () $ dropAnn n) (PVar () (var 1)))' Stem\Mu\Deriving.hs:288:90: No instance for (Num a4) arising from the literal `1' The type variable `a4' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the first argument of `var', namely `1' In the second argument of `PVar', namely `(var 1)' In the fourth argument of `PInfixApp', namely `(PVar () (var 1))' Stem\Mu\Deriving.hs:289:28: No instance for (Integral a5) arising from a use of `list' The type variable `a5' is ambiguous Note: there are several potential instances: instance Integral Int -- Defined in `GHC.Real' instance Integral Integer -- Defined in `GHC.Real' instance Integral GHC.Types.Word -- Defined in `GHC.Real' ...plus 8 others In the second argument of `($)', namely `list (precOf n) [ashow pp $ qvar $ var 0, mkstr (nameString n), ashow pp $ qvar $ var 1]' In the second argument of `($)', namely `shows $ list (precOf n) [ashow pp $ qvar $ var 0, mkstr (nameString n), ashow pp $ qvar $ var 1]' In the expression: method (PInfixApp () (PVar () (var 0)) (UnQual () $ dropAnn n) (PVar () (var 1))) $ shows $ list (precOf n) [ashow pp $ qvar $ var 0, mkstr (nameString n), ashow pp $ qvar $ var 1] Stem\Mu\Deriving.hs:289:34: No instance for (Num a5) arising from a use of `precOf' The type variable `a5' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the first argument of `list', namely `(precOf n)' In the second argument of `($)', namely `list (precOf n) [ashow pp $ qvar $ var 0, mkstr (nameString n), ashow pp $ qvar $ var 1]' In the second argument of `($)', namely `shows $ list (precOf n) [ashow pp $ qvar $ var 0, mkstr (nameString n), ashow pp $ qvar $ var 1]' Stem\Mu\Deriving.hs:289:63: No instance for (Show a6) arising from a use of `var' The type variable `a6' is ambiguous Note: there are several potential instances: instance Show GeneralCategory -- Defined in `Data.Char' instance Show IString -- Defined in `Cortex.Utils.IString' instance Show a => Show (Cortex.Utils.List.Down a) -- Defined in `Cortex.Utils.List' ...plus 171 others In the second argument of `($)', namely `var 0' In the second argument of `($)', namely `qvar $ var 0' In the expression: ashow pp $ qvar $ var 0 Stem\Mu\Deriving.hs:289:67: No instance for (Num a6) arising from the literal `0' The type variable `a6' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the first argument of `var', namely `0' In the second argument of `($)', namely `var 0' In the second argument of `($)', namely `qvar $ var 0' Stem\Mu\Deriving.hs:289:110: No instance for (Show a7) arising from a use of `var' The type variable `a7' is ambiguous Note: there are several potential instances: instance Show GeneralCategory -- Defined in `Data.Char' instance Show IString -- Defined in `Cortex.Utils.IString' instance Show a => Show (Cortex.Utils.List.Down a) -- Defined in `Cortex.Utils.List' ...plus 171 others In the second argument of `($)', namely `var 1' In the second argument of `($)', namely `qvar $ var 1' In the expression: ashow pp $ qvar $ var 1 Stem\Mu\Deriving.hs:289:114: No instance for (Num a7) arising from the literal `1' The type variable `a7' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the first argument of `var', namely `1' In the second argument of `($)', namely `var 1' In the second argument of `($)', namely `qvar $ var 1' Stem\Mu\Deriving.hs:290:37: No instance for (Integral a2) arising from a use of `mkInt' The type variable `a2' is ambiguous Note: there are several potential instances: instance Integral Int -- Defined in `GHC.Real' instance Integral Integer -- Defined in `GHC.Real' instance Integral GHC.Types.Word -- Defined in `GHC.Real' ...plus 8 others In the expression: mkInt () (precOf n + 1) In an equation for `pp': pp = mkInt () (precOf n + 1) In an equation for `sh': sh (QualConDecl _ _ _ (InfixConDecl _ t1 n t2)) = method (PInfixApp () (PVar () (var 0)) (UnQual () $ dropAnn n) (PVar () (var 1))) $ shows $ list (precOf n) [ashow pp $ qvar $ var 0, mkstr (nameString n), ashow pp $ qvar $ var 1] where pp = mkInt () (precOf n + 1) Stem\Mu\Deriving.hs:290:56: No instance for (Num a2) arising from a use of `+' The type variable `a2' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the second argument of `mkInt', namely `(precOf n + 1)' In the expression: mkInt () (precOf n + 1) In an equation for `pp': pp = mkInt () (precOf n + 1) Stem\Mu\Deriving.hs:297:47: No instance for (Integral a8) arising from a use of `mkInt' The type variable `a8' is ambiguous Note: there are several potential instances: instance Integral Int -- Defined in `GHC.Real' instance Integral Integer -- Defined in `GHC.Real' instance Integral GHC.Types.Word -- Defined in `GHC.Real' ...plus 8 others In the first argument of `ashow', namely `(mkInt () 0)' In the second argument of `aapp', namely `ashow (mkInt () 0) (qvar $ dropAnn n)' In the expression: mkstr (nameString n & " = ") `aapp` ashow (mkInt () 0) (qvar $ dropAnn n) Stem\Mu\Deriving.hs:297:56: No instance for (Num a8) arising from the literal `0' The type variable `a8' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the second argument of `mkInt', namely `0' In the first argument of `ashow', namely `(mkInt () 0)' In the second argument of `aapp', namely `ashow (mkInt () 0) (qvar $ dropAnn n)' Stem\Mu\Deriving.hs:337:44: No instance for (Show a10) arising from a use of `varx' The type variable `a10' is ambiguous Note: there are several potential instances: instance Show GeneralCategory -- Defined in `Data.Char' instance Show IString -- Defined in `Cortex.Utils.IString' instance Show a => Show (Cortex.Utils.List.Down a) -- Defined in `Cortex.Utils.List' ...plus 171 others In the first argument of `map', namely `varx' In the expression: map varx [0, 1] In a pattern binding: [x0, x1] = map varx [0, 1] Stem\Mu\Deriving.hs:337:50: No instance for (Num a10) arising from the literal `0' The type variable `a10' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the expression: 0 In the second argument of `map', namely `[0, 1]' In the expression: map varx [0, 1] Stem\Mu\Deriving.hs:338:44: No instance for (Show a9) arising from a use of `vary' The type variable `a9' is ambiguous Note: there are several potential instances: instance Show GeneralCategory -- Defined in `Data.Char' instance Show IString -- Defined in `Cortex.Utils.IString' instance Show a => Show (Cortex.Utils.List.Down a) -- Defined in `Cortex.Utils.List' ...plus 171 others In the first argument of `map', namely `vary' In the expression: map vary [0, 1] In a pattern binding: [y0, y1] = map vary [0, 1] Stem\Mu\Deriving.hs:338:50: No instance for (Num a9) arising from the literal `0' The type variable `a9' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the expression: 0 In the second argument of `map', namely `[0, 1]' In the expression: map vary [0, 1] Stem\Mu\Deriving.hs:366:33: Couldn't match type `DeclS IString TLoc' with `DeclHeadS IString l' Expected type: DeclHead l Actual type: Decl TLoc Relevant bindings include n :: Name l (bound at Stem\Mu\Deriving.hs:366:10) vs :: [TyVarBind l] (bound at Stem\Mu\Deriving.hs:366:13) In the first argument of `splitDeclHead', namely `dh' In the expression: splitDeclHead dh Stem\Mu\Deriving.hs:392:44: No instance for (Show a14) arising from a use of `varx' The type variable `a14' is ambiguous Note: there are several potential instances: instance Show GeneralCategory -- Defined in `Data.Char' instance Show IString -- Defined in `Cortex.Utils.IString' instance Show a => Show (Cortex.Utils.List.Down a) -- Defined in `Cortex.Utils.List' ...plus 171 others In the first argument of `map', namely `varx' In the expression: map varx [0, 1] In a pattern binding: [x0, x1] = map varx [0, 1] Stem\Mu\Deriving.hs:392:50: No instance for (Num a14) arising from the literal `0' The type variable `a14' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the expression: 0 In the second argument of `map', namely `[0, 1]' In the expression: map varx [0, 1] Stem\Mu\Deriving.hs:393:44: No instance for (Show a13) arising from a use of `vary' The type variable `a13' is ambiguous Note: there are several potential instances: instance Show GeneralCategory -- Defined in `Data.Char' instance Show IString -- Defined in `Cortex.Utils.IString' instance Show a => Show (Cortex.Utils.List.Down a) -- Defined in `Cortex.Utils.List' ...plus 171 others In the first argument of `map', namely `vary' In the expression: map vary [0, 1] In a pattern binding: [y0, y1] = map vary [0, 1] Stem\Mu\Deriving.hs:393:50: No instance for (Num a13) arising from the literal `0' The type variable `a13' is ambiguous Note: there are several potential instances: instance Num Double -- Defined in `GHC.Float' instance Num Float -- Defined in `GHC.Float' instance Integral a => Num (GHC.Real.Ratio a) -- Defined in `GHC.Real' ...plus 12 others In the expression: 0 In the second argument of `map', namely `[0, 1]' In the expression: map vary [0, 1] }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11541> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 9

[GHC] #11519: Inferring non-tau kinds
by GHC 18 Feb '16

18 Feb '16

#11519: Inferring non-tau kinds -------------------------------------+------------------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 Keywords: TypeInType | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- While up to my usual type-level shenanigans, I found that I want this definition: {{{ data TypeRep (a :: k) -- abstract data TypeRepX :: (forall k. k -> Constraint) -> Type where TypeRepX :: forall k (c :: forall k'. k' -> Constraint) (a :: k). c a => TypeRep a -> TypeRepX c }}} Note `TypeRepX`'s higher-rank kind. The idea is that I want to optionally constrain `TypeRepX`'s payload. Without using a higher-rank kind, the constraint would necessary fix the kind of the payload, and I don't want that. For example, I sometimes use `TypeRepX ConstTrue`, where {{{ class ConstTrue (a :: k) instance ConstTrue a }}} This actually works just fine, and I've been using the above definition to good effect. But then I wanted a `Show` instance: {{{ instance Show (TypeRep a) -- elsewhere instance Show (TypeRepX c) where show (TypeRepX tr) = show t }}} Looks sensible. But GHC complains. This is because it tries to infer `c`'s kind, by inventing a unification variable and then unifying. But this doesn't work, of course, because `c`'s kind is not a tau-type, so unification fails, lest we let impredicativity sneak in. What's particularly vexing is that, even if I annotate `c` with the correct kind, unification ''still'' fails. This is because that `c` is a ''usage'' of `c`, not a ''binding'' of `c`. Indeed, there is no place in an instance declaration to bind a type variable explicitly, so I have no recourse. I'm not sure what the solution is here. Somehow, it feels that inferring a non-tau kind for `c` is perfectly safe, because the kind is known from the use of `TypeRepX`. This would allow me to drop the kind annotation in the definition of `TypeRepX`, which looks redundant to me. But I'm not fully sure about this assumption. At the least, we could introduce a spot for explicit binding of type variables in instance declarations. I think, actually, I just figured it out. Use `ExpType`s when kind- checking types. Then I think the normal bidirectional thing (actually already implemented) will do the Right Thing. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11519> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 12

[GHC] #11414: Panic with -XStrict: StgCmmEnv: variable not found
by GHC 18 Feb '16

18 Feb '16

#11414: Panic with -XStrict: StgCmmEnv: variable not found -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: new Priority: high | Milestone: 8.0.1 Component: Compiler | Version: 7.11 Keywords: Strict | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- {{{ {-# LANGUAGE Strict #-} main = print $ let x = undefined in True }}} Using HEAD or GHC 8.0: {{{ $ ghc-8.0.0.20160109 Test.hs [1 of 1] Compiling Main ( Test.hs, Test.o ) ghc: panic! (the 'impossible' happened) (GHC version 8.0.0.20160109 for x86_64-unknown-linux): StgCmmEnv: variable not found $dIP_aDK local binds for: Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug }}} Using a devel2 build: {{{ $ ./inplace/bin/ghc-stage2 Test.hs [1 of 1] Compiling Main ( Test.hs, Test.o ) WARNING: file compiler/simplCore/OccurAnal.hs, line 66 Glomming in Main: [aDO :->] WARNING: file compiler/coreSyn/CoreSubst.hs, line 278 CoreSubst.lookupIdSubst simpleOptExpr $dIP_aDO InScope [aDM :-> a_aDM] WARNING: file compiler/simplCore/OccurAnal.hs, line 66 Glomming in Main: [aDO :-> Once] WARNING: file compiler/simplCore/SimplEnv.hs, line 530 $dIP_aDO WARNING: file compiler/simplCore/OccurAnal.hs, line 66 Glomming in Main: [aDO :-> Once] WARNING: file compiler/simplCore/SimplEnv.hs, line 530 $dIP_aDO ghc-stage2: panic! (the 'impossible' happened) (GHC version 8.1.20160103 for x86_64-unknown-linux): ASSERT failed! file compiler/stgSyn/CoreToStg.hs line 1025 $dIP_aDO Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11414> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 14

[GHC] #11599: Why is UndecidableInstances required for an obviously terminating type family?
by GHC 18 Feb '16

18 Feb '16

#11599: Why is UndecidableInstances required for an obviously terminating type family? -------------------------------------+------------------------------------- Reporter: heisenbug | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 (Type checker) | Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- In below (working) snippet {{{#!hs {-# LANGUAGE DataKinds, KindSignatures, TypeFamilies, UndecidableInstances #-} type family Rev (acc :: [*]) (ts :: [*]) :: [*] where Rev acc '[] = acc Rev acc (t ': ts) = Rev (t ': acc) ts type Reverse ts = Rev '[] ts }}} the `Rev` does an exhaustive pattern match on its second argument and recurses on strictly smaller data. {{{#!hs *Main> :kind! Reverse [Char, Bool, Float] Reverse [Char, Bool, Float] :: [*] = '[Float, Bool, Char] }}} So when I remove `UndecidableInstances` it is not clear to me why this would be rejected :-( {{{ error: The type family application Rev (a : acc) as is no smaller than the instance head (Use UndecidableInstances to permit this) In the equations for closed type family Rev In the type family declaration for Rev Failed, modules loaded: none. }}} I tried this on GHC v8.1.today, but older GHCs behave the same. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11599> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #11577: GHCi accepts invalid programs when recompiling
by GHC 18 Feb '16

18 Feb '16

#11577: GHCi accepts invalid programs when recompiling -------------------------------------+------------------------------------- Reporter: crockeea | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: GHCi | Version: 7.10.2-rc2 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: GHC accepts Unknown/Multiple | invalid program Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- This ticket may or may not be a duplicate of #9729, but I ran into it again in a different context, so I'm reporting it. My GHC version is 7.10.2.20151030. The example is as minimal as I could make it. File Bar.hs {{{ {-# LANGUAGE FlexibleInstances, MultiParamTypeClasses #-} module Bar where class Bar a b where (*^) :: a -> b -> b }}} File Foo.hs {{{ {-# LANGUAGE MultiParamTypeClasses #-} module Foo where import Bar import GHC.Prim newtype Foo fp = Foo [fp] instance {-# OVERLAPS #-} Bar (Foo fp) [fp] }}} File Main.hs {{{ {-# LANGUAGE MultiParamTypeClasses #-} import Foo import Bar newtype LW a = LW [a] instance Bar (Foo fp) (LW fp) where r *^ (LW xs) = LW $ r *^ xs }}} If I start GHCi with `ghci Main`, everything compiles as it should. Then I remove the `{-# OVERLAPS #-}` pragma in Foo.hs, which should break Main.hs. But GHCi happily recompiles with `:r`. A couple of notes: *with* the pragma, `:i Bar` gives the instances {{{ instance Bar (Foo fp) (LW fp) -- Defined at Main.hs:8:10 instance Bar a b => Bar a [b] -- Defined at Bar.hs:8:10 instance [overlap ok] Bar (Foo fp) [fp] -- Defined at Foo.hs:22:3 }}} while after (successfully, but incorrectly) recompiling without the pragma, I get the instances {{{ instance Bar (Foo fp) (LW fp) -- Defined at Main.hs:8:10 instance Bar a b => Bar a [b] -- Defined at Bar.hs:8:10 instance Bar (Foo fp) [fp] -- Defined at Foo.hs:22:3 }}} (i.e., without the `[overlap ok]`). Another strange thing is that the bug is only triggered if I import specific (superfluous) modules in Foo.hs. For example, if I replace GHC.Prim with Control.Monad or Data.Maybe, the bug is not triggered (i.e., GHCi correctly detects when I remove the pragma). -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11577> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #9648: ghci fails to reload after deleting/creating an imported module
by GHC 18 Feb '16

18 Feb '16

#9648: ghci fails to reload after deleting/creating an imported module -------------------------------------+------------------------------------- Reporter: NeilMitchell | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: GHCi | Version: 7.8.3 Keywords: | Operating System: Architecture: Unknown/Multiple | Unknown/Multiple Difficulty: Unknown | Type of failure: Blocked By: | None/Unknown Related Tickets: | Test Case: | Blocking: | Differential Revisions: -------------------------------------+------------------------------------- If you start GHCi with a 2 module program, delete the child module, reload, you get an error (as expected). If you recreate the child module and reload, it reloads the dependent module but erroneously claims that parent can't find the child. Note that if you rename the child to something else, then rename it back, then the test works - so it seems the reappearance and the file stamp confuses ghci. Spotted while working on ghcid: https://github.com/ndmitchell/ghcid {{{ $ echo module Util where > Util.hs $ echo import Util; main = print 1 > Main.hs $ ghci Main.hs GHCi, version 7.8.3: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. [1 of 2] Compiling Util ( Util.hs, interpreted ) [2 of 2] Compiling Main ( Main.hs, interpreted ) Ok, modules loaded: Util, Main. *Main> :!del Util.hs *Main> :r Main.hs:1:8: Could not find module `Util' It is a member of the hidden package `ghc-7.8.3'. Use -v to see a list of the files searched for. Failed, modules loaded: Util, Main. *Main> :!echo module Util where > Util.hs *Main> :r [1 of 2] Compiling Util ( Util.hs, interpreted ) [2 of 2] Compiling Main ( Main.hs, interpreted ) [Util changed] Main.hs:1:1: Failed to load interface for `Util' It is a member of the hidden package `ghc-7.8.3'. Use -v to see a list of the files searched for. Failed, modules loaded: Util. }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9648> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

Re: [GHC] #2159: Use a more efficient representation than [DynFlag]
by GHC 18 Feb '16

18 Feb '16

#2159: Use a more efficient representation than [DynFlag] -------------------------------------+------------------------------------- Reporter: igloo | Owner: Type: bug | Status: closed Priority: lowest | Milestone: Component: Compiler | Version: 6.8.2 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: Type of failure: Compile-time | Unknown/Multiple performance bug | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by rwbarton): According to a statistical profiling run that I did some time ago GHC spends about 0.3% of its total time in the module `libraries/containers/Data/IntSet/Base.hs`. I don't know how much of that 0.3% is from `DynFlag`-checking versus other users of `IntSet` (another one is `UnVarSet`, whatever that is). Unfortunately, reliably measuring a speedup that is expected to be at most ~0.25% is itself a somewhat nontrivial project. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/2159#comment:24> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #9041: NCG generates slow loop code
by GHC 17 Feb '16

17 Feb '16

#9041: NCG generates slow loop code -------------------------+------------------------------------------------- Reporter: nh2 | Owner: Type: bug | Status: new Priority: | Milestone: normal | Version: 7.6.3 Component: | Operating System: Unknown/Multiple Compiler (NCG) | Type of failure: Compile-time performance bug Keywords: | Test Case: Architecture: | Blocking: Unknown/Multiple | Difficulty: | Unknown | Blocked By: | Related Tickets: | -------------------------+------------------------------------------------- In http://stackoverflow.com/a/23322255/263061 we compile the code {{{ main :: IO () main = do loop (maxBound :: Word32) $ \i -> do when (i `rem` 100000000 == 0) $ putStrLn "foo" }}} and compare the assembly generated by the NCG and `-fllvm`. The LLVM code is 10 times faster. While the LLVM code looks great, NCG one generated looks quite unfortunate and messy, with a lot of unnecessary `mov`ing around. I am by no means an expert in this, but some of it looks like low hanging potential improvements. This is the '''LLVM code''': {{{ Main_zdwa_info: .LBB1_1: movl $4294967295, %esi /* load the loop bound */ movabsq $-6067343680855748867, %rdi /* load a magic number for the modulus */ jmp .LBB1_2 .LBB1_4: incl %ecx /* loop core start */ .LBB1_2: cmpq %rsi, %rcx je .LBB1_6 /* check loop bound */ /* do the modulus with two multiplications, a shift and a magic number */ /* note : gcc does the same reduction */ movq %rcx, %rax mulq %rdi shrq $26, %rdx imulq $100000000, %rdx, %rax cmpq %rax, %rcx jne .LBB1_4 /* loop core end */ /* Code omitted: print, then return to loop beginning */ .LBB1_6: }}} So the core of the loop is a nice and short: {{{ incl cmpq je movq [division replaced by magic multiplication] mulq shrq imulq cmpq jne }}} Now what '''NCG''' produces: {{{ Main_zdwa_info: /* loop core start */ .Lc3JD: leaq -16(%rbp),%rax /* stack check */ cmpq %r15,%rax jb .Lc3JO /* jump not taken in the normal case */ .Lc3JP: movl $4294967295,%eax /* issue: loading the bound on every iteration */ cmpq %rax,%r14 jne .Lc3JB .Lc3JC: /* Return from main. Code omitted */ .Lc3JB: /* test the index for modulus */ movl $100000000,%eax /* issue: unnecessary moves */ movq %rax,%rbx /* and loading the modulo arg on every iteration */ movq %r14,%rax xorq %rdx,%rdx /* shorter alternative to mov $0,%rdx */ divq %rbx /* issue: doing the division (llvm and gcc avoid this) */ testq %rdx,%rdx jne .Lc3JU /* This jump is usually taken. */ .Lc3JV: /* do the printing. Code omitted. Not relevant */ .Lc3JN: /* increment index and (I guess) restore registers messed up by the printing */ movq 8(%rbp),%rax /* This code is not very relevant because we don't almost never */ incq %rax movl %eax,%r14d addq $16,%rbp jmp Main_zdwa_info .Lc3JU: leaq 1(%r14),%rax /*issue: why not just increment r14? */ movl %eax,%r14d jmp Main_zdwa_info }}} So the core of this loop is {{{ movl [stack check] cmpq jne movl movq movq xorq divq testq jne leaq movl jmp }}} Some issues here: * the stack check is inside the loop * the loop limit is loaded every time inside the loop * the modulo arg is loaded every time inside the loop * we are shuffling around registers * no strength reduction (div is not replaced by cheaper magic number imul) * weird increment using leaq It would be great if somebody with codegen insight could comment on whether these are easy targets for improvement! -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9041> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3