#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature | Status: new request | 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: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- {{{#!hs {-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-} class GEq a b where geq :: a -> b -> Bool instance {-# OVERLAPPING #-} Eq a => GEq a a where geq = (==) instance GEq a b where geq _ _ = False }}} {{{ GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help Prelude> :load GEq.hs [1 of 1] Compiling Main ( GEq.hs, interpreted ) Ok, modules loaded: Main. *Main> geq::a->b->Bool <interactive>:3:1: Overlapping instances for GEq a1 b1 arising from a use of ‘geq’ Matching instances: instance GEq a b -- Defined at GEq.hs:9:10 instance [overlapping] Eq a => GEq a a -- Defined at GEq.hs:6:30 (The choice depends on the instantiation of ‘a1, b1’ To pick the first instance above, use IncoherentInstances when compiling the other instance declarations) In the expression: geq :: a -> b -> Bool In an equation for ‘it’: it = geq :: a -> b -> Bool *Main> }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: closed Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: invalid | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by bgamari): * status: new => closed * resolution: => invalid Comment: In general it's appreciated if you can provide at very least a title for new tickets. In this particular case I think the error message pretty much explains what's going on here: there are two instances which may match your request. GHC in general refuses to choose arbitrarily. If you want to force GHC to choose arbitrarily then you can use `IncoherentInstances`, but you get to keep both pieces if your program breaks. Closing as invalid but feel free to reopen if I have misunderstood your request. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:1 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by zaoqi): * status: closed => new * resolution: invalid => Old description:
{{{#!hs {-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-}
class GEq a b where geq :: a -> b -> Bool
instance {-# OVERLAPPING #-} Eq a => GEq a a where geq = (==)
instance GEq a b where geq _ _ = False }}}
{{{ GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help Prelude> :load GEq.hs [1 of 1] Compiling Main ( GEq.hs, interpreted ) Ok, modules loaded: Main. *Main> geq::a->b->Bool
<interactive>:3:1: Overlapping instances for GEq a1 b1 arising from a use of ‘geq’ Matching instances: instance GEq a b -- Defined at GEq.hs:9:10 instance [overlapping] Eq a => GEq a a -- Defined at GEq.hs:6:30 (The choice depends on the instantiation of ‘a1, b1’ To pick the first instance above, use IncoherentInstances when compiling the other instance declarations) In the expression: geq :: a -> b -> Bool In an equation for ‘it’: it = geq :: a -> b -> Bool *Main> }}}
New description: {{{#!hs {-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-} class GEq a b where geq :: a -> b -> Bool instance {-# OVERLAPPING #-} Eq a => GEq a a where geq = (==) instance GEq a b where geq _ _ = False }}} {{{ GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help Prelude> :load GEq.hs [1 of 1] Compiling Main ( GEq.hs, interpreted ) Ok, modules loaded: Main. *Main> geq::a->b->Bool <interactive>:3:1: Overlapping instances for GEq a1 b1 arising from a use of ‘geq’ Matching instances: instance GEq a b -- Defined at GEq.hs:9:10 instance [overlapping] Eq a => GEq a a -- Defined at GEq.hs:6:30 (The choice depends on the instantiation of ‘a1, b1’ To pick the first instance above, use IncoherentInstances when compiling the other instance declarations) In the expression: geq :: a -> b -> Bool In an equation for ‘it’: it = geq :: a -> b -> Bool *Main> }}} In order to {{{#!hs {-# LANGUAGE KindSignatures, GADTs #-} data Dyn :: * where Dyn :: a -> Dyn instance Eq Dyn where ... }}} -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:2 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: infoneeded Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by RyanGlScott): * status: new => infoneeded Comment: Your description still isn't very clear. What exactly is the bug here? Moreover, what does `GEq` have anything to do with `Dyn`? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:3 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: infoneeded Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by AntC): The error I see is that the `{-# OVERLAPPING #-}` pragma is on the wrong instance. The `GEq a a` instance should have `{-# OVERLAPPABLE #-}`; the `GEq a b` should have `{-# OVERLAPPING #-}`. The instance for `Dyn` doesn't mention `GEq`. I agree with Ben, Ryan: I see no bug. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:4 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by zaoqi): * status: infoneeded => new Old description:
{{{#!hs {-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-}
class GEq a b where geq :: a -> b -> Bool
instance {-# OVERLAPPING #-} Eq a => GEq a a where geq = (==)
instance GEq a b where geq _ _ = False }}}
{{{ GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help Prelude> :load GEq.hs [1 of 1] Compiling Main ( GEq.hs, interpreted ) Ok, modules loaded: Main. *Main> geq::a->b->Bool
<interactive>:3:1: Overlapping instances for GEq a1 b1 arising from a use of ‘geq’ Matching instances: instance GEq a b -- Defined at GEq.hs:9:10 instance [overlapping] Eq a => GEq a a -- Defined at GEq.hs:6:30 (The choice depends on the instantiation of ‘a1, b1’ To pick the first instance above, use IncoherentInstances when compiling the other instance declarations) In the expression: geq :: a -> b -> Bool In an equation for ‘it’: it = geq :: a -> b -> Bool *Main> }}}
In order to {{{#!hs {-# LANGUAGE KindSignatures, GADTs #-} data Dyn :: * where Dyn :: a -> Dyn
instance Eq Dyn where ... }}}
New description: {{{#!hs {-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-} class GEq a b where geq :: a -> b -> Bool instance {-# OVERLAPPING #-} Eq a => GEq a a where geq = (==) instance GEq a b where geq _ _ = False }}} {{{ GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help Prelude> :load GEq.hs [1 of 1] Compiling Main ( GEq.hs, interpreted ) Ok, modules loaded: Main. *Main> geq::a->b->Bool <interactive>:3:1: Overlapping instances for GEq a1 b1 arising from a use of ‘geq’ Matching instances: instance GEq a b -- Defined at GEq.hs:9:10 instance [overlapping] Eq a => GEq a a -- Defined at GEq.hs:6:30 (The choice depends on the instantiation of ‘a1, b1’ To pick the first instance above, use IncoherentInstances when compiling the other instance declarations) In the expression: geq :: a -> b -> Bool In an equation for ‘it’: it = geq :: a -> b -> Bool *Main> }}} In order to {{{#!hs {-# LANGUAGE KindSignatures, GADTs #-} data Dyn :: * where Dyn :: a -> Dyn instance Eq Dyn where (==) = geq }}} -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:5 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Description changed by zaoqi: Old description:
{{{#!hs {-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-}
class GEq a b where geq :: a -> b -> Bool
instance {-# OVERLAPPING #-} Eq a => GEq a a where geq = (==)
instance GEq a b where geq _ _ = False }}}
{{{ GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help Prelude> :load GEq.hs [1 of 1] Compiling Main ( GEq.hs, interpreted ) Ok, modules loaded: Main. *Main> geq::a->b->Bool
<interactive>:3:1: Overlapping instances for GEq a1 b1 arising from a use of ‘geq’ Matching instances: instance GEq a b -- Defined at GEq.hs:9:10 instance [overlapping] Eq a => GEq a a -- Defined at GEq.hs:6:30 (The choice depends on the instantiation of ‘a1, b1’ To pick the first instance above, use IncoherentInstances when compiling the other instance declarations) In the expression: geq :: a -> b -> Bool In an equation for ‘it’: it = geq :: a -> b -> Bool *Main> }}}
In order to {{{#!hs {-# LANGUAGE KindSignatures, GADTs #-} data Dyn :: * where Dyn :: a -> Dyn
instance Eq Dyn where (==) = geq }}}
New description: {{{#!hs {-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-} class GEq a b where geq :: a -> b -> Bool instance {-# OVERLAPPING #-} Eq a => GEq a a where geq = (==) instance GEq a b where geq _ _ = False }}} {{{ GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help Prelude> :load GEq.hs [1 of 1] Compiling Main ( GEq.hs, interpreted ) Ok, modules loaded: Main. *Main> geq::a->b->Bool <interactive>:3:1: Overlapping instances for GEq a1 b1 arising from a use of ‘geq’ Matching instances: instance GEq a b -- Defined at GEq.hs:9:10 instance [overlapping] Eq a => GEq a a -- Defined at GEq.hs:6:30 (The choice depends on the instantiation of ‘a1, b1’ To pick the first instance above, use IncoherentInstances when compiling the other instance declarations) In the expression: geq :: a -> b -> Bool In an equation for ‘it’: it = geq :: a -> b -> Bool *Main> }}} In order to {{{#!hs {-# LANGUAGE KindSignatures, GADTs #-} data Dyn :: * where Dyn :: a -> Dyn instance Eq Dyn where Dyn a == Dyn b = geq a b }}} -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:6 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by AntC): Thanks @zaoqi, you've now provided the full `instance Eq Dyn`. It's defining `(==)` in terms of `geq`. But you haven't changed the overlap pragmas -- see my comment:4. So you get the same compile fail. I think your `instance Eq Dyn` is probably not what you want. `geq` looks at whether the ''types'' are the same, not the values. So you're going to get `Dyn "hello" == Dyn "bye"` coming out `True`. You are still not telling us what you think is wrong/what you expect. So far as I can tell, GHC is behaving correctly. I would not expect this code to compile. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:7 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by bgamari): Moreover, there is no way to satisfy the `Eq a` constraint needed by `geq a b`. Afterall, the `a` type variable here is brought into scope by pattern-matching on the `Dyn` constructor which provides no constraints; not even `Typeable`, so it's not even possible to know at runtime whether the bound `a` and `b` values are of the same type. To be able to make this comparison work you would need something like, {{{#!hs data Dyn :: * where Dyn :: (Eq a, Typeable a) => a -> Dyn instance Eq Dyn where Dyn (a :: a) == Dyn (b :: b) | Just HRefl <- ra `eqTypeRep` rb = a == b | otherwise = False where ra = typeRep :: TypeRep a rb = typeRep :: TypeRep b }}} For instance, {{{ λ> Dyn (1 :: Int) == Dyn (2 :: Int) False λ> Dyn (1 :: Int) == Dyn (1 :: Int) True }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:8 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by AntC): Hi @bgamari, I got this to work just changing the pragmas, per my comment:7. (So I editted that comment after posting.) Note there's a `Eq a =>` constraint on the `GEq a a` instance; but not on the `GEq a b`. {{{ Dyn "hello" == Dyn "bye" ===> False Dyn "hello" == Dyn "hello" ===> True Dyn "hello" == Dyn 'b' ===> False }}} I agree @zaoqi's definition for `Dyn` is 'dodgy'. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:9 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by zaoqi): Replying to [comment:9 AntC]:
Hi @bgamari, I got this to work just changing the pragmas, per my comment:7. (So I editted that comment after posting.) Note there's a `Eq a =>` constraint on the `GEq a a` instance; but not on the `GEq a b`.
{{{
Dyn "hello" == Dyn "bye" ===> False Dyn "hello" == Dyn "hello" ===> True Dyn "hello" == Dyn 'b' ===> False
}}}
I agree @zaoqi's definition for `Dyn` is 'dodgy'.
{{{#!hs {-# LANGUAGE KindSignatures, GADTs #-} {-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-} data Dyn :: * where Dyn :: a -> Dyn instance Eq Dyn where Dyn a == Dyn b = geq a b class GEq a b where geq :: a -> b -> Bool instance {-# OVERLAPPABLE #-} (Eq a) => GEq a a where geq = (==) instance {-# OVERLAPPING #-} GEq a b where geq _ _ = False }}} {{{ GHCi, version 8.0.2: http://www.haskell.org/ghc/ :? for help Prelude> :load Dyn.hs [1 of 1] Compiling Main ( Dyn.hs, interpreted ) Ok, modules loaded: Main. *Main> Dyn () == Dyn () False }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:10 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by AntC): Replying to [comment:10 zaoqi]: Good. You've got it to compile. So we can close the ticket. I apologise: my comment:9 is wrong. I must have confused myself playing with it. Ben is right:
... it's not even possible to know at runtime whether the bound `a` and `b` values are of the same type.
In fact variables `a`, `b` bound by GADT `Dyn` are "rigid type variables". GHC always treats them as different types. They're existentially quantified. See [http://downloads.haskell.org/~ghc/8.0.2/docs/html/users_guide/glasgow_exts.h... #generalised-algebraic-data-types-gadts The User Guide on GADTs] So `instance Eq Dyn` will always return False. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:11 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by zaoqi): Replying to [comment:11 AntC]:
Replying to [comment:10 zaoqi]:
Good. You've got it to compile. So we can close the ticket.
I apologise: my comment:9 is wrong. I must have confused myself playing with it. Ben is right:
... it's not even possible to know at runtime whether the bound `a` and `b` values are of the same type.
In fact variables `a`, `b` bound by GADT `Dyn` are "rigid type variables". GHC always treats them as different types. They're existentially quantified. See [http://downloads.haskell.org/~ghc/8.0.2/docs/html/users_guide/glasgow_exts.h... #generalised-algebraic-data-types-gadts The User Guide on GADTs]
So `instance Eq Dyn` will always return False.
How to write the correct `instance Eq Dyn`, do not change `data Dyn`. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:12 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by AntC): Replying to [comment:12 zaoqi]:
Replying to [comment:11 AntC]:
So `instance Eq Dyn` will always return False.
How to write the correct `instance Eq Dyn`, do not change `data Dyn`.
The short answer is: `data Dyn` has the wrong definition for looking inside. Ben has given you one possibility in comment:8. A more simple one is: {{{ data Dyn a where Dyn :: Eq a => a -> Dyn a }}} If you can't change the definition of `Dyn` (why not?), you need to explain what you are trying to achieve. I suggest you ask a question on the cafe (or StackOverflow). GHC is behaving as intended. There's no fault, so Trac is not the place to look for that kind of help. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:13 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by zaoqi): Replying to [comment:13 AntC]:
Replying to [comment:12 zaoqi]:
Replying to [comment:11 AntC]:
So `instance Eq Dyn` will always return False.
How to write the correct `instance Eq Dyn`, do not change `data Dyn`.
The short answer is: `data Dyn` has the wrong definition for looking inside. Ben has given you one possibility in comment:8. A more simple one is:
{{{
data Dyn a where Dyn :: Eq a => a -> Dyn a
}}}
If you can't change the definition of `Dyn` (why not?), you need to explain what you are trying to achieve.
I suggest you ask a question on the cafe (or StackOverflow). GHC is behaving as intended. There's no fault, so Trac is not the place to look for that kind of help. (I see you've posted several Trac tickets that are not really faults.)
Perhaps it would be easier for you to ask on a Chinese language forum? There seem to be [https://www.reddit.com/r/ChineseLanguage/comments/62qfze/is_there_a_chinese_... some equivalents to reddit], for both Mandarin and Cantonese.
`instance Dyn Ord` `instance Dyn Num` `instance Dyn Read` `instance Dyn Show` ... -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:14 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#14004: G -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: feature request | Status: closed Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 Resolution: invalid | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by RyanGlScott): * status: new => closed * resolution: => invalid -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/14004#comment:15 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
participants (1)
-
GHC