December 2016 - ghc-tickets

[GHC] #10447: DeriveFoldable rejects instances with constraints in last argument of data type
by GHC 01 Aug '17

01 Aug '17

#10447: DeriveFoldable rejects instances with constraints in last argument of data type -------------------------------------+------------------------------------- Reporter: | Owner: RyanGlScott | Status: new Type: bug | Milestone: Priority: normal | Version: 7.10.1 Component: Compiler | Operating System: Unknown/Multiple Keywords: | Type of failure: GHC rejects Architecture: | valid program Unknown/Multiple | Blocked By: Test Case: | Related Tickets: #8678 Blocking: | Differential Revisions: | -------------------------------------+------------------------------------- Currently, the {{{-XDeriveFoldable}}} extension will reject any derived {{{Foldable}}} instance for a data type where the last argument of the type constructor is constrained. For example, using this data type from [http://git.haskell.org/ghc.git/blob/9f968e97a0de9c2509da00f6337b612dd72a038… TcDeriv.hs] as inspiration: {{{#!hs {-# LANGUAGE DeriveFoldable, GADTs, StandaloneDeriving #-} module DeriveFoldableRejected where data T a b where T4 :: Ord b => b -> T a b T5 :: b -> T b b T6 :: T a (b,b) deriving instance Foldable (T a) }}} Compiling {{{DeriveFoldableRejected.hs}}} with GHC 7.10 will currently fail: {{{ DeriveFoldableRejected.hs:9:1: Can't make a derived instance of ‘Foldable (T a)’: Constructor ‘T4’ must be truly polymorphic in the last argument of the data type In the stand-alone deriving instance for ‘Foldable (T a)’ Failed, modules loaded: none. }}} I don't think this restriction needs to apply to {{{Foldable}}} instances. Unlike {{{Functor}}} and {{{Traversable}}} instances, which require the last argument to be truly universal, {{{Foldable}}} instances can get away without this. To demonstrate, here's a slightly modified {{{T}}} data type, without the constraints: {{{#!hs {-# LANGUAGE DeriveFoldable, GADTs, StandaloneDeriving #-} {-# OPTIONS_GHC -ddump-deriv #-} module DeriveFoldableLegal where data T a b where T45 :: b -> T a b T6 :: T a b deriving instance Foldable (T a) }}} The output of {{{-ddump-deriv}}} is: {{{ Derived instances: instance Data.Foldable.Foldable (DeriveFoldableRejected.T a_aDc) where Data.Foldable.foldr f_aDd z_aDe (DeriveFoldableRejected.T45 a1_aDf) = f_aDd a1_aDf z_aDe Data.Foldable.foldr f_aDg z_aDh DeriveFoldableRejected.T6 = z_aDh Data.Foldable.foldMap f_aDi (DeriveFoldableRejected.T45 a1_aDj) = f_aDi a1_aDj Data.Foldable.foldMap f_aDk DeriveFoldableRejected.T6 = GHC.Base.mempty }}} Copying this back into {{{DeriveFoldableRejected.hs}}} (after some cleanup): {{{#!hs {-# LANGUAGE DeriveFoldable, GADTs, StandaloneDeriving #-} module DeriveFoldableRejected where data T a b where T4 :: Ord b => b -> T a b T5 :: b -> T b b T6 :: T a (b,b) instance Foldable (T a) where foldr f z (T4 a) = f a z foldr f z (T5 a) = f a z foldr f z T6 = z foldMap f (T4 a) = f a foldMap f (T5 a) = f a foldMap f T6 = mempty }}} reveals that it will compile correctly with the generated code. Therefore, it seems like the check for universality in the last type argument shouldn't be used in {{{-XDeriveFoldable}}}. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10447> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 25

[GHC] #10524: PolyKinds doesn't interact well with DeriveFunctor
by GHC 01 Aug '17

01 Aug '17

#10524: PolyKinds doesn't interact well with DeriveFunctor -------------------------------------+------------------------------------- Reporter: | Owner: RyanGlScott | Status: new Type: bug | Milestone: Priority: normal | Version: 7.10.1 Component: Compiler | Operating System: Unknown/Multiple Keywords: | Type of failure: GHC rejects Architecture: | valid program Unknown/Multiple | Blocked By: Test Case: | Related Tickets: Blocking: | Differential Revisions: | -------------------------------------+------------------------------------- Using {{{PolyKinds}}} and {{{DeriveFunctor}}} in tandem on GHC 7.10.2-rc1 will cause a kind incompatibility in certain cases: {{{ GHCi, version 7.10.1.20150612: http://www.haskell.org/ghc/ :? for help λ> :set -XPolyKinds -XDeriveFunctor -ddump-deriv λ> newtype Compose f g a = Compose (f (g a)) deriving Functor ==================== Derived instances ==================== Derived instances: instance forall (k_axa :: BOX) (f_axb :: k_axa -> *) (g_axc :: * -> k_axa). (GHC.Base.Functor f_axb, GHC.Base.Functor g_axc) => GHC.Base.Functor (Ghci1.Compose f_axb g_axc) where GHC.Base.fmap f_axd (Ghci1.Compose a1_axe) = Ghci1.Compose (GHC.Base.fmap (GHC.Base.fmap f_axd) a1_axe) Generic representation: Generated datatypes for meta-information: Representation types: <interactive>:3:52: Kind incompatibility when matching types: f0 :: * -> * f :: k -> * Expected type: f (g b) Actual type: f0 (f1 b) Relevant bindings include a1 :: f (g a) (bound at <interactive>:3:52) fmap :: (a -> b) -> Compose f g a -> Compose f g b (bound at <interactive>:3:52) In the first argument of ‘Compose’, namely ‘fmap (fmap f) a1’ In the expression: Compose (fmap (fmap f) a1) When typechecking the code for ‘fmap’ in a derived instance for ‘Functor (Compose f g)’: To see the code I am typechecking, use -ddump-deriv }}} A workaround is to use {{{StandaloneDeriving}}}: {{{ λ> :set -XStandaloneDeriving λ> newtype Compose f g a = Compose (f (g a)) λ> deriving instance (Functor f, Functor g) => Functor (Compose f g) ==================== Derived instances ==================== Derived instances: instance (GHC.Base.Functor f_ayO, GHC.Base.Functor g_ayP) => GHC.Base.Functor (Ghci1.Compose f_ayO g_ayP) where GHC.Base.fmap f_ayQ (Ghci1.Compose a1_ayR) = Ghci1.Compose (GHC.Base.fmap (GHC.Base.fmap f_ayQ) a1_ayR) Generic representation: Generated datatypes for meta-information: Representation types: }}} This problem does not seem to occur in GHC HEAD, however: {{{ GHCi, version 7.11.20150608: http://www.haskell.org/ghc/ :? for help λ> :set -XPolyKinds -XDeriveFunctor -ddump-deriv λ> newtype Compose f g a = Compose (f (g a)) deriving Functor ==================== Derived instances ==================== Derived instances: instance forall (k_a148 :: BOX) (f_a149 :: k_a148 -> *) (g_a14a :: * -> k_a148). (GHC.Base.Functor f_a149, GHC.Base.Functor g_a14a) => GHC.Base.Functor (Ghci3.Compose f_a149 g_a14a) where GHC.Base.fmap f_a14b (Ghci3.Compose a1_a14c) = Ghci3.Compose (GHC.Base.fmap (GHC.Base.fmap f_a14b) a1_a14c) Generic representation: Generated datatypes for meta-information: Representation types: }}} Can this fix be backported in time for GHC 7.10.2? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10524> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 20

[GHC] #10561: "deriving (Functor)" on a polykinded type produces ill-kinded instance
by GHC 01 Aug '17

01 Aug '17

#10561: "deriving (Functor)" on a polykinded type produces ill-kinded instance -------------------------------------+------------------------------------- Reporter: rwbarton | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.11 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Blocked By: Test Case: | Related Tickets: Blocking: | Differential Revisions: | -------------------------------------+------------------------------------- Arose in #10524, and new since 7.10. {{{ rwbarton@morphism:/tmp$ ~/ghc/inplace/bin/ghc-stage2 --interactive GHCi, version 7.11.20150615: http://www.haskell.org/ghc/ :? for help Prelude> :set -XPolyKinds -XDeriveFunctor -ddump-deriv -fprint-explicit- kinds Prelude> newtype Compose f g a = Compose (f (g a)) deriving Functor ==================== Derived instances ==================== Derived instances: instance forall (k_and :: BOX) (f_ane :: k_and -> *) (g_anf :: * -> k_and). (GHC.Base.Functor f_ane, GHC.Base.Functor g_anf) => GHC.Base.Functor (Ghci1.Compose k_and * f_ane g_anf) where GHC.Base.fmap f_ang (Ghci1.Compose a1_anh) = Ghci1.Compose (GHC.Base.fmap (GHC.Base.fmap f_ang) a1_anh) Generic representation: Generated datatypes for meta-information: Representation types: Prelude> :i GHC.Base.Functor class Functor (f :: * -> *) where [...] }}} The context `(GHC.Base.Functor f_ane, GHC.Base.Functor g_anf)` is ill- kinded except when `k_and = *`. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10561> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #10835: Regression in standalone Data deriving for phantom types
by GHC 01 Aug '17

01 Aug '17

#10835: Regression in standalone Data deriving for phantom types -------------------------------------+------------------------------------- Reporter: Feuerbach | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Revisions: | -------------------------------------+------------------------------------- Thise code {{{#!hs {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving, PolyKinds #-} module M where import Data.Data import Data.Typeable data Phantom t = Phantom deriving Typeable deriving instance Typeable t => Data (Phantom t) }}} compiles with 7.8.4 but not with 7.10.2. The error is {{{ data.hs:8:1: Could not deduce (Typeable Phantom) arising from the superclasses of an instance declaration from the context (Typeable t) bound by the instance declaration at data.hs:8:1-48 In the instance declaration for ‘Data (Phantom t)’ }}} PolyKinds here is a hack I came up with to make this compile with 7.8; but ideally, this code should compile whether PolyKinds is enabled or not. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10835> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #12080: RebindableSyntax breaks deriving Ord
by GHC 01 Aug '17

01 Aug '17

#12080: RebindableSyntax breaks deriving Ord -------------------------------------+------------------------------------- Reporter: afarmer | Owner: afarmer Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: #11396 Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- The code generated with `deriving (Ord)` includes if-expressions which are subject to rebindable syntax: {{{ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE RebindableSyntax #-} import Prelude class IfThenElse a b where ifThenElse :: a -> b -> b -> b instance IfThenElse Bool b where ifThenElse c x y = if c then x else y data Foo = Foo | Bar | Baz deriving (Eq, Ord) main :: IO () main = print $ Foo < Bar }}} when loaded into ghci (7.10, but not specific to that version): {{{ [1 of 1] Compiling Main ( Foo.hs, interpreted ) Foo.hs:13:42: Bad call to tagToEnum# at type a_aQy Specify the type by giving a type signature e.g. (tagToEnum# x) :: Bool In the expression: (GHC.Prim.tagToEnum# (a# GHC.Prim.<# b#)) In the expression: if (GHC.Prim.tagToEnum# (a# GHC.Prim.<# b#)) then LT else if (GHC.Prim.tagToEnum# (a# GHC.Prim.==# b#)) then EQ else GT In a case alternative: b# -> if (GHC.Prim.tagToEnum# (a# GHC.Prim.<# b#)) then LT else if (GHC.Prim.tagToEnum# (a# GHC.Prim.==# b#)) then EQ else GT When typechecking the code for ‘compare’ in a derived instance for ‘Ord Foo’: To see the code I am typechecking, use -ddump-deriv Foo.hs:13:42: No instance for (IfThenElse a0 Ordering) arising from an if statement The type variable ‘a0’ is ambiguous Note: there is a potential instance available: instance IfThenElse Bool b -- Defined at Foo.hs:10:10 In the expression: if (GHC.Prim.tagToEnum# (a# GHC.Prim.<# b#)) then LT else if (GHC.Prim.tagToEnum# (a# GHC.Prim.==# b#)) then EQ else GT In a case alternative: b# -> if (GHC.Prim.tagToEnum# (a# GHC.Prim.<# b#)) then LT else if (GHC.Prim.tagToEnum# (a# GHC.Prim.==# b#)) then EQ else GT In the expression: case (Main.$con2tag_rjG b) of { b# -> if (GHC.Prim.tagToEnum# (a# GHC.Prim.<# b#)) then LT else if (GHC.Prim.tagToEnum# (a# GHC.Prim.==# b#)) then EQ else GT } When typechecking the code for ‘compare’ in a derived instance for ‘Ord Foo’: To see the code I am typechecking, use -ddump-deriv Failed, modules loaded: none. }}} The if-expressions are generated by `nlHsIf`, which calls `mkHsIf`, which uses `Just noSyntaxExpr` as its first argument. I'm going to add a new function `nlBuiltInHsIf` which uses `Nothing` as the first argument, forcing the built-in if (according to Note [Rebindable if]), then use this new function when deriving stuff. I'll post a patch soonish. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12080> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 8

[GHC] #12047: Users Guide:
by GHC 01 Aug '17

01 Aug '17

#12047: Users Guide: -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: task | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Documentation Unknown/Multiple | bug Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- In [http://downloads.haskell.org/~ghc/8.0.1-rc4/docs/html/users_guide/glasgow_e… #generalising-the-deriving-clause 9.6.9.1. Generalising the deriving clause] > Notionally, the compiler derives an instance declaration of the form > > {{{#!hs > instance Num Int => Num Dollars > }}} > > which just adds or removes the newtype constructor according to the type. which I find weird, I so I decided to check the actual derived instance {{{ $ ghci -ignore-dot-ghci GHCi, version 8.1.20160503: http://www.haskell.org/ghc/ :? for help Prelude> :set -ddump-deriv Prelude> :set -XGeneralizedNewtypeDeriving Prelude> newtype Dollar = Dollar Int deriving Num ==================== Derived instances ==================== Derived instances: instance GHC.Num.Num Ghci1.Dollar where [...] }}} and neither found it there nor in the `:info` {{{ Prelude> :info Num class Num a where [...] instance [safe] Num Dollar -- Defined at <interactive>:3:38 }}} and while actually defining `instance Num Int => Num Dollar` gives you this awkward encounter {{{ $ ghci -ignore-dot-ghci GHCi, version 8.1.20160503: http://www.haskell.org/ghc/ :? for help Prelude> data Dollar Prelude> instance Num Int => Num Dollar <interactive>:2:10: error: • Non type-variable argument in the constraint: Num Int (Use FlexibleContexts to permit this) • In the context: Num Int While checking an instance declaration In the instance declaration for ‘Num Dollar’ Prelude> :set -XFlexibleContexts Prelude> instance Num Int => Num Dollar <interactive>:4:10: error: • The constraint ‘Num Int’ is no smaller than the instance head (Use UndecidableInstances to permit this) • In the instance declaration for ‘Num Dollar’ Prelude> :set -XUndecidableInstances Prelude> instance NumPrelude Int => Num Dollar <interactive>:6:10: warning: [-Wsimplifiable-class-constraints] The constraint ‘Num Int’ matches an instance declaration instance Num Int -- Defined in ‘GHC.Num’ This makes type inference very fragile; try simplifying it using the instance <interactive>:6:10: warning: [-Wmissing-methods] • No explicit implementation for ‘+’, ‘*’, ‘abs’, ‘signum’, ‘fromInteger’, and (either ‘negate’ or ‘-’) • In the instance declaration for ‘Num Dollar’ }}} {{{ Prelude> :info Dollar data Dollar -- Defined at <interactive>:1:1 instance [safe] Num Int => Num Dollar -- Defined at <interactive>:6:10 }}} Note that it appears with the context in `:info` so I wonder in what way that type signature is correct -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12047> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 8

[GHC] #11837: GHC fails to unify kinds when deriving polykinded typeclass instance for polykinded newtype
by GHC 01 Aug '17

01 Aug '17

#11837: GHC fails to unify kinds when deriving polykinded typeclass instance for polykinded newtype -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: RyanGlScott Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 (Type checker) | Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: GHC rejects Unknown/Multiple | valid program Test Case: | Blocked By: Blocking: | Related Tickets: #8865, #11833 Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- This is failing: {{{#!hs {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE PolyKinds #-} module Example where class Category (cat :: k -> k -> *) where catId :: cat a a catComp :: cat b c -> cat a b -> cat a c newtype T (c :: k -> k -> *) a b = MkT (c a b) deriving Category }}} with the following error: {{{ $ /opt/ghc/8.0.1/bin/ghc Example.hs -fprint-explicit-kinds -ddump-deriv [1 of 1] Compiling Example ( Example.hs, Example.o ) ==================== Derived instances ==================== Derived instances: instance forall k_ayw k_ayx (c_ayy :: k_ayx -> k_ayx -> GHC.Types.*). Example.Category k_ayw c_ayy => Example.Category k_ayw (Example.T k_ayx c_ayy) where Example.catId = GHC.Prim.coerce (Example.catId :: c_apb a_apg a_apg) :: forall (a_apg :: k_XxC). Example.T c_apb a_apg a_apg Example.catComp = GHC.Prim.coerce (Example.catComp :: c_apb b_aph c_api -> c_apb a_apj b_aph -> c_apb a_apj c_api) :: forall (b_aph :: k_XxC) (c_api :: k_XxC) (a_apj :: k_XxC). Example.T c_apb b_aph c_api -> Example.T c_apb a_apj b_aph -> Example.T c_apb a_apj c_api GHC.Generics representation types: Example.hs:9:57: error: • Expected kind ‘k1’, but ‘a1’ has kind ‘k’ • In the second argument of ‘T’, namely ‘a’ In an expression type signature: forall (a :: k). T c a a In the expression: GHC.Prim.coerce (catId :: c a a) :: forall (a :: k). T c a a When typechecking the code for ‘catId’ in a derived instance for ‘Category k (T k c)’: To see the code I am typechecking, use -ddump-deriv • Relevant bindings include catId :: T k1 c a a (bound at Example.hs:9:57) }}} This is very similar to #11833, but in this scenario, //both// the datatype and typeclass are poly-kinded, and I believe the issue here is fundamentally different. With `-fprint-explicit-kinds`, it becomes apparent what the issue is: for some reason, the kind variable of `Category` (`k_ayw`) is not unifying with the kind variable of `T` (`k_ayx`), resulting in a kind mismatch. I'll fix this - patch incoming. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11837> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #11396: deriving Ix with custom ifThenElse causes "Bad call to tagToEnum#"
by GHC 01 Aug '17

01 Aug '17

#11396: deriving Ix with custom ifThenElse causes "Bad call to tagToEnum#" -------------------------------------+------------------------------------- Reporter: Lemming | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | 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: -------------------------------------+------------------------------------- {{{ $ cat IfThenElseIx.hs {-# LANGUAGE RebindableSyntax #-} module IfThenElseIx where import Data.Ix (Ix, ) import Prelude ifThenElse :: Bool -> a -> a -> a ifThenElse True x _ = x ifThenElse False _ x = x data T = A | B deriving (Eq, Ord, Ix) $ ghci-8.0.0.20160109 IfThenElseIx.hs GHCi, version 8.0.0.20160109: http://www.haskell.org/ghc/ :? for help [1 of 1] Compiling IfThenElseIx ( IfThenElseIx.hs, interpreted ) IfThenElseIx.hs:13:35: error: • Bad call to tagToEnum# at type a_a2ky Specify the type by giving a type signature e.g. (tagToEnum# x) :: Bool • In the second argument of ‘ifThenElse’, namely ‘(GHC.Prim.tagToEnum# (c# GHC.Prim.<=# b#))’ In the expression: if (GHC.Prim.tagToEnum# (c# GHC.Prim.>=# a#)) then (GHC.Prim.tagToEnum# (c# GHC.Prim.<=# b#)) else False In a case alternative: c# -> if (GHC.Prim.tagToEnum# (c# GHC.Prim.>=# a#)) then (GHC.Prim.tagToEnum# (c# GHC.Prim.<=# b#)) else False When typechecking the code for ‘GHC.Arr.inRange’ in a derived instance for ‘Ix T’: To see the code I am typechecking, use -ddump-deriv Failed, modules loaded: none. }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11396> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #11174: Traversable can't be derived for datatypes with unboxed arguments
by GHC 01 Aug '17

01 Aug '17

#11174: Traversable can't be derived for datatypes with unboxed arguments -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: RyanGlScott Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: GHC rejects Unknown/Multiple | valid program Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Unlike `Functor` and `Foldable`, `Traversable` cannot be derived for datatypes that contain arguments with unboxed types. A simple example: {{{#!hs {-# LANGUAGE DeriveTraversable, MagicHash #-} import GHC.Prim (Int#) data IntHash a = IntHash Int# deriving (Functor, Foldable, Traversable) }}} The generated `Traversable` instance reveals the issue: {{{#!hs instance Traversable IntHash where traverse f (IntHash a1) = fmap IntHash (pure a1) }}} {{{ Couldn't match kind `*' with `#' When matching types a0 :: * Int# :: # Expected type: a0 -> IntHash b Actual type: Int# -> IntHash b In the first argument of `fmap', namely `IntHash' In the expression: fmap IntHash (pure a1) When typechecking the code for `traverse' in a derived instance for `Traversable IntHash': To see the code I am typechecking, use -ddump-deriv }}} We have to avoid calling `pure` on `a1`, since `pure` expects an argument with a `*`-kinded type, not a `#`-kinded one. One way to fix this would be restructuring the derived `traverse` implementation such that unboxed arguments are moved to the function initially lifted with `pure`, and doing nothing with them later. To better articulate what I mean, envision something like this: {{{#!hs data IntHash2 a = IntHash2 Int# a (IntHash2 a) Int# deriving (Functor, Foldable) }}} Then a derived `Traversable` instance that would typecheck would be: {{{#!hs instance Traversable IntHash2 where traverse f (IntHash2 a1 a2 a3 a4) = pure (\x2 x3 -> IntHash2 a1 x2 x3 a4) <*> f a2 <*> traverse f a3 }}} Conceptually, this doesn't sound hard to implement. The tricky part is figuring out how much of the existing `Functor`/`Foldable`/`Traversable` deriving machinery would need to be tweaked to make this work. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11174> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #12399: DeriveFunctor fail
by GHC 01 Aug '17

01 Aug '17

#12399: DeriveFunctor fail -------------------------------------+------------------------------------- Reporter: osa1 | 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: -------------------------------------+------------------------------------- {{{#!haskell {-# LANGUAGE DeriveFunctor, MagicHash, UnboxedTuples #-} module Lib where import GHC.Exts newtype RmLoopsM a = RmLoopsM { runRmLoops :: Int# -> (# Int#, a #) } }}} Functor instance for this can be derived like this: {{{#!haskell instance Functor RmLoopsM where fmap f (RmLoopsM m) = RmLoopsM $ \i -> case m i of (# i', r #) -> (# i', f r #) }}} `DeriveFunctor` instead generates something like this: {{{#!haskell instance Functor RmLoopsM where fmap f_a2Oh (Lib.RmLoopsM a1_a2Oi) = RmLoopsM ((\ b6_a2Oj b7_a2Ok -> (\ b5_a2Ol -> case b5_a2Ol of { ((#,#) a1_a2Om a2_a2On a3_a2Oo a4_a2Op) -> (#,#) ((\ b2_a2Oq -> b2_a2Oq) a1_a2Om) ((\ b3_a2Or -> b3_a2Or) a2_a2On) ((\ b4_a2Os -> b4_a2Os) a3_a2Oo) (f_a2Oh a4_a2Op) }) (b6_a2Oj ((\ b1_a2Ot -> b1_a2Ot) b7_a2Ok))) a1_a2Oi) }}} which fails with {{{ Main.hs:17:25: error: • The constructor ‘(#,#)’ should have 2 arguments, but has been given 4 • In the pattern: (#,#) a1_a2Om a2_a2On a3_a2Oo a4_a2Op In a case alternative: ((#,#) a1_a2Om a2_a2On a3_a2Oo a4_a2Op) -> (#,#) ((\ b2_a2Oq -> b2_a2Oq) a1_a2Om) ((\ b3_a2Or -> b3_a2Or) a2_a2On) ((\ b4_a2Os -> b4_a2Os) a3_a2Oo) (f_a2Oh a4_a2Op) In the expression: case b5_a2Ol of { ((#,#) a1_a2Om a2_a2On a3_a2Oo a4_a2Op) -> (#,#) ((\ b2_a2Oq -> b2_a2Oq) a1_a2Om) ((\ b3_a2Or -> b3_a2Or) a2_a2On) ((\ b4_a2Os -> b4_a2Os) a3_a2Oo) (f_a2Oh a4_a2Op) } }}} I think it's supposed to ignore RuntimeRep args during the fold (`TcGenDeriv.functorLikeTraverse`). Tried with: HEAD, 8.0.1. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12399> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 10