- ghc-commits - Haskell.org

[Git][ghc/ghc][wip/sjakobi/udfm-placement] UniqDFM: make head-element cost explicit in Note [Cost of deterministic iteration]
by Simon Jakobi (＠sjakobi2) 02 Jul '26

02 Jul '26

Simon Jakobi pushed to branch wip/sjakobi/udfm-placement at Glasgow Haskell Compiler / GHC Commits: 9da8424e by Simon Jakobi at 2026-07-02T17:59:23+02:00 UniqDFM: make head-element cost explicit in Note [Cost of deterministic iteration] Spell out that producing even the first element allocates an O(n)-sized array (or O(n log n) cons cells on the fallback path), and that laziness does not make the iteration incremental. Assisted-by: Claude Fable 5 - - - - - 1 changed file: - compiler/GHC/Types/Unique/DFM.hs Changes: ===================================== compiler/GHC/Types/Unique/DFM.hs ===================================== @@ -351,11 +351,12 @@ nonDetStrictFoldUDFM k z (UDFM m _i) = foldl' k' z m -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- Deterministic iteration orders elements by insertion tag, and any such -- ordering must inspect every element's tag before it can emit the first --- element. So even the head of the result costs a full O(n) traversal of the --- map -- the iteration is not incremental, and laziness in the result list (see --- Note [Placement sort in eltsUDFM]) saves allocation for undemanded --- elements, not that up-front traversal. #27459 shows this cost biting in --- consumers that demanded only the head. +-- element. So even the head of the result costs a full traversal of the map +-- plus the allocation of an O(n)-sized array -- or, on the fallback path, +-- O(n log n) cons cells (see Note [Placement sort in eltsUDFM]). Laziness in +-- the result list only avoids allocating for elements that are never +-- demanded; it does not make the iteration incremental. #27459 shows this +-- cost biting in consumers that demanded only the head. -- -- So: to test for emptiness, use isNullUDFM rather than null on eltsUDFM; -- for order-oblivious queries, prefer short-circuiting anyUDFM/allUDFM; and View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/9da8424e1da6991f9493f5e91f77b46… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/9da8424e1da6991f9493f5e91f77b46… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc] Pushed new branch wip/hadrian-target
by Zubin (＠wz1000) 02 Jul '26

02 Jul '26

Zubin pushed new branch wip/hadrian-target at Glasgow Haskell Compiler / GHC -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/tree/wip/hadrian-target You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/romes/ast-ohne-faststring] 33 commits: gitlab-ci: Drop vestigial references to make build system
by Rodrigo Mesquita (＠alt-romes) 02 Jul '26

02 Jul '26

Rodrigo Mesquita pushed to branch wip/romes/ast-ohne-faststring at Glasgow Haskell Compiler / GHC Commits: 701088db by Ben Gamari at 2026-07-01T10:34:03-04:00 gitlab-ci: Drop vestigial references to make build system - - - - - 62d54a53 by Ben Gamari at 2026-07-01T10:34:03-04:00 gitlab-ci: Add support for running specifying a job's testsuite ways - - - - - 7f97ac2c by Ben Gamari at 2026-07-01T10:34:03-04:00 gitlab-ci: Run llvm testsuite ways in llvm jobs Addresses #25762. - - - - - 7ea75116 by ARATA Mizuki at 2026-07-01T10:34:03-04:00 testsuite: Add normalise_ddump_deriv setup function Some tests check the result of -ddump-deriv, which may contain INLINE pragmas depending on optimization flags. With normalise_ddump_deriv setup function, INLINE pragmas are stripped off. - - - - - c7a8199f by ARATA Mizuki at 2026-07-01T10:34:03-04:00 testsuite: Use -dsuppress-idinfo to make tests more robust Previously, T18052a and T21755 were failing on 'optasm' and 'optllvm' ways because of visibility of unfoldings. - - - - - a12122e5 by ARATA Mizuki at 2026-07-01T10:34:03-04:00 testsuite: Use a trick to keep large objects alive Previously, T17574 and T19381 were failing on 'optasm' and 'optllvm' ways because of compiler optimizations. Change them to use NOINLINE to prevent unwanted optimizations. - - - - - 1a95b327 by ARATA Mizuki at 2026-07-01T10:34:03-04:00 testsuite: Only run T24224 in 'normal' way This test is a frontend-only one and breaks if optimizations are enabled. - - - - - 8abea737 by ARATA Mizuki at 2026-07-01T10:34:03-04:00 testsuite: Ignore T18118's stderr When optimizations are enabled, the compiler emits a warning (You cannot SPECIALISE ...). The message is not important, so ignore it. - - - - - 9453a722 by ARATA Mizuki at 2026-07-01T10:34:03-04:00 testsuite: Mark T816 and tc216 broken with optimizations These tests are about type checking, so we should not care too much if they are broken with optimizations. See #26952 - - - - - 0aef9ec0 by Ben Gamari at 2026-07-01T10:34:03-04:00 testsuite: ds014 is not longer broken It now appears to pass in the ways it was marked as broken in. Closes #14901. - - - - - 4692d1e4 by Ben Gamari at 2026-07-01T10:34:03-04:00 testsuite: Only run stack cloning tests in the normal way These are too dependent upon code generation specifics to pass in most other ways. - - - - - c154df26 by ARATA Mizuki at 2026-07-01T10:34:03-04:00 testsuite: Update options_ghc_fbyte-code The `-fbyte-code` option used to be overriden by `-fllvm` but it is no longer true since !14872 was merged. I updated the test to accept the new behavior. Closes #27049 - - - - - 5d8bb7b5 by ARATA Mizuki at 2026-07-01T10:34:03-04:00 testsuite: Only run T22744 in 'normal' way This test takes a long time on optimized ways. - - - - - d1e74c8e by ARATA Mizuki at 2026-07-01T10:34:03-04:00 testsuite: Disable tests that use -finfo-table-map on llvm ways Currently, -finfo-table-map does not work with -fllvm. See #26435 - - - - - 3bf38c84 by ARATA Mizuki at 2026-07-01T10:34:03-04:00 testsuite: Don't run T24726 on optimized ways If optimizations are enabled, the rewrite rule just fires and -drule-check will report nothing. - - - - - e4eef116 by ARATA Mizuki at 2026-07-01T10:34:03-04:00 testsuite: Use -fno-unoptimized-core-for-interpreter when running LinkableUsage01/02 Optimizations for the bytecode interpreter are considered experimental, and need a flag to be enabled. - - - - - 234a9872 by ARATA Mizuki at 2026-07-01T10:34:03-04:00 testsuite: Suppress unwanted optimizations on T25284 - - - - - 99a2af2f by ARATA Mizuki at 2026-07-01T10:34:03-04:00 testsuite: Don't run stack_big_ret with optimizations Stack layout may change with optimizations enabled. - - - - - 04c836df by ARATA Mizuki at 2026-07-01T10:34:04-04:00 testsuite: Mark memo001 broken on optimized ways See #27396 - - - - - 1a8a24f4 by ARATA Mizuki at 2026-07-01T10:34:04-04:00 testsuite: Mark syn-perf broken on optimized ways See #27398 - - - - - 40412093 by Duncan Coutts at 2026-07-01T10:34:50-04:00 Add a test for thread scheduler fairness It also tests that the interval timer and context switching works. We also test that fairness is lost when the context switching interval is too coarse for the duration of the test. We add this test before doing surgery on the interval timer, so we have decent coverage. - - - - - 3f34d557 by Duncan Coutts at 2026-07-01T10:34:50-04:00 Make exported stop/startTimer no-ops, and rename internal functions Specifically, internally rename: stop/startTimer to pause/unpauseTimer stop/startTicker to pause/unpauseTicker and keep stop/startTimer as exported functions, but now as no-ops. In the past the stop/startTicker actions were used incorrectly as if they were synchronous, which they are not. See issue #27105. We now document pause/unpackTicker as being async and not to be used for the purpose of concurrency safety. The existing stop/startTimer (note Timer not Ticker, the Timer calls the Ticker!) are also exported from the RTS as a public API. This was historically because the ticker used signals and it was important to suspend the timer signel over a process fork. So these functions were exported to be used by the process and unix libraries. We cannot just remove the RTS exports, but we now make them no-ops, and they can be removed from the process and unix library later. This was already documented in a changelog.d entry no-more-timer-signal but due to changes during the MR process the change to make stop/startTicker into no-ops didn't make it into the earlier MR. - - - - - 02e84e5f by Duncan Coutts at 2026-07-01T10:34:51-04:00 Make exitTicker/exitTimer unconditionally synchronous We never use them asynchronously, and we should never need to do so. And update some related comments. - - - - - 13db6a72 by Duncan Coutts at 2026-07-01T10:34:51-04:00 posix ticker: update and improve comments on (un)pause and exit Clarify what is async vs sync. - - - - - 43d9a07d by Duncan Coutts at 2026-07-01T10:34:51-04:00 posix ticker: split out ppoll/select helper functions Move the #ifdefs out of the main code body by introducing local helper functions and types, which themselves have two implementations (with a common API) based on ppoll or select. This helps improve clarity/readability. - - - - - a5491baa by Duncan Coutts at 2026-07-01T10:34:51-04:00 posix ticker: improve the implementation The existing implementation supported pausing and exiting, with the implementation of pausing reling on a mutex and condition variable. It needed to check the pause and stop shared variables on every iteration. It relies on ppoll or select, to wait on the timeout and also wait on an interrupt fd. The interrupt fd was only used for prompt exit/shutdown, and not for pausing or other notification. The pause only needed a lock and a memory operation, but the pause was not prompt. The resume used a lock, and signaling a cond var. The new implementation uses a somewhat more regular design: every notification is done by setting a shared variable and interrupting/notifying the ticker via the fd. The ticker thread does not need to check any shared variables on normal timer expiry, only when it recevies notification. This may be a micro-optimisation, but the tick occurs 100 times a second by default so any improvements in the hot path are amplified. When the ticker thread does receive notification it can check the various shared variables and update its local state. The blocking relies on using ppoll/select but without a timeout. This avoids the condition var and also allows further notifications when paused (also used for unpausing). This design can be extended with further notification types if needed by using and checking further shared vars (or making existing shared vars an enum or counter). This may be used in future for additional notifications to the ticker thread. This will likely be used to proxy wakeUpRts from a single handler context for example. And this approach, avoiding mutexes, is compatible with use from signal handlers. So overall, it's: * slightly simpler / more regular; * easier to extend with additional notifications; * probably slightly more efficient (but a micro-optimisation); * and supports calling notification from signal handlers - - - - - 5b20821e by Duncan Coutts at 2026-07-01T10:34:51-04:00 posix ticker: further minor local renaming for code clarity Improve the clarity with better choice of names for several local vars and function. - - - - - 1f3ec5e0 by Duncan Coutts at 2026-07-01T10:34:51-04:00 win32 ticker: split out local helper functions - - - - - 596e7307 by Duncan Coutts at 2026-07-01T10:34:51-04:00 win32 ticker: provide guarantee about concurrency and idempotency Use a lock to ensure pause/unpause can be used concurrently. Use a paused variable, protected by the lock, to ensure that pause and unpause are both idempotent. This is what the portable API expects. - - - - - 1870edd7 by Duncan Coutts at 2026-07-01T10:34:51-04:00 win32 ticker: make the initial tick be after one wait interval There is no need to tick immediately. This is consistent with the posix implementation. - - - - - 7c15ab5b by Duncan Coutts at 2026-07-01T10:34:51-04:00 ticker: remove now-unnecessary layer of enable/disable There was an atomic variable used to block *part* of the actions of the tick handler. This still did not make stopTimer synchronous, even for the part of the the handle_tick actions it covered. It also added a more expensive (sequentuially consistent) atomic operation in the hot path for the handle_tick action, whereas our new design requires no atomic ops at all. Now that we have eliminate the need for synchronous stop/startTicker, we don't need this not-quite-working-anyway atomic protocol. The new pause/unpauseTicker is explicitly asynchronous and idempotent. - - - - - 8585f8cb by Duncan Coutts at 2026-07-01T10:34:51-04:00 ticker: add TODOs about issue #27250: too much being done from handle_tick The handle_tick should not perform I/O, block, perform long-running operations or call arbitrary user code. Unfortunately, everything to do with the eventlog (at the moment) falls into all those categories. - - - - - 8d69c720 by Rodrigo Mesquita at 2026-07-02T16:46:41+01:00 ttg: Using Text over FastString in the AST To make the AST independent of GHC, this commit replaces usages of `FastString` with `HText` in the AST, killing the last edge from Language.Haskell.* to GHC.* modules. Even though we /do/ want to use FastStrings in general -- critically in Names or Ids -- there is no particular reason for the FastStrings that occur in the AST proper to be FastStrings. Strings in the AST are typically unique and don't benefit particularly from being interned FastStrings with Uniques for fast comparison. `HText` is a type synonym for `ShortText` which uses GHC's Modified UTF-8 encoding exclusively. Modified UTF-8 must be used to represent the Haskell AST because the Haskell Report allows surrogate code points. `Data.Text.Text` functions use Standard UTF-8 which replace surrogates with a placeholder value, thus `Data.Text.Text` is unsuitable for AST strings. See the `Language.Haskell.Syntax.Text` module header for more details. Final progress towards #21592 Closes #21628 - - - - - 138 changed files: - .gitlab/ci.sh - .gitlab/generate-ci/gen_ci.hs - .gitlab/jobs.yaml - + changelog.d/T21628 - compiler/GHC/Builtin/Utils.hs - compiler/GHC/Cmm/CLabel.hs - compiler/GHC/Core/Ppr.hs - compiler/GHC/Core/TyCon.hs - compiler/GHC/Data/FastString.hs - compiler/GHC/Data/StringBuffer.hs - compiler/GHC/Driver/Errors/Ppr.hs - compiler/GHC/Driver/Session.hs - compiler/GHC/Hs/Decls.hs - compiler/GHC/Hs/Expr.hs - compiler/GHC/Hs/Lit.hs - compiler/GHC/Hs/Type.hs - compiler/GHC/Hs/Utils.hs - compiler/GHC/HsToCore.hs - compiler/GHC/HsToCore/Errors/Types.hs - compiler/GHC/HsToCore/Expr.hs - compiler/GHC/HsToCore/Foreign/C.hs - compiler/GHC/HsToCore/Foreign/JavaScript.hs - compiler/GHC/HsToCore/Foreign/Wasm.hs - compiler/GHC/HsToCore/Match.hs - compiler/GHC/HsToCore/Match/Literal.hs - compiler/GHC/HsToCore/Pmc/Desugar.hs - compiler/GHC/HsToCore/Pmc/Solver/Types.hs - compiler/GHC/HsToCore/Quote.hs - compiler/GHC/Iface/Syntax.hs - compiler/GHC/Parser.y - compiler/GHC/Parser/Errors/Ppr.hs - compiler/GHC/Parser/Errors/Types.hs - compiler/GHC/Parser/HaddockLex.x - compiler/GHC/Parser/Lexer.x - compiler/GHC/Parser/PostProcess.hs - compiler/GHC/Rename/Bind.hs - compiler/GHC/Rename/Env.hs - compiler/GHC/Rename/HsType.hs - compiler/GHC/Rename/Module.hs - compiler/GHC/Rename/Splice.hs - compiler/GHC/Rename/Utils.hs - compiler/GHC/StgToByteCode.hs - compiler/GHC/StgToCmm/Foreign.hs - compiler/GHC/StgToCmm/Prim.hs - compiler/GHC/StgToJS/FFI.hs - compiler/GHC/Tc/Deriv/Generate.hs - compiler/GHC/Tc/Deriv/Generics.hs - compiler/GHC/Tc/Errors.hs - compiler/GHC/Tc/Errors/Ppr.hs - compiler/GHC/Tc/Gen/Bind.hs - compiler/GHC/Tc/Gen/Expr.hs - compiler/GHC/Tc/Gen/HsType.hs - compiler/GHC/Tc/Gen/Pat.hs - compiler/GHC/Tc/Gen/Sig.hs - compiler/GHC/Tc/Gen/Splice.hs - compiler/GHC/Tc/Instance/Class.hs - compiler/GHC/Tc/Solver/Dict.hs - compiler/GHC/Tc/TyCl.hs - compiler/GHC/Tc/TyCl/Utils.hs - compiler/GHC/Tc/Types/Origin.hs - compiler/GHC/Tc/Validity.hs - compiler/GHC/ThToHs.hs - compiler/GHC/Types/Basic.hs - compiler/GHC/Types/Error.hs - compiler/GHC/Types/FieldLabel.hs - compiler/GHC/Types/ForeignCall.hs - compiler/GHC/Types/Literal.hs - compiler/GHC/Unit/Module/Warnings.hs - compiler/GHC/Utils/Binary.hs - compiler/GHC/Utils/Outputable.hs - compiler/Language/Haskell/Syntax/Basic.hs - compiler/Language/Haskell/Syntax/Decls.hs - compiler/Language/Haskell/Syntax/Decls/Foreign.hs - compiler/Language/Haskell/Syntax/Expr.hs - compiler/Language/Haskell/Syntax/Lit.hs - compiler/Language/Haskell/Syntax/Module/Name.hs - + compiler/Language/Haskell/Syntax/Text.hs - compiler/Language/Haskell/Syntax/Type.hs - compiler/ghc.cabal.in - libraries/base/tests/all.T - libraries/ghc-boot/GHC/Data/ShortText.hs - libraries/ghc-heap/tests/all.T - rts/RtsStartup.c - rts/Schedule.c - rts/Ticker.h - rts/Timer.c - rts/Timer.h - rts/include/rts/Timer.h - rts/posix/Ticker.c - rts/win32/Ticker.c - testsuite/driver/testlib.py - testsuite/tests/arityanal/should_compile/T21755.stderr - testsuite/tests/arityanal/should_compile/all.T - testsuite/tests/bytecode/TLinkable/all.T - testsuite/tests/cmm/should_compile/all.T - + testsuite/tests/concurrent/should_run/T27105.hs - testsuite/tests/concurrent/should_run/all.T - testsuite/tests/core-to-stg/T25284/Cls.hs - testsuite/tests/count-deps/CountDepsAst.stdout - testsuite/tests/count-deps/CountDepsParser.stdout - testsuite/tests/deSugar/should_fail/all.T - testsuite/tests/deSugar/should_run/all.T - testsuite/tests/deriving/should_compile/all.T - testsuite/tests/driver/options_ghc/Mod_fbyte_code.hs - testsuite/tests/driver/options_ghc/all.T - testsuite/tests/driver/options_ghc/options_ghc_fbyte-code.stderr - testsuite/tests/generics/GenDerivOutput.hs - testsuite/tests/generics/GenDerivOutput1_0.hs - testsuite/tests/generics/GenDerivOutput1_1.hs - testsuite/tests/generics/T10604/T10604_deriving.hs - testsuite/tests/generics/T10604/all.T - testsuite/tests/generics/all.T - testsuite/tests/parser/should_compile/DumpParsedAst.stderr - testsuite/tests/parser/should_compile/DumpParsedAstComments.stderr - testsuite/tests/parser/should_compile/DumpRenamedAst.stderr - testsuite/tests/parser/should_compile/DumpTypecheckedAst.stderr - + testsuite/tests/parser/should_run/StringStartsWithNull.hs - + testsuite/tests/parser/should_run/StringStartsWithNull.stdout - testsuite/tests/parser/should_run/all.T - testsuite/tests/perf/compiler/all.T - testsuite/tests/perf/compiler/hard_hole_fits.stderr - testsuite/tests/printer/T18052a.stderr - testsuite/tests/printer/all.T - testsuite/tests/profiling/perf/T23103/all.T - testsuite/tests/profiling/should_run/all.T - testsuite/tests/rts/T17574.hs - testsuite/tests/rts/T19381.hs - testsuite/tests/rts/all.T - testsuite/tests/rts/ipe/T24005/all.T - testsuite/tests/simplCore/should_compile/all.T - testsuite/tests/typecheck/should_compile/all.T - utils/check-exact/ExactPrint.hs - utils/check-exact/check-exact.cabal - utils/haddock/haddock-api/haddock-api.cabal - utils/haddock/haddock-api/src/Haddock/Backends/Hyperlinker/Parser.hs - utils/haddock/haddock-api/src/Haddock/Convert.hs - utils/haddock/haddock-api/src/Haddock/Interface/Create.hs - utils/haddock/haddock-api/src/Haddock/Interface/LexParseRn.hs The diff was not included because it is too large. View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/3ae75a6a3e6a8a221af43082d85ed0… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/3ae75a6a3e6a8a221af43082d85ed0… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/sjakobi/udfm-placement] UniqDFM: add Note [Cost of deterministic iteration]
by Simon Jakobi (＠sjakobi2) 02 Jul '26

02 Jul '26

Simon Jakobi pushed to branch wip/sjakobi/udfm-placement at Glasgow Haskell Compiler / GHC Commits: 66057bcf by Simon Jakobi at 2026-07-02T16:46:29+02:00 UniqDFM: add Note [Cost of deterministic iteration] Deterministic iteration cannot be incremental: even the head of the result costs a full O(n) traversal, as observed in #27459. Document this in a new Note and reference it from eltsUDFM, foldUDFM, udfmToList, the Foldable/Traversable instances, and the module head. Assisted-by: Claude Fable 5 - - - - - 1 changed file: - compiler/GHC/Types/Unique/DFM.hs Changes: ===================================== compiler/GHC/Types/Unique/DFM.hs ===================================== @@ -99,7 +99,8 @@ import qualified GHC.Data.Word64Set as W -- -- There is an implementation cost: each element is given a serial number -- as it is added, and `udfmToList` orders its result by this serial number --- (see Note [Placement sort in eltsUDFM]). So you should only use `UniqDFM` +-- (see Note [Placement sort in eltsUDFM] and +-- Note [Cost of deterministic iteration]). So you should only use `UniqDFM` -- if you need the deterministic property. -- -- `foldUDFM` also preserves determinism. @@ -159,11 +160,15 @@ data UniqDFM key ele = -- time. See Note [Overflow on plusUDFM] deriving (Data, Functor) --- | Deterministic. See Note [Placement sort in eltsUDFM] for the cost. +-- | Deterministic. +-- +-- See Note [Cost of deterministic iteration]. instance Foldable (UniqDFM key) where foldr = foldUDFM --- | Deterministic. See Note [Placement sort in eltsUDFM] for the cost. +-- | Deterministic. +-- +-- See Note [Cost of deterministic iteration]. instance Traversable (UniqDFM key) where traverse f = fmap listToUDFM_Directly . traverse (\(u,a) -> (u,) <$> f a) @@ -316,14 +321,18 @@ elemUDFM :: Uniquable key => key -> UniqDFM key elt -> Bool elemUDFM k (UDFM m _i) = M.member (getKey $ getUnique k) m -- | Performs a deterministic fold over the UniqDFM. +-- -- It's O(n) in the common case, with an O(n log n) fallback --- (see Note [Placement sort in eltsUDFM]). +-- (see Note [Placement sort in eltsUDFM]), and pays that in full even if +-- only a prefix is demanded (see Note [Cost of deterministic iteration]). foldUDFM :: (elt -> a -> a) -> a -> UniqDFM key elt -> a {-# INLINE foldUDFM #-} -- This INLINE prevents a regression in !10568 foldUDFM k z m = foldr k z (eltsUDFM m) --- | Like 'foldUDFM' but the function also receives a key +-- | Like 'foldUDFM' but the function also receives a key. +-- +-- See Note [Cost of deterministic iteration]. foldWithKeyUDFM :: (Unique -> elt -> a -> a) -> a -> UniqDFM key elt -> a {-# INLINE foldWithKeyUDFM #-} -- This INLINE was copied from foldUDFM @@ -338,6 +347,24 @@ nonDetStrictFoldUDFM k z (UDFM m _i) = foldl' k' z m where k' acc (TaggedVal v _) = k v acc +-- Note [Cost of deterministic iteration] +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- Deterministic iteration orders elements by insertion tag, and any such +-- ordering must inspect every element's tag before it can emit the first +-- element. So even the head of the result costs a full O(n) traversal of the +-- map -- the iteration is not incremental, and laziness in the result list (see +-- Note [Placement sort in eltsUDFM]) saves allocation for undemanded +-- elements, not that up-front traversal. #27459 shows this cost biting in +-- consumers that demanded only the head. +-- +-- So: to test for emptiness, use isNullUDFM rather than null on eltsUDFM; +-- for order-oblivious queries, prefer short-circuiting anyUDFM/allUDFM; and +-- if you don't need the deterministic order at all, use the nonDet functions +-- (with a justification). + +-- | Deterministic, in order of insertion. +-- +-- See Note [Cost of deterministic iteration]. eltsUDFM :: UniqDFM key elt -> [elt] {-# INLINE eltsUDFM #-} -- The INLINE makes it a good producer (from the map) @@ -359,7 +386,8 @@ sort_it m = sortBy (compare `on` taggedSnd) (M.elems m) -- its tag, freeze, and read out in index order. That's O(i) work (which -- subsumes the O(n) fill, since distinct tags force n <= i), no comparisons, -- and the readout is lazy, so consumers that demand only a prefix pay almost --- nothing beyond the fill. +-- nothing beyond the fill (but the fill itself is unavoidable; see +-- Note [Cost of deterministic iteration]). -- -- Holes: slots whose tag never occurs keep the initial sentinel, a TaggedVal -- with tag -1. Real tags are non-negative, so the readout skips on tag < 0; @@ -378,7 +406,9 @@ usePlacement :: Int -> Int -> Bool usePlacement n i = i <= 4 * n -- | Order a list of 'TaggedVal's by tag, by placing each at array index = --- its tag. The tags must be distinct and in @[0, i)@. +-- its tag. +-- +-- The tags must be distinct and in @[0, i)@. -- See Note [Placement sort in eltsUDFM]. placementSort :: forall r. Int -> [TaggedVal r] -> [r] placementSort i tvs = runST (ST (\s0 -> @@ -420,8 +450,10 @@ udfmRestrictKeysSet (UDFM val_set i) set = in UDFM (M.restrictKeys val_set key_set) i -- | Converts `UniqDFM` to a list, with elements in deterministic order. +-- -- It's O(n) in the common case, with an O(n log n) fallback --- (see Note [Placement sort in eltsUDFM]). +-- (see Note [Placement sort in eltsUDFM]), and pays that in full even if +-- only a prefix is demanded (see Note [Cost of deterministic iteration]). udfmToList :: UniqDFM key elt -> [(Unique, elt)] udfmToList (UDFM m i) | n <= 1 = [ (mkUniqueGrimily k, taggedFst v) | (k, v) <- M.toList m ] View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/66057bcf09f120f72f8247dfe9f5915… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/66057bcf09f120f72f8247dfe9f5915… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/semaphore-compat-2.0.1] Bump semaphore-compat submodule to 2.0.1
by Zubin (＠wz1000) 02 Jul '26

02 Jul '26

Zubin pushed to branch wip/semaphore-compat-2.0.1 at Glasgow Haskell Compiler / GHC Commits: 3a0c0693 by Zubin Duggal at 2026-07-02T20:02:08+05:30 Bump semaphore-compat submodule to 2.0.1 This versions includes some cruicial fixes for darwin - - - - - 2 changed files: - changelog.d/semaphore-v2 - libraries/semaphore-compat Changes: ===================================== changelog.d/semaphore-v2 ===================================== @@ -2,7 +2,7 @@ section: compiler issues: #25087 mrs: !15729 synopsis: - Update to semaphore-compat 2.0.0 (``-jsem`` protocol v2) + Update to semaphore-compat 2.0.1 (``-jsem`` protocol v2) description: On Linux and other POSIX platforms, GHC's ``-jsem`` jobserver client now speaks v2 of the semaphore-compat protocol, which uses Unix ===================================== libraries/semaphore-compat ===================================== @@ -1 +1 @@ -Subproject commit 44e7488dd93cbf333ceca1319a60146898f6224f +Subproject commit ebcb68506e67de9c8190c0394e10c913593d85da View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/3a0c06935946314f0c70543ea05c9fe… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/3a0c06935946314f0c70543ea05c9fe… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc] Pushed new branch wip/T27466
by Simon Peyton Jones (＠simonpj) 02 Jul '26

02 Jul '26

Simon Peyton Jones pushed new branch wip/T27466 at Glasgow Haskell Compiler / GHC -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/tree/wip/T27466 You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/sjakobi/udfm-placement] Use a placement sort for deterministic UniqDFM iteration
by Simon Jakobi (＠sjakobi2) 02 Jul '26

02 Jul '26

Simon Jakobi pushed to branch wip/sjakobi/udfm-placement at Glasgow Haskell Compiler / GHC Commits: 67814479 by Simon Jakobi at 2026-07-02T16:09:28+02:00 Use a placement sort for deterministic UniqDFM iteration eltsUDFM/udfmToList (and with them foldUDFM and UniqDFM's Foldable instance) ordered elements with a list mergesort on insertion tags, allocating ~n*log n cons cells per call; in the profile of #27459 this pipeline accounted for a large share of total allocation. Since all tags in (UDFM m i) are distinct Ints in [0, i), we can instead place each element into an array at index = its tag and read it out in index order: O(n) after the guard, no comparisons, lazy readout. Maps whose tag bound has drifted far above their size fall back to the old sort, and singleton maps skip sorting entirely. See Note [Placement sort in eltsUDFM]. Assisted-by: Claude Fable 5 - - - - - 1 changed file: - compiler/GHC/Types/Unique/DFM.hs Changes: ===================================== compiler/GHC/Types/Unique/DFM.hs ===================================== @@ -14,6 +14,9 @@ See Note [Unique Determinism] in GHC.Types.Unique for explanation why @Unique@ o is not deterministic. -} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE UnboxedTuples #-} + {-# OPTIONS_GHC -Wall #-} module GHC.Types.Unique.DFM ( @@ -79,6 +82,9 @@ import Data.Functor.Classes (Eq1 (..)) import Data.List (sortBy) import Data.Function (on) import GHC.Types.Unique.FM (UniqFM, nonDetUFMToList, ufmToIntMap, unsafeIntMapToUFM) +import GHC.Data.SmallArray +import GHC.Exts (State#) +import GHC.ST (ST(..), runST) import Unsafe.Coerce import qualified GHC.Data.Word64Set as W @@ -92,9 +98,9 @@ import qualified GHC.Data.Word64Set as W -- order then `udfmToList` returns them in deterministic order. -- -- There is an implementation cost: each element is given a serial number --- as it is added, and `udfmToList` sorts its result by this serial --- number. So you should only use `UniqDFM` if you need the deterministic --- property. +-- as it is added, and `udfmToList` orders its result by this serial number +-- (see Note [Placement sort in eltsUDFM]). So you should only use `UniqDFM` +-- if you need the deterministic property. -- -- `foldUDFM` also preserves determinism. -- @@ -153,11 +159,11 @@ data UniqDFM key ele = -- time. See Note [Overflow on plusUDFM] deriving (Data, Functor) --- | Deterministic, in O(n log n). +-- | Deterministic. See Note [Placement sort in eltsUDFM] for the cost. instance Foldable (UniqDFM key) where foldr = foldUDFM --- | Deterministic, in O(n log n). +-- | Deterministic. See Note [Placement sort in eltsUDFM] for the cost. instance Traversable (UniqDFM key) where traverse f = fmap listToUDFM_Directly . traverse (\(u,a) -> (u,) <$> f a) @@ -310,7 +316,8 @@ elemUDFM :: Uniquable key => key -> UniqDFM key elt -> Bool elemUDFM k (UDFM m _i) = M.member (getKey $ getUnique k) m -- | Performs a deterministic fold over the UniqDFM. --- It's O(n log n) while the corresponding function on `UniqFM` is O(n). +-- It's O(n) in the common case, with an O(n log n) fallback +-- (see Note [Placement sort in eltsUDFM]). foldUDFM :: (elt -> a -> a) -> a -> UniqDFM key elt -> a {-# INLINE foldUDFM #-} -- This INLINE prevents a regression in !10568 @@ -334,11 +341,68 @@ nonDetStrictFoldUDFM k z (UDFM m _i) = foldl' k' z m eltsUDFM :: UniqDFM key elt -> [elt] {-# INLINE eltsUDFM #-} -- The INLINE makes it a good producer (from the map) -eltsUDFM (UDFM m _i) = map taggedFst (sort_it m) +eltsUDFM (UDFM m i) + | n <= 1 = map taggedFst (M.elems m) -- no sorting needed + | usePlacement n i = placementSort i (M.elems m) + | otherwise = map taggedFst (sort_it m) + where n = M.size m sort_it :: M.Word64Map (TaggedVal elt) -> [TaggedVal elt] sort_it m = sortBy (compare `on` taggedSnd) (M.elems m) +-- Note [Placement sort in eltsUDFM] +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- Deterministic iteration must order elements by insertion tag. Instead of a +-- comparison sort -- the list mergesort behind sortBy allocates ~n*log n cons +-- cells -- we exploit the invariant that in (UDFM m i) all tags are distinct +-- Ints in [0, i): allocate an array of size i, write each element at index = +-- its tag, freeze, and read out in index order. That's O(i) work (which +-- subsumes the O(n) fill, since distinct tags force n <= i), no comparisons, +-- and the readout is lazy, so consumers that demand only a prefix pay almost +-- nothing beyond the fill. +-- +-- Holes: slots whose tag never occurs keep the initial sentinel, a TaggedVal +-- with tag -1. Real tags are non-negative, so the readout skips on tag < 0; +-- the sentinel's value field is never touched (it is unsafeCoerced ()). +-- +-- The array loses when i is much larger than n: i never shrinks (overwrites +-- keep bumping it, delete/filter shrink n but not i). We compute n = M.size m +-- (O(n), cheap next to either sort) and fall back to the mergesort when +-- i > 4 * n. Maps built by plain insertion -- the common case -- have i == n. +-- The guard also caps the fast path's O(i) at O(n). +-- +-- Determinism is unaffected: the tags are distinct, so they fully determine +-- the order; the previous sort never relied on stability. + +usePlacement :: Int -> Int -> Bool +usePlacement n i = i <= 4 * n + +-- | Order a list of 'TaggedVal's by tag, by placing each at array index = +-- its tag. The tags must be distinct and in @[0, i)@. +-- See Note [Placement sort in eltsUDFM]. +placementSort :: forall r. Int -> [TaggedVal r] -> [r] +placementSort i tvs = runST (ST (\s0 -> + case newSmallArray i hole s0 of + (# s1, marr #) -> case fill marr tvs s1 of + s2 -> case unsafeFreezeSmallArray marr s2 of + (# s3, arr #) -> (# s3, readout arr 0 #))) + where + hole :: TaggedVal r + hole = TaggedVal (unsafeCoerce ()) (-1) + + fill :: SmallMutableArray s (TaggedVal r) -> [TaggedVal r] -> State# s -> State# s + fill _ [] s = s + fill marr (tv : tvs') s = + case writeSmallArray marr (taggedSnd tv) tv s of + s' -> fill marr tvs' s' + + readout :: SmallArray (TaggedVal r) -> Int -> [r] + readout arr j + | j >= i = [] + | t < 0 = readout arr (j + 1) + | otherwise = v : readout arr (j + 1) + where TaggedVal v t = indexSmallArray arr j + filterUDFM :: (elt -> Bool) -> UniqDFM key elt -> UniqDFM key elt filterUDFM p (UDFM m i) = UDFM (M.filter (\(TaggedVal v _) -> p v) m) i @@ -356,11 +420,21 @@ udfmRestrictKeysSet (UDFM val_set i) set = in UDFM (M.restrictKeys val_set key_set) i -- | Converts `UniqDFM` to a list, with elements in deterministic order. --- It's O(n log n) while the corresponding function on `UniqFM` is O(n). +-- It's O(n) in the common case, with an O(n log n) fallback +-- (see Note [Placement sort in eltsUDFM]). udfmToList :: UniqDFM key elt -> [(Unique, elt)] -udfmToList (UDFM m _i) = - [ (mkUniqueGrimily k, taggedFst v) - | (k, v) <- sortBy (compare `on` (taggedSnd . snd)) $ M.toList m ] +udfmToList (UDFM m i) + | n <= 1 = [ (mkUniqueGrimily k, taggedFst v) | (k, v) <- M.toList m ] + -- Unlike eltsUDFM, this allocates a fresh TaggedVal + pair per element + -- before the sort. If it ever matters, a parallel Word64 array of + -- keys filled in the same pass would avoid the eager boxes. + | usePlacement n i = placementSort i + (M.foldrWithKey (\k tv rest -> + TaggedVal (mkUniqueGrimily k, taggedFst tv) (taggedSnd tv) : rest) [] m) + | otherwise = + [ (mkUniqueGrimily k, taggedFst v) + | (k, v) <- sortBy (compare `on` (taggedSnd . snd)) $ M.toList m ] + where n = M.size m -- Determines whether two 'UniqDFM's contain the same keys. equalKeysUDFM :: UniqDFM key a -> UniqDFM key b -> Bool View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/67814479462f5e0d542ae214e6d4f45… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/67814479462f5e0d542ae214e6d4f45… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/fix-26971] Decoupling 'L.H.S' from 'GHC.Hs.Doc'
by recursion-ninja (＠recursion-ninja) 02 Jul '26

02 Jul '26

recursion-ninja pushed to branch wip/fix-26971 at Glasgow Haskell Compiler / GHC Commits: 809c867c by Recursion Ninja at 2026-07-02T09:52:21-04:00 Decoupling 'L.H.S' from 'GHC.Hs.Doc' * Migrated 'GHC.Hs.Doc' and 'GHC.Hs.DocString' AST defintions from 'GHC.*' namespace, to new 'Language.Haskell.Syntax.Doc' module in the 'L.H.S' "namespace." * Updated 'HsDocString to be TTG-parameterised as 'HsDocString pass'. * Added 'GHC.Hs.Extension.Pass': splits 'GhcPass'/'Pass' and all 'HsDocString' TTG instances out of 'GHC.Hs.Extension', which re-exports it unchanged (this is backwards compatible and prevents the introduction of a boot file). * Deleted 'GHC.Hs.Doc.hs-boot'; removed all 'L.H.S.*' imports of 'GHC.Hs.Doc'. * Updated 'GHC.Hs.DocString' to be TTG pass-parameterised throughout; moved 'mkHsDocStringChunk'/'unpackHDSC' here (require 'GHC.Utils.Encoding'). * Split 'GHC.Rename.Doc.rnHsDoc' from 'rnHsDocIdentifiersOnly'. * Updated parser, renamer, typechecker, HIE, and exact-print for new types. * Added 'HsDocString' TTG instances for 'DocNameI' to 'Haddock.Types'. * Killed the last module loop between GHC.* and LHS.*. - Only edges from LHS.* to GHC.Data.FastString now! Resolves #26971 - - - - - 46 changed files: - compiler/GHC/Builtin/Utils.hs - compiler/GHC/Hs.hs - compiler/GHC/Hs/Doc.hs - − compiler/GHC/Hs/Doc.hs-boot - compiler/GHC/Hs/DocString.hs - compiler/GHC/Hs/Extension.hs - + compiler/GHC/Hs/Extension/Pass.hs - compiler/GHC/Hs/ImpExp.hs - compiler/GHC/HsToCore/Docs.hs - compiler/GHC/Iface/Ext/Ast.hs - compiler/GHC/Iface/Syntax.hs - compiler/GHC/Parser/Annotation.hs - compiler/GHC/Parser/HaddockLex.x - compiler/GHC/Parser/Lexer.x - compiler/GHC/Parser/PostProcess/Haddock.hs - compiler/GHC/Rename/Doc.hs - compiler/GHC/Rename/Module.hs - compiler/GHC/Tc/Errors/Hole.hs - compiler/GHC/Tc/Errors/Hole/FitTypes.hs - compiler/GHC/Tc/Gen/Splice.hs - compiler/GHC/Tc/Module.hs - compiler/GHC/Types/Basic.hs - compiler/Language/Haskell/Syntax.hs - compiler/Language/Haskell/Syntax/Decls.hs - + compiler/Language/Haskell/Syntax/Doc.hs - compiler/Language/Haskell/Syntax/Expr.hs-boot - compiler/Language/Haskell/Syntax/Extension.hs - compiler/Language/Haskell/Syntax/ImpExp.hs - compiler/Language/Haskell/Syntax/Type.hs - − compiler/Language/Haskell/Syntax/Type.hs-boot - compiler/ghc.cabal.in - testsuite/tests/count-deps/CountDepsAst.stdout - testsuite/tests/count-deps/CountDepsParser.stdout - testsuite/tests/haddock/should_compile_flag_haddock/T17544.stderr - testsuite/tests/haddock/should_compile_flag_haddock/T24221.stderr - testsuite/tests/parser/should_compile/T23315/T23315.stderr - testsuite/tests/showIface/DocsInHiFile1.stdout - testsuite/tests/showIface/HaddockSpanIssueT24378.stdout - testsuite/tests/showIface/MagicHashInHaddocks.stdout - testsuite/tests/showIface/NoExportList.stdout - utils/check-exact/ExactPrint.hs - utils/check-exact/Utils.hs - utils/haddock/haddock-api/src/Haddock/Interface/Create.hs - utils/haddock/haddock-api/src/Haddock/Interface/LexParseRn.hs - utils/haddock/haddock-api/src/Haddock/Interface/Rename.hs - utils/haddock/haddock-api/src/Haddock/Types.hs The diff was not included because it is too large. View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/809c867c9a64e34616b1be09b5aff62… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/809c867c9a64e34616b1be09b5aff62… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/jeltsch/textual-bytecode-output] Add support for missing cost center information
by Wolfgang Jeltsch (＠jeltsch) 02 Jul '26

02 Jul '26

Wolfgang Jeltsch pushed to branch wip/jeltsch/textual-bytecode-output at Glasgow Haskell Compiler / GHC Commits: 8966f683 by Wolfgang Jeltsch at 2026-07-02T16:42:22+03:00 Add support for missing cost center information - - - - - 1 changed file: - compiler/GHC/ByteCode/Show.hs Changes: ===================================== compiler/GHC/ByteCode/Show.hs ===================================== @@ -8,16 +8,29 @@ module GHC.ByteCode.Show (showByteCode) where import Prelude ((+), (-), Integral, div) import Control.Arrow ((>>>)) import Control.Exception (assert) -import Data.Eq ((==)) +import Data.Eq (Eq, (==)) +import Data.Ord ((<=)) import Data.Bits (FiniteBits, finiteBitSize) import Data.Function (($), id, (.)) import Data.Tuple (fst, snd, uncurry) import Data.Bool (Bool, otherwise, not, (&&)) import Data.Int (Int) import Data.Word (Word) -import Data.Maybe (Maybe, maybe) +import Data.Maybe (Maybe (Nothing, Just), maybe) import Data.Either (Either, either) -import Data.List (length, (++), map, zipWith, zipWith5, take, drop, replicate) +import Data.List + ( + length, + (++), + repeat, + map, + zipWith, + zipWith5, + and, + take, + drop, + replicate + ) import Data.String (String) import Data.ByteString (ByteString, unpack) import Data.ByteString.Short (ShortByteString) @@ -44,6 +57,7 @@ import GHC.Utils.Outputable ( defaultDumpStyle, SDoc, + empty, text, (<>), (<+>), @@ -297,46 +311,56 @@ pprBreakpointsInSource :: Module -> ModBreaks -> SDoc pprBreakpointsInSource currentModule ModBreaks {..} = entry (text "breakpoints in source:") $ assert (modBreaks_module == currentModule) $ - assert boundsAreIdentical $ + assert boundsAreConsistent $ vcatOrNone $ zipWith5 pprBreakpointInSource (indices modBreaks_locs_) (elems modBreaks_locs_) (elems modBreaks_decls) (elems modBreaks_vars) - (elems modBreaks_ccs) + potentialCostCenterInfos where - boundsAreIdentical :: Bool - boundsAreIdentical = bounds modBreaks_locs_ == bounds modBreaks_decls && - bounds modBreaks_locs_ == bounds modBreaks_vars && - bounds modBreaks_locs_ == bounds modBreaks_ccs + costCenterInfoIsPresent :: Bool + costCenterInfoIsPresent = fst (bounds modBreaks_ccs) <= + snd (bounds modBreaks_ccs) + + boundsAreConsistent :: Bool + boundsAreConsistent + = allAreEqual $ + [ + bounds modBreaks_locs_, + bounds modBreaks_decls, + bounds modBreaks_vars + ] ++ if costCenterInfoIsPresent then [bounds modBreaks_ccs] else [] + where + + allAreEqual :: Eq a => [a] -> Bool + allAreEqual list = and $ zipWith (==) list (drop 1 list) + + potentialCostCenterInfos :: [Maybe (ShortByteString, ShortByteString)] + potentialCostCenterInfos + | costCenterInfoIsPresent = map Just (elems modBreaks_ccs) + | otherwise = repeat Nothing -- | […] pprBreakpointInSource :: BreakTickIndex -> BinSrcSpan -> [String] -> [OccName] - -> (ShortByteString, ShortByteString) + -> Maybe (ShortByteString, ShortByteString) -> SDoc -pprBreakpointInSource ix srcSpan declarationPath freeVars costCenterInfo +pprBreakpointInSource ix + srcSpan + declarationPath + freeVars + potentialCostCenterInfo = entry (text "breakpoint" <+> ppr ix <> text ":") $ vcat [ - pprSrcSpan $ srcSpan, - pprDeclarationPath $ declarationPath, - pprFreeVariables $ freeVars, - pprCostCenterPath $ costCenterPath, - pprCostCenterLocation $ costCenterLocation + pprSrcSpan $ srcSpan, + pprDeclarationPath $ declarationPath, + pprFreeVariables $ freeVars, + pprPotentialCostCenterInfo $ potentialCostCenterInfo ] - where - - costCenterPath :: String - costCenterPath = utf8DecodeShortByteString (fst costCenterInfo) - - costCenterLocation :: String - costCenterLocation = utf8DecodeShortByteString (snd costCenterInfo) - - -- The structure of the cost center information is apparent from the - -- implementation of 'GHC.HsToCore.Breakpoints.mkModBreaks'. -- | […] pprSrcSpan :: BinSrcSpan -> SDoc @@ -350,6 +374,26 @@ pprDeclarationPath = entry (text "declaration path:") . vcat . map text pprFreeVariables :: [OccName] -> SDoc pprFreeVariables = entry (text "free variables:") . hsep . map ppr +-- | […] +pprPotentialCostCenterInfo :: Maybe (ShortByteString, ShortByteString) -> SDoc +pprPotentialCostCenterInfo Nothing + = empty +pprPotentialCostCenterInfo (Just costCenterInfo) + = vcat [ + pprCostCenterPath $ costCenterPath, + pprCostCenterLocation $ costCenterLocation + ] + where + + costCenterPath :: String + costCenterPath = utf8DecodeShortByteString (fst costCenterInfo) + + costCenterLocation :: String + costCenterLocation = utf8DecodeShortByteString (snd costCenterInfo) + + -- The structure of the cost center information is apparent from the + -- implementation of 'GHC.HsToCore.Breakpoints.mkModBreaks'. + -- | […] pprCostCenterPath :: String -> SDoc pprCostCenterPath = entry (text "cost center path:") . text View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/8966f683f2ca0e03fb3648aed64b747… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/8966f683f2ca0e03fb3648aed64b747… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/jeltsch/textual-bytecode-output] Change wrong use of `(<$>)` and `(<*>)` to `zipWith5` use
by Wolfgang Jeltsch (＠jeltsch) 02 Jul '26

02 Jul '26

Wolfgang Jeltsch pushed to branch wip/jeltsch/textual-bytecode-output at Glasgow Haskell Compiler / GHC Commits: a1681c68 by Wolfgang Jeltsch at 2026-07-02T16:22:47+03:00 Change wrong use of `(<$>)` and `(<*>)` to `zipWith5` use - - - - - 1 changed file: - compiler/GHC/ByteCode/Show.hs Changes: ===================================== compiler/GHC/ByteCode/Show.hs ===================================== @@ -6,7 +6,6 @@ module GHC.ByteCode.Show (showByteCode) where import Prelude ((+), (-), Integral, div) -import Control.Applicative ((<$>), (<*>)) import Control.Arrow ((>>>)) import Control.Exception (assert) import Data.Eq ((==)) @@ -18,7 +17,7 @@ import Data.Int (Int) import Data.Word (Word) import Data.Maybe (Maybe, maybe) import Data.Either (Either, either) -import Data.List (length, (++), map, zipWith, take, drop, replicate) +import Data.List (length, (++), map, zipWith, zipWith5, take, drop, replicate) import Data.String (String) import Data.ByteString (ByteString, unpack) import Data.ByteString.Short (ShortByteString) @@ -296,15 +295,15 @@ pprBreakpointsData currentModule InternalModBreaks {..} -- | […] pprBreakpointsInSource :: Module -> ModBreaks -> SDoc pprBreakpointsInSource currentModule ModBreaks {..} - = entry (text "breakpoints in source:") $ - assert (modBreaks_module == currentModule) $ - assert boundsAreIdentical $ - vcatOrNone $ - pprBreakpointInSource <$> indices modBreaks_locs_ <*> - elems modBreaks_locs_ <*> - elems modBreaks_decls <*> - elems modBreaks_vars <*> - elems modBreaks_ccs + = entry (text "breakpoints in source:") $ + assert (modBreaks_module == currentModule) $ + assert boundsAreIdentical $ + vcatOrNone $ + zipWith5 pprBreakpointInSource (indices modBreaks_locs_) + (elems modBreaks_locs_) + (elems modBreaks_decls) + (elems modBreaks_vars) + (elems modBreaks_ccs) where boundsAreIdentical :: Bool View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/a1681c68a2fb169acf861f59e5af4df… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/a1681c68a2fb169acf861f59e5af4df… You're receiving this email because of your account on gitlab.haskell.org.

1 0