Merge pull request #279413 from NixOS/haskell-updates

it. However, the non-standard package sets are not tested regularly and, as a

result, contain fewer working packages. The corresponding package set for GHC

9.4.5 is `haskell.packages.ghc945`. In fact `haskellPackages` is just an alias

for `haskell.packages.ghc927`:

for `haskell.packages.ghc964`:

```console

$ nix-env -f '<nixpkgs>' -qaP -A haskell.packages.ghc927

: Sets `doCheck` to `false` for `drv`. Useful if a package has a broken,

flaky or otherwise problematic test suite breaking the build.

`dontCheckIf condition drv`

: Sets `doCheck` to `false` for `drv`, but only if `condition` applies.

Otherwise it's a no-op. Useful to conditionally disable tests for a package

without interfering with previous overrides or default values.

<!-- Purposefully omitting the non-list variants here. They are a bit

ugly, and we may want to deprecate them at some point. -->

let

  pkgs = import ../../.. {};

  inherit (pkgs) lib;

  getDeps = _: pkg: {

    deps = builtins.filter (x: x != null) (map (x: x.pname or null) (pkg.propagatedBuildInputs or []));

  getDeps = _: pkg: let

    pname = pkg.pname or null;

  in {

    deps = builtins.filter (x: x != null && x != pname) (map (x: x.pname or null) (pkg.propagatedBuildInputs or []));

    broken = (pkg.meta.hydraPlatforms or [null]) == [];

  };

in

import Data.List (sortOn)

import Control.Concurrent.Async (concurrently)

import Control.Exception (evaluate)

import qualified Data.IntMap.Strict as IntMap

import qualified Data.IntMap.Lazy as IntMap

import qualified Data.IntSet as IntSet

import Data.Bifunctor (second)

import Data.Data (Proxy)

   Map.fromDistinctAscList $ zip keys (zip (rdepMap False) (rdepMap True))

 where

    -- This code tries to efficiently invert the dependency map and calculate

    -- it’s transitive closure by internally identifying every pkg with it’s index

    -- its transitive closure by internally identifying every pkg with its index

    -- in the package list and then using memoization.

    keys :: [PkgName]

    keys = Map.keys depMap

    intDeps :: [(Int, (Bool, [Int]))]

    intDeps = zip [0..] (fmap depInfoToIdx depInfos)

    rdepMap onlyUnbroken = IntSet.size <$> resultList

    rdepMap onlyUnbroken = IntSet.size <$> IntMap.elems resultList

     where

       resultList = go <$> [0..]

       resultList = IntMap.fromDistinctAscList [(i, go i) | i <- [0..length keys - 1]]

       oneStepMap = IntMap.fromListWith IntSet.union $ (\(key,(_,deps)) -> (,IntSet.singleton key) <$> deps) <=< filter (\(_, (broken,_)) -> not (broken && onlyUnbroken)) $ intDeps

       go pkg = IntSet.unions (oneStep:((resultList !!) <$> IntSet.toList oneStep))

       go pkg = IntSet.unions (oneStep:((resultList IntMap.!) <$> IntSet.toList oneStep))

        where oneStep = IntMap.findWithDefault mempty pkg oneStepMap

-- | Generate a mapping of Hydra job names to maintainer GitHub handles. Calls

HACKAGE2NIX="${HACKAGE2NIX:-hackage2nix}"

# To prevent hackage2nix fails because of encoding.

# See: https://github.com/NixOS/nixpkgs/pull/122023

export LC_ALL=C.UTF-8

config_dir=pkgs/development/haskell-modules/configuration-hackage2nix

run_hackage2nix() {

# (should be capitalized like the display name)

SOLVER=LTS

# Stackage solver verson, if any. Use latest if empty

VERSION=21

VERSION=

TMP_TEMPLATE=update-stackage.XXXXXXX

readonly SOLVER

readonly VERSION