- ghc-tickets - Haskell.org

[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

[GHC] #13263: cant derive functor on function newtype with unboxed tuple result
by GHC 01 Aug '17

01 Aug '17

#13263: cant derive functor on function newtype with unboxed tuple result -------------------------------------+------------------------------------- Reporter: carter | 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 not sure if this is a bug or a feature request, but i have a simple example that I think should work with deriving functor but falls over {{{ {-# LANGUAGE ScopedTypeVariables, BangPatterns, UnboxedTuples, MagicHash, GADTs #-} {-# LANGUAGE DeriveFunctor #-} module Test where newtype Eww a = Ew# (Int -> (# a, Int #)) deriving (Functor) }}} the error i get is {{{ src/System/Random/SplitMix/Internal.hs:88:13: error: • The constructor ‘(#,#)’ should have 2 arguments, but has been given 4 • In the pattern: (#,#) a1 a2 a3 a4 In a case alternative: ((#,#) a1 a2 a3 a4) -> (#,#) ((\ b2 -> b2) a1) ((\ b3 -> b3) a2) (f a3) ((\ b4 -> b4) a4) In the expression: case b5 of { ((#,#) a1 a2 a3 a4) -> (#,#) ((\ b2 -> b2) a1) ((\ b3 -> b3) a2) (f a3) ((\ b4 -> b4) a4) } When typechecking the code for ‘fmap’ in a derived instance for ‘Functor Eww’: To see the code I am typechecking, use -ddump-deriv }}} and the dumped deriving is {{{ [1 of 1] Compiling System.Random.SplitMix.Internal ( src/System/Random/SplitMix/Internal.hs, /Users/carter/WorkSpace/projects/active/random-hs/dist- newstyle/build/random-2.0.0.0/build/System/Random/SplitMix/Internal.o ) ==================== Derived instances ==================== Derived instances: instance GHC.Base.Functor System.Random.SplitMix.Internal.Eww where GHC.Base.fmap f_a4Vn (System.Random.SplitMix.Internal.Ew# a1_a4Vo) = System.Random.SplitMix.Internal.Ew# ((\ b6_a4Vp b7_a4Vq -> (\ b5_a4Vr -> case b5_a4Vr of { ((#,#) a1_a4Vs a2_a4Vt a3_a4Vu a4_a4Vv) -> (#,#) ((\ b2_a4Vw -> b2_a4Vw) a1_a4Vs) ((\ b3_a4Vx -> b3_a4Vx) a2_a4Vt) (f_a4Vn a3_a4Vu) ((\ b4_a4Vy -> b4_a4Vy) a4_a4Vv) }) (b6_a4Vp ((\ b1_a4Vz -> b1_a4Vz) b7_a4Vq))) a1_a4Vo) GHC.Generics representation types: }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13263> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #12768: 8.0.2 derives invalid code when class method is constrained by itself
by GHC 01 Aug '17

01 Aug '17

#12768: 8.0.2 derives invalid code when class method is constrained by itself -------------------------------------+------------------------------------- Reporter: jophish | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 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: -------------------------------------+------------------------------------- GHC 8.0.1 is able to compile this without a problem and doesn't require FlexibleContexts. {{{#!hs {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE ConstrainedClassMethods #-} module A where class C m where foo :: C m => m () newtype N m a = N (m a) deriving C }}} Compare the output of 8.0.1, 8.0.2 and 8.1. I turned on -fdefer-type- errors in order for -ddump-deriv to work. {{{ $ ghc --version The Glorious Glasgow Haskell Compilation System, version 8.0.1 $ ghc -ddump-deriv A.hs [1 of 1] Compiling A ( A.hs, A.o ) ==================== Derived instances ==================== Derived instances: instance A.C m_aNK => A.C (A.N m_aNK) where A.foo = GHC.Prim.coerce (A.foo :: m_ap1 ()) :: A.N m_ap1 () GHC.Generics representation types: }}} {{{ $ ghc --version The Glorious Glasgow Haskell Compilation System, version 8.0.2 $ ghc A.hs [1 of 1] Compiling A ( A.hs, A.o ) A.hs:10:12: error: • Couldn't match type ‘m’ with ‘N m’ arising from the coercion of the method ‘foo’ from type ‘C m => m ()’ to type ‘C (N m) => N m ()’ ‘m’ is a rigid type variable bound by the deriving clause for ‘C (N m)’ at A.hs:10:12 • When deriving the instance for (C (N m)) $ ghc -ddump-deriv -fdefer-type-errors A.hs [1 of 1] Compiling A ( A.hs, A.o ) ==================== Derived instances ==================== Derived instances: instance A.C m_awm => A.C (A.N m_awm) where A.foo = GHC.Prim.coerce @(A.C m_ap0 => m_ap0 ()) @(A.C (A.N m_ap0) => A.N m_ap0 ()) A.foo GHC.Generics representation types: A.hs:11:12: warning: [-Wdeferred-type-errors] • Couldn't match type ‘m’ with ‘N m’ arising from a use of ‘GHC.Prim.coerce’ ‘m’ is a rigid type variable bound by the instance declaration at A.hs:11:12 • In the expression: GHC.Prim.coerce @(C m => m ()) @(C (N m) => N m ()) foo In an equation for ‘foo’: foo = GHC.Prim.coerce @(C m => m ()) @(C (N m) => N m ()) foo When typechecking the code for ‘foo’ in a derived instance for ‘C (N m)’: To see the code I am typechecking, use -ddump-deriv In the instance declaration for ‘C (N m)’ • Relevant bindings include foo :: N m () (bound at A.hs:11:12) }}} There's no '8.0.2' version to report this against so I've chosen 8.1. GHC 8.1 gives very similar results: {{{ $ ghc --version The Glorious Glasgow Haskell Compilation System, version 8.1.20160930 $ ghc A.hs [1 of 1] Compiling A ( A.hs, A.o ) A.hs:11:12: error: • Couldn't match type ‘m’ with ‘N m’ arising from the coercion of the method ‘foo’ from type ‘C m => m ()’ to type ‘C (N m) => N m ()’ ‘m’ is a rigid type variable bound by the deriving clause for ‘C (N m)’ at A.hs:11:12 • When deriving the instance for (C (N m)) $ ghc -ddump-deriv -fdefer-type-errors A.hs [1 of 1] Compiling A ( A.hs, A.o ) ==================== Derived instances ==================== Derived instances: instance A.C m_awK => A.C (A.N m_awK) where A.foo = GHC.Prim.coerce @(A.C m_app => m_app ()) @(A.C (A.N m_app) => A.N m_app ()) A.foo GHC.Generics representation types: A.hs:11:12: warning: [-Wsimplifiable-class-constraints] The constraint ‘C (N m)’ matches an instance declaration instance C m => C (N m) -- Defined at A.hs:11:12 This makes type inference for inner bindings fragile; either use MonoLocalBinds, or simplify it using the instance A.hs:11:12: warning: [-Wdeferred-type-errors] • Couldn't match type ‘m’ with ‘N m’ arising from a use of ‘GHC.Prim.coerce’ ‘m’ is a rigid type variable bound by the instance declaration at A.hs:11:12 • In the expression: GHC.Prim.coerce @(C m => m ()) @(C (N m) => N m ()) foo In an equation for ‘foo’: foo = GHC.Prim.coerce @(C m => m ()) @(C (N m) => N m ()) foo When typechecking the code for ‘foo’ in a derived instance for ‘C (N m)’: To see the code I am typechecking, use -ddump-deriv In the instance declaration for ‘C (N m)’ • Relevant bindings include foo :: N m () (bound at A.hs:11:12) }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12768> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 15

[GHC] #13748: Variables pretty-printed from -ddump-deriv are not scoped properly
by GHC 01 Aug '17

01 Aug '17

#13748: Variables pretty-printed from -ddump-deriv are not scoped properly -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.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: -------------------------------------+------------------------------------- This bug is present on GHC 8.0.1, 8.0.2, 8.2.1 and HEAD, and originally noted in https://ghc.haskell.org/trac/ghc/ticket/13738#comment:2. Take this code: {{{#!hs {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE PolyKinds #-} {-# OPTIONS_GHC -ddump-deriv #-} module Works where newtype Wrap f a = Wrap (f a) deriving C class C f where c :: f a }}} When you compile it with GHC 8.0.2, you'll get this unsavory output: {{{ GHCi, version 8.0.2: http://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/rgscott/.ghci [1 of 1] Compiling Works ( Works.hs, interpreted ) ==================== Derived instances ==================== Derived instances: instance forall k_a14U (f_a14V :: k_a14U -> *). Works.C f_a14V => Works.C (Works.Wrap f_a14V) where Works.c = GHC.Prim.coerce @(forall (a_a13F :: k_a14u). f_a13G a_a13F) @(forall (a_a13F :: k_a14u). Works.Wrap f_a13G a_a13F) Works.c GHC.Generics representation types: }}} This is wrong, since the quantified variables in the instance head (`k_a14U` and `f_a14V`) do not match the occurrences that they bind (`k_a14u` and `f_a13G`). This is somewhat easier to see on GHC 8.2.1 or HEAD, since the binding sites are printed without uniques: {{{ GHCi, version 8.3.20170516: http://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/rgscott/.ghci [1 of 1] Compiling Works ( Works.hs, interpreted ) ==================== Derived instances ==================== Derived class instances: instance forall k (f :: k -> *). Works.C f => Works.C (Works.Wrap f) where Works.c = GHC.Prim.coerce @(forall (a_a1tD :: k_a1uE). f_a1tE a_a1tD) @(forall (a_a1tD :: k_a1uE). Works.Wrap f_a1tE a_a1tD) Works.c Derived type family instances: }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13748> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #12417: API annotations for unboxed sums needs reworking
by GHC 01 Aug '17

01 Aug '17

#12417: API annotations for unboxed sums needs reworking -------------------------------------+------------------------------------- Reporter: osa1 | 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: -------------------------------------+------------------------------------- API annotations for unboxed sums are not entirely correct. As far as I understand, some of the bars (`|`) in the concrete syntax are not properly attached to any of the AST nodes. Some discussion can be seen in [https://phabricator.haskell.org/D2259#69809 the Phab page]. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12417> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6

[GHC] #12478: Template Haskell support for unboxed sums
by GHC 01 Aug '17

01 Aug '17

#12478: Template Haskell support for unboxed sums -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: Type: feature | Status: new request | Priority: normal | Milestone: 8.2.1 Component: Template | Version: 8.1 Haskell | Keywords: | Operating System: Unknown/Multiple TemplateHaskell | Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Currently, you can't use unboxed sums with Template Haskell. This makes me sad. Patch incoming. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12478> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6