commit 60dfb9bae8400764fe013dbab8cf9d79998ed74e · pyrox.dev/nixpkgs

doc/release-notes/rl-2511.section.md

···

46
46

47
47

- `conduwuit` was removed due to upstream ceasing development and deleting their repository. For existing data, a migration to `matrix-conduit`, `matrix-continuwuity` or `matrix-tuwunel` may be possible.

48
48

49
49
+
- The GHCJS 8.10.7, exposed via `haskell.compiler.ghcjs` and `haskell.compiler.ghcjs810`, has been removed. Downstream users should migrate their projects to the new JavaScript backend of GHC proper which can be used via `pkgsCross.ghcjs` from Nixpkgs.

50
50
+

49
51

- `gnome-keyring` no longer ships with an SSH agent anymore because it has been deprecated upstream. You should use `gcr_4` instead, which provides the same features. More information on why this was done can be found on [the relevant GCR upstream PR](https://gitlab.gnome.org/GNOME/gcr/-/merge_requests/67).

50
52

51
53

- `stdenv.mkDerivation` and other derivation builders that use it no longer allow the value of `env` to be anything but an attribute set, for the purpose of setting environment variables that are available to the [builder](https://nix.dev/manual/nix/latest/store/derivation/#builder) process. An environment variable called `env` can still be provided by means of `mkDerivation { env.env = ...; }`, though we recommend to use a more specific name than "env".

-42

pkgs/development/compilers/ghcjs/8.10/common-overrides.nix

···

       1
       1
       -
       {

     

       2
       2
       -
         haskellLib,

     

       3
       3
       -
         fetchpatch,

     

       4
       4
       -
         buildPackages,

     

       5
       5
       -
       }:

     

       6
       6
       -
       

     

       7
       7
       -
       let

     

       8
       8
       -
         inherit (haskellLib)

     

       9
       9
       -
           addBuildTools

     

       10
       10
       -
           appendConfigureFlag

     

       11
       11
       -
           dontHaddock

     

       12
       12
       -
           doJailbreak

     

       13
       13
       -
           markUnbroken

     

       14
       14
       -
           overrideCabal

     

       15
       15
       -
           ;

     

       16
       16
       -
       in

     

       17
       17
       -
       self: super: {

     

       18
       18
       -
         ghcjs =

     

       19
       19
       -
           overrideCabal

     

       20
       20
       -
             (drv: {

     

       21
       21
       -
               # Jailbreak and patch can be dropped after https://github.com/ghcjs/ghcjs/pull/833

     

       22
       22
       -
               jailbreak = true;

     

       23
       23
       -
               patches = drv.patches or [ ] ++ [

     

       24
       24
       -
                 (fetchpatch {

     

       25
       25
       -
                   name = "ghcjs-aeson-2.0.patch";

     

       26
       26
       -
                   url = "https://github.com/ghcjs/ghcjs/commit/9ef1f92d740e8503d15d91699f57db147f0474cc.patch";

     

       27
       27
       -
                   sha256 = "0cgxcy6b5870bv4kj54n3bzcqinh4gl4w4r78dg43h2mblhkzbnj";

     

       28
       28
       -
                 })

     

       29
       29
       -
               ];

     

       30
       30
       -
             })

     

       31
       31
       -
             (

     

       32
       32
       -
               super.ghcjs.overrideScope (

     

       33
       33
       -
                 self: super: {

     

       34
       34
       -
                   # Allow transformers-compat >= 0.7

     

       35
       35
       -
                   optparse-applicative = doJailbreak self.optparse-applicative_0_15_1_0;

     

       36
       36
       -
                   ansi-wl-pprint = self.ansi-wl-pprint_0_6_9;

     

       37
       37
       -
                   ansi-terminal = self.ansi-terminal_1_0_2;

     

       38
       38
       -
                   ansi-terminal-types = self.ansi-terminal-types_0_11_5;

     

       39
       39
       -
                 }

     

       40
       40
       -
               )

     

       41
       41
       -
             );

     

       42
       42
       -
       }

-70

pkgs/development/compilers/ghcjs/8.10/configured-ghcjs-src.nix

···

       1
       1
       -
       {

     

       2
       2
       -
         perl,

     

       3
       3
       -
         autoconf,

     

       4
       4
       -
         automake,

     

       5
       5
       -
         python3,

     

       6
       6
       -
         gcc,

     

       7
       7
       -
         cabal-install,

     

       8
       8
       -
         runCommand,

     

       9
       9
       -
         fetchpatch,

     

       10
       10
       -
       

     

       11
       11
       -
         ghc,

     

       12
       12
       -
         happy,

     

       13
       13
       -
         alex,

     

       14
       14
       -
       

     

       15
       15
       -
         ghcjsSrc,

     

       16
       16
       -
         version,

     

       17
       17
       -
       }:

     

       18
       18
       -
       

     

       19
       19
       -
       runCommand "configured-ghcjs-src"

     

       20
       20
       -
         {

     

       21
       21
       -
           nativeBuildInputs = [

     

       22
       22
       -
             perl

     

       23
       23
       -
             autoconf

     

       24
       24
       -
             automake

     

       25
       25
       -
             python3

     

       26
       26
       -
             ghc

     

       27
       27
       -
             happy

     

       28
       28
       -
             alex

     

       29
       29
       -
             cabal-install

     

       30
       30
       -
             gcc

     

       31
       31
       -
           ];

     

       32
       32
       -
       

     

       33
       33
       -
           inherit ghcjsSrc;

     

       34
       34
       -
       

     

       35
       35
       -
           ctimePatch = fetchpatch {

     

       36
       36
       -
             name = "ghcjs-base-ctime-64-bit.patch";

     

       37
       37
       -
             url = "https://github.com/ghcjs/ghcjs/commit/b7711fbca7c3f43a61f1dba526e6f2a2656ef44c.patch";

     

       38
       38
       -
             hash = "sha256-zZ3l8/5gbIGtvu0s2Xl92fEDhkhJ2c2w+5Ql5qkvr3s=";

     

       39
       39
       -
           };

     

       40
       40
       -
         }

     

       41
       41
       -
         ''

     

       42
       42
       -
           export HOME=$(pwd)

     

       43
       43
       -
           mkdir $HOME/.cabal

     

       44
       44
       -
           touch $HOME/.cabal/config

     

       45
       45
       -
           cp -r "$ghcjsSrc" "$out"

     

       46
       46
       -
           chmod -R +w "$out"

     

       47
       47
       -
           cd "$out"

     

       48
       48
       -
       

     

       49
       49
       -
           patch -p1 -i "$ctimePatch"

     

       50
       50
       -
       

     

       51
       51
       -
           # TODO: Find a better way to avoid impure version numbers

     

       52
       52
       -
           sed -i 's/RELEASE=NO/RELEASE=YES/' ghc/configure.ac

     

       53
       53
       -
       

     

       54
       54
       -
           # These files are needed by ghc-boot package, and these are generated by the

     

       55
       55
       -
           # make/hadrian build system when compiling ghc. Since we dont have access to

     

       56
       56
       -
           # the generated code of the ghc while it got built, here is a little hack to

     

       57
       57
       -
           # generate these again.

     

       58
       58
       -
           runhaskell ${./generate_host_version.hs}

     

       59
       59
       -
           mkdir -p utils/pkg-cache/ghc/libraries/ghc-boot/dist-install/build/GHC/Platform

     

       60
       60
       -
           mv Host.hs utils/pkg-cache/ghc/libraries/ghc-boot/dist-install/build/GHC/Platform/Host.hs

     

       61
       61
       -
           mv Version.hs utils/pkg-cache/ghc/libraries/ghc-boot/dist-install/build/GHC/Version.hs

     

       62
       62
       -
       

     

       63
       63
       -
           # The ghcjs has the following hardcoded paths of lib dir in its code. Patching

     

       64
       64
       -
           # these to match the path expected by the nixpkgs's generic-builder, etc.

     

       65
       65
       -
           sed -i 's/libSubDir = "lib"/libSubDir = "lib\/ghcjs-${version}"/' src-bin/Boot.hs

     

       66
       66
       -
           sed -i 's@let libDir = takeDirectory haddockPath </> ".." </> "lib"@let libDir = takeDirectory haddockPath </> ".." </> "lib/ghcjs-${version}"@' src-bin/HaddockDriver.hs

     

       67
       67
       -
       

     

       68
       68
       -
           patchShebangs .

     

       69
       69
       -
           ./utils/makePackages.sh copy

     

       70
       70
       -
         ''

-144

pkgs/development/compilers/ghcjs/8.10/default.nix

···

       1
       1
       -
       {

     

       2
       2
       -
         stdenv,

     

       3
       3
       -
         pkgsHostHost,

     

       4
       4
       -
         callPackage,

     

       5
       5
       -
         fetchgit,

     

       6
       6
       -
         fetchpatch,

     

       7
       7
       -
         ghcjsSrcJson ? null,

     

       8
       8
       -
         ghcjsSrc ? fetchgit (lib.importJSON ghcjsSrcJson),

     

       9
       9
       -
         bootPkgs,

     

       10
       10
       -
         stage0,

     

       11
       11
       -
         haskellLib,

     

       12
       12
       -
         cabal-install,

     

       13
       13
       -
         nodejs,

     

       14
       14
       -
         makeWrapper,

     

       15
       15
       -
         xorg,

     

       16
       16
       -
         gmp,

     

       17
       17
       -
         pkg-config,

     

       18
       18
       -
         gcc,

     

       19
       19
       -
         lib,

     

       20
       20
       -
         ghcjsDepOverrides ? (_: _: { }),

     

       21
       21
       -
         linkFarm,

     

       22
       22
       -
         buildPackages,

     

       23
       23
       -
       }:

     

       24
       24
       -
       

     

       25
       25
       -
       let

     

       26
       26
       -
         passthru = {

     

       27
       27
       -
           configuredSrc = callPackage ./configured-ghcjs-src.nix {

     

       28
       28
       -
             inherit ghcjsSrc;

     

       29
       29
       -
             inherit (bootPkgs) ghc alex;

     

       30
       30
       -
             inherit (bootGhcjs) version;

     

       31
       31
       -
             happy = bootPkgs.happy_1_19_12;

     

       32
       32
       -
           };

     

       33
       33
       -
           bootPkgs = bootPkgs.extend (

     

       34
       34
       -
             lib.foldr lib.composeExtensions (_: _: { }) [

     

       35
       35
       -
               (

     

       36
       36
       -
                 self: _:

     

       37
       37
       -
                 import stage0 {

     

       38
       38
       -
                   inherit (passthru) configuredSrc;

     

       39
       39
       -
                   inherit (self) callPackage;

     

       40
       40
       -
                 }

     

       41
       41
       -
               )

     

       42
       42
       -
       

     

       43
       43
       -
               (callPackage ./common-overrides.nix {

     

       44
       44
       -
                 inherit haskellLib fetchpatch buildPackages;

     

       45
       45
       -
               })

     

       46
       46
       -
               ghcjsDepOverrides

     

       47
       47
       -
             ]

     

       48
       48
       -
           );

     

       49
       49
       -
       

     

       50
       50
       -
           targetPrefix = "";

     

       51
       51
       -
           inherit bootGhcjs;

     

       52
       52
       -
           inherit (bootGhcjs) version;

     

       53
       53
       -
           isGhcjs = true;

     

       54
       54
       -
       

     

       55
       55
       -
           llvmPackages = null;

     

       56
       56
       -
           enableShared = true;

     

       57
       57
       -
       

     

       58
       58
       -
           socket-io = pkgsHostHost.nodePackages."socket.io";

     

       59
       59
       -
       

     

       60
       60
       -
           haskellCompilerName = "ghcjs-${bootGhcjs.version}";

     

       61
       61
       -
         };

     

       62
       62
       -
       

     

       63
       63
       -
         bootGhcjs = haskellLib.justStaticExecutables passthru.bootPkgs.ghcjs;

     

       64
       64
       -
       

     

       65
       65
       -
         # This provides the stuff we need from the emsdk

     

       66
       66
       -
         emsdk = linkFarm "emsdk" [

     

       67
       67
       -
           {

     

       68
       68
       -
             name = "upstream/bin";

     

       69
       69
       -
             path = buildPackages.clang + "/bin";

     

       70
       70
       -
           }

     

       71
       71
       -
           {

     

       72
       72
       -
             name = "upstream/emscripten";

     

       73
       73
       -
             path = buildPackages.emscripten + "/bin";

     

       74
       74
       -
           }

     

       75
       75
       -
         ];

     

       76
       76
       -
       

     

       77
       77
       -
       in

     

       78
       78
       -
       stdenv.mkDerivation {

     

       79
       79
       -
         name = bootGhcjs.name;

     

       80
       80
       -
         src = passthru.configuredSrc;

     

       81
       81
       -
         nativeBuildInputs = [

     

       82
       82
       -
           bootGhcjs

     

       83
       83
       -
           passthru.bootPkgs.ghc

     

       84
       84
       -
           cabal-install

     

       85
       85
       -
           nodejs

     

       86
       86
       -
           makeWrapper

     

       87
       87
       -
           xorg.lndir

     

       88
       88
       -
           gmp

     

       89
       89
       -
           pkg-config

     

       90
       90
       -
         ]

     

       91
       91
       -
         ++ lib.optionals stdenv.hostPlatform.isDarwin [

     

       92
       92
       -
           gcc # https://github.com/ghcjs/ghcjs/issues/663

     

       93
       93
       -
         ];

     

       94
       94
       -
         dontConfigure = true;

     

       95
       95
       -
         dontInstall = true;

     

       96
       96
       -
       

     

       97
       97
       -
         # Newer versions of `config.sub` reject the `js-ghcjs` host string, but the

     

       98
       98
       -
         # older `config.sub` filed vendored within `ghc` still works

     

       99
       99
       -
         dontUpdateAutotoolsGnuConfigScripts = true;

     

       100
       100
       -
       

     

       101
       101
       -
         buildPhase = ''

     

       102
       102
       -
           export HOME=$TMP

     

       103
       103
       -
           mkdir $HOME/.cabal

     

       104
       104
       -
           touch $HOME/.cabal/config

     

       105
       105
       -
           cd lib/boot

     

       106
       106
       -
       

     

       107
       107
       -
           export EM_CACHE="$HOME/.emscriptencache"

     

       108
       108
       -
           mkdir -p "$EM_CACHE"

     

       109
       109
       -
       

     

       110
       110
       -
           mkdir -p $out/bin

     

       111
       111
       -
           mkdir -p $out/lib/${bootGhcjs.name}

     

       112
       112
       -
           lndir ${bootGhcjs}/bin $out/bin

     

       113
       113
       -
           chmod -R +w $out/bin

     

       114
       114
       -
           rm $out/bin/ghcjs-boot

     

       115
       115
       -
           cp ${bootGhcjs}/bin/ghcjs-boot $out/bin

     

       116
       116
       -
           rm $out/bin/haddock

     

       117
       117
       -
           cp ${bootGhcjs}/bin/haddock $out/bin

     

       118
       118
       -
           cp ${bootGhcjs}/bin/private-ghcjs-hsc2hs $out/bin/ghcjs-hsc2hs

     

       119
       119
       -
       

     

       120
       120
       -
           wrapProgram $out/bin/ghcjs-boot --set ghcjs_libexecdir $out/bin

     

       121
       121
       -
       

     

       122
       122
       -
           wrapProgram $out/bin/ghcjs --add-flags "-B$out/lib/${bootGhcjs.name}"

     

       123
       123
       -
           wrapProgram $out/bin/haddock --add-flags "-B$out/lib/${bootGhcjs.name}"

     

       124
       124
       -
           wrapProgram $out/bin/ghcjs-pkg --add-flags "--global-package-db=$out/lib/${bootGhcjs.name}/package.conf.d"

     

       125
       125
       -
           wrapProgram $out/bin/ghcjs-hsc2hs --add-flags "-I$out/lib/${bootGhcjs.name}/include --template=$out/lib/${bootGhcjs.name}/include/template-hsc.h"

     

       126
       126
       -
       

     

       127
       127
       -
           env PATH=$out/bin:$PATH $out/bin/ghcjs-boot --with-emsdk=${emsdk} --no-haddock

     

       128
       128
       -
         '';

     

       129
       129
       -
       

     

       130
       130
       -
         enableParallelBuilding = true;

     

       131
       131
       -
       

     

       132
       132
       -
         inherit passthru;

     

       133
       133
       -
       

     

       134
       134
       -
         meta = {

     

       135
       135
       -
           platforms = with lib.platforms; linux ++ darwin;

     

       136
       136
       -
       

     

       137
       137
       -
           # Hydra limits jobs to only outputting 1 gigabyte worth of files.

     

       138
       138
       -
           # GHCJS outputs over 3 gigabytes.

     

       139
       139
       -
           # https://github.com/NixOS/nixpkgs/pull/137066#issuecomment-922335563

     

       140
       140
       -
           hydraPlatforms = lib.platforms.none;

     

       141
       141
       -
       

     

       142
       142
       -
           maintainers = with lib.maintainers; [ obsidian-systems-maintenance ];

     

       143
       143
       -
         };

     

       144
       144
       -
       }

-54

pkgs/development/compilers/ghcjs/8.10/generate_host_version.hs

···

       1
       1
       -
       -- Generate the Host.hs and Version.hs as done by hadrian/src/Rules/Generate.hs

     

       2
       2
       -
       

     

       3
       3
       -
       import GHC.Platform.Host

     

       4
       4
       -
       import GHC.Version

     

       5
       5
       -
       

     

       6
       6
       -
       main = do

     

       7
       7
       -
         writeFile "Version.hs" versionHs

     

       8
       8
       -
         writeFile "Host.hs" platformHostHs

     

       9
       9
       -
       

     

       10
       10
       -
       -- | Generate @Version.hs@ files.

     

       11
       11
       -
       versionHs :: String

     

       12
       12
       -
       versionHs = unlines

     

       13
       13
       -
               [ "module GHC.Version where"

     

       14
       14
       -
               , ""

     

       15
       15
       -
               , "import Prelude -- See Note [Why do we import Prelude here?]"

     

       16
       16
       -
               , ""

     

       17
       17
       -
               , "cProjectGitCommitId   :: String"

     

       18
       18
       -
               , "cProjectGitCommitId   = " ++ show cProjectGitCommitId

     

       19
       19
       -
               , ""

     

       20
       20
       -
               , "cProjectVersion       :: String"

     

       21
       21
       -
               , "cProjectVersion       = " ++ show cProjectVersion

     

       22
       22
       -
               , ""

     

       23
       23
       -
               , "cProjectVersionInt    :: String"

     

       24
       24
       -
               , "cProjectVersionInt    = " ++ show cProjectVersionInt

     

       25
       25
       -
               , ""

     

       26
       26
       -
               , "cProjectPatchLevel    :: String"

     

       27
       27
       -
               , "cProjectPatchLevel    = " ++ show cProjectPatchLevel

     

       28
       28
       -
               , ""

     

       29
       29
       -
               , "cProjectPatchLevel1   :: String"

     

       30
       30
       -
               , "cProjectPatchLevel1   = " ++ show cProjectPatchLevel1

     

       31
       31
       -
               , ""

     

       32
       32
       -
               , "cProjectPatchLevel2   :: String"

     

       33
       33
       -
               , "cProjectPatchLevel2   = " ++ show cProjectPatchLevel2

     

       34
       34
       -
               ]

     

       35
       35
       -
       

     

       36
       36
       -
       -- | Generate @Platform/Host.hs@ files.

     

       37
       37
       -
       platformHostHs :: String

     

       38
       38
       -
       platformHostHs = unlines

     

       39
       39
       -
               [ "module GHC.Platform.Host where"

     

       40
       40
       -
               , ""

     

       41
       41
       -
               , "import GHC.Platform"

     

       42
       42
       -
               , ""

     

       43
       43
       -
               , "cHostPlatformArch :: Arch"

     

       44
       44
       -
               , "cHostPlatformArch = " ++ show cHostPlatformArch

     

       45
       45
       -
               , ""

     

       46
       46
       -
               , "cHostPlatformOS   :: OS"

     

       47
       47
       -
               , "cHostPlatformOS   = " ++ show cHostPlatformOS

     

       48
       48
       -
               , ""

     

       49
       49
       -
               , "cHostPlatformMini :: PlatformMini"

     

       50
       50
       -
               , "cHostPlatformMini = PlatformMini"

     

       51
       51
       -
               , "  { platformMini_arch = cHostPlatformArch"

     

       52
       52
       -
               , "  , platformMini_os = cHostPlatformOS"

     

       53
       53
       -
               , "  }"

     

       54
       54
       -
               ]

-6

pkgs/development/compilers/ghcjs/8.10/git.json

···

       1
       1
       -
       {

     

       2
       2
       -
         "url": "https://github.com/obsidiansystems/ghcjs",

     

       3
       3
       -
         "rev": "9fc935f2c3ba6c33ec62eb83afc9f52a893eb68c",

     

       4
       4
       -
         "sha256": "sha256:063dmir39c4i1z8ypnmq86g1x2vhqndmdpzc4hyzsy5jjqcbx6i3",

     

       5
       5
       -
         "fetchSubmodules": true

     

       6
       6
       -
       }

-245

pkgs/development/compilers/ghcjs/8.10/stage0.nix

···

       1
       1
       -
       { callPackage, configuredSrc }:

     

       2
       2
       -
       

     

       3
       3
       -
       {

     

       4
       4
       -
       

     

       5
       5
       -
         ghcjs = callPackage (

     

       6
       6
       -
           {

     

       7
       7
       -
             mkDerivation,

     

       8
       8
       -
             aeson,

     

       9
       9
       -
             alex,

     

       10
       10
       -
             array,

     

       11
       11
       -
             attoparsec,

     

       12
       12
       -
             base,

     

       13
       13
       -
             base16-bytestring,

     

       14
       14
       -
             base64-bytestring,

     

       15
       15
       -
             binary,

     

       16
       16
       -
             bytestring,

     

       17
       17
       -
             Cabal,

     

       18
       18
       -
             containers,

     

       19
       19
       -
             cryptohash,

     

       20
       20
       -
             data-default,

     

       21
       21
       -
             deepseq,

     

       22
       22
       -
             directory,

     

       23
       23
       -
             executable-path,

     

       24
       24
       -
             filepath,

     

       25
       25
       -
             ghc-boot,

     

       26
       26
       -
             ghc-boot-th,

     

       27
       27
       -
             ghc-compact,

     

       28
       28
       -
             ghc-heap,

     

       29
       29
       -
             ghc-paths,

     

       30
       30
       -
             ghci,

     

       31
       31
       -
             happy,

     

       32
       32
       -
             hashable,

     

       33
       33
       -
             hpc,

     

       34
       34
       -
             http-types,

     

       35
       35
       -
             HUnit,

     

       36
       36
       -
             lens,

     

       37
       37
       -
             lib,

     

       38
       38
       -
             lifted-base,

     

       39
       39
       -
             mtl,

     

       40
       40
       -
             network,

     

       41
       41
       -
             optparse-applicative,

     

       42
       42
       -
             parallel,

     

       43
       43
       -
             parsec,

     

       44
       44
       -
             process,

     

       45
       45
       -
             random,

     

       46
       46
       -
             safe,

     

       47
       47
       -
             shelly,

     

       48
       48
       -
             split,

     

       49
       49
       -
             stringsearch,

     

       50
       50
       -
             syb,

     

       51
       51
       -
             tar,

     

       52
       52
       -
             template-haskell,

     

       53
       53
       -
             terminfo,

     

       54
       54
       -
             test-framework,

     

       55
       55
       -
             test-framework-hunit,

     

       56
       56
       -
             text,

     

       57
       57
       -
             time,

     

       58
       58
       -
             transformers,

     

       59
       59
       -
             unix,

     

       60
       60
       -
             unix-compat,

     

       61
       61
       -
             unordered-containers,

     

       62
       62
       -
             vector,

     

       63
       63
       -
             wai,

     

       64
       64
       -
             wai-app-static,

     

       65
       65
       -
             wai-extra,

     

       66
       66
       -
             wai-websockets,

     

       67
       67
       -
             warp,

     

       68
       68
       -
             webdriver,

     

       69
       69
       -
             websockets,

     

       70
       70
       -
             wl-pprint-text,

     

       71
       71
       -
             xhtml,

     

       72
       72
       -
             yaml,

     

       73
       73
       -
           }:

     

       74
       74
       -
           mkDerivation {

     

       75
       75
       -
             pname = "ghcjs";

     

       76
       76
       -
             version = "8.10.7";

     

       77
       77
       -
             src = configuredSrc + /.;

     

       78
       78
       -
             isLibrary = true;

     

       79
       79
       -
             isExecutable = true;

     

       80
       80
       -
             libraryHaskellDepends = [

     

       81
       81
       -
               aeson

     

       82
       82
       -
               array

     

       83
       83
       -
               attoparsec

     

       84
       84
       -
               base

     

       85
       85
       -
               base16-bytestring

     

       86
       86
       -
               base64-bytestring

     

       87
       87
       -
               binary

     

       88
       88
       -
               bytestring

     

       89
       89
       -
               Cabal

     

       90
       90
       -
               containers

     

       91
       91
       -
               cryptohash

     

       92
       92
       -
               data-default

     

       93
       93
       -
               deepseq

     

       94
       94
       -
               directory

     

       95
       95
       -
               filepath

     

       96
       96
       -
               ghc-boot

     

       97
       97
       -
               ghc-boot-th

     

       98
       98
       -
               ghc-compact

     

       99
       99
       -
               ghc-heap

     

       100
       100
       -
               ghc-paths

     

       101
       101
       -
               ghci

     

       102
       102
       -
               hashable

     

       103
       103
       -
               hpc

     

       104
       104
       -
               lens

     

       105
       105
       -
               mtl

     

       106
       106
       -
               optparse-applicative

     

       107
       107
       -
               parallel

     

       108
       108
       -
               parsec

     

       109
       109
       -
               process

     

       110
       110
       -
               safe

     

       111
       111
       -
               split

     

       112
       112
       -
               stringsearch

     

       113
       113
       -
               syb

     

       114
       114
       -
               template-haskell

     

       115
       115
       -
               terminfo

     

       116
       116
       -
               text

     

       117
       117
       -
               time

     

       118
       118
       -
               transformers

     

       119
       119
       -
               unix

     

       120
       120
       -
               unordered-containers

     

       121
       121
       -
               vector

     

       122
       122
       -
               wl-pprint-text

     

       123
       123
       -
               yaml

     

       124
       124
       -
             ];

     

       125
       125
       -
             libraryToolDepends = [

     

       126
       126
       -
               alex

     

       127
       127
       -
               happy

     

       128
       128
       -
             ];

     

       129
       129
       -
             executableHaskellDepends = [

     

       130
       130
       -
               aeson

     

       131
       131
       -
               array

     

       132
       132
       -
               base

     

       133
       133
       -
               binary

     

       134
       134
       -
               bytestring

     

       135
       135
       -
               Cabal

     

       136
       136
       -
               containers

     

       137
       137
       -
               deepseq

     

       138
       138
       -
               directory

     

       139
       139
       -
               executable-path

     

       140
       140
       -
               filepath

     

       141
       141
       -
               ghc-boot

     

       142
       142
       -
               lens

     

       143
       143
       -
               mtl

     

       144
       144
       -
               optparse-applicative

     

       145
       145
       -
               parsec

     

       146
       146
       -
               process

     

       147
       147
       -
               tar

     

       148
       148
       -
               terminfo

     

       149
       149
       -
               text

     

       150
       150
       -
               time

     

       151
       151
       -
               transformers

     

       152
       152
       -
               unix

     

       153
       153
       -
               unix-compat

     

       154
       154
       -
               unordered-containers

     

       155
       155
       -
               vector

     

       156
       156
       -
               xhtml

     

       157
       157
       -
               yaml

     

       158
       158
       -
             ];

     

       159
       159
       -
             testHaskellDepends = [

     

       160
       160
       -
               aeson

     

       161
       161
       -
               base

     

       162
       162
       -
               bytestring

     

       163
       163
       -
               data-default

     

       164
       164
       -
               deepseq

     

       165
       165
       -
               directory

     

       166
       166
       -
               filepath

     

       167
       167
       -
               http-types

     

       168
       168
       -
               HUnit

     

       169
       169
       -
               lens

     

       170
       170
       -
               lifted-base

     

       171
       171
       -
               network

     

       172
       172
       -
               optparse-applicative

     

       173
       173
       -
               process

     

       174
       174
       -
               random

     

       175
       175
       -
               shelly

     

       176
       176
       -
               test-framework

     

       177
       177
       -
               test-framework-hunit

     

       178
       178
       -
               text

     

       179
       179
       -
               time

     

       180
       180
       -
               transformers

     

       181
       181
       -
               unordered-containers

     

       182
       182
       -
               wai

     

       183
       183
       -
               wai-app-static

     

       184
       184
       -
               wai-extra

     

       185
       185
       -
               wai-websockets

     

       186
       186
       -
               warp

     

       187
       187
       -
               webdriver

     

       188
       188
       -
               websockets

     

       189
       189
       -
               yaml

     

       190
       190
       -
             ];

     

       191
       191
       -
             description = "Haskell to JavaScript compiler";

     

       192
       192
       -
             license = lib.licenses.mit;

     

       193
       193
       -
           }

     

       194
       194
       -
         ) { };

     

       195
       195
       -
       

     

       196
       196
       -
         ghcjs-th = callPackage (

     

       197
       197
       -
           {

     

       198
       198
       -
             mkDerivation,

     

       199
       199
       -
             base,

     

       200
       200
       -
             binary,

     

       201
       201
       -
             bytestring,

     

       202
       202
       -
             containers,

     

       203
       203
       -
             ghc-prim,

     

       204
       204
       -
             ghci,

     

       205
       205
       -
             lib,

     

       206
       206
       -
             template-haskell,

     

       207
       207
       -
           }:

     

       208
       208
       -
           mkDerivation {

     

       209
       209
       -
             pname = "ghcjs-th";

     

       210
       210
       -
             version = "0.1.0.0";

     

       211
       211
       -
             src = configuredSrc + /lib/ghcjs-th;

     

       212
       212
       -
             libraryHaskellDepends = [

     

       213
       213
       -
               base

     

       214
       214
       -
               binary

     

       215
       215
       -
               bytestring

     

       216
       216
       -
               containers

     

       217
       217
       -
               ghc-prim

     

       218
       218
       -
               ghci

     

       219
       219
       -
               template-haskell

     

       220
       220
       -
             ];

     

       221
       221
       -
             homepage = "https://github.com/ghcjs";

     

       222
       222
       -
             license = lib.licenses.mit;

     

       223
       223
       -
           }

     

       224
       224
       -
         ) { };

     

       225
       225
       -
       

     

       226
       226
       -
         ghcjs-prim = callPackage (

     

       227
       227
       -
           {

     

       228
       228
       -
             mkDerivation,

     

       229
       229
       -
             base,

     

       230
       230
       -
             ghc-prim,

     

       231
       231
       -
             lib,

     

       232
       232
       -
           }:

     

       233
       233
       -
           mkDerivation {

     

       234
       234
       -
             pname = "ghcjs-prim";

     

       235
       235
       -
             version = "0.1.1.0";

     

       236
       236
       -
             src = ./.;

     

       237
       237
       -
             libraryHaskellDepends = [

     

       238
       238
       -
               base

     

       239
       239
       -
               ghc-prim

     

       240
       240
       -
             ];

     

       241
       241
       -
             homepage = "https://github.com/ghcjs";

     

       242
       242
       -
             license = lib.licenses.mit;

     

       243
       243
       -
           }

     

       244
       244
       -
         ) { };

     

       245
       245
       -
       }

-87

pkgs/development/compilers/ghcjs/ghcjs-base.nix

···

       1
       1
       -
       {

     

       2
       2
       -
         mkDerivation,

     

       3
       3
       -
         aeson,

     

       4
       4
       -
         array,

     

       5
       5
       -
         attoparsec,

     

       6
       6
       -
         base,

     

       7
       7
       -
         binary,

     

       8
       8
       -
         bytestring,

     

       9
       9
       -
         containers,

     

       10
       10
       -
         deepseq,

     

       11
       11
       -
         directory,

     

       12
       12
       -
         dlist,

     

       13
       13
       -
         fetchFromGitHub,

     

       14
       14
       -
         ghc-prim,

     

       15
       15
       -
         ghcjs-prim,

     

       16
       16
       -
         hashable,

     

       17
       17
       -
         HUnit,

     

       18
       18
       -
         integer-gmp,

     

       19
       19
       -
         primitive,

     

       20
       20
       -
         QuickCheck,

     

       21
       21
       -
         quickcheck-unicode,

     

       22
       22
       -
         random,

     

       23
       23
       -
         scientific,

     

       24
       24
       -
         test-framework,

     

       25
       25
       -
         test-framework-hunit,

     

       26
       26
       -
         test-framework-quickcheck2,

     

       27
       27
       -
         text,

     

       28
       28
       -
         time,

     

       29
       29
       -
         transformers,

     

       30
       30
       -
         unordered-containers,

     

       31
       31
       -
         vector,

     

       32
       32
       -
         lib,

     

       33
       33
       -
       }:

     

       34
       34
       -
       mkDerivation {

     

       35
       35
       -
         pname = "ghcjs-base";

     

       36
       36
       -
         version = "0.2.1.0";

     

       37
       37
       -
         # This is the release 0.2.1.0, but the hackage release misses test source files,

     

       38
       38
       -
         # so lets use github https://github.com/ghcjs/ghcjs-base/issues/132

     

       39
       39
       -
         src = fetchFromGitHub {

     

       40
       40
       -
           owner = "ghcjs";

     

       41
       41
       -
           repo = "ghcjs-base";

     

       42
       42
       -
           rev = "fbaae59b05b020e91783df122249095e168df53f";

     

       43
       43
       -
           sha256 = "sha256-x6eCAK1Hne0QkV3Loi9YpxbleNHU593E4AO8cbk2vUc=";

     

       44
       44
       -
         };

     

       45
       45
       -
         libraryHaskellDepends = [

     

       46
       46
       -
           aeson

     

       47
       47
       -
           attoparsec

     

       48
       48
       -
           base

     

       49
       49
       -
           binary

     

       50
       50
       -
           bytestring

     

       51
       51
       -
           containers

     

       52
       52
       -
           deepseq

     

       53
       53
       -
           dlist

     

       54
       54
       -
           ghc-prim

     

       55
       55
       -
           ghcjs-prim

     

       56
       56
       -
           hashable

     

       57
       57
       -
           integer-gmp

     

       58
       58
       -
           primitive

     

       59
       59
       -
           scientific

     

       60
       60
       -
           text

     

       61
       61
       -
           time

     

       62
       62
       -
           transformers

     

       63
       63
       -
           unordered-containers

     

       64
       64
       -
           vector

     

       65
       65
       -
         ];

     

       66
       66
       -
         testHaskellDepends = [

     

       67
       67
       -
           array

     

       68
       68
       -
           base

     

       69
       69
       -
           bytestring

     

       70
       70
       -
           deepseq

     

       71
       71
       -
           directory

     

       72
       72
       -
           ghc-prim

     

       73
       73
       -
           ghcjs-prim

     

       74
       74
       -
           HUnit

     

       75
       75
       -
           primitive

     

       76
       76
       -
           QuickCheck

     

       77
       77
       -
           quickcheck-unicode

     

       78
       78
       -
           random

     

       79
       79
       -
           test-framework

     

       80
       80
       -
           test-framework-hunit

     

       81
       81
       -
           test-framework-quickcheck2

     

       82
       82
       -
           text

     

       83
       83
       -
         ];

     

       84
       84
       -
         homepage = "https://github.com/ghcjs/ghcjs-base";

     

       85
       85
       -
         description = "base library for GHCJS";

     

       86
       86
       -
         license = lib.licenses.mit;

     

       87
       87
       -
       }

-1

pkgs/development/haskell-modules/configuration-arm.nix

···

       37
       37
        
       

     

       38
       38
        
         # Similar to https://ghc.haskell.org/trac/ghc/ticket/13062

     

       39
       39
        
         happy = dontCheck super.happy;

     

       40
       40
       -
         happy_1_19_12 = doDistribute (dontCheck super.happy_1_19_12);

     

       41
       40
        
       

     

       42
       41
        
         # add arm specific library

     

       43
       42
        
         wiringPi = overrideCabal (

-10

pkgs/development/haskell-modules/configuration-common.nix

···

       1831
       1831
        
         # https://github.com/biocad/servant-openapi3/issues/30

     

       1832
       1832
        
         servant-openapi3 = dontCheck super.servant-openapi3;

     

       1833
       1833
        
       

     

       1834
       1834
       -
         # Point hspec 2.7.10 to correct dependencies

     

       1835
       1835
       -
         hspec_2_7_10 = super.hspec_2_7_10.override {

     

       1836
       1836
       -
           hspec-discover = self.hspec-discover_2_7_10;

     

       1837
       1837
       -
           hspec-core = self.hspec-core_2_7_10;

     

       1838
       1838
       -
         };

     

       1839
       1839
       -
         hspec-discover_2_7_10 = super.hspec-discover_2_7_10.override {

     

       1840
       1840
       -
           hspec-meta = self.hspec-meta_2_7_8;

     

       1841
       1841
       -
         };

     

       1842
       1842
       -
         hspec-core_2_7_10 = doJailbreak (dontCheck super.hspec-core_2_7_10);

     

       1843
       1843
       -
       

     

       1844
       1834
        
         # Disable test cases that were broken by insignificant changes in icu 76

     

       1845
       1835
        
         # https://github.com/haskell/text-icu/issues/108

     

       1846
       1836
        
         text-icu = overrideCabal (drv: {

+1 -4

pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix

···

       8
       8
        
       in

     

       9
       9
        
       

     

       10
       10
        
       self: super: {

     

       11
       11
       -
       

     

       12
       12
       -
         # ghcjs does not use `llvmPackages` and exposes `null` attribute.

     

       13
       13
       -
         llvmPackages =

     

       14
       14
       -
           if self.ghc.llvmPackages != null then pkgs.lib.dontRecurseIntoAttrs self.ghc.llvmPackages else null;

     

       11
       11
       +
         llvmPackages = pkgs.lib.dontRecurseIntoAttrs self.ghc.llvmPackages;

     

       15
       12
        
       

     

       16
       13
        
         # Disable GHC 8.10.x core libraries.

     

       17
       14
        
         array = null;

-154

pkgs/development/haskell-modules/configuration-ghcjs-8.x.nix

···

       1
       1
       -
       # GHCJS package fixes

     

       2
       2
       -
       #

     

       3
       3
       -
       # Please insert new packages *alphabetically*

     

       4
       4
       -
       # in the OTHER PACKAGES section.

     

       5
       5
       -
       { pkgs, haskellLib }:

     

       6
       6
       -
       

     

       7
       7
       -
       let

     

       8
       8
       -
         removeLibraryHaskellDepends =

     

       9
       9
       -
           pnames: depends: builtins.filter (e: !(builtins.elem (e.pname or "") pnames)) depends;

     

       10
       10
       -
       in

     

       11
       11
       -
       

     

       12
       12
       -
       with haskellLib;

     

       13
       13
       -
       

     

       14
       14
       -
       self: super:

     

       15
       15
       -
       

     

       16
       16
       -
       ## GENERAL SETUP BASE PACKAGES

     

       17
       17
       -
       {

     

       18
       18
       -
         inherit (self.ghc.bootPkgs)

     

       19
       19
       -
           jailbreak-cabal

     

       20
       20
       -
           alex

     

       21
       21
       -
           happy

     

       22
       22
       -
           gtk2hs-buildtools

     

       23
       23
       -
           rehoo

     

       24
       24
       -
           hoogle

     

       25
       25
       -
           ;

     

       26
       26
       -
       

     

       27
       27
       -
         # Test suite fails; https://github.com/ghcjs/ghcjs-base/issues/133

     

       28
       28
       -
         ghcjs-base = dontCheck (

     

       29
       29
       -
           self.callPackage ../compilers/ghcjs/ghcjs-base.nix {

     

       30
       30
       -
             fetchFromGitHub = pkgs.buildPackages.fetchFromGitHub;

     

       31
       31
       -
             aeson = self.aeson_1_5_6_0;

     

       32
       32
       -
           }

     

       33
       33
       -
         );

     

       34
       34
       -
       

     

       35
       35
       -
         # Included in ghcjs itself

     

       36
       36
       -
         ghcjs-prim = null;

     

       37
       37
       -
       

     

       38
       38
       -
         ghcjs-websockets = markUnbroken super.ghcjs-websockets;

     

       39
       39
       -
       

     

       40
       40
       -
         # GHCJS does not ship with the same core packages as GHC.

     

       41
       41
       -
         # https://github.com/ghcjs/ghcjs/issues/676

     

       42
       42
       -
         stm = doJailbreak self.stm_2_5_3_1;

     

       43
       43
       -
         exceptions = dontCheck self.exceptions_0_10_10;

     

       44
       44
       -
       

     

       45
       45
       -
         ## OTHER PACKAGES

     

       46
       46
       -
       

     

       47
       47
       -
         # Runtime exception in tests, missing C API h$realloc

     

       48
       48
       -
         base-compat-batteries = dontCheck super.base-compat-batteries;

     

       49
       49
       -
       

     

       50
       50
       -
         # nodejs crashes during test

     

       51
       51
       -
         ChasingBottoms = dontCheck super.ChasingBottoms;

     

       52
       52
       -
       

     

       53
       53
       -
         # runs forever

     

       54
       54
       -
         text-short = dontCheck super.text-short;

     

       55
       55
       -
       

     

       56
       56
       -
         # doctest doesn't work on ghcjs, but sometimes dontCheck doesn't seem to get rid of the dependency

     

       57
       57
       -
         doctest = pkgs.lib.warn "ignoring dependency on doctest" null;

     

       58
       58
       -
       

     

       59
       59
       -
         ghcjs-dom = overrideCabal (drv: {

     

       60
       60
       -
           libraryHaskellDepends = with self; [

     

       61
       61
       -
             ghcjs-base

     

       62
       62
       -
             ghcjs-dom-jsffi

     

       63
       63
       -
             text

     

       64
       64
       -
             transformers

     

       65
       65
       -
           ];

     

       66
       66
       -
           configureFlags = [

     

       67
       67
       -
             "-fjsffi"

     

       68
       68
       -
             "-f-webkit"

     

       69
       69
       -
           ];

     

       70
       70
       -
         }) super.ghcjs-dom;

     

       71
       71
       -
       

     

       72
       72
       -
         ghcjs-dom-jsffi = overrideCabal (drv: {

     

       73
       73
       -
           libraryHaskellDepends = (drv.libraryHaskellDepends or [ ]) ++ [

     

       74
       74
       -
             self.ghcjs-base

     

       75
       75
       -
             self.text

     

       76
       76
       -
           ];

     

       77
       77
       -
           broken = false;

     

       78
       78
       -
         }) super.ghcjs-dom-jsffi;

     

       79
       79
       -
       

     

       80
       80
       -
         # https://github.com/Deewiant/glob/issues/39

     

       81
       81
       -
         Glob = dontCheck super.Glob;

     

       82
       82
       -
       

     

       83
       83
       -
         # Test fails to compile during the hsc2hs stage

     

       84
       84
       -
         hashable = dontCheck super.hashable;

     

       85
       85
       -
       

     

       86
       86
       -
         # uses doctest

     

       87
       87
       -
         http-types = dontCheck super.http-types;

     

       88
       88
       -
       

     

       89
       89
       -
         jsaddle = overrideCabal (drv: {

     

       90
       90
       -
           libraryHaskellDepends = (drv.libraryHaskellDepends or [ ]) ++ [ self.ghcjs-base ];

     

       91
       91
       -
         }) super.jsaddle;

     

       92
       92
       -
       

     

       93
       93
       -
         # Tests hang, possibly some issue with tasty and race(async) usage in the nonTerminating tests

     

       94
       94
       -
         logict = dontCheck super.logict;

     

       95
       95
       -
       

     

       96
       96
       -
         patch = dontCheck super.patch;

     

       97
       97
       -
       

     

       98
       98
       -
         # TODO: tests hang

     

       99
       99
       -
         pcre-light = dontCheck super.pcre-light;

     

       100
       100
       -
       

     

       101
       101
       -
         # Terminal test not supported on ghcjs

     

       102
       102
       -
         QuickCheck = dontCheck super.QuickCheck;

     

       103
       103
       -
       

     

       104
       104
       -
         reflex = overrideCabal (drv: {

     

       105
       105
       -
           libraryHaskellDepends = (drv.libraryHaskellDepends or [ ]) ++ [ self.ghcjs-base ];

     

       106
       106
       -
         }) super.reflex;

     

       107
       107
       -
       

     

       108
       108
       -
         reflex-dom = overrideCabal (drv: {

     

       109
       109
       -
           libraryHaskellDepends = removeLibraryHaskellDepends [ "jsaddle-webkit2gtk" ] (

     

       110
       110
       -
             drv.libraryHaskellDepends or [ ]

     

       111
       111
       -
           );

     

       112
       112
       -
         }) super.reflex-dom;

     

       113
       113
       -
       

     

       114
       114
       -
         # https://github.com/dreixel/syb/issues/21

     

       115
       115
       -
         syb = dontCheck super.syb;

     

       116
       116
       -
       

     

       117
       117
       -
         # nodejs crashes during test

     

       118
       118
       -
         scientific = dontCheck super.scientific;

     

       119
       119
       -
       

     

       120
       120
       -
         # Tests use TH which gives error

     

       121
       121
       -
         tasty-quickcheck = dontCheck super.tasty-quickcheck;

     

       122
       122
       -
       

     

       123
       123
       -
         temporary = dontCheck super.temporary;

     

       124
       124
       -
       

     

       125
       125
       -
         # TODO: The tests have a TH error, which has been fixed in ghc

     

       126
       126
       -
         # https://gitlab.haskell.org/ghc/ghc/-/issues/15481 but somehow the issue is

     

       127
       127
       -
         # still present here https://github.com/glguy/th-abstraction/issues/53

     

       128
       128
       -
         th-abstraction = dontCheck super.th-abstraction;

     

       129
       129
       -
       

     

       130
       130
       -
         # Need hedgehog for tests, which fails to compile due to dep on concurrent-output

     

       131
       131
       -
         zenc = dontCheck super.zenc;

     

       132
       132
       -
       

     

       133
       133
       -
         hspec = self.hspec_2_7_10;

     

       134
       134
       -
         hspec-core = self.hspec-core_2_7_10;

     

       135
       135
       -
         hspec-meta = self.hspec-meta_2_7_8;

     

       136
       136
       -
         hspec-discover = self.hspec-discover_2_7_10;

     

       137
       137
       -
       

     

       138
       138
       -
         # ReferenceError: h$primop_ShrinkSmallMutableArrayOp_Char is not defined

     

       139
       139
       -
         unordered-containers = dontCheck super.unordered-containers;

     

       140
       140
       -
       

     

       141
       141
       -
         # Without this revert, test suites using tasty fail with:

     

       142
       142
       -
         # ReferenceError: h$getMonotonicNSec is not defined

     

       143
       143
       -
         # https://github.com/UnkindPartition/tasty/pull/345#issuecomment-1538216407

     

       144
       144
       -
         tasty = appendPatch (pkgs.fetchpatch {

     

       145
       145
       -
           name = "tasty-ghcjs.patch";

     

       146
       146
       -
           url = "https://github.com/UnkindPartition/tasty/commit/e692065642fd09b82acccea610ad8f49edd207df.patch";

     

       147
       147
       -
           revert = true;

     

       148
       148
       -
           relative = "core";

     

       149
       149
       -
           hash = "sha256-ryABU2ywkVOEPC/jWv8humT3HaRpCwMYEk+Ux3hhi/M=";

     

       150
       150
       -
         }) super.tasty;

     

       151
       151
       -
       

     

       152
       152
       -
         # Tests take unacceptably long.

     

       153
       153
       -
         vector = dontCheck super.vector;

     

       154
       154
       -
       }

+1 -11

pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml

···

       45
       45
        
       

     

       46
       46
        
       # keep-sorted start skip_lines=1 case=no numeric=yes

     

       47
       47
        
       extra-packages:

     

       48
       48
       -
         - aeson < 2                           # required by pantry-0.5.2

     

       49
       48
        
         - algebraic-graphs < 0.7              # 2023-08-14: Needed for building weeder < 2.6.0

     

       50
       50
       -
         - ansi-terminal < 1.1                 # 2025-02-27: required for ghcjs

     

       51
       51
       -
         - ansi-terminal-types == 0.11.5       # 2025-02-27: required for ghcjs

     

       52
       52
       -
         - ansi-wl-pprint >= 0.6 && < 0.7      # 2024-03-23: required for ghcjs

     

       53
       53
       -
         - apply-refact == 0.9.*               # 2022-12-12: needed for GHC < 9.2

     

       49
       49
       +
         - ansi-wl-pprint >= 0.6 && < 0.7      # 2025-07-07: used by gren <= 0.5.4

     

       54
       50
        
         - attoparsec == 0.13.*                # 2022-02-23: Needed to compile elm for now

     

       55
       51
        
         - Cabal == 3.2.*                      # Used for packages needing newer Cabal on ghc 8.6 and 8.8

     

       56
       52
        
         - Cabal == 3.10.*

     
···

       85
       81
        
         - ghc-tags == 1.5.*                   # 2023-02-18: preserve for ghc-lib == 9.2.*

     

       86
       82
        
         - ghc-tags == 1.7.*                   # 2023-02-18: preserve for ghc-lib == 9.6.*

     

       87
       83
        
         - ghc-tags == 1.8.*                   # 2023-02-18: preserve for ghc-lib == 9.8.*

     

       88
       88
       -
         - happy == 1.19.12                    # for ghcjs

     

       89
       84
        
         - happy == 1.20.*                     # for ghc-lib-parser == 9.6.*

     

       90
       85
        
         - hasql < 1.7                         # 2025-01-19: Needed for building postgrest

     

       91
       86
        
         - hasql-dynamic-statements < 0.3.1.6  # 2025-01-19: Needed for building postgrest

     
···

       96
       91
        
         - hlint == 3.4.1                      # 2022-09-21: preserve for ghc 8.10

     

       97
       92
        
         - hlint == 3.6.*                      # 2025-04-14: needed for hls with ghc-lib-parser 9.6

     

       98
       93
        
         - hnix-store-core < 0.7               # 2023-12-11: required by hnix-store-remote 0.6

     

       99
       99
       -
         - hspec < 2.8                         # 2022-04-07: Needed for tasty-hspec 1.1.6

     

       100
       100
       -
         - hspec-core < 2.8                    # 2022-04-07: Needed for tasty-hspec 1.1.6

     

       101
       101
       -
         - hspec-discover < 2.8                # 2022-04-07: Needed for tasty-hspec 1.1.6

     

       102
       94
        
         - hspec-megaparsec == 2.2.0           # 2023-11-18: Latest version compatible with ghc 9.0

     

       103
       103
       -
         - hspec-meta < 2.8                    # 2022-12-07: Needed for elmPackages.elm / hspec-discover

     

       104
       95
        
         - language-javascript == 0.7.0.0      # required by purescript

     

       105
       96
        
         - lsp < 2.5                           # 2024-07-08: need for koka

     

       106
       97
        
         - lsp == 2.1.*                        # 2024-02-28: need for dhall-lsp-server

     

       107
       98
        
         - lsp-types == 2.1.*                  # 2024-02-28: need for dhall-lsp-server and koka

     

       108
       99
        
         - network-run == 0.4.0                # 2024-10-20: for GHC 9.10/network == 3.1.*

     

       109
       109
       -
         - optparse-applicative < 0.16         # needed for niv-0.2.19

     

       110
       100
        
         - ormolu == 0.5.2.0                   # 2023-08-08: preserve for ghc 9.0

     

       111
       101
        
         - ormolu == 0.7.2.0                   # 2023-11-13: for ghc-lib-parser 9.6 compat

     

       112
       102
        
         - ormolu == 0.7.7.0                   # 2025-01-27: for ghc 9.10 compat

+3 -9

pkgs/development/haskell-modules/configuration-nix.nix

···

       635
       635
        
         tasty = overrideCabal (drv: {

     

       636
       636
        
           libraryHaskellDepends =

     

       637
       637
        
             (drv.libraryHaskellDepends or [ ])

     

       638
       638
       -
             ++

     

       639
       639
       -
               lib.optionals

     

       640
       640
       -
                 (

     

       641
       641
       -
                   !(pkgs.stdenv.hostPlatform.isAarch64 || pkgs.stdenv.hostPlatform.isx86_64)

     

       642
       642
       -
                   || (self.ghc.isGhcjs or false)

     

       643
       643
       -
                 )

     

       644
       644
       -
                 [

     

       645
       645
       -
                   self.unbounded-delays

     

       646
       646
       -
                 ];

     

       638
       638
       +
             ++ lib.optionals (!(pkgs.stdenv.hostPlatform.isAarch64 || pkgs.stdenv.hostPlatform.isx86_64)) [

     

       639
       639
       +
               self.unbounded-delays

     

       640
       640
       +
             ];

     

       647
       641
        
         }) super.tasty;

     

       648
       642
        
       

     

       649
       643
        
         tasty-discover = overrideCabal (drv: {

-543

pkgs/development/haskell-modules/hackage-packages.nix

···

       53573
       53573
        
           }

     

       53574
       53574
        
         ) { };

     

       53575
       53575
        
       

     

       53576
       53576
       -
         "aeson_1_5_6_0" = callPackage (

     

       53577
       53577
       -
           {

     

       53578
       53578
       -
             mkDerivation,

     

       53579
       53579
       -
             attoparsec,

     

       53580
       53580
       -
             base,

     

       53581
       53581
       -
             base-compat,

     

       53582
       53582
       -
             base-compat-batteries,

     

       53583
       53583
       -
             base-orphans,

     

       53584
       53584
       -
             base16-bytestring,

     

       53585
       53585
       -
             bytestring,

     

       53586
       53586
       -
             containers,

     

       53587
       53587
       -
             data-fix,

     

       53588
       53588
       -
             deepseq,

     

       53589
       53589
       -
             Diff,

     

       53590
       53590
       -
             directory,

     

       53591
       53591
       -
             dlist,

     

       53592
       53592
       -
             filepath,

     

       53593
       53593
       -
             generic-deriving,

     

       53594
       53594
       -
             ghc-prim,

     

       53595
       53595
       -
             hashable,

     

       53596
       53596
       -
             hashable-time,

     

       53597
       53597
       -
             integer-logarithms,

     

       53598
       53598
       -
             primitive,

     

       53599
       53599
       -
             QuickCheck,

     

       53600
       53600
       -
             quickcheck-instances,

     

       53601
       53601
       -
             scientific,

     

       53602
       53602
       -
             strict,

     

       53603
       53603
       -
             tagged,

     

       53604
       53604
       -
             tasty,

     

       53605
       53605
       -
             tasty-golden,

     

       53606
       53606
       -
             tasty-hunit,

     

       53607
       53607
       -
             tasty-quickcheck,

     

       53608
       53608
       -
             template-haskell,

     

       53609
       53609
       -
             text,

     

       53610
       53610
       -
             th-abstraction,

     

       53611
       53611
       -
             these,

     

       53612
       53612
       -
             time,

     

       53613
       53613
       -
             time-compat,

     

       53614
       53614
       -
             unordered-containers,

     

       53615
       53615
       -
             uuid-types,

     

       53616
       53616
       -
             vector,

     

       53617
       53617
       -
           }:

     

       53618
       53618
       -
           mkDerivation {

     

       53619
       53619
       -
             pname = "aeson";

     

       53620
       53620
       -
             version = "1.5.6.0";

     

       53621
       53621
       -
             sha256 = "1s5z4bgb5150h6a4cjf5vh8dmyrn6ilh29gh05999v6jwd5w6q83";

     

       53622
       53622
       -
             revision = "7";

     

       53623
       53623
       -
             editedCabalFile = "1qbsyy605hlfh7wfj3q33yx0xmb4n81z6h0y99x7khyxmy0plqbf";

     

       53624
       53624
       -
             libraryHaskellDepends = [

     

       53625
       53625
       -
               attoparsec

     

       53626
       53626
       -
               base

     

       53627
       53627
       -
               base-compat-batteries

     

       53628
       53628
       -
               bytestring

     

       53629
       53629
       -
               containers

     

       53630
       53630
       -
               data-fix

     

       53631
       53631
       -
               deepseq

     

       53632
       53632
       -
               dlist

     

       53633
       53633
       -
               ghc-prim

     

       53634
       53634
       -
               hashable

     

       53635
       53635
       -
               primitive

     

       53636
       53636
       -
               scientific

     

       53637
       53637
       -
               strict

     

       53638
       53638
       -
               tagged

     

       53639
       53639
       -
               template-haskell

     

       53640
       53640
       -
               text

     

       53641
       53641
       -
               th-abstraction

     

       53642
       53642
       -
               these

     

       53643
       53643
       -
               time

     

       53644
       53644
       -
               time-compat

     

       53645
       53645
       -
               unordered-containers

     

       53646
       53646
       -
               uuid-types

     

       53647
       53647
       -
               vector

     

       53648
       53648
       -
             ];

     

       53649
       53649
       -
             testHaskellDepends = [

     

       53650
       53650
       -
               attoparsec

     

       53651
       53651
       -
               base

     

       53652
       53652
       -
               base-compat

     

       53653
       53653
       -
               base-orphans

     

       53654
       53654
       -
               base16-bytestring

     

       53655
       53655
       -
               bytestring

     

       53656
       53656
       -
               containers

     

       53657
       53657
       -
               data-fix

     

       53658
       53658
       -
               Diff

     

       53659
       53659
       -
               directory

     

       53660
       53660
       -
               dlist

     

       53661
       53661
       -
               filepath

     

       53662
       53662
       -
               generic-deriving

     

       53663
       53663
       -
               ghc-prim

     

       53664
       53664
       -
               hashable

     

       53665
       53665
       -
               hashable-time

     

       53666
       53666
       -
               integer-logarithms

     

       53667
       53667
       -
               QuickCheck

     

       53668
       53668
       -
               quickcheck-instances

     

       53669
       53669
       -
               scientific

     

       53670
       53670
       -
               strict

     

       53671
       53671
       -
               tagged

     

       53672
       53672
       -
               tasty

     

       53673
       53673
       -
               tasty-golden

     

       53674
       53674
       -
               tasty-hunit

     

       53675
       53675
       -
               tasty-quickcheck

     

       53676
       53676
       -
               template-haskell

     

       53677
       53677
       -
               text

     

       53678
       53678
       -
               these

     

       53679
       53679
       -
               time

     

       53680
       53680
       -
               time-compat

     

       53681
       53681
       -
               unordered-containers

     

       53682
       53682
       -
               uuid-types

     

       53683
       53683
       -
               vector

     

       53684
       53684
       -
             ];

     

       53685
       53685
       -
             description = "Fast JSON parsing and encoding";

     

       53686
       53686
       -
             license = lib.licenses.bsd3;

     

       53687
       53687
       -
             hydraPlatforms = lib.platforms.none;

     

       53688
       53688
       -
           }

     

       53689
       53689
       -
         ) { };

     

       53690
       53690
       -
       

     

       53691
       53576
        
         "aeson" = callPackage (

     

       53692
       53577
        
           {

     

       53693
       53578
        
             mkDerivation,

     
···

       76649
       76534
        
           }

     

       76650
       76535
        
         ) { };

     

       76651
       76536
        
       

     

       76652
       76652
       -
         "ansi-terminal_1_0_2" = callPackage (

     

       76653
       76653
       -
           {

     

       76654
       76654
       -
             mkDerivation,

     

       76655
       76655
       -
             ansi-terminal-types,

     

       76656
       76656
       -
             base,

     

       76657
       76657
       -
             colour,

     

       76658
       76658
       -
           }:

     

       76659
       76659
       -
           mkDerivation {

     

       76660
       76660
       -
             pname = "ansi-terminal";

     

       76661
       76661
       -
             version = "1.0.2";

     

       76662
       76662
       -
             sha256 = "0d6qm3ph6drim7g81yx46nmgspxsf4nnr2d91fa0fy3cyv5idra6";

     

       76663
       76663
       -
             isLibrary = true;

     

       76664
       76664
       -
             isExecutable = true;

     

       76665
       76665
       -
             libraryHaskellDepends = [

     

       76666
       76666
       -
               ansi-terminal-types

     

       76667
       76667
       -
               base

     

       76668
       76668
       -
               colour

     

       76669
       76669
       -
             ];

     

       76670
       76670
       -
             description = "Simple ANSI terminal support";

     

       76671
       76671
       -
             license = lib.licenses.bsd3;

     

       76672
       76672
       -
             hydraPlatforms = lib.platforms.none;

     

       76673
       76673
       -
           }

     

       76674
       76674
       -
         ) { };

     

       76675
       76675
       -
       

     

       76676
       76537
        
         "ansi-terminal" = callPackage (

     

       76677
       76538
        
           {

     

       76678
       76539
        
             mkDerivation,

     
···

       76775
       76636
        
             testToolDepends = [ hspec-discover ];

     

       76776
       76637
        
             description = "cross-platform library for terminal games";

     

       76777
       76638
        
             license = lib.licenses.gpl3Only;

     

       76778
       76778
       -
           }

     

       76779
       76779
       -
         ) { };

     

       76780
       76780
       -
       

     

       76781
       76781
       -
         "ansi-terminal-types_0_11_5" = callPackage (

     

       76782
       76782
       -
           {

     

       76783
       76783
       -
             mkDerivation,

     

       76784
       76784
       -
             base,

     

       76785
       76785
       -
             colour,

     

       76786
       76786
       -
           }:

     

       76787
       76787
       -
           mkDerivation {

     

       76788
       76788
       -
             pname = "ansi-terminal-types";

     

       76789
       76789
       -
             version = "0.11.5";

     

       76790
       76790
       -
             sha256 = "1lgxnhnzgk4mwlnh8zdgx8w8pa4q4n140mvd1880acgli41j6yxz";

     

       76791
       76791
       -
             revision = "1";

     

       76792
       76792
       -
             editedCabalFile = "02mhl78kmjfa0h22khcjdaaxyvanv717rb2mi3l0jiawv7gl117p";

     

       76793
       76793
       -
             libraryHaskellDepends = [

     

       76794
       76794
       -
               base

     

       76795
       76795
       -
               colour

     

       76796
       76796
       -
             ];

     

       76797
       76797
       -
             description = "Types and functions used to represent SGR aspects";

     

       76798
       76798
       -
             license = lib.licenses.bsd3;

     

       76799
       76799
       -
             hydraPlatforms = lib.platforms.none;

     

       76800
       76639
        
           }

     

       76801
       76640
        
         ) { };

     

       76802
       76641
        
       

     
···

       80797
       80636
        
             ];

     

       80798
       80637
        
             description = "Lift a binary, non-decreasing function onto ordered lists and order the output";

     

       80799
       80638
        
             license = lib.licenses.bsd3;

     

       80800
       80800
       -
           }

     

       80801
       80801
       -
         ) { };

     

       80802
       80802
       -
       

     

       80803
       80803
       -
         "apply-refact_0_9_3_0" = callPackage (

     

       80804
       80804
       -
           {

     

       80805
       80805
       -
             mkDerivation,

     

       80806
       80806
       -
             base,

     

       80807
       80807
       -
             containers,

     

       80808
       80808
       -
             directory,

     

       80809
       80809
       -
             extra,

     

       80810
       80810
       -
             filemanip,

     

       80811
       80811
       -
             filepath,

     

       80812
       80812
       -
             ghc,

     

       80813
       80813
       -
             ghc-boot-th,

     

       80814
       80814
       -
             ghc-exactprint,

     

       80815
       80815
       -
             optparse-applicative,

     

       80816
       80816
       -
             process,

     

       80817
       80817
       -
             refact,

     

       80818
       80818
       -
             silently,

     

       80819
       80819
       -
             syb,

     

       80820
       80820
       -
             tasty,

     

       80821
       80821
       -
             tasty-expected-failure,

     

       80822
       80822
       -
             tasty-golden,

     

       80823
       80823
       -
             transformers,

     

       80824
       80824
       -
             uniplate,

     

       80825
       80825
       -
             unix-compat,

     

       80826
       80826
       -
           }:

     

       80827
       80827
       -
           mkDerivation {

     

       80828
       80828
       -
             pname = "apply-refact";

     

       80829
       80829
       -
             version = "0.9.3.0";

     

       80830
       80830
       -
             sha256 = "1sn5g71sx8xa4ggyk49m661iip6zrzl65vb87l16l31kf79bbm7w";

     

       80831
       80831
       -
             revision = "1";

     

       80832
       80832
       -
             editedCabalFile = "0hgdjm6ydfc29d922h1cpwrch61r5qchzrw21dz80kdry53qxl5q";

     

       80833
       80833
       -
             isLibrary = true;

     

       80834
       80834
       -
             isExecutable = true;

     

       80835
       80835
       -
             libraryHaskellDepends = [

     

       80836
       80836
       -
               base

     

       80837
       80837
       -
               containers

     

       80838
       80838
       -
               directory

     

       80839
       80839
       -
               extra

     

       80840
       80840
       -
               filemanip

     

       80841
       80841
       -
               ghc

     

       80842
       80842
       -
               ghc-boot-th

     

       80843
       80843
       -
               ghc-exactprint

     

       80844
       80844
       -
               process

     

       80845
       80845
       -
               refact

     

       80846
       80846
       -
               syb

     

       80847
       80847
       -
               transformers

     

       80848
       80848
       -
               uniplate

     

       80849
       80849
       -
               unix-compat

     

       80850
       80850
       -
             ];

     

       80851
       80851
       -
             executableHaskellDepends = [

     

       80852
       80852
       -
               base

     

       80853
       80853
       -
               containers

     

       80854
       80854
       -
               directory

     

       80855
       80855
       -
               extra

     

       80856
       80856
       -
               filemanip

     

       80857
       80857
       -
               filepath

     

       80858
       80858
       -
               ghc

     

       80859
       80859
       -
               ghc-boot-th

     

       80860
       80860
       -
               ghc-exactprint

     

       80861
       80861
       -
               optparse-applicative

     

       80862
       80862
       -
               process

     

       80863
       80863
       -
               refact

     

       80864
       80864
       -
               syb

     

       80865
       80865
       -
               transformers

     

       80866
       80866
       -
               uniplate

     

       80867
       80867
       -
               unix-compat

     

       80868
       80868
       -
             ];

     

       80869
       80869
       -
             testHaskellDepends = [

     

       80870
       80870
       -
               base

     

       80871
       80871
       -
               containers

     

       80872
       80872
       -
               directory

     

       80873
       80873
       -
               extra

     

       80874
       80874
       -
               filemanip

     

       80875
       80875
       -
               filepath

     

       80876
       80876
       -
               ghc

     

       80877
       80877
       -
               ghc-boot-th

     

       80878
       80878
       -
               ghc-exactprint

     

       80879
       80879
       -
               optparse-applicative

     

       80880
       80880
       -
               process

     

       80881
       80881
       -
               refact

     

       80882
       80882
       -
               silently

     

       80883
       80883
       -
               syb

     

       80884
       80884
       -
               tasty

     

       80885
       80885
       -
               tasty-expected-failure

     

       80886
       80886
       -
               tasty-golden

     

       80887
       80887
       -
               transformers

     

       80888
       80888
       -
               uniplate

     

       80889
       80889
       -
               unix-compat

     

       80890
       80890
       -
             ];

     

       80891
       80891
       -
             description = "Perform refactorings specified by the refact library";

     

       80892
       80892
       -
             license = lib.licenses.bsd3;

     

       80893
       80893
       -
             hydraPlatforms = lib.platforms.none;

     

       80894
       80894
       -
             mainProgram = "refactor";

     

       80895
       80639
        
           }

     

       80896
       80640
        
         ) { };

     

       80897
       80641
        
       

     
···

       297969
       297713
        
           }

     

       297970
       297714
        
         ) { };

     

       297971
       297715
        
       

     

       297972
       297972
       -
         "happy_1_19_12" = callPackage (

     

       297973
       297973
       -
           {

     

       297974
       297974
       -
             mkDerivation,

     

       297975
       297975
       -
             array,

     

       297976
       297976
       -
             base,

     

       297977
       297977
       -
             containers,

     

       297978
       297978
       -
             mtl,

     

       297979
       297979
       -
             process,

     

       297980
       297980
       -
           }:

     

       297981
       297981
       -
           mkDerivation {

     

       297982
       297982
       -
             pname = "happy";

     

       297983
       297983
       -
             version = "1.19.12";

     

       297984
       297984
       -
             sha256 = "03xlmq6qmdx4zvzw8bp33kd9g7yvcq5cz4wg50xilw812kj276pv";

     

       297985
       297985
       -
             revision = "1";

     

       297986
       297986
       -
             editedCabalFile = "13wydw1mmdry4l9r63vxjk4h55ci9hgwzn1a842qqk1m2rb4xiln";

     

       297987
       297987
       -
             isLibrary = false;

     

       297988
       297988
       -
             isExecutable = true;

     

       297989
       297989
       -
             enableSeparateDataOutput = true;

     

       297990
       297990
       -
             executableHaskellDepends = [

     

       297991
       297991
       -
               array

     

       297992
       297992
       -
               base

     

       297993
       297993
       -
               containers

     

       297994
       297994
       -
               mtl

     

       297995
       297995
       -
             ];

     

       297996
       297996
       -
             testHaskellDepends = [

     

       297997
       297997
       -
               base

     

       297998
       297998
       -
               process

     

       297999
       297999
       -
             ];

     

       298000
       298000
       -
             description = "Happy is a parser generator for Haskell";

     

       298001
       298001
       -
             license = lib.licenses.bsd2;

     

       298002
       298002
       -
             hydraPlatforms = lib.platforms.none;

     

       298003
       298003
       -
             mainProgram = "happy";

     

       298004
       298004
       -
           }

     

       298005
       298005
       -
         ) { };

     

       298006
       298006
       -
       

     

       298007
       297716
        
         "happy_1_20_1_1" = callPackage (

     

       298008
       297717
        
           {

     

       298009
       297718
        
             mkDerivation,

     
···

       355226
       354935
        
           }

     

       355227
       354936
        
         ) { };

     

       355228
       354937
        
       

     

       355229
       355229
       -
         "hspec_2_7_10" = callPackage (

     

       355230
       355230
       -
           {

     

       355231
       355231
       -
             mkDerivation,

     

       355232
       355232
       -
             base,

     

       355233
       355233
       -
             hspec-core,

     

       355234
       355234
       -
             hspec-discover,

     

       355235
       355235
       -
             hspec-expectations,

     

       355236
       355236
       -
             QuickCheck,

     

       355237
       355237
       -
           }:

     

       355238
       355238
       -
           mkDerivation {

     

       355239
       355239
       -
             pname = "hspec";

     

       355240
       355240
       -
             version = "2.7.10";

     

       355241
       355241
       -
             sha256 = "0z0lwrmrqkglr78n6k2c36n4h68142bh785ys0x4jaibjshvs6rw";

     

       355242
       355242
       -
             libraryHaskellDepends = [

     

       355243
       355243
       -
               base

     

       355244
       355244
       -
               hspec-core

     

       355245
       355245
       -
               hspec-discover

     

       355246
       355246
       -
               hspec-expectations

     

       355247
       355247
       -
               QuickCheck

     

       355248
       355248
       -
             ];

     

       355249
       355249
       -
             description = "A Testing Framework for Haskell";

     

       355250
       355250
       -
             license = lib.licenses.mit;

     

       355251
       355251
       -
             hydraPlatforms = lib.platforms.none;

     

       355252
       355252
       -
           }

     

       355253
       355253
       -
         ) { };

     

       355254
       355254
       -
       

     

       355255
       354938
        
         "hspec" = callPackage (

     

       355256
       354939
        
           {

     

       355257
       354940
        
             mkDerivation,

     
···

       355448
       355131
        
           }

     

       355449
       355132
        
         ) { };

     

       355450
       355133
        
       

     

       355451
       355451
       -
         "hspec-core_2_7_10" = callPackage (

     

       355452
       355452
       -
           {

     

       355453
       355453
       -
             mkDerivation,

     

       355454
       355454
       -
             ansi-terminal,

     

       355455
       355455
       -
             array,

     

       355456
       355456
       -
             base,

     

       355457
       355457
       -
             call-stack,

     

       355458
       355458
       -
             clock,

     

       355459
       355459
       -
             deepseq,

     

       355460
       355460
       -
             directory,

     

       355461
       355461
       -
             filepath,

     

       355462
       355462
       -
             hspec-expectations,

     

       355463
       355463
       -
             hspec-meta,

     

       355464
       355464
       -
             HUnit,

     

       355465
       355465
       -
             process,

     

       355466
       355466
       -
             QuickCheck,

     

       355467
       355467
       -
             quickcheck-io,

     

       355468
       355468
       -
             random,

     

       355469
       355469
       -
             setenv,

     

       355470
       355470
       -
             silently,

     

       355471
       355471
       -
             stm,

     

       355472
       355472
       -
             temporary,

     

       355473
       355473
       -
             tf-random,

     

       355474
       355474
       -
             transformers,

     

       355475
       355475
       -
           }:

     

       355476
       355476
       -
           mkDerivation {

     

       355477
       355477
       -
             pname = "hspec-core";

     

       355478
       355478
       -
             version = "2.7.10";

     

       355479
       355479
       -
             sha256 = "12k9yp5gznrda449ir60d5wv3xl7nnyffkb5mhfc0svw9f8lxlv1";

     

       355480
       355480
       -
             revision = "2";

     

       355481
       355481
       -
             editedCabalFile = "0l16mgxgapnihrvbwvhbz9i60v5fx68mhpv6zww9b68bdj6cpbsk";

     

       355482
       355482
       -
             libraryHaskellDepends = [

     

       355483
       355483
       -
               ansi-terminal

     

       355484
       355484
       -
               array

     

       355485
       355485
       -
               base

     

       355486
       355486
       -
               call-stack

     

       355487
       355487
       -
               clock

     

       355488
       355488
       -
               deepseq

     

       355489
       355489
       -
               directory

     

       355490
       355490
       -
               filepath

     

       355491
       355491
       -
               hspec-expectations

     

       355492
       355492
       -
               HUnit

     

       355493
       355493
       -
               QuickCheck

     

       355494
       355494
       -
               quickcheck-io

     

       355495
       355495
       -
               random

     

       355496
       355496
       -
               setenv

     

       355497
       355497
       -
               stm

     

       355498
       355498
       -
               tf-random

     

       355499
       355499
       -
               transformers

     

       355500
       355500
       -
             ];

     

       355501
       355501
       -
             testHaskellDepends = [

     

       355502
       355502
       -
               ansi-terminal

     

       355503
       355503
       -
               array

     

       355504
       355504
       -
               base

     

       355505
       355505
       -
               call-stack

     

       355506
       355506
       -
               clock

     

       355507
       355507
       -
               deepseq

     

       355508
       355508
       -
               directory

     

       355509
       355509
       -
               filepath

     

       355510
       355510
       -
               hspec-expectations

     

       355511
       355511
       -
               hspec-meta

     

       355512
       355512
       -
               HUnit

     

       355513
       355513
       -
               process

     

       355514
       355514
       -
               QuickCheck

     

       355515
       355515
       -
               quickcheck-io

     

       355516
       355516
       -
               random

     

       355517
       355517
       -
               setenv

     

       355518
       355518
       -
               silently

     

       355519
       355519
       -
               stm

     

       355520
       355520
       -
               temporary

     

       355521
       355521
       -
               tf-random

     

       355522
       355522
       -
               transformers

     

       355523
       355523
       -
             ];

     

       355524
       355524
       -
             testToolDepends = [ hspec-meta ];

     

       355525
       355525
       -
             testFlags = [

     

       355526
       355526
       -
               "--skip"

     

       355527
       355527
       -
               "'Test.Hspec.Core.Runner.hspecResult runs specs in parallel'"

     

       355528
       355528
       -
             ];

     

       355529
       355529
       -
             description = "A Testing Framework for Haskell";

     

       355530
       355530
       -
             license = lib.licenses.mit;

     

       355531
       355531
       -
             hydraPlatforms = lib.platforms.none;

     

       355532
       355532
       -
           }

     

       355533
       355533
       -
         ) { };

     

       355534
       355534
       -
       

     

       355535
       355134
        
         "hspec-core" = callPackage (

     

       355536
       355135
        
           {

     

       355537
       355136
        
             mkDerivation,

     
···

       355659
       355258
        
             description = "Helper functions to simplify adding integration tests";

     

       355660
       355259
        
             license = lib.licenses.bsd3;

     

       355661
       355260
        
             hydraPlatforms = lib.platforms.none;

     

       355662
       355662
       -
           }

     

       355663
       355663
       -
         ) { };

     

       355664
       355664
       -
       

     

       355665
       355665
       -
         "hspec-discover_2_7_10" = callPackage (

     

       355666
       355666
       -
           {

     

       355667
       355667
       -
             mkDerivation,

     

       355668
       355668
       -
             base,

     

       355669
       355669
       -
             directory,

     

       355670
       355670
       -
             filepath,

     

       355671
       355671
       -
             hspec-meta,

     

       355672
       355672
       -
             QuickCheck,

     

       355673
       355673
       -
           }:

     

       355674
       355674
       -
           mkDerivation {

     

       355675
       355675
       -
             pname = "hspec-discover";

     

       355676
       355676
       -
             version = "2.7.10";

     

       355677
       355677
       -
             sha256 = "13yzvd3b679skvs1insk4s0wc4zvmz6hs38kc8q0j6vzqq06smqa";

     

       355678
       355678
       -
             isLibrary = true;

     

       355679
       355679
       -
             isExecutable = true;

     

       355680
       355680
       -
             libraryHaskellDepends = [

     

       355681
       355681
       -
               base

     

       355682
       355682
       -
               directory

     

       355683
       355683
       -
               filepath

     

       355684
       355684
       -
             ];

     

       355685
       355685
       -
             executableHaskellDepends = [

     

       355686
       355686
       -
               base

     

       355687
       355687
       -
               directory

     

       355688
       355688
       -
               filepath

     

       355689
       355689
       -
             ];

     

       355690
       355690
       -
             testHaskellDepends = [

     

       355691
       355691
       -
               base

     

       355692
       355692
       -
               directory

     

       355693
       355693
       -
               filepath

     

       355694
       355694
       -
               hspec-meta

     

       355695
       355695
       -
               QuickCheck

     

       355696
       355696
       -
             ];

     

       355697
       355697
       -
             testToolDepends = [ hspec-meta ];

     

       355698
       355698
       -
             description = "Automatically discover and run Hspec tests";

     

       355699
       355699
       -
             license = lib.licenses.mit;

     

       355700
       355700
       -
             hydraPlatforms = lib.platforms.none;

     

       355701
       355701
       -
             mainProgram = "hspec-discover";

     

       355702
       355702
       -
             maintainers = [ lib.maintainers.maralorn ];

     

       355703
       355261
        
           }

     

       355704
       355262
        
         ) { };

     

       355705
       355263
        
       

     
···

       356397
       355955
        
             ];

     

       356398
       355956
        
             description = "Utility functions for testing Megaparsec parsers with Hspec";

     

       356399
       355957
        
             license = lib.licenses.bsd3;

     

       356400
       356400
       -
           }

     

       356401
       356401
       -
         ) { };

     

       356402
       356402
       -
       

     

       356403
       356403
       -
         "hspec-meta_2_7_8" = callPackage (

     

       356404
       356404
       -
           {

     

       356405
       356405
       -
             mkDerivation,

     

       356406
       356406
       -
             ansi-terminal,

     

       356407
       356407
       -
             array,

     

       356408
       356408
       -
             base,

     

       356409
       356409
       -
             call-stack,

     

       356410
       356410
       -
             clock,

     

       356411
       356411
       -
             deepseq,

     

       356412
       356412
       -
             directory,

     

       356413
       356413
       -
             filepath,

     

       356414
       356414
       -
             QuickCheck,

     

       356415
       356415
       -
             quickcheck-io,

     

       356416
       356416
       -
             random,

     

       356417
       356417
       -
             setenv,

     

       356418
       356418
       -
             stm,

     

       356419
       356419
       -
             time,

     

       356420
       356420
       -
             transformers,

     

       356421
       356421
       -
           }:

     

       356422
       356422
       -
           mkDerivation {

     

       356423
       356423
       -
             pname = "hspec-meta";

     

       356424
       356424
       -
             version = "2.7.8";

     

       356425
       356425
       -
             sha256 = "0sfj0n2hy1r8ifysgbcmfdygcd7vyzr13ldkcp0l2ml337f8j0si";

     

       356426
       356426
       -
             isLibrary = true;

     

       356427
       356427
       -
             isExecutable = true;

     

       356428
       356428
       -
             libraryHaskellDepends = [

     

       356429
       356429
       -
               ansi-terminal

     

       356430
       356430
       -
               array

     

       356431
       356431
       -
               base

     

       356432
       356432
       -
               call-stack

     

       356433
       356433
       -
               clock

     

       356434
       356434
       -
               deepseq

     

       356435
       356435
       -
               directory

     

       356436
       356436
       -
               filepath

     

       356437
       356437
       -
               QuickCheck

     

       356438
       356438
       -
               quickcheck-io

     

       356439
       356439
       -
               random

     

       356440
       356440
       -
               setenv

     

       356441
       356441
       -
               stm

     

       356442
       356442
       -
               time

     

       356443
       356443
       -
               transformers

     

       356444
       356444
       -
             ];

     

       356445
       356445
       -
             executableHaskellDepends = [

     

       356446
       356446
       -
               ansi-terminal

     

       356447
       356447
       -
               array

     

       356448
       356448
       -
               base

     

       356449
       356449
       -
               call-stack

     

       356450
       356450
       -
               clock

     

       356451
       356451
       -
               deepseq

     

       356452
       356452
       -
               directory

     

       356453
       356453
       -
               filepath

     

       356454
       356454
       -
               QuickCheck

     

       356455
       356455
       -
               quickcheck-io

     

       356456
       356456
       -
               random

     

       356457
       356457
       -
               setenv

     

       356458
       356458
       -
               stm

     

       356459
       356459
       -
               time

     

       356460
       356460
       -
               transformers

     

       356461
       356461
       -
             ];

     

       356462
       356462
       -
             description = "A version of Hspec which is used to test Hspec itself";

     

       356463
       356463
       -
             license = lib.licenses.mit;

     

       356464
       356464
       -
             hydraPlatforms = lib.platforms.none;

     

       356465
       356465
       -
             mainProgram = "hspec-meta-discover";

     

       356466
       355958
        
           }

     

       356467
       355959
        
         ) { };

     

       356468
       355960
        
       

     
···

       495260
       494752
        
             license = lib.licenses.mit;

     

       495261
       494753
        
             hydraPlatforms = lib.platforms.none;

     

       495262
       494754
        
             broken = true;

     

       495263
       495263
       -
           }

     

       495264
       495264
       -
         ) { };

     

       495265
       495265
       -
       

     

       495266
       495266
       -
         "optparse-applicative_0_15_1_0" = callPackage (

     

       495267
       495267
       -
           {

     

       495268
       495268
       -
             mkDerivation,

     

       495269
       495269
       -
             ansi-wl-pprint,

     

       495270
       495270
       -
             base,

     

       495271
       495271
       -
             bytestring,

     

       495272
       495272
       -
             process,

     

       495273
       495273
       -
             QuickCheck,

     

       495274
       495274
       -
             transformers,

     

       495275
       495275
       -
             transformers-compat,

     

       495276
       495276
       -
           }:

     

       495277
       495277
       -
           mkDerivation {

     

       495278
       495278
       -
             pname = "optparse-applicative";

     

       495279
       495279
       -
             version = "0.15.1.0";

     

       495280
       495280
       -
             sha256 = "1ws6y3b3f6hsgv0ff0yp6lw4hba1rps4dnvry3yllng0s5gngcsd";

     

       495281
       495281
       -
             revision = "1";

     

       495282
       495282
       -
             editedCabalFile = "0zmhqkd96v2z1ilhqdkd9z4jgsnsxb8yi2479ind8m5zm9363zr9";

     

       495283
       495283
       -
             libraryHaskellDepends = [

     

       495284
       495284
       -
               ansi-wl-pprint

     

       495285
       495285
       -
               base

     

       495286
       495286
       -
               process

     

       495287
       495287
       -
               transformers

     

       495288
       495288
       -
               transformers-compat

     

       495289
       495289
       -
             ];

     

       495290
       495290
       -
             testHaskellDepends = [

     

       495291
       495291
       -
               base

     

       495292
       495292
       -
               bytestring

     

       495293
       495293
       -
               QuickCheck

     

       495294
       495294
       -
             ];

     

       495295
       495295
       -
             description = "Utilities and combinators for parsing command line options";

     

       495296
       495296
       -
             license = lib.licenses.bsd3;

     

       495297
       495297
       -
             hydraPlatforms = lib.platforms.none;

     

       495298
       494755
        
           }

     

       495299
       494756
        
         ) { };

     

       495300
       494757

+9 -18

pkgs/top-level/haskell-packages.nix

···

       5
       5
        
         pkgs,

     

       6
       6
        
         newScope,

     

       7
       7
        
         stdenv,

     

       8
       8
       +
         config,

     

       8
       9
        
       }:

     

       9
       10
        
       

     

       10
       11
        
       let

     
···

       25
       26
        
           "ghc924Binary"

     

       26
       27
        
           "ghc963Binary"

     

       27
       28
        
           "ghc984Binary"

     

       28
       28
       -
           # ghcjs

     

       29
       29
       -
           "ghcjs"

     

       30
       30
       -
           "ghcjs810"

     

       31
       29
        
         ];

     

       32
       30
        
       

     

       33
       31
        
         haskellLibUncomposable = import ../development/haskell-modules/lib {

     
···

       460
       458
        
               llvmPackages = pkgs.llvmPackages_18;

     

       461
       459
        
             };

     

       462
       460
        
       

     

       463
       463
       -
             ghcjs = compiler.ghcjs810;

     

       464
       464
       -
             ghcjs810 = callPackage ../development/compilers/ghcjs/8.10 {

     

       465
       465
       -
               bootPkgs = bb.packages.ghc810;

     

       466
       466
       -
               ghcjsSrcJson = ../development/compilers/ghcjs/8.10/git.json;

     

       467
       467
       -
               stage0 = ../development/compilers/ghcjs/8.10/stage0.nix;

     

       468
       468
       -
             };

     

       469
       469
       -
       

     

       470
       461
        
             # The integer-simple attribute set contains all the GHC compilers

     

       471
       462
        
             # build with integer-simple instead of integer-gmp.

     

       472
       463
        
             integer-simple =

     
···

       494
       485
        
                   name: compiler.${name}.override { enableNativeBignum = true; }

     

       495
       486
        
                 )

     

       496
       487
        
               );

     

       488
       488
       +
           }

     

       489
       489
       +
           // pkgs.lib.optionalAttrs config.allowAliases {

     

       490
       490
       +
             ghcjs = throw "'haskell.compiler.ghcjs' has been removed. Please use 'pkgsCross.ghcjs' instead."; # Added 2025-09-06

     

       491
       491
       +
             ghcjs810 = throw "'haskell.compiler.ghcjs810' has been removed. Please use 'pkgsCross.ghcjs' instead."; # Added 2025-09-06

     

       497
       492
        
           }

     

       498
       493
        
         );

     

       499
       494
        
       

     
···

       647
       642
        
               compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.14.x.nix { };

     

       648
       643
        
             };

     

       649
       644
        
       

     

       650
       650
       -
             ghcjs = packages.ghcjs810;

     

       651
       651
       -
             ghcjs810 = callPackage ../development/haskell-modules rec {

     

       652
       652
       -
               buildHaskellPackages = ghc.bootPkgs;

     

       653
       653
       -
               ghc = bh.compiler.ghcjs810;

     

       654
       654
       -
               compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { };

     

       655
       655
       -
               packageSetConfig = callPackage ../development/haskell-modules/configuration-ghcjs-8.x.nix { };

     

       656
       656
       -
             };

     

       657
       657
       -
       

     

       658
       645
        
             # The integer-simple attribute set contains package sets for all the GHC compilers

     

       659
       646
        
             # using integer-simple instead of integer-gmp.

     

       660
       647
        
             integer-simple =

     
···

       687
       674
        
                   buildHaskellPackages = bh.packages.native-bignum.${name};

     

       688
       675
        
                 }

     

       689
       676
        
               );

     

       677
       677
       +
           }

     

       678
       678
       +
           // pkgs.lib.optionalAttrs config.allowAliases {

     

       679
       679
       +
             ghcjs = throw "'haskell.packages.ghcjs' has been removed. Please use 'pkgsCross.ghcjs' instead."; # Added 2025-09-06

     

       680
       680
       +
             ghcjs810 = throw "'haskell.packages.ghcjs810' has been removed. Please use 'pkgsCross.ghcjs' instead."; # Added 2025-09-06

     

       690
       681
        
           };

     

       691
       682
        
       }

-1

pkgs/top-level/release-cross.nix

···

       212
       212
        
       

     

       213
       213
        
         # Javascript

     

       214
       214
        
         ghcjs = mapTestOnCross systems.examples.ghcjs {

     

       215
       215
       -
           haskell.packages.ghcjs.hello = nativePlatforms;

     

       216
       215
        
           haskell.packages.native-bignum.ghcHEAD.hello = nativePlatforms;

     

       217
       216
        
           haskellPackages.hello = nativePlatforms;

     

       218
       217
        
         };

+1 -21

pkgs/top-level/release-haskell.nix

···

       238
       238
        
         jobs = recursiveUpdateMany [

     

       239
       239
        
           (mapTestOn {

     

       240
       240
        
             haskellPackages = packagePlatforms pkgs.haskellPackages;

     

       241
       241
       -
             haskell.compiler =

     

       242
       242
       -
               packagePlatforms pkgs.haskell.compiler

     

       243
       243
       -
               // (lib.genAttrs

     

       244
       244
       -
                 [

     

       245
       245
       -
                   "ghcjs"

     

       246
       246
       -
                   "ghcjs810"

     

       247
       247
       -
                 ]

     

       248
       248
       -
                 (ghcjsName: {

     

       249
       249
       -
                   # We can't build ghcjs itself, since it exceeds 3GB (Hydra's output limit) due

     

       250
       250
       -
                   # to the size of its bundled libs. We can however save users a bit of compile

     

       251
       251
       -
                   # time by building the bootstrap ghcjs on Hydra. For this reason, we overwrite

     

       252
       252
       -
                   # the ghcjs attributes in haskell.compiler with a reference to the bootstrap

     

       253
       253
       -
                   # ghcjs attribute in their bootstrap package set (exposed via passthru) which

     

       254
       254
       -
                   # would otherwise be ignored by Hydra.

     

       255
       255
       -
                   bootGhcjs = (packagePlatforms pkgs.haskell.compiler.${ghcjsName}.passthru).bootGhcjs;

     

       256
       256
       -
                 })

     

       257
       257
       -
               );

     

       258
       258
       -
       

     

       241
       241
       +
             haskell.compiler = packagePlatforms pkgs.haskell.compiler;

     

       259
       242
        
             tests.haskell = packagePlatforms pkgs.tests.haskell;

     

       260
       243
        
       

     

       261
       244
        
             nixosTests = {

     
···

       413
       396
        
                     # remove musl ghc865Binary since it is known to be broken and

     

       414
       397
        
                     # causes an evaluation error on darwin.

     

       415
       398
        
                     ghc865Binary = { };

     

       416
       416
       -
       

     

       417
       417
       -
                     ghcjs = { };

     

       418
       418
       -
                     ghcjs810 = { };

     

       419
       399
        
                   };

     

       420
       400
        
       

     

       421
       401
        
                   # Get some cache going for MUSL-enabled GHC.