HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
ghc-proposals
ghc-proposals
Python2018–2025
ghc-proposals / ghc-proposals

ghc-proposals

Proposed compiler and language changes for GHC and GHC/Haskell

33Distinct people
41Mentions
0Explicit recommenders
707GitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

Proposed compiler and language changes for GHC and GHC/Haskell

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

No other repository is repeatedly linked in the same discussions.

This week on Hacker News

Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 5:04:57 PM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year41 dated mentions

Observed mentions: 2018-03-17 05:22:28 UTC to 2025-11-09 05:51:26 UTC.

0510152018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 6 mentions; 5 submissions, 1 comments20182019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 4 mentions; 0 submissions, 4 comments2020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 13 mentions; 1 submissions, 12 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 7 mentions; 0 submissions, 7 comments20212022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 4 mentions; 0 submissions, 4 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments2025

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC651
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC404
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC13112
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC707
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC303
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC101
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC404
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC303

From the project README

An excerpt from the repository, fetched Nov 13, 2026.

Read the project’s introduction
GHC Proposals This repository contains specifications for proposed changes to the Glasgow Haskell Compiler. The purpose of the GHC proposal process and of the GHC Steering Committee is to broaden the discussion of the evolution of GHC. ≡ List of proposals under discussion ≡ List of proposals waiting for shepherd recommendation ≡ List of proposals waiting for committee decision ≡ List of accepted proposals ≡ List of rejected proposals ≡ List of proposals needing revision ≡ List of proposals pending implementation ≡ List of implemented proposals ≡ List of all proposals 1   What is a proposal? A GHC Proposal is a document describing a proposed change to the compiler, the specification of the language it accepts, or the surrounding ecosystem. These include: A change to the syntax or semantics of the GHC/Haskell language (e.g. the various ShortImports proposals, do expressions without $) A major change to the user-visible behaviour of the compiler (e.g. the recent change in super-class solving, and -Wall behavior) The addition of major features to the compiler (e.g. -XTypeInType, GHCi commands, type-indexed Typeable representations) Changes that are not necessarily within the scope of the committee include: changes to declarations in base, which should be addressed to the Core Libraries Committee; changes to other core libraries, which should be addressed to the relevant library maintainers; changes to the GHC API, the plugin API, or compiler internals, which can be contributed following the usual GHC MR review workflow; bug fixes and other minor changes that do not warrant additional overheads. Should the GHC maintainers deem a change significant or controversial enough, they may, at their discretion, involve the GHC Steering Committee and ask the contributor to write a formal proposal. Proposals are evaluated against our principles, which cover both language design and language stability 2   The life cycle of a proposal This section outlines what stages a proposal may go through. 2.1   Table of stages In brief all stages of the Reviewing process are shown in the table. [*]Click the link to see a detailed description. [†]Click the link to see a list of proposals with this label at this stage / outcome. Stage [*] / Outcome GitHub label [†] Max duration Responsibility for next action Action New stage / Outcome Proposal creation ‒ Indefinite Author Pull request Community discussion Community discussion ‒ (No label) Indefinite Author Submit to committee Shepherd appointment Close request Withdrawn Withdrawn ‒ (Withdrawn) ‒ (PR closed) ‒ ‒ Shepherd appointment ‒ 1 week Secretary Assign shepherd Shepherd review Shepherd review Pending shepherd recommendation 2 weeks Shepherd Make recommendation Committee discussion Send back for revision Needs revision Committee discussion Pending committee review 4-5 weeks Shepherd Accept Accepted Reject Rejected Send back for revision Needs revision Needs revision Needs revision Indefinite Author Resubmit to committee Shepherd review Close request Withdrawn Rejected Rejected ‒ (PR closed) ‒ ‒ Accepted Accepted 2 weeks Author & Shepherd Do final corrections Implementation 1 week Shepherd / Secretary Merge Implementation Accepted (PR closed) Indefinite Unspecified Implement the proposal Implemented Implemented Implemented ‒ (PR closed) ‒ ‒ 2.2   Detailed list of stages The stage is identified by a GitHub label, which is identified in the following list. Stage: Proposal creation. (No label.) Responsibility for next action: author. The author drafts / writes / rewrites a proposal. When they are ready they submit the proposal to the wider Haskell community for discussion, as a pull request against this repository, which moves the proposal to the Community discussion stage. What is a proposal? How to start a new proposal How to amend an accepted proposal Language design principles Stage: Community discussion. (No label.) Responsibility for next action: author. The wider community discusses the proposal by commenting on the pull request, while the author refines the proposal. Discussion goals Guidelines for respectful communication How to comment on a proposal ≡ List of new proposals under discussion If the proposal is an amendment to an already accepted proposal, the committee secretary additionally labels that proposal with the Amendment label. Community discussion may continue indefinitely until the author takes one of the following actions: Action: Submit to committee. Once they are satisfied they have addressed everything raised in the discussion, the proposal author should explicitly comment on the proposal, asking the committee secretary to bring the proposal before the committee for review. This moves the proposal to the Shepherd appointment stage. The review process does NOT start automatically when the discussion ends. The Committee Secretary could remind in comments that it is the author's responsibility to move the proposal forward. How to bring a proposal before the committee Action: Close request. If as a result of the discussion the author no longer wishes to champion the proposal, they may withdraw the proposal at any time by closing the pull request. ≡ List of withdrawn proposals after community discussion If the author abandons their own proposal and the proposal sees no activity for a long time (more than a year), it might be closed by the committee secretary. At any time, the proposer could reopen a proposal. Outcome: Withdrawn. (No label with PR closed.) Withdrawn proposals are those that have been closed by the author themselves, or closed by the secretary because the proposal was dormant for a long time. This may be because the idea was unfinished, unimplementable, or inconsistent with the Haskell language. ≡ List of withdrawn proposals after community discussion ≡ List of withdrawn proposals after revision ≡ List of all withdrawn proposals Stage: Shephe
Read the full README on GitHub

What Hacker News says

41 sources
Not necessarily. You can implement them using a monad. See https://dl.acm.org/doi/10.1145/2804302.2804319. That said, in GHC Haskell the implementation on top of stack switching seems to outperform other implementation strategies. See https://github.com/ghc-proposals/ghc-proposals/blob/master/p.... In OCaml 5, we’ve made it quite fast: https://kcsrk.info/papers/drafts/retro-concurrency.pdf. For us, the goal is to implement concurrent programming, for which a stack switching implementation works well. If you use OCaml effect handlers to implement state effect, it is going to be slower than using mutable state directly. And that’s fine. We’re not aiming to simulate all effects using effect handlers, only non-local control flow primitives like concurrency, generators, etc.
In Control structures in programming languages: from goto to algebraic effects
> The compiler and the build system have gotten a lot more stable over the past several years. GHC2021 promises backwards compatibility, but it includes ill-specified extensions like ScopedTypeVariables. TypeAbstractions were just added, and they do the same thing, but differently.[0] It hasn't even been decided yet which extensions are stable[1], yet GHC2021 still promises compatibility in future compiler versions. So either, you'll have GHC retain inferior semantics because of backwards compatibility, or multiple ways of doing the same thing. GHC2024 goes even further and includes extensions that are even more unstable, like DataKinds. Another sign of instability is the fact that GHC 9.4 is still the recommended[2] release even though there are three newer 'stable' GHCs. I don't know of other languages where the recommendation is so far
Read the rest
behind! GHC 9.4.1 is from Aug 2022. It was the same situation with Cabal, it took forever to move beyond Cabal 3.6 because the subsequent releases had bugs.[3] [0]: https://serokell.io/blog/ghc-dependent-types-in-haskell-3 [1]: https://github.com/ghc-proposals/ghc-proposals/pull/669 [2]: https://github.com/haskell/ghcup-metadata/issues/220 [3]: https://github.com/haskell/ghcup-metadata/issues/40
In Why Haskell?
> Haskell has an endemic problem where way too many development resources are put into fringe parts of GHC There has been an incredible amount of work over the last decade put into all the things you mentioned, which it sounds like you're unfamiliar with. https://github.com/haskell/haskell-language-server in particular is a pleasure to use in my experience. Package management is far from perfect, but it's always being worked on and I'll take it over anything in Python or the Node.js ecosystems any day. Developer experience has improved a lot since I started using the language and this is an area that the community and leadership absolutely cares about--I'd be surprised if anyone spent time reading relevant discussions in https://github.com/ghc-proposals/ghc-proposals or https://discourse.haskell.org/ or etc. and agreed with you. > Haskell
Read the rest
has the worst support for records of all its peers. SML, OCaml, F# all have better records. > Without good records it’s unreasonably hard to write large software projects. > AFAIK it’s hard to retrofit ML-style structural subtyped records onto Haskell, because the type system is designed around that not being possible. Haskell is not ML, and while Haskell records are weak they are not what is preventing people from writing big projects in Haskell. There is much more to the language than records. But I said this in my previous comment. Nothing you've written resonates with me, and I've written Haskell and PureScript professionally as well as Java and JS along with a bunch of other languages that haven't been mentioned. I'm also actively working on an open source project in my spare time with thousands of lines of Haskell and PureScript code (https://github.com/ddellacosta/automation-service), not to mention a half dozen other random half-done projects and contributions I've made to other open source libraries and applications. What have you written in Haskell that has made you dislike it so much? > Talk is cheap. Yes it is.
In Why does everyone hate Haskell, jazz, and pure math?
I always write existential quantification data Showable = forall a. Show a => Showable a with GADT syntax because it can be confusing for people to infer the type of `Showable' from the above definition when you can write it out data Showable where Showable :: Show a => a -> Showable josephcsible is right. `forall.' in that context doesn't play a different role. Rather a variable bound by `forall.' is logically the same as existential quantification if it does not appear in the return type which `a' doesn't: Showable :: forall a. Show a => a -> Showable We will get a proper existential quantifier soon * https://github.com/ghc-proposals/ghc-proposals/pull/473 * https://richarde.dev/papers/2021/exists/exists.pdf and then length :: forall a. [a] -> Int can be replaced with length :: (exists a. [a]) -> Int and `Showable' wi
Read the rest
ll be isomorphic to the "packed constraint" `exists a. Show a ∧ a', explained in the paper. This is a tupled constraint, not a function: `(Dict (Show a), a)'
In Tutorial: `Forall` in Haskell – Wasp
Hard to say if it's gotten more popular (yet), but development speed has picked up and some longstanding things have been fixed. A lot of things in the ecosystem have improved as well. It feels like it's all moving again, and to a place it could start gaining popularity. Off the top of my head: * Haskell language server solved the ide support problem * Easy record access with . syntax (i.e. person.name to get a name off a person) * A new {-# LANGUAGE GHC2021 #-} pragma that turns on a bunch of flags by default to write modern haskell * GHCup to control installed haskell & tool versions * Haskell foundation formed to support growing haskell * A proposal* to work towards supporting dependent types was accepted A lot more of course but it all points to making haskell more enjoyable to get into and use, and a good future ahead. * https://gi
Read the rest
In GHC 9.4.1 is now available
\cases is a nice syntax improvement https://github.com/ghc-proposals/ghc-proposals/blob/master/p... \foo bar baz -> case (foo, bar, baz) of (Just 4, 3, False) -> 42 _ -> 0 -- becomes \cases (Just 4) 3 False -> 42 _ _ _ -> --- extremelyLengthyFunctionIdentifier (Just a) False = Just 42 extremelyLengthyFunctionIdentifier (Just a) True = Just (a / 2) extremelyLengthyFunctionIdentifier _ _ = Nothing -- becomes extremelyLengthyFunctionIdentifier = \cases (Just a) False -> Just 42 (Just a) True -> Just (a / 2) _ _ -> Nothing
In GHC 9.4.1 is now available
> I think Haskell, like Java, and unlike C or C++, promises you still get a meaningful program if you have a data race This is true (when you insist on mutable shared memory), but in Haskell the safety guarantee is in fact not so far from Rust. The Haskell community is well aware of concurrency issues very early, and they developed a dozen of composable abstractions to solve these problems. (IMHO Rust is the only one that has a truly novel solution in recent years.) In Haskell, either you have to use `unsafe` functions to share bulk of memory or you don't share memory at all (as mutability is a pita in Haskell). On top of these unsafe functions, you can build other safe abstractions, just like Rust. These abstractions are often available as higher-order functions in libraries, making them highly composable and reusable. E.g., the canonica
Read the rest
l memory-sharing data type is `TVar`, which must be access from the `STM` monad [1], guaranteeing both atomicity and data race freedom. (BTW, STM stands for software transactional memory if you aren't familiar with it.) A major offender is `IORef`, and fortunately Haskell provides atomic operations on `IORef`s. GHC Haskell also offers free parallelism for all pure computations via the `Eval` monad [2]. > Mistakenly instead of processing 1GB per thread, you process the same 1GB on all sixteen threads This is highly unlikely in Haskell. Haskell emphasizes on composable combinators, so a program that does not share memory would probably look like foldr accumulateFunc initValue . mapConcurrently processBatch . split batchSize $ data (mapConcurrently here is a real function [3].) I'm sure C++, Java, and Rust have similar abstractions, but imperative languages make it too easy for programmers to do `for` loops, making it much more error-prone. Several array libraries provide safe parallelism. The interface is similar to Rust rayon, but the way they work differs greatly. For example, in Repa [4] you can do computeP $ traverse inputArray newShapeFn (\getElem curIdx -> ...) Here `traverse` results in a "delayed" array: the results are not immediately available, and what you are doing is just composing array operations. `computeP` forces the computation to happen _in parallel_. Since GHC is very capable of optimizing intermediate data structures away, this code can compile to very efficient machine code -- there is no mutability at all, yet you get very safe and efficient parallelism. PS: what Haskell is really bad at so far is safe in-place updates for arbitrary data types (like custom ADTs), which is solved by Rust cleanly. GHC 9.0 added Linear Types [5] to address this problem. Haskell and Rust are both bad at safe in-place updates of arrays, vectors, etc., and are likely to be bad for a long time -- their indices are arbitrary integers, which cannot be analyzed statically at compile time. Haskell probably can solve this problem completely when it gets dependent types [6], whereas Rust is unlikely to support DT any time soon, if ever [7]. [1] https://hackage.haskell.org/package/stm-2.5.0.1/docs/Control... [2] https://hackage.haskell.org/package/parallel-3.2.2.0/docs/Co... [3] https://hackage.haskell.org/package/async-2.2.4/docs/Control... [4] https://hackage.haskell.org/package/repa [5] https://github.com/ghc-proposals/ghc-proposals/blob/master/p... [6] https://github.com/ghc-proposals/ghc-proposals/blob/master/p... [7] https://github.com/rust-lang/rfcs/issues/1930
In Sayonara, C++, and Hello to Rust
FYI there was a proposal for a "Haskell 2021 Language" Extensions (similar to Haskell 98 and 2010), which was approved. This enables a bunch of extensions (and I guess will become default): https://github.com/ghc-proposals/ghc-proposals/blob/master/p... That being said, while there are alternative preludes, I'm not sure how or when (or ever) the current prelude will be changed or replaced. In terms of language evolution, the community seems to focus on further extensions of the Type System (linear types, quicklook impredicativity, dependent types), where I think there is a bigger need in better tooling. Of course, there too, lots of things are happening, like haskell-language-server, ghc-debug etc. etc. But still lots of work to do. Would be great if more people worked on modern tooling and improving GHC. And even better if more companies
Read the rest
would fund that =)
In Haskell: The Bad Parts, part 2 (2020)

Showing the 15 most recent of 41 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.