- ghc-devs - Haskell.org

Request for Nominations to the GHC Steering Committee
by Joachim Breitner 11 Dec '19

11 Dec '19

Dear Haskell community, the GHC Steering committee is seeking nominations for one new member. The committee scrutinizes, nitpicks, improves, weights and eventually accepts or rejects proposals that extend or change the language supported by GHC and other (public-facing) aspects of GHC. Our processes are described at https://github.com/ghc-proposals/ghc-proposals which is also the GitHub repository where proposals are proposed. We are looking for a member who has the ability * to understand such language extension proposals, * to find holes and missing corner cases in the specifications, * foresee the interaction with other language features and specifications, * comment constructively and improve the proposals, * judge the cost/benefit ratio and * finally come to a justifiable conclusion. We look for committee members who have some of these properties: * have substantial experience in writing Haskell applications or libraries, which they can use to inform judgements about the utility or otherwise of proposed features, * have made active contributions to the Haskell community, for some time, * have expertise in language design and implementation, in either Haskell or related languages, which they can share with us. The committee’s work requires a small, but non-trivial amount of time, especially when you are assigned a proposal for shepherding. We estimate the workload to be around 2 hours per week, and our process works best if members usually respond to technical emails within 1-2 weeks (within days is even better). Please keep that in mind if your email inbox is already overflowing. The GHC developers themselves are already well represented already. We seek Haskell _users_ more than GHC hackers. There is no shortage of people who are eager to get fancy new features into the language, both in the committee and the wider community. But each new feature imposes a cost, to implement, to learn, (particularly) through its unexpected interaction with other features. We need to strike a balance, one that encourages innovation (as GHC always has) while still making Haskell attractive for real-world production use and for teaching. We therefore explicitly invite “conservative” members of the community to join the committee. To make a nomination, please send an email to me (as the committee secretary) at mail(a)joachim-breitner.de until January 2nd. I will distribute the nominations among the committee, and we will keep the nominations and our deliberations private. We explicitly encourage self-nominations. You can nominate others, but please obtain their explicit consent to do so. (We don’t want to choose someone who turns out to be unable to serve.) On behalf of the committee, Joachim Breitner -- Joachim Breitner mail(a)joachim-breitner.de http://www.joachim-breitner.de/

1 0

GitLab # trick
by Richard Eisenberg 10 Dec '19

10 Dec '19

Today I learned that if you type # in an input field on GitLab, you can start typing the description of a ticket, and GitLab will find the number of the (open) ticket for you. For example, I typed #zap and got #16775, just what I was looking for. (That I would get this was very clear in the UI -- no surprises here.) Maybe others already knew this, but this was just so snazzy and ergonomic, I had to write. Richard

1 0

Total failure
by Simon Peyton Jones 10 Dec '19

10 Dec '19

Bad things are happening. I can't build GHC at all! I'm trying 'sh validate -fast' on a clean build of a master checkout HEAD detached at 3a96a0b6db (this is the master checkout from which !2276 branches off) But alas I get this Exit code: 1 Stderr: compiler/main/DynFlags.hs:323:0: error: error: "GHC_STAGE" is not defined, evaluates to 0 [-Werror=undef] #if GHC_STAGE >= 2 | 323 | #if GHC_STAGE >= 2 | ^ compiler/main/DynFlags.hs:5750:0: error: error: "GHC_STAGE" is not defined, evaluates to 0 [-Werror=undef] #if GHC_STAGE < 2 | 5750 | #if GHC_STAGE < 2 | ^ cc1: all warnings being treated as errors What should I do? Simon

2 2

Re: More failure
by Andrey Mokhov 10 Dec '19

10 Dec '19

Hi Simon, (Re-sending from the email address that's allowed on the mailing list.) > Ugh. That's not a very happy state of affairs, is it? It didn't happen with 'make'. > Is it a fundamental problem, or just not yet fixed? I think this is not a fundamental problem, but the problem of getting dependencies right. In this case, the complexity comes from the fact that a single invocation of GHC produces a set of files, and which set depends on the command line flags, which are in turn determined dynamically by reading environment settings (specifically, `platformSupportsSharedLibs`). Such rules are hard to describe precisely, because build systems are tuned to the typical case where we statically know, for every output file, which rule produces it -- recall the Tasks = k -> Maybe Task function from our paper. In this case, we deal with something like k -> f (Maybe Task) instead, i.e. with `f` around the Maybe. The Make build system happens to do the right thing, somehow. I believe we should be able to express the same logic in Shake, but it's not easy. (I never really had a chance to look at dynamic builds, since they are not supported on Windows. I guess I should finally find a Linux box for Hadrian.) Cheers, Andrey

2 2

Running test with the stage-1 compiler
by Simon Peyton Jones 10 Dec '19

10 Dec '19

Apparently 'sh validate' now uses Hadrian. This has broken one of my workflows: * build the stage1 compiler * cd testsuite/tests * make stage=1 That is, run the testsuite with the stage-1 compile. (This often produces a small test case for a compiler crash, much easier than debugging GHC compiling itself.) How do I do this? Thanks Simon

4 4

More failure
by Simon Peyton Jones 09 Dec '19

09 Dec '19

More pain. I said sh validate --fast --no-clean and got this output Error when running Shake build system: at action, called at src/Rules.hs:71:19 in main:Rules at need, called at src/Rules.hs:93:5 in main:Rules * Depends on: _validatebuild/stage1/lib/package.conf.d/base-4.14.0.0.conf at need, called at src/Rules/Register.hs:113:5 in main:Rules.Register * Depends on: _validatebuild/stage1/libraries/base/build/libHSbase-4.14.0.0-ghc8.11.0.20191201.so at need, called at src/Rules/Library.hs:146:5 in main:Rules.Library * Depends on: _validatebuild/stage1/libraries/base/build/GHC/IO/Handle/Lock/Common.dyn_o at &%>, called at src/Rules/Compile.hs:54:7 in main:Rules.Compile * Depends on: _validatebuild/stage1/libraries/base/build/GHC/IO/Handle/Lock/Common.dyn_o _validatebuild/stage1/libraries/base/build/GHC/IO/Handle/Lock/Common.dyn_hi at error, called at src/Development/Shake/Internal/Rules/Files.hs:245:13 in shake-0.18.3-593067565aafb558d09b4352b8abc327d8911a39a0e9abab2804b002b1ae536e:Development.Shake.Internal.Rules.Files * Raised the exception: Error, &%> rule failed to produce 1 file (out of 2) _validatebuild/stage1/libraries/base/build/GHC/IO/Handle/Lock/Common.dyn_o _validatebuild/stage1/libraries/base/build/GHC/IO/Handle/Lock/Common.dyn_hi - MISSING I think I'm going to have to revert to 'sh validate -legacy'. Please let me know when I should try again with Hadrian. Simon

2 2

re-engineering overloading and rebindable syntax
by Richard Eisenberg 05 Dec '19

05 Dec '19

Hi devs, I've recently discovered the `overloaded` package, which allows us to do very clever things around overloading in a source plugin. In my over-excitement, I wondered about removing GHC's capability to do overloading and rebindable syntax, leaving those features to be implemented by source plugins. To first approximation, this would work well. But there are many drawbacks: poorer error messages, worries around the trustworthiness of non-GHC source plugins, cross compilation, etc. The idea is not viable right now. Yet: I wonder if we couldn't take the general idea of doing this as source plugins, without actually implementing it that way. Currently, there is a good deal of code scattered throughout GHC to deal with overloaded constructs (numbers, strings, lists) and rebindable syntax. These make their presence known in a number of places in HsExpr and friends, and various machinations in the renamer and type-checker are needed to deal with them. The type-checker for rebindable syntax is buggy (#14963 and friends); the fix will involve likely *more* code devoted to rebindable syntax (albeit simpler code than what we have today). If, say, the renamer implemented all overloading and rebindable syntax just by a straightforward syntactic transformation, this would all be much simpler. (Actually, it could also be done in the parser, but I think the renamer is a better home.) Pros: - much, much simpler implementation - localized implementation: nothing in the type checker at all nor in HsSyn Con: - worse error messages, which would now refer to the desugared code instead of the user-written code. I can't think of any other downside. How can we mitigate this? By expanding the possibilities of a SrcSpan. A SrcSpan is really a description of the provenance of a piece of AST. Right now, it considers two possibilities: that the code came from a specific stretch of rows and columns in an input file, or that the code came from elsewhere. Instead, we can expand (and perhaps rename) SrcSpan to include more possibilities. In support of my idea above, we could now have a SrcSpan that says some AST came from overloading. Such code is suppressed by default when pretty-printing. Thus, `fromString "blah"` could render as just `"blah"` (what the user wrote), if fromString was inserted by the translation pass described above. We can have a separate new SrcSpan that says that AST was written by translation from some original AST. That way, `ifThenElse a b c` can be printed as `if a then b else c`, if the former were translated from the latter. Though it's beyond my use-case above, we can also imagine a new SrcSpans that refer to a Template Haskell splice or a quasiquote. What do we think? Is this a worthwhile direction of travel? I think the end result would be both a cleaner implementation of overloading and rebindable syntax *and* more informative and useful source-code provenances. Richard

4 3

users-guide page for master branch
by Takenobu Tani 03 Dec '19

03 Dec '19

Hi Ben, devs, This is not in hurry. It looks like the users-guide page for master branch [1] has not been updated recently. [1]: https://ghc.gitlab.haskell.org/ghc/doc/users_guide Regards, Takenobu

2 3

Injecting imported functions using a core plugin
by Josef Svenningsson 26 Nov '19

26 Nov '19

Hi ghc-devs, I’m currently writing a core plugin that I could use some help with. Consider the following two modules: ``` module A where foo :: Int bar :: Int module B where baz :: Int baz = bar ``` When compiling module B I run my plugin. The goal of the plugin is to replace the occurrence of `bar` with `foo`. Note that we can be sure that `foo` is actually imported, but unfortunately doesn’t occur anywhere in B before the plugin performs the transformation. The problem I have is that in order to inject `foo` in B I need to have an `Id` which represents `foo` and I’m having some trouble constructing such an `Id`. I’ve looked through the various environments that are available during the core to core transformations but none of them provides enough information to actually produce the `foo` `Id` as far as I can see. I hope I’m missing something. What do I need to do in order to construct the `foo` `Id` in module B? Thanks, Josef PS. The way I’ve phrased my problem in this email it would be possible to solve it with rewrite rules. My actual use case is unfortunately more complicated and rewrite rules don’t provide enough power to do what I want.

3 4

Multiple instance pragmas
by Domínguez, Facundo 25 Nov '19

25 Nov '19

Dear devs, I have a program [1] which depends on the ability to specify some instances to be both overlappable and incoherent. GHC so far, allows only one of the OVERLAPPABLE or INCOHERENT pragmas to be specified per instance. One can still have an overlappable and incoherent instance by using -XIncoherenInstances, but this extension is deprecated. Is there any chance that a patch is accepted to allow multiple instance pragmas? And if not, what would the reason for this constraint? Thanks, Facundo [1] https://gist.github.com/facundominguez/2c0292bf6a721b450c46486ff3b71f24

3 2