#15928: Reduction stack overflow when using "coerce" -------------------------------------+------------------------------------- Reporter: harendra | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.6.3 Component: Compiler | Version: 8.6.2 Resolution: | Keywords: Operating System: MacOS X | Architecture: Type of failure: Compile-time | Unknown/Multiple crash or panic | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by harendra): I think GHC needs to move on from "by GHC developers for GHC developers" to "by GHC developers for mortal Haskell programmers". You have a lot more context here than a Haskell programmer at large would have. The error needs to be resolved quickly, in a few seconds or perhaps minutes would be fine too. The error message and the documentation does not serve that purpose, it (Data.Coerce) refers to the paper and the roles wiki page (referring to papers is common theme for GHC and Haskell libraries), the paper is accessible to only a very small population, and we should not expect a large population of programmers to go read the paper and spend hours or even days or weeks trying to understand it and having to learning a lot of other things in the process. For that one error message, which can be explained better in just a few more words, it becomes a big digression. I am sorry about that rant, GHC devs are doing a terrific job, it is a wonderful technology but it has a potential to become much more usable by a lot more ordinary programmers like me if the error messages and the documentation become a little better. Keeping that aside, I still have a few questions about the issue at hand, I suspect there is a bug here: 1) Why a and a0 are treated as different types in the first version of the code? If a ~ a0 then there won't be a loop. In fact, this code is coercing a type into itself, which should be trivial. In the second version of the code where it works, the two types have been explicitly forced to be the same via a type signature. 2) This code works fine if the "Stream" type is defined using "data" instead of a "newtype". It puzzles me, why in that case we are not going into a loop? Why in that case the types a and a0 are the same? About the error message, I think it can be improved. First of all, a regular programmer won't have any idea what a "reduction stack" is, they can just guess, it is possibly a GHC internal thing. The error message is for GHC developers, not for users. The flag "-freduction-depth" is only mentioned in "Undecidable Instances section" of the guide, nowhere else. If the programmer is supposed to know about the reduction stack then it should be documented and the concept should be explained. But I guess we can do better even without doing that. The error message can perhaps be phrased something like this, it might be inaccurate, but just to give an idea: {{{ When trying to determine that the representation of type x is the same as that of type y, we expanded the types n times but still could not determine that they are equal, we can go on but we are limited by the reduction stack size which can be changed by using the -freduction-depth option. In some cases where the types are recursively defined, it is possible that the expansion forms an infinite loop that never terminates. For more details and examples see this manual page. }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/15928#comment:2 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler