[GHC] #8745: GeneralizedNewtypeDeriving is still not Safe
#8745: GeneralizedNewtypeDeriving is still not Safe ------------------------------------+------------------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.1-rc1 Keywords: Safe | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- In GHC 7.8, !GeneralizedNewtypeDeriving (GND) is type-safe, due to the advent of roles. Although GND allows looking through unimported constructors, the notion of abstraction has changed -- for a type to be fully abstract in 7.8, it must not export its constructors, and the roles of all its parameters must be nominal. Thus, it would seem that GND should be Safe; that is, in the Safe Haskell subset. See also #5498. Currently, GND is not considered Safe. Along similar lines, the `Coercible` and `coerce` mechanism could be considered Safe, but there is no way to import these into a Safe module (they are in `GHC.Exts`). -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------+------------------------------------ Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.1-rc1 Resolution: | Keywords: Safe Operating System: Unknown/Multiple | Architecture: Unknown/Multiple Type of failure: None/Unknown | Difficulty: Unknown Test Case: | Blocked By: Blocking: | Related Tickets: -------------------------------------+------------------------------------ Changes (by thoughtpolice): * cc: nomeata (added) Comment: The GND change seems reasonable to me, and I believe we discussed it prior to this (but I can't find the mailing list post just yet) - we just need to remove `-XGeneralizedNewtypeDeriving` from `unsafeFlags` in `DynFlags`. I'm not so sure about Coerce though, at least not yet - we're still considering it somewhat experimental I think, so perhaps exposing it to Safe Haskell isn't the best idea just yet. Joachim, what are your thoughts on this? Do you think we should consider `Coercible` as safe? If so, I'm willing to defer to you here (and I'll even write the patch - but not sure where to export it from - perhaps a `Trustworthy` module called `GHC.Coerce`?) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:1 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------+------------------------------------ Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.1-rc1 Resolution: | Keywords: Safe Operating System: Unknown/Multiple | Architecture: Unknown/Multiple Type of failure: None/Unknown | Difficulty: Unknown Test Case: | Blocked By: Blocking: | Related Tickets: -------------------------------------+------------------------------------ Comment (by goldfire): The comments I've seen in relation to this are all in #5498. GND is now actually built on top of `coerce`, so I think it's a little incongruent to have one be Safe but not the other. To be fair, I'm not 100% sure that GND should be Safe, myself. While I am as confident as I can be about its type safety, it is very easy to imagine a library author omitting a key role annotation that would allow clients to (perhaps unwittingly) break class coherence or invariants. For example, if `base`'s `Set` doesn't have a role annotation, it would be very easy to cause the `Set` operations to misbehave. Simon PJ has advocated (see #5498) that GND should be Safe, on the other hand. My goal in creating this ticket is to make a reasoned decision on the matter, as opposed to letting inertia make the decision for us. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:2 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------+------------------------------------ Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.1-rc1 Resolution: | Keywords: Safe Operating System: Unknown/Multiple | Architecture: Unknown/Multiple Type of failure: None/Unknown | Difficulty: Unknown Test Case: | Blocked By: Blocking: | Related Tickets: -------------------------------------+------------------------------------ Comment (by nomeata): We have some special handling in Safe mode in place where we do the Coerible thing, but it is neither well tested nor well discussed. (`getCoercibleInst` in `TcInteract`) Currently, in Safe Mode, the following additional restrictions exist when checking whether something is `Coercible`:
To coerce under a type constructor, ''all'' data constructors of ''all'' type constructors involved in the definition of that type constructors need to be in scope.
No additional constraint is put on unfolding a newtype, but there we already require the constructor to be in scope. I believe that this condition is sufficient for “the use can implement coerce himself (ignoring the run-time cost)”. If anything, it might turn out too strong. If that works as intended, `Coercible` and GND should be safe. There might possibly be ways to break it, maybe with different modules, some safe and some not... but that would simply be bugs then, and I’m not claiming bug freeness. A trustworthy `GHC.Coerce` might be nice. Or maybe even `Data.Coerce`? After all the interface could be provided by other compilers as well... Not only for Safe, but to avoid people having to import the mingle-mangle of `GHC.Exts`. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:3 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------+------------------------------------ Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.1-rc1 Resolution: | Keywords: Safe Operating System: Unknown/Multiple | Architecture: Unknown/Multiple Type of failure: None/Unknown | Difficulty: Unknown Test Case: | Blocked By: Blocking: | Related Tickets: -------------------------------------+------------------------------------ Comment (by goldfire): I had forgotten about this detail. With this in place (is it tested by anything in the testsuite?), I'm much more in favor of labeling GND and `coerce` as Safe. It's possible that the (rather draconian, admittedly) check that Joachim (nomeata) describes could be relaxed in the future once library authors are more familiar with role annotations. I no longer see a downside to making GND and `coerce` Safe. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:4 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------+------------------------------------ Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.1-rc1 Resolution: | Keywords: Safe Operating System: Unknown/Multiple | Architecture: Unknown/Multiple Type of failure: None/Unknown | Difficulty: Unknown Test Case: | Blocked By: Blocking: | Related Tickets: -------------------------------------+------------------------------------ Comment (by goldfire): I've found a weird corner case that is very relevant. Consider {{{ class Foo a where ... type role Foo representational data PackFoo a where MkPF :: Foo a => PackFoo a instance Foo Int where ... newtype Age = MkAge Int instance Foo Age where ... incoherent :: PackFoo Age incoherent = coerce (MkPF :: PackFoo Int) useIncoherent = case incoherent of MkPF -> {- here, we two incompatible instances of Foo Age available! -} }}} The problem, as I see it, boils down to the role annotation on `Foo`, which allows users to create incoherence. Should we perhaps disallow role annotations on classes in Safe Haskell? It would be analogous to the restrictions on overlapping instances, I think. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:5 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: Resolution: | 7.8.1-rc1 Operating System: Unknown/Multiple | Keywords: Safe Type of failure: None/Unknown | Architecture: Test Case: | Unknown/Multiple should_fail/TcCoercibleFailSafe | Difficulty: Blocking: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Changes (by nomeata): * testcase: => should_fail/TcCoercibleFailSafe Comment:
With this in place (is it tested by anything in the testsuite?)
One simple test case is in place (`typecheck/should_fail/TcCoercibleFailSafe`).
class Foo a where ... type role Foo representational
Why is that even accepted? I thought role annotation can only stricten roles (i.e. P→N, P→R, R→N), and we have decided that classes have role nominal by default, so I would expect `type role Foo representational` to be rejected even in non-Safe Haskell. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:6 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: Resolution: | 7.8.1-rc1 Operating System: Unknown/Multiple | Keywords: Safe Type of failure: None/Unknown | Architecture: Test Case: | Unknown/Multiple should_fail/TcCoercibleFailSafe | Difficulty: Blocking: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Comment (by goldfire): The role annotation story is this: the annotations, if provided, simply override defaults (phantom for datatypes, nominal for classes). Then role inference happens (annotations or no). If, after inference, the annotations disagree with the inferred roles, the annotation is rejected. Because it's perfectly type-safe to have a class with a representational parameter, the role annotation is accepted and works. This can be useful if, say, someone wanted to have something like `Coercible` implemented in user-land somehow -- note that `Coercible`'s parameters are representational. One way forward here is to allow role annotations on classes only when we have !IncoherentInstances. In fact, I rather like that solution -- a role annotation on a class quickly leads to the possibility of incoherence, and this solution also neatly prohibits such annotations in Safe Haskell. Thoughts? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:7 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: Resolution: | 7.8.1-rc1 Operating System: Unknown/Multiple | Keywords: Safe Type of failure: None/Unknown | Architecture: Test Case: | Unknown/Multiple should_fail/TcCoercibleFailSafe | Difficulty: Blocking: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Comment (by nomeata):
One way forward here is to allow role annotations on classes only when we have IncoherentInstances. In fact, I rather like that solution -- a role annotation on a class quickly leads to the possibility of incoherence, and this solution also neatly prohibits such annotations in Safe Haskell. Thoughts?
That’s what I was about to propose as well. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:8 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: Resolution: | 7.8.1-rc1 Operating System: Unknown/Multiple | Keywords: Safe Type of failure: None/Unknown | Architecture: Test Case: | Unknown/Multiple should_fail/TcCoercibleFailSafe | Difficulty: Blocking: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Comment (by goldfire): Great. I've made #8773 to track that offshoot of this bug. I expect to do it and push tomorrow. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:9 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: 7.8.1 Component: Compiler | Version: Resolution: | 7.8.1-rc1 Operating System: Unknown/Multiple | Keywords: Safe Type of failure: None/Unknown | Architecture: Test Case: | Unknown/Multiple should_fail/TcCoercibleFailSafe | Difficulty: Blocking: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Changes (by thoughtpolice): * milestone: => 7.8.1 -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:10 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: 7.8.1 Component: Compiler | Version: Resolution: | 7.8.1-rc1 Operating System: Unknown/Multiple | Keywords: Safe Type of failure: None/Unknown | Architecture: Test Case: | Unknown/Multiple should_fail/TcCoercibleFailSafe | Difficulty: Blocking: | Unknown | Blocked By: 8773 | Related Tickets: -------------------------------------------------+------------------------- Changes (by thoughtpolice): * blockedby: => 8773 -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:11 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: 7.8.1 Component: Compiler | Version: Resolution: | 7.8.1-rc1 Operating System: Unknown/Multiple | Keywords: Safe Type of failure: None/Unknown | Architecture: Test Case: | Unknown/Multiple should_fail/TcCoercibleFailSafe | Difficulty: Blocking: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Changes (by goldfire): * blockedby: 8773 => Comment: #8773 fixed. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:12 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe
-------------------------------------------------+-------------------------
Reporter: goldfire | Owner:
Type: bug | Status: new
Priority: normal | Milestone: 7.8.1
Component: Compiler | Version:
Resolution: | 7.8.1-rc1
Operating System: Unknown/Multiple | Keywords: Safe
Type of failure: None/Unknown | Architecture:
Test Case: | Unknown/Multiple
should_fail/TcCoercibleFailSafe | Difficulty:
Blocking: | Unknown
| Blocked By:
| Related Tickets:
-------------------------------------------------+-------------------------
Comment (by Austin Seipp
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: merge Priority: normal | Milestone: 7.8.1 Component: Compiler | Version: Resolution: | 7.8.1-rc1 Operating System: Unknown/Multiple | Keywords: Safe Type of failure: None/Unknown | Architecture: Test Case: | Unknown/Multiple should_fail/TcCoercibleFailSafe | Difficulty: Blocking: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Changes (by thoughtpolice): * status: new => merge -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:14 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: Priority: normal | closed Component: Compiler | Milestone: 7.8.1 Resolution: fixed | Version: Operating System: Unknown/Multiple | 7.8.1-rc1 Type of failure: None/Unknown | Keywords: Safe Test Case: | Architecture: should_fail/TcCoercibleFailSafe | Unknown/Multiple Blocking: | Difficulty: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Changes (by thoughtpolice): * status: merge => closed * resolution: => fixed Comment: Merged in 7.8. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:15 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: Priority: normal | closed Component: Compiler | Milestone: 7.8.1 Resolution: fixed | Version: Operating System: Unknown/Multiple | 7.8.1-rc1 Type of failure: None/Unknown | Keywords: Safe Test Case: | Architecture: should_fail/TcCoercibleFailSafe | Unknown/Multiple Blocking: | Difficulty: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Comment (by goldfire): Did this fix also export `coerce` from a Trustworthy module? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:16 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: Priority: normal | closed Component: Compiler | Milestone: 7.8.1 Resolution: fixed | Version: Operating System: Unknown/Multiple | 7.8.1-rc1 Type of failure: None/Unknown | Keywords: Safe Test Case: | Architecture: should_fail/TcCoercibleFailSafe | Unknown/Multiple Blocking: | Difficulty: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Comment (by thoughtpolice): Ah, no, it did not. I forgot that. We can still do this under the caveat that `coerce` is still experimental, but I'm literally making the RC2 srcdist as we speak... So it'll have to wait for the final release at best. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:17 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: 7.8.1 Component: Compiler | Version: Resolution: | 7.8.1-rc1 Operating System: Unknown/Multiple | Keywords: Safe Type of failure: None/Unknown | Architecture: Test Case: | Unknown/Multiple should_fail/TcCoercibleFailSafe | Difficulty: Blocking: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Changes (by goldfire): * status: closed => new * resolution: fixed => Comment: Reopening the ticket, as without a Safe way of importing coerce, this issue isn't fully solved. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:18 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: 7.8.1 Component: Compiler | Version: Resolution: | 7.8.1-rc1 Operating System: Unknown/Multiple | Keywords: Safe Type of failure: None/Unknown | Architecture: Test Case: | Unknown/Multiple should_fail/TcCoercibleFailSafe | Difficulty: Blocking: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Comment (by thoughtpolice): For the record, unless there are any other suggestions, I'll likely take Joachim's suggestion of putting this in `Data.Coerce`. Any other suggestions? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:19 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: 7.8.1 Component: Compiler | Version: Resolution: | 7.8.1-rc1 Operating System: Unknown/Multiple | Keywords: Safe Type of failure: None/Unknown | Architecture: Test Case: | Unknown/Multiple should_fail/TcCoercibleFailSafe | Difficulty: Blocking: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Comment (by nomeata): I’m still on holidays with bad connection, otherwise I’d do it. `Data.Coerce` sounds good, which should be the haddock home module. `GHC.Exts` should then only re-export that module. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:20 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe
-------------------------------------------------+-------------------------
Reporter: goldfire | Owner:
Type: bug | Status: new
Priority: normal | Milestone: 7.8.1
Component: Compiler | Version:
Resolution: | 7.8.1-rc1
Operating System: Unknown/Multiple | Keywords: Safe
Type of failure: None/Unknown | Architecture:
Test Case: | Unknown/Multiple
should_fail/TcCoercibleFailSafe | Difficulty:
Blocking: | Unknown
| Blocked By:
| Related Tickets:
-------------------------------------------------+-------------------------
Comment (by Austin Seipp
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: merge Priority: normal | Milestone: 7.8.1 Component: Compiler | Version: Resolution: | 7.8.1-rc1 Operating System: Unknown/Multiple | Keywords: Safe Type of failure: None/Unknown | Architecture: Test Case: | Unknown/Multiple should_fail/TcCoercibleFailSafe | Difficulty: Blocking: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Changes (by thoughtpolice): * status: new => merge -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:22 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: Priority: normal | closed Component: Compiler | Milestone: 7.8.1 Resolution: fixed | Version: Operating System: Unknown/Multiple | 7.8.1-rc1 Type of failure: None/Unknown | Keywords: Safe Test Case: | Architecture: should_fail/TcCoercibleFailSafe | Unknown/Multiple Blocking: | Difficulty: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Changes (by thoughtpolice): * status: merge => closed * resolution: => fixed Comment: Merged in 7.8 for RC2. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:23 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe
-------------------------------------------------+-------------------------
Reporter: goldfire | Owner:
Type: bug | Status:
Priority: normal | closed
Component: Compiler | Milestone: 7.8.1
Resolution: fixed | Version:
Operating System: Unknown/Multiple | 7.8.1-rc1
Type of failure: None/Unknown | Keywords: Safe
Test Case: | Architecture:
should_fail/TcCoercibleFailSafe | Unknown/Multiple
Blocking: | Difficulty:
| Unknown
| Blocked By:
| Related Tickets:
-------------------------------------------------+-------------------------
Comment (by Herbert Valerio Riedel
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: Priority: normal | closed Component: Compiler | Milestone: 7.8.1 Resolution: fixed | Version: Operating System: Unknown/Multiple | 7.8.1-rc1 Type of failure: None/Unknown | Keywords: Safe Test Case: | Architecture: should_fail/TcCoercibleFailSafe | Unknown/Multiple Blocking: | Difficulty: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Comment (by goldfire): See also [changeset:"59722295bb8da8f01d37356fbed6aef7321a8195/ghc"] which was meant to reference this ticket. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:25 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
#8745: GeneralizedNewtypeDeriving is still not Safe
-------------------------------------------------+-------------------------
Reporter: goldfire | Owner:
Type: bug | Status:
Priority: normal | closed
Component: Compiler | Milestone: 7.8.1
Resolution: fixed | Version:
Operating System: Unknown/Multiple | 7.8.1-rc1
Type of failure: None/Unknown | Keywords: Safe
Test Case: | Architecture:
should_fail/TcCoercibleFailSafe | Unknown/Multiple
Blocking: | Difficulty:
| Unknown
| Blocked By:
| Related Tickets:
-------------------------------------------------+-------------------------
Comment (by Austin Seipp
#8745: GeneralizedNewtypeDeriving is still not Safe -------------------------------------------------+------------------------- Reporter: goldfire | Owner: Type: bug | Status: Priority: normal | closed Component: Compiler | Milestone: 7.8.1 Resolution: fixed | Version: Operating System: Unknown/Multiple | 7.8.1-rc1 Type of failure: None/Unknown | Keywords: Safe Test Case: | Architecture: should_fail/TcCoercibleFailSafe | Unknown/Multiple Blocking: | Difficulty: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Comment (by simonpj): Don't miss the long discussion in #8827 -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8745#comment:27 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler
participants (1)
-
GHC