- ghc-steering-committee

GHC stability discussions
by Simon Peyton Jones 09 Nov '23

09 Nov '23

Dear GHC Steering Committee We have several threads about GHC's stability in progress: - Proposal 601: GHC extension life cycle <https://github.com/david-christiansen/ghc-proposals/blob/extension-lifecycl…>. This introduces the notion of a "Stable" and "Experimental" extension. It was written by David C but has stalled now that he has stepped down as ED. - GHC Stability Goals <https://docs.google.com/document/d/1wtbAK6cUhiAmM6eHV5TLh8azEdNtsmGwm47Zulg…>, builds on #601 with general rules GR1-3. This is not a change to GHC (hence not a GHC proposal) more a clarification about how the GHC Steering Committee works. - Proposal 620: Extensions and warnings <https://github.com/ghc-proposals/ghc-proposals/blob/wip/spj-extensions-and-…>. This proposal keeps moving in the same direction, unifying warnings and extensions. - Proposal 617: add -experimental flag <https://github.com/ghc-proposals/ghc-proposals/pull/617>. This builds on #601 by providing an enforcement mechanism. It is strongly affected by #620. It would be good to get some of this decided. Too much is in the air at the moment! Personally I think: - We can agree at least the Stable/Experimental part of #601 - The Stability Goals seem fairly uncontroversial. Shall we just make it part of the GHC Proposal process documentation - #620 is new; your views would be welcome - The approach to #617 may depend on the outcome of #620. Simon

2 3

#536: Type-level literals as a separate language extension
by Vladislav Zavialov 20 Oct '23

20 Oct '23

Dear Committee, Back in March I initiated a discussion of #536 "Type-level literals as a separate language extension" by Ross Paterson. Quick recap: currently DataKinds controls promotion of ADTs and Symbol/Natural/Char literals. The proposal is to factor out promotion of literals into their own extension, TypeLevelLiterals. I recommended acceptance but received mixed feedback. Summary of opinions: Vlad: "rec: accept" SPJ: "content to accept" Joachim: "unsure how that fits with the overall direction we have for namespaces" Arnaud: "unconvinced that it is worth yet one extra extension" Richard: "pretty strongly against" Adam: "avoid bundling together distinct features" (i.e. accept) Chris: "in favour" Iavor (as ex-member): "strongly in favor" Haven't yet expressed their opinion: Simon M. and Moritz. So we have roughly 5 votes in-favor-or-don't-mind and 3 votes against-or-unconvinced. SPJ suggested that we simply count the votes, but after reading the discussion, I find that there's a deeper reason for disagreement. Essentially, we have two camps: 1. "Let a thousand flowers bloom": Haskell should be customizable, built out of small extensions à la carte. (A necessary implication here is that this gives rise to dialects of Haskell that depend on the set of enabled extensions) 2. "More extensions make me wince": Extensions are a necessary evil while we explore the language design space, and we shouldn't create them unnecessarily. (Language editions like GHC2021 help with that, allowing the users to forget about individual extensions and simply use a better/newer Haskell) The 1st paradigm suggests that TypeLevelLiterals should be factored out. TypeLevelLiterals+TypeData form a dialect different from DataKinds with regards to name resolution, which some users might prefer. Let them have it, why not? The 2nd paradigm suggests that breaking DataKinds into smaller extensions is counterproductive. Do we want fewer extensions or more extensions, after all? And as a steering committee, don't we have a clear direction in which we steer? Unfortunately, we don't have a general policy that would clearly tell us which camp/paradigm is right. And it's about time that we make a decision regarding #536, even if we don't have a policy to guide us. Because of that, my new plan is to reject the proposal out of caution. We have at least one "strongly against", and it's enough to give me pause. It's probably better to stick to the status quo, at least until we develop a concrete stance w.r.t. fine-grained extensions. (Pardon a digression, but this also calls into question whether 448 is justified in splitting ScopedTypeVariables into ExtendedForAllScope, MethodTypeVariables, PatternSignatures. Maybe we don't want fine-grained extensions after all) The new recommendation is to reject the proposal, but I still can't make this decision single-handedly. So let's do another round of discussion, only this time let's stick to practicalities, not general considerations. Is there anyone on the committee (or do we know someone) who needs TypeLevelLiterals for practical reasons, not just as a matter of taste? For example, 1. You are writing a book and you want to introduce TypeLevelLiterals before DataKinds 2. You are developing or maintaining a library or application that needs TypeLevelLiterals but cannot use DataKinds 3. You are working on an alternative Haskell implementation and intend to support TypeLevelLiterals but not DataKinds If any of the above (or similar) applies, speak up. Vlad

7 8

Stability
by Simon Peyton Jones 13 Oct '23

13 Oct '23

Dear GHC SC To avoid derailing the debate about -Wsevere <https://mail.haskell.org/pipermail/ghc-steering-committee/2023-September/00…>, and HasField redesign <https://mail.haskell.org/pipermail/ghc-steering-committee/2023-September/00…>, I'm starting a new (email for now) thread about stability. I have tried to articulate what I believe is an evolving consensus in this document <https://docs.google.com/document/d/1wtbAK6cUhiAmM6eHV5TLh8azEdNtsmGwm47Zulg…> . If we converge, we'll turn that into a proper PR for the GHC proposal process, although it has wider implications than just GHC proposals and we should share with a broader audience. But let's start with the steering committee. Any views? You all have edit rights. I think that the draft covers Moritz's and Julian's goals, at least that was my intention. I have pasted Moritz's last email below, for context. Simon ========= Moritz's last email ============ Now, this is derailing the original discussion a bit, and I'm not sure how far we want to take this. But, regarding @Simon Marlow <marlowsd(a)gmail.com>'s comment This is one cultural aspect of our community I'd like to shift: the > expectation that it's OK to make breaking changes as long as you warn about > them or go through a migration cycle. It just isn't! (and I speak as > someone who used to make lots of changes, I'm now fully repentant!). That's > not to say that we shouldn't ever change anything, but when considering the > cost/benefit tradeoff adding a migration cycle doesn't reduce the cost, it > just defers it. I actually read this as we should stop having breaking changes to begin with. And _if_ we do have breaking changes, that deprecation does not change the need to actually change code (cost). As outlined in my reply to that, and @Richard Eisenberg <lists(a)richarde.dev>'s observation, it "smears" the cost. The--to me--_much_ bigger implication of deprecation cycles is that we _inform_ our _customers_ about upcoming changes _early_, instead of _after the fact_. We also give them ample time to react. Being by changing their code, or raising their concerns. Would the Simplified Subsumptions / Deep Subsumptions change have looked differently? As such I see deprecation cycles as orthogonal to the question if we should have breaking changes to begin with. Thus I believe the following: > - Do have a deprecation cycle if possible. > - Do not treat a deprecation cycle as an excuse. Costs are deferred but > are as large as ever. should be upgraded to: - Preferably _no_ breaking changes. - If breaking changes, then with a deprecation cycle, unless technically infeasible. - An understanding that any breaking change incurs significant costs. Ocaml recently added multicore support, and they put tremendous effort into making sure it keeps backwards compatibility: https://github.com/ocaml-multicore/docs/blob/main/ocaml_5_design.md PS: we should also agree that a "stable" extension should not require > dependencies on ghc-experimental. To become stable, any library support > for an extension must move into `base`. This seems like a good idea, however I still remain that _experimental_ features should not be on-by-default in a stable compiler. Yes, ideally I'd not even see them in a stable compiler, but I know this view is contentious. The use of `ghc-experimental` should therefore be guarded by `--std=experimental` as Julian suggested. That is a loud opt-in to experimental features.

7 32

#583: HasField redesign, rec: accept
by Arnaud Spiwack 12 Oct '23

12 Oct '23

Dear all, [ Proposal #583 https://github.com/ghc-proposals/ghc-proposals/pull/583 ] Our own Adam proposes to amend the design of the highly experimental OverloadedRecordUpdate extension as had been designed in proposal #158 [ https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0158-r… ] and #405 [ https://github.com/ghc-proposals/ghc-proposals/pull/405 ]. Specifically, Adam proposes a modification of the type classes that would back the extension. In the previous design the HasField class is defined as a lens: class HasField (n :: k) r a | r n -> a hasField :: r -> (a -> r, a) The proposal is to replace it by two classes (slightly simplified) class HasField (n :: k) r a | r n -> a hasField :: r -> a class SetField (n::k) r a | r n -> a modifyField :: (a -> a) -> r -> a setField :: a -> r -> a This is originally motivated by some performance consideration: the prototype implementation of HasField as a lens can be very time consuming because instances of HasFields are generated eagerly at record definition sites, whereas the simple HasField instances can simply reuse the selectors already generated by GHC. But a lot of thoughts have been put into the new design, and my summary can certainly not do it justice: the proposal is very well argumented. A point I'll make here is that the new design is actually parametric in the data representation of the field type. Something that wasn't possible in the original design. This proposal is not technically backward compatible, because the order of argument in which OverloadedRecordUpdate expects the argument of setField is changed. This is not essential to the proposal, but this is a more consistent order argument with the rest of Haskell. And considering that OverloadedRecordUpdate is very loudly advertised as experimental, I recommend accepting this breakage. Overall the proposal is actually more backward compatible with GHC 9.8 than the original design, as the HasField class is left unchanged. Overall, the proposal looks quite reasonable to me, and well-argued. I recommend acceptance. -- Arnaud Spiwack Director, Research at https://moduscreate.com and https://tweag.io.

8 25

Please review #571: -Wsevere, Shepherd: Adam
by Joachim Breitner 11 Oct '23

11 Oct '23

Dear Committee, based on suggestions by Oleg Grenrus, I wrote a proposal to introduce a warning group -Wsevere for on-by-defaults, error-by-default warnings, and initially fill it with missing-methods and missing-fields. https://github.com/ghc-proposals/ghc-proposals/pull/571 https://github.com/ghc-proposals/ghc-proposals/blob/wsevere/proposals/0000-… I’d like to nominate Adam as the shepherd, who already reviewed it a bit on Github. Please guide us to a conclusion as outlined in https://github.com/ghc-proposals/ghc-proposals#committee-process Cheers, Joachim -- Joachim Breitner mail(a)joachim-breitner.de http://www.joachim-breitner.de/

9 51

GHC2024 timeline
by Joachim Breitner 11 Oct '23

11 Oct '23

Dear Committee, like every year so far, I will make a push to define a new GHC20xx. Maybe this year it will happen… TL;DR: If you want GHC2024, head to https://github.com/ghc-proposals/ghc-proposals/pull/613 and tell us what it should look like. I am proposing the following procedure and timeline: Phase 1 (now): Nominations and discussion The community (including us) nominates extensions for inclusion (or removal) for GHC2024, relative to GHC2021, at https://github.com/ghc-proposals/ghc-proposals/pull/613 together, and everyone can help refining the rationales/pros/cons. I have taken the list from last year to seed this document I propose to conclude this by end of October. Phase 2 (November): Committee deliberation Based on that list, we do what we do best: discuss. Until end of November Phase 3 (early Decemb): Voting Finally, we vote. Last year, we first had a “should do we GHC20xx” vote, which (had it not been rejected) would be followed by a vote where each nominated extension can be yay’ed/nay’ed individually. I guess we can do the same this year. Cheers, Joachim -- Joachim Breitner mail(a)joachim-breitner.de http://www.joachim-breitner.de/

1 0

Amend or patterns (#522) to use p1 ; p2 (#609)
by Chris Dornan 08 Oct '23

08 Oct '23

Proposal: Amend or patterns (#522) to use p1 ; p2 (#609) Author: Sebastian Graf, David Knothe Rendered proposal: https://github.com/ghc-proposals/ghc-proposals/blob/eb4b67c29282520b2c5c6a4… Discussion: https://github.com/ghc-proposals/ghc-proposals/pull/609 Recommendation: Acceptance ## Summary This proposal refines the syntax of an already accpted proposal (#522) for writing or patterns. The syntax of the old proposal, ```haskell stringOfT :: T -> Maybe String stringOfT (T1 s) = Just s stringOfT (one of T2{}, T3{}) = Nothing ``` is replaced with ```haskell stringOfT :: T -> Maybe String stringOfT (T1 s) = Just s stringOfT (T2{}; T3{}) = Nothing ``` or indeed ```haskell stringOfT :: T -> Maybe String stringOfT x = case x of T1 s -> Just s T2{} T3{} -> Nothing ``` (Beacuse the '(' ... ')' are optional here, we can remove them and naturally exploit layout.) The authors have conducted polls to see what folks preferred, landing on this proposal. The adjustments to the Haskell grammar are really quite minimal requiring one extra production. ## Recommendation The proposal is nondiruptive and as a whole addresses an important practical topic. I recommend that we accept it

10 22

#526: Applicative Comprehensions (rec: accept)
by Simon Marlow 03 Oct '23

03 Oct '23

Dear committee, #526 proposes a new extension ApplicativeComprehensions (implying MonadComprehensions). It would provide the equivalent of the current ApplicativeDo desugaring for do-expressions to list comprehensions. - Github thread <https://github.com/ghc-proposals/ghc-proposals/pull/526> - Rendered <https://github.com/strake/ghc-proposals/blob/acomp/proposals/0000-applicati…> The extension itself is relatively uncontroversial, but there are some unresolved quirks in the original ApplicativeDo extension which made us uneasy about extending it. However, after various discussions I'm going to propose accepting this proposal in its current state. Rationale: - It doesn't make things worse, and the implementation isn't likely to add significant complexity. - It retains consistency between ApplicativeDo and ApplicativeComprehensions (in contrast to the idea of making ApplicativeComprehensions perform a simpler desugaring, which came up during the discussion) - A future proposal can add a simpler version of the desugaring for both extensions later. Cheers Simon

8 9

Please review #612: -fhpc tix file changes, Shepherd: Moritz
by Joachim Breitner 27 Sep '23

27 Sep '23

Dear Committee, David Binder suggests to change how -fhpc handles existing tix files by default: https://github.com/ghc-proposals/ghc-proposals/pull/612 https://github.com/BinderDavid/ghc-proposals/blob/change-fhpc-semantics/pro… I’d like to nominate Moritz as the shepherd. Please guide us to a conclusion as outlined in https://github.com/ghc-proposals/ghc-proposals#committee-process Cheers, Joachim -- Joachim Breitner mail(a)joachim-breitner.de http://www.joachim-breitner.de/

1 0

Warnings
by Simon Peyton Jones 25 Sep '23

25 Sep '23

Dear GHC SC You may or may not have been following GHC ticket #22141 <https://gitlab.haskell.org/ghc/ghc/-/issues/22141>, and Ryan's merge request !11314 <https://gitlab.haskell.org/ghc/ghc/-/merge_requests/11314>. The story is this: - There is a bug in GHC that allows programs to use DataKinds without the -XDataKinds extension. - The MR fixes the bug. - But of course that will mean that some programs that previously compiled (exploiting the bug) will now fail to compile (correctly). It seems like an example of our (GR2) discussion, but with a very different flavour than the (3+4=8) example. Personally I think we should do it -- with a deprecation cycle saying "You need DataKinds for this program, and you don't have it on, but you will need it in the next release". I don't want us to grandfather bugs into GHC indefinitely -- although you could argue that the status quo does little harm, I suppose. Any views? We will have some idea of the impact on head.hackage shortly. *And specifically: do you want a GHC proposal for this change?* Simon

6 6