January 2017 - ghc-tickets

[GHC] #12073: Missing instance of MonadFix for Q
by GHC 06 Jul '18

06 Jul '18

#12073: Missing instance of MonadFix for Q -------------------------------------+------------------------------------- Reporter: jophish | Owner: Type: feature | Status: new request | Priority: normal | Milestone: Component: Template | Version: Haskell | 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: -------------------------------------+------------------------------------- `Q` is capable of being an instance of `MonadFix`. The definition of `mfix` is the same as `fixIO` except that the `MVar` handling is wrapped in `runIO`. {{{#!hs instance MonadFix Q where mfix k = do m <- runIO newEmptyMVar ans <- runIO (unsafeInterleaveIO (takeMVar m)) result <- k ans runIO (putMVar m result) pure result }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12073> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #11523: Infinite Loop when mixing UndecidableSuperClasses and the class/instance constraint synonym trick.
by GHC 05 Jul '18

05 Jul '18

#11523: Infinite Loop when mixing UndecidableSuperClasses and the class/instance constraint synonym trick. -------------------------------------+------------------------------------- Reporter: ekmett | Owner: Type: bug | Status: new Priority: highest | Milestone: 8.0.1 Component: Compiler | Version: 7.10.3 (Type checker) | Keywords: | Operating System: Unknown/Multiple UndecidableSuperClasses | Architecture: | Type of failure: GHC rejects Unknown/Multiple | valid program Test Case: | Blocked By: Blocking: | Related Tickets: #11480 Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- There seems to be a bad interaction between `UndecidableSuperClasses` and the common trick of using a cyclic definition of a class and instance to make an alias at the constraint level: {{{#!hs class (Foo f, Bar f) => Baz f instance (Foo f, Bar f) => Baz f }}} Unfortunately, there are circumstances in which you can't eliminate it, such as {{{#!hs class (p, q) => p & q instance (p, q) => p & q }}} There we can't partially apply (,) at the constraint level, but we can talk about `(&) :: Constraint -> Constraint -> Constraint` and `(&) (Eq a) :: Constraint -> Constraint`. This doesn't seem to happen on simpler examples like the above, but once I modify the categories example from #11480 to move the domain and codomain of a functor into class associated types, so that they don't infect every single subclass of functor, we run into a problem. The following stripped down version of the code seems to send the compiler into an infinite loop: {{{#!hs {-# language KindSignatures #-} {-# language PolyKinds #-} {-# language DataKinds #-} {-# language TypeFamilies #-} {-# language RankNTypes #-} {-# language NoImplicitPrelude #-} {-# language FlexibleContexts #-} {-# language MultiParamTypeClasses #-} {-# language GADTs #-} {-# language ConstraintKinds #-} {-# language FlexibleInstances #-} {-# language TypeOperators #-} {-# language ScopedTypeVariables #-} {-# language DefaultSignatures #-} {-# language FunctionalDependencies #-} {-# language UndecidableSuperClasses #-} {-# language UndecidableInstances #-} {-# language TypeInType #-} import GHC.Types (Constraint, Type) import qualified Prelude type Cat i = i -> i -> Type newtype Y (p :: i -> j -> Type) (a :: j) (b :: i) = Y { getY :: p b a } class Vacuous (a :: i) instance Vacuous a class (Functor p, Dom p ~ Op p, Cod p ~ Nat p (->)) => Category (p :: Cat i) where type Op p :: Cat i type Op p = Y p type Ob p :: i -> Constraint type Ob p = Vacuous class (Category (Dom f), Category (Cod f)) => Functor (f :: i -> j) where type Dom f :: Cat i type Cod f :: Cat j class (Functor f, Dom f ~ p, Cod f ~ q) => Fun (p :: Cat i) (q :: Cat j) (f :: i -> j) | f -> p q instance (Functor f, Dom f ~ p, Cod f ~ q) => Fun (p :: Cat i) (q :: Cat j) (f :: i -> j) data Nat (p :: Cat i) (q :: Cat j) (f :: i -> j) (g :: i -> j) instance (Category p, Category q) => Category (Nat p q) where type Ob (Nat p q) = Fun p q instance (Category p, Category q) => Functor (Nat p q) where type Dom (Nat p q) = Y (Nat p q) type Cod (Nat p q) = Nat (Nat p q) (->) instance (Category p, Category q) => Functor (Nat p q f) where type Dom (Nat p q f) = Nat p q type Cod (Nat p q f) = (->) instance Category (->) instance Functor ((->) e) where type Dom ((->) e) = (->) type Cod ((->) e) = (->) instance Functor (->) where type Dom (->) = Y (->) type Cod (->) = Nat (->) (->) instance (Category p, Op p ~ Y p) => Category (Y p) where type Op (Y p) = p instance (Category p, Op p ~ Y p) => Functor (Y p a) where type Dom (Y p a) = Y p type Cod (Y p a) = (->) instance (Category p, Op p ~ Y p) => Functor (Y p) where type Dom (Y p) = p type Cod (Y p) = Nat (Y p) (->) }}} Here I need the circular definition of `Fun` to talk about the fact that the objects in the category of natural transformations from a category p to a category q are functors with domain p and codomain q, so to give the definition of the class-associated `type Ob (Nat p q)` I need such a cyclic definition. I can't leave the domain and codomain of `Functor` in fundeps, otherwise if I go to define a subclass of Functor I'd have to include the arguments, and I have a ''lot'' of those subclasses! -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11523> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 33

[GHC] #11547: Accessing shadowed definitions in GHCi
by GHC 05 Jul '18

05 Jul '18

#11547: Accessing shadowed definitions in GHCi -------------------------------------+------------------------------------- Reporter: mniip | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: GHCi | Version: 8.0.1-rc1 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: -------------------------------------+------------------------------------- Apparently GHCi creates a qualified namespace for each line it interprets, as can be observed with: {{{#!hs > data A = A > data A = B > :t A A :: Ghci3.A }}} Apparently accessing shadowed definitions in this way sometimes breaks GHCi: {{{#!hs > let a = a > let a = a > :t Ghci7.a <interactive>:1:1: error: • GHC internal error: ‘Ghci7.a’ is not in scope during type checking, but it passed the renamer tcl_env of environment: [] • In the expression: Ghci7.a }}} More specifically, complete reproduction instructions: {{{#!hs GHCi, version 8.1.20160205: http://www.haskell.org/ghc/ :? for help > let foo = foo > :t Ghci1.foo Ghci1.foo :: t > let foo = foo > :t Ghci1.foo <interactive>:1:1: error: • GHC internal error: ‘Ghci1.foo’ is not in scope during type checking, but it passed the renamer tcl_env of environment: [] • In the expression: Ghci1.foo }}} 7.10.2 (and 7.8.3 as verified over IRC by monochrom) appears to have a slightly different behavior. It seems it only creates namespaces for data/newtype/class declarations. Yet still, it fails with an error the first time but works completely fine thereafter: {{{#!hs > data A = A > data A = A > :t Ghci1.A Failed to load interface for ‘Ghci1’ no package key matching ‘interactive’ was found > :t Ghci1.A Ghci1.A :: Ghci1.A }}} 7.6.3 uses a different approach to displaying out of scope names so the behavior doesn't apply: {{{#!hs > data A = A > data A = B > :t A A :: main::Interactive.A }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11547> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 11

[GHC] #8263: allow duplicate deriving / standalone deriving
by GHC 04 Jul '18

04 Jul '18

#8263: allow duplicate deriving / standalone deriving ------------------------------------+------------------------------------- Reporter: aavogt | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- I would like to avoid conditional compilation. Currently I need to write: {{{ #if MIN_VERSION_Cabal(1,18,0) -- cabal 1.18 has these instances #else deriving instance Typeable Flag #endif }}} Would it be sane to have the deriving instance do nothing if the imported instance that clashes was also derived? reifyInstances together with a fixed #8100 could allow faking this feature. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8263> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #10391: Ability to get contents of TH reified module
by GHC 02 Jul '18

02 Jul '18

#10391: Ability to get contents of TH reified module -------------------------------------+------------------------------------- Reporter: dmcclean | Owner: Type: feature | Status: new request | Milestone: Priority: low | Version: Component: Template | Operating System: Unknown/Multiple Haskell | Type of failure: None/Unknown Keywords: | Blocked By: Architecture: | Related Tickets: Unknown/Multiple | Test Case: | Blocking: | Differential Revisions: | -------------------------------------+------------------------------------- After using reifyModule, I'd like to be able to inspect the list of exports from that module. At first I thought that this could perhaps be done by changing from {{{#!hs data ModuleInfo = -- | Contains the import list of the module. ModuleInfo [Module] }}} to {{{#!hs data ModuleInfo = -- | Contains the import list and export list of the module. ModuleInfo [Module] [Name] }}} but I now wonder if this is the best plan, because `thisModule >>= reifyModule` might be expected to function as a time machine, allowing us to see declarations that may not have been made yet (in the case where this module's export list is implicit). Can anyone propose a type that would allow us to perform this inspection for modules that have already been baked, but not for "this" module? An intended use case would be in our dimensional types library. We have several modules that define a whole bunch of units. It's useful for the unit name parser to have access to a dictionary with all of those units in it, but maintaining the definition of such a dictionary is redundant. If this feature existed, a module in the parser could import the modules where units are defined, examine the export lists, reify the names in the export lists, determine which represent unit definitions, and emit a declaration of a dictionary that contains them all. (This is in some ways similar to #9699, though perhaps more difficult?) -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10391> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 8

[GHC] #12449: Broken types in identifiers bound by :print
by GHC 02 Jul '18

02 Jul '18

#12449: Broken types in identifiers bound by :print -------------------------------------+------------------------------------- Reporter: mniip | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: GHCi crash Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- {{{#!hs GHCi, version 8.0.1: http://www.haskell.org/ghc/ :? for help Prelude> :print show show = (_t1::Show a => a -> String) Prelude> :t _t1 <interactive>:1:1: error: No instance for (Show a) arising from a use of ‘it’ }}} Furthermore: {{{#!hs Prelude> _t1 "foo" <interactive>:3:5: error:ghc: panic! (the 'impossible' happened) (GHC version 8.0.1 for x86_64-unknown-linux): No skolem info: a_a1hz Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug Prelude> }}} Enabling `-fprint-explicit-foralls`, I think, reveals the issue: {{{#!hs Prelude> :set -fprint-explicit-foralls Prelude> :print id id = (_t2::a1 -> a1) Prelude> :t id id :: forall {a}. a -> a Prelude> :t _t2 _t2 :: a1 -> a1 }}} Similar behavior albeit with a different panic message happens on 7.8.4 and 7.10.3 as verified by bennofs over IRC: {{{ GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help Prelude> :print print print = (_t1::Show a => a -> IO ()) Prelude> _t1 ghc: panic! (the 'impossible' happened) (GHC version 7.10.3 for x86_64-unknown-linux): tcTyVarDetails a_apc Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug }}} 7.6.3 doesn't exhibit this issue: {{{ GHCi, version 7.6.3: http://www.haskell.org/ghc/ :? for help Prelude> :print id id = (_t1::forall a. a -> a) }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12449> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6

[GHC] #12410: Somehow detect splicing in ghci
by GHC 02 Jul '18

02 Jul '18

#12410: Somehow detect splicing in ghci -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 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: -------------------------------------+------------------------------------- I'm no TH expert but currently it seems you need a hack (adding `data X ;` or `pure []`) to do the following {{{ ghci> $(reify ''() >>= runIO.print >> return []) <interactive>:210:3: error: • Couldn't match type ‘[t0]’ with ‘Exp’ Expected type: ExpQ Actual type: Q [t0] • In the expression: reify ''() >>= runIO . print >> return [] In the untyped splice: $(reify ''() >>= runIO . print >> return []) }}} {{{#!hs >>> data X; $(reify ''() >>= runIO.print >> return []) TyConI (DataD [] GHC.Tuple.() [] Nothing [NormalC GHC.Tuple.() []] []) >>> pure []; $(reify ''() >>= runIO.print >> return []) TyConI (DataD [] GHC.Tuple.() [] Nothing [NormalC GHC.Tuple.() []] []) }}} Same with [https://hackage.haskell.org/package/lens-4.14/docs/Control- Lens-TH.html#v:makeLenses makeLenses] (discussed [https://artyom.me/lens- over-tea-6 here], [https://github.com/ekmett/lens/issues/461 there]): {{{ >>> data A = B { _int :: Int } >>> makeLenses ''A <interactive>:209:1: error: • No instance for (Show DecsQ) arising from a use of ‘print’ • In a stmt of an interactive GHCi command: print it }}} the following two work {{{#!hs >>> data A = B { _int :: Int } >>> pure []; makeLenses ''A >>> view int (B 42) 42 }}} {{{#!hs >>> data A = B { _int :: Int }; makeLenses ''A >>> view int (B 42) 42 }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12410> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 10

[GHC] #8489: clean up dependency and usages handling in interface files
by GHC 01 Jul '18

01 Jul '18

#8489: clean up dependency and usages handling in interface files ----------------------------------------------+---------------------------- Reporter: errge | Owner: errge Type: task | Status: new Priority: normal | Milestone: 7.10.1 Component: Template Haskell | Version: 7.7 Keywords: | Operating System: Architecture: Unknown/Multiple | Unknown/Multiple Difficulty: Moderate (less than a day) | Type of failure: Blocked By: 1480 | None/Unknown Related Tickets: | Test Case: | Blocking: ----------------------------------------------+---------------------------- While reviewing #1480, it was found that there are corner cases that are not easy to handle. This task is about fixing TH module reification to reify direct import list, not usages. For this we may need to extend the current `ModIface`. This task also includes cleaning up the comments and code in related areas, to quote simonpj: "we need more precise commentary on the fields of `HscTypes.Dependencies`, `TcRnTypes.ImportAvails`, and `mi_usages` of `ModIface`. For example, I wonder whether the `mi_usages` field could be part of the `Dependencies`". -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8489> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 9

[GHC] #11812: Template Haskell can induce non-unique Uniques
by GHC 01 Jul '18

01 Jul '18

#11812: Template Haskell can induce non-unique Uniques -------------------------------------+------------------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Template | Version: 8.1 Haskell | 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: -------------------------------------+------------------------------------- When quoting a Template Haskell expression (or type), you can get your hands on renamed variables. These variables have assigned Uniques. If you then use the same variable locally in ''different'' top-level expressions, chaos can ensue. It's certainly expected that something bizarre would happen if you used the same Unique twice within the same scope, but it surprised me that using the same Unique twice in different scopes would cause a problem. Below is the rather hard-won reduced test case: {{{ {-# LANGUAGE TemplateHaskell, PolyKinds, RankNTypes, TypeFamilies #-} module Bug where import Language.Haskell.TH import Data.Type.Equality type Const a b = a $( do ForallT [PlainTV n] _ _ <- [t| forall n. n |] let noBang = Bang NoSourceUnpackedness NoSourceStrictness return [ClosedTypeFamilyD (TypeFamilyHead (mkName "F1") [ KindedTV (mkName "a") (VarT n) , PlainTV (mkName "b") ] (KindSig (VarT n)) Nothing) [TySynEqn [VarT (mkName "a"), VarT (mkName "b")] (ConT ''Const `AppT` VarT (mkName "a") `AppT` (ConT (mkName "T1") `AppT` VarT (mkName "a") `AppT` VarT (mkName "b")))] ,DataD [] (mkName "T1") [ KindedTV (mkName "a") (VarT n) , PlainTV (mkName "b") , PlainTV (mkName "c")] Nothing [NormalC (mkName "K1") [(noBang, ConT ''(:~:) `AppT` VarT (mkName "c") `AppT` (ConT (mkName "F1") `AppT` VarT (mkName "a") `AppT` VarT (mkName "b")))]] []]) }}} This blob produces {{{ type family F1 (a :: n_auRf) b :: n_auRf where F1 a b = Const a (T1 a b) data T1 (a :: n_auRf) b c = K1 ((:~:) c (F1 a b)) }}} which compiles fine when typed in directly. Note that this hinges on the `SigTv` behavior of kind variables in non-CUSK declarations, but I don't think that's the nub of the problem. What happens is this: during renaming, the `n`s are renamed to have the same `Unique`, because `n` is `Exact`. Type-checking invents `SigTv`s for each `n`. Naturally, both `n`s have ''different'' `IORef`s stored in their `TcTyVarDetails`. When the two `n`s are compared during checking, though, their `Unique`s are the same, and so nothing happens -- even though they should be unified. The upshot is that we get one logical variable `n` with different `IORef`s in different occurrences, causing chaos. It might be reasonable to punt on this, but we should document in the manual what the problem is. It puzzled me for quite a while when the problem came up in real code! -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11812> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #8695: Arithmetic overflow from (minBound :: Int) `quot` (-1)
by GHC 30 Jun '18

30 Jun '18

#8695: Arithmetic overflow from (minBound :: Int) `quot` (-1) -------------------------------------+------------------------------------- Reporter: rleslie | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: | Version: 7.6.3 libraries/haskell2010 | Operating System: Unknown/Multiple Keywords: | Type of failure: Incorrect result Architecture: Unknown/Multiple | at runtime Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | -------------------------------------+------------------------------------- According to the documentation for Data.Int, “All arithmetic is performed modulo 2!^n, where n is the number of bits in the type.” However, this promise is broken by the following exception: {{{ Prelude> (minBound :: Int) `quot` (-1) *** Exception: arithmetic overflow }}} (This also occurs with Int8, Int16, Int32, and Int64, and likewise for `div`.) If all arithmetic is performed modulo 2!^n, I would rather expect the above to evaluate to `minBound`, since after all `minBound * (-1) == minBound`. The fact that an exception is raised adds an unnecessary burden in pure code to ensure `quot` (or `div`) is never called with these specific arguments. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8695> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 39