iko/ghcjs-patch-master..aaf333d · haskell.nix

git.iko.soy/haskell.nix

305 files changed+1245−33304

unifiedsplit

.buildkite/pipeline.yml−6

@@ -44,9 +44,3 @@ steps:

4444 - nix build .#roots.x86_64-linux --option allow-import-from-derivation false

4545 agents:

4646 system: x86_64-linux

47−

48− - label: 'Check that evaluation of hydra jobs works without using remote builders'

49− command:

50− - nix-instantiate release.nix -A required-unstable-ghc8107-x86_64-darwin-native --show-trace --builders ''

51− agents:

52− system: x86_64-linux

.github/workflows/rebase.yamldeleted−28

@@ -1,28 +0,0 @@

1−name: Rebase on iohk/haskell.nix

2−

3−on:

4− schedule:

5− - cron: 0 0 * * *

6−

7−jobs:

8− Linux:

9− runs-on: ubuntu-latest

10− steps:

11− - uses: actions/checkout@v2.4.0

12− with:

13− fetch-depth: 0

14− - name: Rebase and push

15− run: |

16− git config --global user.name "GitHub Actions"

17−

18−

19− git remote add iohk https://github.com/input-output-hk/haskell.nix.git

20− git fetch iohk

21−

22− git checkout iko/ghcjs-patch-master

23− git rebase iohk/master

24− git push --force

25−

26− git checkout --track origin/master

27− git reset --hard iohk/master

28− git push --force

README.md−16

@@ -1,19 +1,3 @@

1−# What is this fork?

2−

3−This fork contains a patched version of GHCJS 8.10 which improves performance and memory usage.

4−

5−For more info see this PR: https://github.com/input-output-hk/haskell.nix/pull/1306

6−

7−## Package versions

8−

9−This branch is updated every day with commits from https://github.com/input-output-hk/haskell.nix/tree/master. This means that it receives all of the updates the initial project does.

10−

11−## Caching

12−

13−Building the patched compiler itself takes around 2-3 hours. The [Typeable](https://typeable.io) public nix cache probably has a cached version of the compiler. You can follow these instruction to set it up: [app.cachix.org/organization/typeable/cache/typeable](https://app.cachix.org/organization/typeable/cache/typeable).

14−

15−---

16−

171# `haskell.nix` is infrastructure for building Haskell packages with Nix

182

193[![](https://badge.buildkite.com/d453edcd29bd2f8f3f3b32c9b7d6777a33773d9671c37a6ccc.svg?branch=master)](https://buildkite.com/input-output-hk/haskell-dot-nix)

build.nix+6−8

@@ -8,9 +8,8 @@ in

88{ nixpkgs ? haskellNix.sources.nixpkgs-2111

99, nixpkgsArgs ? haskellNix.nixpkgsArgs

1010, pkgs ? import nixpkgs nixpkgsArgs

11−, evalPackages ? import nixpkgs nixpkgsArgs

1211, nixpkgsForHydra ? haskellNix.sources.nixpkgs-2105

13−, pkgsForHydra ? import nixpkgsForHydra (nixpkgsArgs // { inherit (pkgs) system; })

12+, pkgsForHydra ? import nixpkgsForHydra nixpkgsArgs

1413, ifdLevel ? 1000

1514, compiler-nix-name ? throw "No `compiler-nix-name` passed to build.nix"

1615}:

@@ -20,13 +19,12 @@ let

2019 buildHaskell = pkgs.buildPackages.haskell-nix;

2120 tool = buildHaskell.tool;

2221in rec {

23− tests = import ./test/default.nix { inherit pkgs evalPackages ifdLevel compiler-nix-name; };

22+ tests = import ./test/default.nix { inherit pkgs ifdLevel compiler-nix-name; };

2423

2524 tools = pkgs.lib.optionalAttrs (ifdLevel >= 3) (

2625 pkgs.recurseIntoAttrs ({

27− cabal-latest = tool compiler-nix-name "cabal" { inherit evalPackages; };

26+ cabal-latest = tool compiler-nix-name "cabal" "latest";

2827 hlint-latest = tool compiler-nix-name "hlint" {

29− inherit evalPackages;

3028 version = {

3129 "ghc865" = "3.2.8";

3230 "ghc882" = "3.3.6";

@@ -34,8 +32,8 @@ in rec {

3432 "ghc884" = "3.3.6";

3533 }.compiler-nix-name or "latest";

3634 };

37− } // pkgs.lib.optionalAttrs (!__elem compiler-nix-name ["ghc921" "ghc922" "ghc923" "ghc924"]) {

38− hls-latest = tool compiler-nix-name "haskell-language-server" { inherit evalPackages; };

35+ } // pkgs.lib.optionalAttrs (!__elem compiler-nix-name ["ghc921" "ghc922" "ghc923"]) {

36+ hls-latest = tool compiler-nix-name "haskell-language-server" "latest";

3937 })

4038 );

4139

@@ -87,7 +85,7 @@ in rec {

8785 # These are pure parts of maintainer-script so they can be built by hydra

8886 # and added to the cache to speed up buildkite.

8987 maintainer-script-cache = pkgs.recurseIntoAttrs (

90− (pkgs.lib.optionalAttrs (pkgsForHydra.system == "x86_64-linux") {

88+ (pkgs.lib.optionalAttrs pkgs.stdenv.hostPlatform.isLinux {

9189 inherit (maintainer-scripts) check-hydra;

9290 })

9391 // (pkgs.lib.optionalAttrs (ifdLevel > 2) {

builder/comp-builder.nix+2−27

@@ -50,7 +50,6 @@ let self =

5050, writeHieFiles ? component.writeHieFiles

5151

5252, ghcOptions ? component.ghcOptions

53−, contentAddressed ? component.contentAddressed

5453

5554# Options for Haddock generation

5655, doHaddock ? component.doHaddock # Enable haddock and hoogle generation

@@ -317,13 +316,7 @@ let

317316 componentDrv = drv;

318317 };

319318

320− contentAddressedAttrs = lib.optionalAttrs contentAddressed {

321− __contentAddressed = true;

322− outputHashMode = "recursive";

323− outputHashAlgo = "sha256";

324− };

325−

326− drv = stdenv.mkDerivation (commonAttrs // contentAddressedAttrs // {

319+ drv = stdenv.mkDerivation (commonAttrs // {

327320 pname = nameOnly;

328321 inherit (package.identifier) version;

329322

@@ -356,14 +349,6 @@ let

356349 description = package.synopsis or "";

357350 license = haskellLib.cabalToNixpkgsLicense package.license;

358351 platforms = if platforms == null then lib.platforms.all else platforms;

359− } // lib.optionalAttrs (haskellLib.isExecutableType componentId) {

360− # Set main executable name for executable components, so that `nix run` in

361− # nix flakes will work correctly. When not set, `nix run` would (typically

362− # erroneously) deduce the executable name from the derivation name and

363− # attempt to run, for example,

364− # `/nix/store/...-project-exe-app-0.1.0.0/bin/project-exe-app` instead of

365− # `/nix/store/...-project-exe-app-0.1.0.0/bin/app`.

366− mainProgram = exeName;

367352 };

368353

369354 propagatedBuildInputs =

@@ -420,17 +405,7 @@ let

420405 (lib.optionalString stdenv.hostPlatform.isWindows ''

421406 export pkgsHostTargetAsString="''${pkgsHostTarget[@]}"

422407 '') +

423− # The following could be refactored but would lead to many rebuilds

424−

425− # In case of content addressed components we need avoid parallel building (passing -j1)

426− # in order to have a deterministic output and therefore avoid potential situations

427− # where the binary cache becomes useless

428− # See also https://gitlab.haskell.org/ghc/ghc/-/issues/12935

429− (if contentAddressed then ''

430− runHook preBuild

431− $SETUP_HS build ${haskellLib.componentTarget componentId} -j1 ${lib.concatStringsSep " " setupBuildFlags}

432− runHook postBuild

433− '' else if stdenv.hostPlatform.isGhcjs then ''

408+ (if stdenv.hostPlatform.isGhcjs then ''

434409 runHook preBuild

435410 # https://gitlab.haskell.org/ghc/ghc/issues/9221

436411 $SETUP_HS build ${haskellLib.componentTarget componentId} ${lib.concatStringsSep " " setupBuildFlags}

builder/default.nix+2−3

@@ -1,4 +1,4 @@

1−{ pkgs, buildPackages, evalPackages, stdenv, lib, haskellLib, ghc, compiler-nix-name, fetchurl, pkgconfig, nonReinstallablePkgs, hsPkgs, compiler }:

1+{ pkgs, buildPackages, stdenv, lib, haskellLib, ghc, compiler-nix-name, fetchurl, pkgconfig, nonReinstallablePkgs, hsPkgs, compiler }:

33let

44 # Builds a single component of a package.

@@ -46,7 +46,6 @@ let

4646 hoogleLocal = let

4747 nixpkgsHoogle = import (pkgs.path + /pkgs/development/haskell-modules/hoogle.nix);

4848 in { packages ? [], hoogle ? pkgs.buildPackages.haskell-nix.tool "ghc8107" "hoogle" {

49− inherit evalPackages;

5049 version = "5.0.18.3";

5150 index-state = pkgs.haskell-nix.internalHackageIndexState;

5251 }

@@ -67,7 +66,7 @@ let

6766

6867 # Same as haskellPackages.shellFor in nixpkgs.

6968 shellFor = haskellLib.weakCallPackage pkgs ./shell-for.nix {

70− inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib buildPackages evalPackages compiler;

69+ inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib buildPackages compiler;

7170 inherit (buildPackages) glibcLocales;

7271 };

7372

builder/hspkg-builder.nix+25−22

@@ -39,28 +39,37 @@ let

3939

4040 defaultSetupSrc = if stdenv.hostPlatform.isGhcjs then ./Setup.ghcjs.hs else ./Setup.hs;

4141

42− # This is the `Cabal` library that was built for `cabal-install` to use.

43− # It makes sense to use this version (when possible) because it will match the behavior of

44− # building with `cabal-install` (including fixes that may not be in the

45− # version of Cabal bundled with GHC).

46− cabalFromCabalInstall = buildPackages.haskell-nix.cabal-install-unchecked.${compiler-nix-name}.project.hsPkgs.Cabal.components.library;

42+ # Get the Cabal lib used to build `cabal-install`.

43+ # To avoid infinite recursion we have to leave this out for packages

44+ # needed to build `cabal-install`.

45+ # We always do this for ghcjs as the patched version of Cabal is needed.

46+ cabalLibDepends = lib.optional (

47+ stdenv.hostPlatform.isGhcjs || (

48+ !builtins.elem package.identifier.name

49+ ["nix-tools" "alex" "happy" "hscolour" "Cabal" "bytestring" "aeson" "time"

50+ "filepath" "base-compat-batteries" "base-compat" "unix" "directory" "transformers"

51+ "containers" "binary" "mtl" "text" "process" "parsec"]

52+ )

53+ )

54+ buildPackages.haskell-nix.cabal-install-unchecked.${compiler-nix-name}.project.hsPkgs.Cabal.components.library;

4755

48− # Check there is no chance we are building `cabalFromCabalInstall`. Using `cabalFromCabalInstall`

49− # to build itseld would cause infinite recursion.

50− useCabalFromCabalInstall =

51− # `cabalFromCabalInstall` is not cross compiled

52− stdenv.buildPlatform != stdenv.hostPlatform

53− ||

54− # These are the dependencies of `Cabal`

56+ # This logic is needed so that we don't get duplicate packages if we

57+ # add a custom Cabal package to the dependencies. That way custom

58+ # setups won't complain about e.g. binary from the Cabal dependencies

59+ # and binary from the global package-db.

60+ nonReinstallablePkgs = if (

61+ stdenv.hostPlatform.isGhcjs || (

5562 !builtins.elem package.identifier.name

5663 ["nix-tools" "alex" "happy" "hscolour" "Cabal" "bytestring" "aeson" "time"

5764 "filepath" "base-compat-batteries" "base-compat" "unix" "directory" "transformers"

58− "containers" "binary" "mtl" "text" "process" "parsec"];

65+ "containers" "binary" "mtl" "text" "process" "parsec"]

66+ )

67+ ) then [] else null;

5968

6069 defaultSetup = setup-builder ({

6170 name = "${ghc.targetPrefix}default-Setup";

6271 component = {

63− depends = config.setup-depends ++ lib.optional useCabalFromCabalInstall cabalFromCabalInstall;

72+ depends = config.setup-depends ++ cabalLibDepends;

6473 libs = [];

6574 frameworks = [];

6675 doExactConfig = false;

@@ -94,13 +103,7 @@ let

94103 cat ${defaultSetupSrc} > $out/Setup.hs

95104 '';

96105 inherit defaultSetupSrc;

97− } // lib.optionalAttrs useCabalFromCabalInstall {

98− # This is needed so that we don't get duplicate packages when we

99− # add a custom Cabal package to the dependencies. That way custom

100− # setups won't complain about e.g. binary from the Cabal dependencies

101− # and binary from the global package-db.

102− nonReinstallablePkgs = [];

103− });

106+ } // (if nonReinstallablePkgs == null then {} else { inherit nonReinstallablePkgs; }));

104107

105108 # buildPackages.runCommand "default-Setup" { nativeBuildInputs = [(ghc.passthru.buildGHC or ghc)]; } ''

106109 # cat ${defaultSetupSrc} > Setup.hs

@@ -131,7 +134,7 @@ in rec {

131134 checks = pkgs.recurseIntoAttrs (builtins.mapAttrs

132135 (_: d: haskellLib.check d)

133136 (lib.filterAttrs (_: d: d.config.doCheck) components.tests));

134− inherit (package) identifier detailLevel isLocal isProject buildType;

137+ inherit (package) identifier detailLevel isLocal isProject;

135138 inherit setup cabalFile;

136139 isHaskell = true;

137140 inherit src;

builder/setup-builder.nix+4−3

@@ -76,12 +76,13 @@ let

7676 for f in Setup.hs Setup.lhs; do

7777 if [ -f $f ]; then

7878 echo Compiling package $f

79− ghc $f -threaded ${if includeGhcPackage then "-package ghc " else ""

80− }-package-db ${configFiles}/${configFiles.packageCfgDir} --make -o ./Setup

79+ ghc $f -threaded '' + (if includeGhcPackage then "-package ghc " else "")

80+ + ''-package-db ${configFiles}/${configFiles.packageCfgDir} --make -o ./Setup

81+ setup=$(pwd)/Setup

8182 fi

8283 done

8384 [ -f ./Setup ] || (echo Failed to build Setup && exit 1)

84− runHook postBuild

85+ runHook preBuild

8586 '';

8687

8788 installPhase = ''

builder/shell-for.nix+5−13

@@ -1,4 +1,4 @@

1−{ lib, stdenv, mkShell, glibcLocales, pkgconfig, ghcForComponent, makeConfigFiles, hsPkgs, hoogleLocal, haskellLib, buildPackages, evalPackages, compiler }:

1+{ lib, stdenv, mkShell, glibcLocales, pkgconfig, ghcForComponent, makeConfigFiles, hsPkgs, hoogleLocal, haskellLib, buildPackages, compiler }:

33{ # `packages` function selects packages that will be worked on in the shell itself.

44 # These packages will not be built by `shellFor`, but their

@@ -71,12 +71,9 @@ let

7171 removeSelectedInputs =

7272 lib.filter (input: !(isSelectedComponent input));

7373

74− # The configs of all the selected components.

75− # This excludes the `setup` dependencies of `Simple` packages, because

76− # `cabal-install` does not build a `Setup` executable for `Simple` packages.

74+ # The configs of all the selected components

7775 selectedConfigs = map (c: c.config) selectedComponents

78− ++ lib.optionals packageSetupDeps (map (p: p.setup.config)

79− (lib.filter (p: p.buildType != "Simple") selectedPackages));

76+ ++ lib.optionals packageSetupDeps (map (p: p.setup.config) selectedPackages);

8077

8178 name = if lib.length selectedPackages == 1

8279 then "ghc-shell-for-${(lib.head selectedPackages).identifier.name}"

@@ -133,12 +130,7 @@ let

133130 # inherit (hsPkgs) hoogle;

134131 } // (

135132 lib.optionalAttrs (args ? tools && args.tools ? hoogle) {

136− hoogle = buildPackages.haskell-nix.hackage-tool (

137− haskellLib.versionOrModToMods args.tools.hoogle ++ [{

138− name = "hoogle";

139− compiler-nix-name = compiler.nix-name;

140− inherit evalPackages;

141− }]);

133+ hoogle = buildPackages.haskell-nix.tool compiler.nix-name "hoogle" args.tools.hoogle;

142134 }

143135 ));

144136

@@ -152,7 +144,7 @@ in

152144 nativeBuildInputs = [ ghcEnv ]

153145 ++ nativeBuildInputs

154146 ++ mkDrvArgs.nativeBuildInputs or []

155− ++ lib.attrValues (buildPackages.haskell-nix.tools' evalPackages compiler.nix-name tools)

147+ ++ lib.attrValues (buildPackages.haskell-nix.tools compiler.nix-name tools)

156148 # If this shell is a cross compilation shell include

157149 # wrapper script for running cabal build with appropriate args.

158150 # Includes `--with-compiler` in case the `cabal.project` file has `with-compiler:` in it.

changelog.md−26

@@ -1,32 +1,6 @@

11This file contains a summary of changes to Haskell.nix and `nix-tools`

22that will impact users.

4−## Jul 27, 2022

5−* Removed reliance on `builtins.currentSystem`. It was used it to provide

6− `pkgs.evalPackages` via an overlay that it used to run derivations

7− used in imports from derivation (IFDs).

8−

9− These derivations are now run on `buildPackages` by default.

10−

11− Passsing `evalPackages` to a project function will change where all the

12− derivations used in IFDs are run for that project (including shell tools):

13− evalPackages = import nixpkgs haskellNix.nixpkgsArgs;

14−

15− Passing `evalSystem` instead will use create a suitable `nixpkgs` using `pkgs.path`

16− and `pkgs.overlay`:

17− evalSystem = "x86_64-linux";

18− or

19− evalSystem = builtins.currentSystem;

20−

21− The `haskellLib.cleanGit` function is also affected by this change. If you are cross

22− compiling and using `cleanGit` you should probably do something like:

23− pkgs = import nixpkgs haskellNix.nixpkgsArgs;

24− evalPackages = import nixpkgs (haskellNix.nixpkgsArgs // { system = evalSystem; });

25− p = pkgs.pkgsCross.mingwW64.haskell-nix.cabalProject {

26− inherit evalPackages;

27− src = evalPackages.haskell-nix.haskellLib.cleanGit { src = ./.; };

28− };

29−

304## Feb 16, 2022

315* Removed lookupSha256 argument from project functions.

326 Pass a `sha256map` instead.

ci.nix+13−22

@@ -11,17 +11,10 @@

1111 inherit (pkgs.haskell-nix) sources;

1212 nixpkgsVersions = {

1313 "R2111" = "nixpkgs-2111";

14− "R2205" = "nixpkgs-2205";

1514 "unstable" = "nixpkgs-unstable";

1615 };

17− haskellNix = import ./default.nix { inherit checkMaterialization; };

18− nixpkgsArgs = haskellNix.nixpkgsArgs // {

19− # Needed for dwarf tests

20− config = haskellNix.nixpkgsArgs.config // {

21− permittedInsecurePackages = ["libdwarf-20210528" "libdwarf-20181024" "dwarfdump-20181024"];

22− };

23− };

2416 compilerNixNames = nixpkgsName: nixpkgs: builtins.mapAttrs (compiler-nix-name: runTests: {

17+ inherit (import ./default.nix { inherit checkMaterialization; }) nixpkgsArgs;

2518 inherit runTests;

2619 }) (

2720 # GHC version to cache and whether to run the tests against them.

@@ -33,15 +26,12 @@

3326 nixpkgs.lib.optionalAttrs (nixpkgsName == "R2111") {

3427 ghc865 = false;

3528 ghc8107 = true;

36− } // nixpkgs.lib.optionalAttrs (nixpkgsName == "R2205") {

37− ghc865 = false;

38− ghc8107 = true;

3929 } // nixpkgs.lib.optionalAttrs (nixpkgsName == "unstable") {

4030 ghc865 = false;

4131 ghc884 = false; # Native version is used to boot 9.0.1

4232 ghc8107 = true;

4333 ghc902 = true;

44− ghc924 = true;

34+ ghc923 = true;

4535 });

4636 systems = nixpkgsName: nixpkgs: compiler-nix-name: nixpkgs.lib.genAttrs (

4737 nixpkgs.lib.filter (v:

@@ -62,14 +52,14 @@

6252 # of 'lib.systems.examples' are not understood between all versions

6353 let lib = nixpkgs.lib;

6454 in lib.optionalAttrs (nixpkgsName == "unstable"

65− && ((system == "x86_64-linux" && __elem compiler-nix-name ["ghc865" "ghc884" "ghc8107"])

55+ && ((system == "x86_64-linux" && __elem compiler-nix-name ["ghc865" "ghc884" "ghc8107"])

6656 || (system == "x86_64-darwin" && __elem compiler-nix-name ["ghc8107"]))) {

6757 inherit (lib.systems.examples) ghcjs;

6858 } // lib.optionalAttrs (nixpkgsName == "unstable"

69− && ((system == "x86_64-linux" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc924"])

59+ && ((system == "x86_64-linux" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc923"])

7060 || (system == "x86_64-darwin" && __elem compiler-nix-name []))) { # TODO add ghc versions when we have more darwin build capacity

7161 inherit (lib.systems.examples) mingwW64;

72− } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc922" "ghc923" "ghc924"]) {

62+ } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc922" "ghc923"]) {

7363 # Musl cross only works on linux

7464 # aarch64 cross only works on linux

7565 inherit (lib.systems.examples) musl64 aarch64-multiplatform;

@@ -78,11 +68,12 @@

7868in

7969dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:

8070 let pinnedNixpkgsSrc = sources.${nixpkgs-pin};

81− evalPackages = import pinnedNixpkgsSrc nixpkgsArgs;

82− in dimension "GHC version" (compilerNixNames nixpkgsName evalPackages) (compiler-nix-name: {runTests}:

83− dimension "System" (systems nixpkgsName evalPackages compiler-nix-name) (systemName: system:

71+ # We need this for generic nixpkgs stuff at the right version

72+ genericPkgs = import pinnedNixpkgsSrc {};

73+ in dimension "GHC version" (compilerNixNames nixpkgsName genericPkgs) (compiler-nix-name: {nixpkgsArgs, runTests}:

74+ dimension "System" (systems nixpkgsName genericPkgs compiler-nix-name) (systemName: system:

8475 let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system; });

85− build = import ./build.nix { inherit pkgs evalPackages ifdLevel compiler-nix-name; };

76+ build = import ./build.nix { inherit pkgs ifdLevel compiler-nix-name; };

8677 platformFilter = platformFilterGeneric pkgs system;

8778 in filterAttrsOnlyRecursive (_: v: platformFilter v && !(isDisabled v)) ({

8879 # Native builds

@@ -95,14 +86,14 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:

9586 } // pkgs.lib.optionalAttrs (ifdLevel >= 1) {

9687 iserv-proxy = pkgs.ghc-extra-projects."${compiler-nix-name}".getComponent "iserv-proxy:exe:iserv-proxy";

9788 } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {

98− hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; inherit evalPackages compiler-nix-name; }).getComponent "exe:hello";

89+ hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; inherit compiler-nix-name; }).getComponent "exe:hello";

9990 });

10091 }

10192 //

102− dimension "Cross system" (crossSystems nixpkgsName evalPackages compiler-nix-name system) (crossSystemName: crossSystem:

93+ dimension "Cross system" (crossSystems nixpkgsName genericPkgs compiler-nix-name system) (crossSystemName: crossSystem:

10394 # Cross builds

10495 let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system crossSystem; });

105− build = import ./build.nix { inherit pkgs evalPackages ifdLevel compiler-nix-name; };

96+ build = import ./build.nix { inherit pkgs ifdLevel compiler-nix-name; };

10697 in pkgs.recurseIntoAttrs (pkgs.lib.optionalAttrs (ifdLevel >= 1) ({

10798 roots = pkgs.haskell-nix.roots' compiler-nix-name ifdLevel;

10899 ghc = pkgs.buildPackages.haskell-nix.compiler."${compiler-nix-name}";

compiler/ghc/default.nix+8−35

@@ -13,9 +13,7 @@ let self =

1313, autoreconfHook

1414, bash

1515

16−, libiconv ? null

17−

18−, ncurses # TODO remove this once the cross compilers all work without

16+, libiconv ? null, ncurses

1917

2018, installDeps

2119

@@ -31,9 +29,6 @@ let self =

3129, # If enabled, GHC will be built with the GPL-free but slower integer-simple

3230 # library instead of the faster but GPLed integer-gmp library.

3331 enableIntegerSimple ? !(lib.any (lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms), gmp

34−, # If enabled, GHC will be built with the GPL-free native backend of the

35− # bignum library that is nearly as fast as GMP

36− enableNativeBignum ? !((lib.any (lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms) || enableIntegerSimple)

3732

3833, # If enabled, use -fPIC when compiling static libs.

3934 enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform && !stdenv.targetPlatform.isAarch32

@@ -46,9 +41,8 @@ let self =

4641

4742, enableDWARF ? false

4843

49−, enableTerminfo ?

50− # Terminfo does not work on older ghc cross arm and windows compilers

51− (!haskell-nix.haskellLib.isCrossTarget || !(stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isWindows) || builtins.compareVersions ghc-version "8.10" >= 0)

44+, # Whether to build terminfo. Musl fails to build terminfo as ncurses seems to be linked to glibc

45+ enableTerminfo ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.isMusl

5246

5347, # Wheter to build in NUMA support

5448 enableNUMA ? true

@@ -74,11 +68,7 @@ let self =

7468, extra-passthru ? {}

7569}@args:

7670

77−assert !(enableIntegerSimple || enableNativeBignum) -> gmp != null;

78−

79−# Early check to make sure only one of these is enabled

80−assert enableNativeBignum -> !enableIntegerSimple;

81−assert enableIntegerSimple -> !enableNativeBignum;

71+assert !enableIntegerSimple -> gmp != null;

8272

8373let

8474 inherit (stdenv) buildPlatform hostPlatform targetPlatform;

@@ -86,17 +76,6 @@ let

8676

8777 inherit (bootPkgs) ghc;

8878

89− ghcHasNativeBignum = builtins.compareVersions ghc-version "9.0" >= 0;

90−

91− bignumSpec =

92− assert ghcHasNativeBignum -> !enableIntegerSimple;

93− assert !ghcHasNativeBignum -> !enableNativeBignum;

94− if ghcHasNativeBignum then ''

95− BIGNUM_BACKEND = ${if enableNativeBignum then "native" else "gmp"}

96− '' else ''

97− INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}

98− '';

99−

10079 # TODO check if this possible fix for segfaults works or not.

10180 targetLibffi =

10281 # on native platforms targetPlatform.{libffi, gmp} do not exist; thus fall back

@@ -124,7 +103,7 @@ let

124103 include mk/flavours/\$(BuildFlavour).mk

125104 endif

126105 DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}

127− '' + bignumSpec + ''

106+ INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}

128107 EXTRA_HADDOCK_OPTS += --quickjump --hyperlinked-source

129108 '' + lib.optionalString (targetPlatform != hostPlatform) ''

130109 CrossCompilePrefix = ${targetPrefix}

@@ -139,10 +118,6 @@ let

139118 '' + lib.optionalString enableRelocatedStaticLibs ''

140119 GhcLibHcOpts += -fPIC

141120 GhcRtsHcOpts += -fPIC

142− GhcRtsCcOpts += -fPIC

143− '' + lib.optionalString (enableRelocatedStaticLibs && targetPlatform.isx86_64 && !targetPlatform.isWindows) ''

144− GhcLibHcOpts += -fexternal-dynamic-refs

145− GhcRtsHcOpts += -fexternal-dynamic-refs

146121 '' + lib.optionalString enableDWARF ''

147122 GhcLibHcOpts += -g3

148123 GhcRtsHcOpts += -g3

@@ -169,13 +144,11 @@ let

169144 '';

170145

171146 # Splicer will pull out correct variations

172− libDeps = platform: lib.optional enableTerminfo [ targetPackages.ncurses targetPackages.ncurses.dev ]

147+ libDeps = platform: lib.optional enableTerminfo [ ncurses ncurses.dev ]

173148 ++ [targetLibffi]

174149 ++ lib.optional (!enableIntegerSimple) gmp

175150 ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv

176− ++ lib.optional (enableNUMA && platform.isLinux && !platform.isAarch32 && !platform.isAndroid) numactl

177− # Even with terminfo disabled some older ghc cross arm and windows compilers do not build unless `ncurses` is found and they seem to want the buildPlatform version

178− ++ lib.optional (!enableTerminfo && haskell-nix.haskellLib.isCrossTarget && (stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isWindows) && builtins.compareVersions ghc-version "8.10" < 0) ncurses.dev;

151+ ++ lib.optional (enableNUMA && platform.isLinux && !platform.isAarch32 && !platform.isAndroid) numactl;

179152

180153 toolsForTarget =

181154 if hostPlatform == buildPlatform then

@@ -267,7 +240,7 @@ stdenv.mkDerivation (rec {

267240 # `--with` flags for libraries needed for RTS linker

268241 configureFlags = [

269242 "--datadir=$doc/share/doc/ghc"

270− "--with-curses-includes=${targetPackages.ncurses.dev}/include" "--with-curses-libraries=${targetPackages.ncurses.out}/lib"

243+ "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"

271244 ] ++ lib.optionals (targetLibffi != null) ["--with-system-libffi" "--with-ffi-includes=${targetLibffi.dev}/include" "--with-ffi-libraries=${targetLibffi.out}/lib"

272245 ] ++ lib.optional (!enableIntegerSimple) [

273246 "--with-gmp-includes=${targetGmp.dev}/include" "--with-gmp-libraries=${targetGmp.out}/lib"

compiler/ghcjs/ghcjs.nix+1−8

@@ -7,7 +7,6 @@

77 then "ghc884"

88 else "ghc865"

99, ghc ? pkgs.buildPackages.ghc

10−, overrideBootPackages ? [] # adds if not present, overrides if present.

1110}:

1211let

1312 isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" >= 0;

@@ -15,14 +14,8 @@ let

1514

1615 project = pkgs.buildPackages.haskell-nix.ghcjsProject {

1716 src = ghcjsSrc;

18− inherit ghcjsVersion compiler-nix-name overrideBootPackages;

17+ inherit ghcjsVersion compiler-nix-name;

1918 index-state = "2020-04-25T00:00:00Z";

20− patches = if isGhcjs810

21− then [

22− ./patches/810/fast-weak.patch

23− ./patches/810/boot-optimization-flags.patch

24− ]

25− else [];

2619# plan-sha256 = "1wy2lr08maxyi7r8jiwf2gj6pdayk5vxxwh42bj4s2gg4035z0yc";

2720# materialized = ../../materialized/ghcjs;

2821 };

compiler/ghcjs/ghcjs810-patched-boot-packages/aeson.patchdeleted−13

@@ -1,13 +0,0 @@

1−diff --git a/aeson.cabal b/aeson.cabal

2−index a0ebd59..552f160 100755

3−--- a/aeson.cabal

4−+++ b/aeson.cabal

5−@@ -150,7 +150,7 @@ library

6− dlist >= 0.8.0.4 && < 0.9,

7− hashable >= 1.2.7.0 && < 1.4,

8− scientific >= 0.3.6.2 && < 0.4,

9−- th-abstraction >= 0.2.8.0 && < 0.4,

10−+ th-abstraction >= 0.2.8.0 && < 0.5,

11− uuid-types >= 1.0.3 && < 1.1,

12− vector >= 0.12.0.1 && < 0.13

13−

compiler/ghcjs/ghcjs810-patched-boot-packages/default.nixdeleted−176

@@ -1,176 +0,0 @@

1−{ pkgs

2−, ...

3−}:

4−let

5− patch = p: path: pkgs.runCommand "patched" { buildInputs = [ pkgs.gnupatch ]; } ''

6− cp -r ${path} $out

7− chmod -R +w $out

8− cd $out

9− patch -p1 <${p}

10− '';

11− getSubdir = d: path: pkgs.runCommand "subdir" { } ''

12− cp -r ${path}/${d} $out

13− '';

14−in

15−[

16− {

17− name = "primitive";

18− src = pkgs.fetchgit {

19− url = "https://github.com/haskell/primitive.git";

20− rev = "11ff865fd2157a1dfd7dfd525b1cf27e1a300633";

21− sha256 = "1skim1vlmf0v4ixm8h8ja3m1pz0h10xrfdh1rfzawsy8rvrp2cc0";

22− };

23− }

24− {

25− name = "dlist";

26− src = pkgs.fetchgit {

27− url = "https://github.com/spl/dlist.git";

28− rev = "567cfeb2f5da30f2e5faf167895b3ee04c698ca0";

29− sha256 = "0b8ij3ls7bccbp9rlm8dnflnf1wim9xsg42wmirvwxwmh2c0r0hg";

30− };

31− }

32− {

33− name = "vector";

34− src = pkgs.fetchgit {

35− url = "https://github.com/haskell/vector.git";

36− rev = "de10fd281fa5d8beee3623e809a71385a5ef6864";

37− sha256 = "09vhbvrkw90xgqfrybmhy120rwcy4snw2f97004alr3n96lwpg1q";

38− };

39− }

40− {

41− name = "ghcjs-base";

42− src = patch ./ghcjs-base.patch (pkgs.fetchgit {

43− url = "https://github.com/ghcjs/ghcjs-base.git";

44− rev = "85e31beab9beffc3ea91b954b61a5d04e708b8f2";

45− sha256 = "15fdkjv0l7hpbbsn5238xxgzfdg61g666nzbv2sgxkwryn5rycv0";

46− });

47− }

48− {

49− name = "text";

50− src = pkgs.fetchgit {

51− url = "https://github.com/dfordivam/text.git";

52− rev = "126174753ea8e5f45df8fcbba609e3f1c453bf27";

53− sha256 = "0l7nbln2w77s12fm4ybhi0jsfnxkyiwskfx3b682pfisa6n32rgm";

54− };

55− }

56− {

57− name = "hashable";

58− src = patch ./hashable.patch (pkgs.fetchgit {

59− url = "https://github.com/haskell-unordered-containers/hashable.git";

60− rev = "819fdbeaeeb62ed1344fb057de17fa29b10fa3e1";

61− sha256 = "0xnwfwnnh0bxq16wx0qmdakvgvj8i22km3bhvvki15rd9jil04cc";

62− });

63− }

64− {

65− name = "integer-logarithms";

66− src = pkgs.fetchgit {

67− url = "https://github.com/haskellari/integer-logarithms.git";

68− rev = "df09cef2c8eb0d5899e2bcccee2a4fad413bdc11";

69− sha256 = "1k17hjnjmy44dfywx9nr804qiqmjjhkpfpll5bsfvzvpnl5r75nj";

70− };

71− }

72− {

73− name = "scientific";

74− src = pkgs.fetchgit {

75− url = "https://github.com/basvandijk/scientific.git";

76− rev = "1d049cdf04e2d92ab187754044b0df933c5e6b0d";

77− sha256 = "1v4fmfq8hyhdb5ck5r2b45s1izr7hx97v4g7s597ajbv72ldvilq";

78− };

79− }

80− {

81− name = "attoparsec";

82− src = pkgs.fetchgit {

83− url = "https://github.com/dfordivam/attoparsec.git";

84− rev = "cbfb944aeff61144059a28ada93c579e93ccf7d2";

85− sha256 = "0bbr4943439sy3grwpwbna4mk7iv87ijaiv3jjfhxhp7y67z51h8";

86− };

87− }

88− {

89− name = "splitmix";

90− src = pkgs.fetchgit {

91− url = "https://github.com/haskellari/splitmix.git";

92− rev = "d8c1b57bb75178675423f87b1ff58429f37bc9fe";

93− sha256 = "1m8v439vlwqpqw28dbr04n6m0j2cfb169ly285lp0bjmzcwlr289";

94− };

95− }

96− {

97− name = "random";

98− src = pkgs.fetchgit {

99− url = "https://github.com/haskell/random.git";

100− rev = "8c59bd0fda84fa581d53069b45100d810f5a778f";

101− sha256 = "1drdipfbmpg2g2cdrnq1k8yysh86i7ljwm6zkrrs3g8l47n4ha4d";

102− };

103− }

104− {

105− name = "uuid-types";

106− src = getSubdir "uuid-types" (pkgs.fetchgit {

107− url = "https://github.com/haskell-hvr/uuid.git";

108− rev = "e8dc7126582ba4d3abc5e0f26dc1d8477caab01e";

109− sha256 = "037cnfz7rhkw383rn117b994jzs93i3bwdv47x5qiza5h5syd76f";

110− });

111− }

112− {

113− name = "unordered-containers";

114− src = pkgs.fetchgit {

115− url = "https://github.com/haskell-unordered-containers/unordered-containers.git";

116− rev = "db9ddde2b243366976a1bdfbb12a5e257ca762c3";

117− sha256 = "1wd5hxppj1gg9fa1ihcn3s2y0i70ykv2sf8sym6dlf3r4snda9zi";

118− };

119− }

120− {

121− name = "base-orphans";

122− src = pkgs.fetchgit {

123− url = "https://github.com/haskell-compat/base-orphans.git";

124− rev = "1af3a3512efbcc12e0c34637a0e433ab6e195932";

125− sha256 = "14b6qwc3dbnmrhqk66a2cn4pvv3nf6kb3h7ym1hjn5xs7n62zhw1";

126− };

127− }

128− {

129− name = "time-compat";

130− src = pkgs.fetchgit {

131− url = "https://github.com/haskellari/time-compat.git";

132− rev = "67b8b063295601fb1db185baad363a3f33ed63a9";

133− sha256 = "0nbjsn7yrygv4i1fd8x90mnf4janq536ffvkjd5zsnyzm8qk8k3j";

134− };

135− }

136− {

137− name = "th-abstraction";

138− src = pkgs.fetchgit {

139− url = "https://github.com/glguy/th-abstraction.git";

140− rev = "d75761bc5a0f912aeeb508e2c227b9fd830153fd";

141− sha256 = "070ihxncymzsbrgvwmrm717n0qq5bf9nvc2k210nkil1cwrsnhvc";

142− };

143− }

144− {

145− name = "tagged";

146− src = pkgs.fetchgit {

147− url = "https://github.com/ekmett/tagged.git";

148− rev = "15fcfe90c779efea951ecf4d451d709aed5f7d32";

149− sha256 = "1x1wr4zf7k1kvd6rj06h9shw7p5di1jra9fysyw0jx7riiq0v3ch";

150− };

151− }

152− {

153− name = "base-compat";

154− src = getSubdir "base-compat" (pkgs.fetchgit {

155− url = "https://github.com/haskell-compat/base-compat.git";

156− rev = "e8dbac72251e898fc4b1c1abb34d6578da12f476";

157− sha256 = "1gs15g8h7p8gab9j5fjvjlhrfv112w91plraf9chq80c5slvk016";

158− });

159− }

160− {

161− name = "base-compat-batteries";

162− src = getSubdir "base-compat-batteries" (pkgs.fetchgit {

163− url = "https://github.com/haskell-compat/base-compat.git";

164− rev = "e8dbac72251e898fc4b1c1abb34d6578da12f476";

165− sha256 = "1gs15g8h7p8gab9j5fjvjlhrfv112w91plraf9chq80c5slvk016";

166− });

167− }

168− {

169− name = "aeson";

170− src = patch ./aeson.patch (pkgs.fetchgit {

171− url = "https://github.com/dfordivam/aeson.git";

172− rev = "9a8f57a52eb748a030bc2bcf5c3159a5e2e696b2";

173− sha256 = "1y8j3ddxxddpnb7c0vi73ijb08sr09z1gdzfg1rfyzn82d6i38zv";

174− });

175− }

176−]

compiler/ghcjs/ghcjs810-patched-boot-packages/ghcjs-base.patchdeleted−471

@@ -1,471 +0,0 @@

1−diff --git a/Data/JSString.hs b/Data/JSString.hs

2−index 176aad4..9ca6693 100644

3−--- a/Data/JSString.hs

4−+++ b/Data/JSString.hs

5−@@ -99,6 +99,7 @@ module Data.JSString ( JSString

6− , breakOnEnd

7− , break

8− , span

9−+ , span_

10− , group

11− , group'

12− , groupBy

13−@@ -1231,19 +1232,23 @@ splitAt (I# n) x = case js_splitAt n x of (# y, z #) -> (y, z)

14− -- of @t@ of elements that satisfy @p@, and whose second is the

15− -- remainder of the list.

16− span :: (Char -> Bool) -> JSString -> (JSString, JSString)

17−-span p x = case js_length x of

18−- 0# -> (empty, empty)

19−- l -> let c0 = js_uncheckedIndex 0# x

20−- in if p (C# (chr# c0)) then loop 0# l else (empty, x)

21−+span p x = let (# a, b #) = span_ p x in (a, b)

22−+{-# INLINE span #-}

23−+

24−+span_ :: (Char -> Bool) -> JSString -> (# JSString, JSString #)

25−+span_ p x = case js_length x of

26−+ 0# -> (# empty, empty #)

27−+ l -> let c0 = js_uncheckedIndex 0# x

28−+ in if p (C# (chr# c0)) then loop 0# l else (# empty, x #)

29− where

30− loop i l

31−- | isTrue# (i >=# l) = (x, empty)

32−+ | isTrue# (i >=# l) = (# x, empty #)

33− | otherwise =

34− let c = js_uncheckedIndex i x

35− in if p (C# (chr# c))

36− then loop (i +# charWidth c) l

37−- else (js_substr 0# i x, js_substr1 i x)

38−-{-# INLINE span #-}

39−+ else (# js_substr 0# i x, js_substr1 i x #)

40−+{-# INLINE span_ #-}

41−

42− -- | /O(n)/ 'break' is like 'span', but the prefix returned is

43− -- over elements that fail the predicate @p@.

44−diff --git a/GHCJS/Foreign.hs b/GHCJS/Foreign.hs

45−index 5bbc5c5..b128f24 100644

46−--- a/GHCJS/Foreign.hs

47−+++ b/GHCJS/Foreign.hs

48−@@ -82,7 +82,7 @@ import GHCJS.Marshal

49− import GHCJS.Marshal.Pure

50− -}

51− import Data.String (IsString(..))

52−-import qualified Data.Text as T

53−+-- import qualified Data.Text as T

54−

55−

56− class ToJSString a where

57−diff --git a/GHCJS/Foreign/Internal.hs b/GHCJS/Foreign/Internal.hs

58−index 5ac81f0..449bfe4 100644

59−--- a/GHCJS/Foreign/Internal.hs

60−+++ b/GHCJS/Foreign/Internal.hs

61−@@ -100,10 +100,10 @@ import Data.Typeable (Typeable)

62− import Data.ByteString (ByteString)

63− import Data.ByteString.Unsafe (unsafePackAddressLen)

64−

65−-import qualified Data.Text.Array as A

66−-import qualified Data.Text as T

67−-import qualified Data.Text.Internal as T

68−-import qualified Data.Text.Lazy as TL (Text, toStrict, fromStrict)

69−+-- import qualified Data.Text.Array as A

70−+-- import qualified Data.Text as T

71−+-- import qualified Data.Text.Internal as T

72−+-- import qualified Data.Text.Lazy as TL (Text, toStrict, fromStrict)

73−

74− import Unsafe.Coerce

75−

76−diff --git a/GHCJS/Marshal.hs b/GHCJS/Marshal.hs

77−index a36aca2..6256a73 100644

78−--- a/GHCJS/Marshal.hs

79−+++ b/GHCJS/Marshal.hs

80−@@ -16,7 +16,7 @@

81−

82− module GHCJS.Marshal ( FromJSVal(..)

83− , ToJSVal(..)

84−- , toJSVal_aeson

85−+ -- , toJSVal_aeson

86− , toJSVal_pure

87− ) where

88−

89−@@ -24,17 +24,17 @@ import Control.Applicative

90− import Control.Monad

91− import Control.Monad.Trans.Maybe (MaybeT(..), runMaybeT)

92−

93−-import qualified Data.Aeson as AE

94−-import Data.Attoparsec.Number (Number(..))

95−+-- import qualified Data.Aeson as AE

96−+-- import Data.Attoparsec.Number (Number(..))

97− import Data.Bits ((.&.))

98− import Data.Char (chr, ord)

99−-import qualified Data.HashMap.Strict as H

100−+-- import qualified Data.HashMap.Strict as H

101− import Data.Int (Int8, Int16, Int32)

102− import qualified Data.JSString as JSS

103−-import qualified Data.JSString.Text as JSS

104−+-- import qualified Data.JSString.Text as JSS

105− import Data.Maybe

106−-import Data.Scientific (Scientific, scientific, fromFloatDigits)

107−-import Data.Text (Text)

108−+-- import Data.Scientific (Scientific, scientific, fromFloatDigits)

109−+-- import Data.Text (Text)

110− import qualified Data.Vector as V

111− import Data.Word (Word8, Word16, Word32, Word)

112− import Data.Primitive.ByteArray

113−@@ -85,11 +85,11 @@ instance FromJSVal JSString where

114− {-# INLINE fromJSValUnchecked #-}

115− fromJSVal = fromJSVal_pure

116− {-# INLINE fromJSVal #-}

117−-instance FromJSVal Text where

118−- fromJSValUnchecked = fromJSValUnchecked_pure

119−- {-# INLINE fromJSValUnchecked #-}

120−- fromJSVal = fromJSVal_pure

121−- {-# INLINE fromJSVal #-}

122−+-- instance FromJSVal Text where

123−+-- fromJSValUnchecked = fromJSValUnchecked_pure

124−+-- {-# INLINE fromJSValUnchecked #-}

125−+-- fromJSVal = fromJSVal_pure

126−+-- {-# INLINE fromJSVal #-}

127− instance FromJSVal Char where

128− fromJSValUnchecked = fromJSValUnchecked_pure

129− {-# INLINE fromJSValUnchecked #-}

130−@@ -154,24 +154,24 @@ instance FromJSVal Double where

131− {-# INLINE fromJSValUnchecked #-}

132− fromJSVal = fromJSVal_pure

133− {-# INLINE fromJSVal #-}

134−-instance FromJSVal AE.Value where

135−- fromJSVal r = case jsonTypeOf r of

136−- JSONNull -> return (Just AE.Null)

137−- JSONInteger -> liftM (AE.Number . flip scientific 0 . (toInteger :: Int -> Integer))

138−- <$> fromJSVal r

139−- JSONFloat -> liftM (AE.Number . (fromFloatDigits :: Double -> Scientific))

140−- <$> fromJSVal r

141−- JSONBool -> liftM AE.Bool <$> fromJSVal r

142−- JSONString -> liftM AE.String <$> fromJSVal r

143−- JSONArray -> liftM (AE.Array . V.fromList) <$> fromJSVal r

144−- JSONObject -> do

145−- props <- OI.listProps (OI.Object r)

146−- runMaybeT $ do

147−- propVals <- forM props $ \p -> do

148−- v <- MaybeT (fromJSVal =<< OI.getProp p (OI.Object r))

149−- return (JSS.textFromJSString p, v)

150−- return (AE.Object (H.fromList propVals))

151−- {-# INLINE fromJSVal #-}

152−+-- instance FromJSVal AE.Value where

153−+-- fromJSVal r = case jsonTypeOf r of

154−+-- JSONNull -> return (Just AE.Null)

155−+-- JSONInteger -> liftM (AE.Number . flip scientific 0 . (toInteger :: Int -> Integer))

156−+-- <$> fromJSVal r

157−+-- JSONFloat -> liftM (AE.Number . (fromFloatDigits :: Double -> Scientific))

158−+-- <$> fromJSVal r

159−+-- JSONBool -> liftM AE.Bool <$> fromJSVal r

160−+-- JSONString -> liftM AE.String <$> fromJSVal r

161−+-- JSONArray -> liftM (AE.Array . V.fromList) <$> fromJSVal r

162−+-- JSONObject -> do

163−+-- props <- OI.listProps (OI.Object r)

164−+-- runMaybeT $ do

165−+-- propVals <- forM props $ \p -> do

166−+-- v <- MaybeT (fromJSVal =<< OI.getProp p (OI.Object r))

167−+-- return (JSS.textFromJSString p, v)

168−+-- return (AE.Object (H.fromList propVals))

169−+-- {-# INLINE fromJSVal #-}

170− instance (FromJSVal a, FromJSVal b) => FromJSVal (a,b) where

171− fromJSVal r = runMaybeT $ (,) <$> jf r 0 <*> jf r 1

172− {-# INLINE fromJSVal #-}

173−@@ -204,15 +204,15 @@ jf r n = MaybeT $ do

174− instance ToJSVal JSVal where

175− toJSVal = toJSVal_pure

176− {-# INLINE toJSVal #-}

177−-instance ToJSVal AE.Value where

178−- toJSVal = toJSVal_aeson

179−- {-# INLINE toJSVal #-}

180−+-- instance ToJSVal AE.Value where

181−+-- toJSVal = toJSVal_aeson

182−+-- {-# INLINE toJSVal #-}

183− instance ToJSVal JSString where

184− toJSVal = toJSVal_pure

185− {-# INLINE toJSVal #-}

186−-instance ToJSVal Text where

187−- toJSVal = toJSVal_pure

188−- {-# INLINE toJSVal #-}

189−+-- instance ToJSVal Text where

190−+-- toJSVal = toJSVal_pure

191−+-- {-# INLINE toJSVal #-}

192− instance ToJSVal Char where

193− toJSVal = return . pToJSVal

194− {-# INLINE toJSVal #-}

195−@@ -285,21 +285,21 @@ foreign import javascript unsafe "[$1,$2,$3,$4,$5]" arr5 :: JSVal -> J

196− foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6]" arr6 :: JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> IO JSVal

197− foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7]" arr7 :: JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> IO JSVal

198−

199−-toJSVal_aeson :: AE.ToJSON a => a -> IO JSVal

200−-toJSVal_aeson x = cv (AE.toJSON x)

201−- where

202−- cv = convertValue

203−+-- toJSVal_aeson :: AE.ToJSON a => a -> IO JSVal

204−+-- toJSVal_aeson x = cv (AE.toJSON x)

205−+-- where

206−+-- cv = convertValue

207−

208−- convertValue :: AE.Value -> IO JSVal

209−- convertValue AE.Null = return jsNull

210−- convertValue (AE.String t) = return (pToJSVal t)

211−- convertValue (AE.Array a) = (\(AI.SomeJSArray x) -> x) <$>

212−- (AI.fromListIO =<< mapM convertValue (V.toList a))

213−- convertValue (AE.Number n) = toJSVal (realToFrac n :: Double)

214−- convertValue (AE.Bool b) = return (toJSBool b)

215−- convertValue (AE.Object o) = do

216−- obj@(OI.Object obj') <- OI.create

217−- mapM_ (\(k,v) -> convertValue v >>= \v' -> OI.setProp (JSS.textToJSString k) v' obj) (H.toList o)

218−- return obj'

219−+-- convertValue :: AE.Value -> IO JSVal

220−+-- convertValue AE.Null = return jsNull

221−+-- convertValue (AE.String t) = return (pToJSVal t)

222−+-- convertValue (AE.Array a) = (\(AI.SomeJSArray x) -> x) <$>

223−+-- (AI.fromListIO =<< mapM convertValue (V.toList a))

224−+-- convertValue (AE.Number n) = toJSVal (realToFrac n :: Double)

225−+-- convertValue (AE.Bool b) = return (toJSBool b)

226−+-- convertValue (AE.Object o) = do

227−+-- obj@(OI.Object obj') <- OI.create

228−+-- mapM_ (\(k,v) -> convertValue v >>= \v' -> OI.setProp (JSS.textToJSString k) v' obj) (H.toList o)

229−+-- return obj'

230−

231−

232−diff --git a/GHCJS/Marshal/Pure.hs b/GHCJS/Marshal/Pure.hs

233−index 902fa20..268489d 100644

234−--- a/GHCJS/Marshal/Pure.hs

235−+++ b/GHCJS/Marshal/Pure.hs

236−@@ -28,11 +28,11 @@ import Data.Data

237− import Data.Int (Int8, Int16, Int32)

238− import Data.JSString.Internal.Type

239− import Data.Maybe

240−-import Data.Text (Text)

241−+-- import Data.Text (Text)

242− import Data.Typeable

243− import Data.Word (Word8, Word16, Word32, Word)

244− import Data.JSString

245−-import Data.JSString.Text

246−+-- import Data.JSString.Text

247− import Data.Bits ((.&.))

248− import Unsafe.Coerce (unsafeCoerce)

249− import GHC.Int

250−@@ -65,8 +65,8 @@ instance PFromJSVal JSString where pFromJSVal = JSString

251− {-# INLINE pFromJSVal #-}

252− instance PFromJSVal [Char] where pFromJSVal = Prim.fromJSString

253− {-# INLINE pFromJSVal #-}

254−-instance PFromJSVal Text where pFromJSVal = textFromJSVal

255−- {-# INLINE pFromJSVal #-}

256−+-- instance PFromJSVal Text where pFromJSVal = textFromJSVal

257−+-- {-# INLINE pFromJSVal #-}

258− instance PFromJSVal Char where pFromJSVal x = C# (jsvalToChar x)

259− {-# INLINE pFromJSVal #-}

260− instance PFromJSVal Bool where pFromJSVal = isTruthy

261−@@ -103,8 +103,8 @@ instance PToJSVal JSString where pToJSVal = jsval

262− {-# INLINE pToJSVal #-}

263− instance PToJSVal [Char] where pToJSVal = Prim.toJSString

264− {-# INLINE pToJSVal #-}

265−-instance PToJSVal Text where pToJSVal = jsval . textToJSString

266−- {-# INLINE pToJSVal #-}

267−+-- instance PToJSVal Text where pToJSVal = jsval . textToJSString

268−+-- {-# INLINE pToJSVal #-}

269− instance PToJSVal Char where pToJSVal (C# c) = charToJSVal c

270− {-# INLINE pToJSVal #-}

271− instance PToJSVal Bool where pToJSVal True = jsTrue

272−diff --git a/JavaScript/JSON/Types/Instances.hs b/JavaScript/JSON/Types/Instances.hs

273−index 2b288ec..6d7074c 100644

274−--- a/JavaScript/JSON/Types/Instances.hs

275−+++ b/JavaScript/JSON/Types/Instances.hs

276−@@ -57,7 +57,7 @@ import Control.Applicative ((<$>), (<*>), (<|>), pure, empty)

277−

278− import Data.JSString (JSString)

279− import qualified Data.JSString as JSS

280−-import qualified Data.JSString.Text as JSS

281−+-- import qualified Data.JSString.Text as JSS

282−

283− import JavaScript.Array (JSArray)

284− import qualified JavaScript.Array as JSA

285−@@ -335,21 +335,21 @@ instance FromJSON JSString where

286− parseJSON = withJSString "JSString" pure

287− {-# INLINE parseJSON #-}

288−

289−-instance ToJSON Text where

290−- toJSON = stringValue . JSS.textToJSString

291−- {-# INLINE toJSON #-}

292−+-- instance ToJSON Text where

293−+-- toJSON = stringValue . JSS.textToJSString

294−+-- {-# INLINE toJSON #-}

295−

296−-instance FromJSON Text where

297−- parseJSON = withJSString "Text" ( pure . JSS.textFromJSString )

298−- {-# INLINE parseJSON #-}

299−+-- instance FromJSON Text where

300−+-- parseJSON = withJSString "Text" ( pure . JSS.textFromJSString )

301−+-- {-# INLINE parseJSON #-}

302−

303−-instance ToJSON LT.Text where

304−- toJSON = stringValue . JSS.textToJSString . LT.toStrict

305−- {-# INLINE toJSON #-}

306−+-- instance ToJSON LT.Text where

307−+-- toJSON = stringValue . JSS.textToJSString . LT.toStrict

308−+-- {-# INLINE toJSON #-}

309−

310−-instance FromJSON LT.Text where

311−- parseJSON = withJSString "Lazy Text" $ pure . LT.fromStrict . JSS.textFromJSString

312−- {-# INLINE parseJSON #-}

313−+-- instance FromJSON LT.Text where

314−+-- parseJSON = withJSString "Lazy Text" $ pure . LT.fromStrict . JSS.textFromJSString

315−+-- {-# INLINE parseJSON #-}

316−

317− instance (ToJSON a) => ToJSON [a] where

318− toJSON = arrayValue . arrayValueList . map toJSON

319−diff --git a/JavaScript/Web/Canvas.hs b/JavaScript/Web/Canvas.hs

320−index 0a7684c..74490c2 100644

321−--- a/JavaScript/Web/Canvas.hs

322−+++ b/JavaScript/Web/Canvas.hs

323−@@ -69,7 +69,7 @@ import Control.Monad

324−

325− import Data.Data

326− import Data.Maybe (fromJust)

327−-import Data.Text (Text)

328−+-- import Data.Text (Text)

329− import Data.Typeable

330−

331− import GHCJS.Foreign

332−diff --git a/ghcjs-base.cabal b/ghcjs-base.cabal

333−index 4a64694..acf8806 100644

334−--- a/ghcjs-base.cabal

335−+++ b/ghcjs-base.cabal

336−@@ -55,7 +55,7 @@ library

337− Data.JSString.RealFloat

338− Data.JSString.RegExp

339− Data.JSString.Internal

340−- Data.JSString.Text

341−+ -- Data.JSString.Text

342− Data.JSString.Internal.Fusion

343− Data.JSString.Internal.Fusion.Types

344− Data.JSString.Internal.Fusion.Common

345−@@ -78,12 +78,12 @@ library

346− JavaScript.Array.Internal

347− JavaScript.Array.ST

348− JavaScript.Cast

349−- JavaScript.JSON

350−- JavaScript.JSON.Types

351−- JavaScript.JSON.Types.Class

352−- JavaScript.JSON.Types.Generic

353−- JavaScript.JSON.Types.Instances

354−- JavaScript.JSON.Types.Internal

355−+ -- JavaScript.JSON

356−+ -- JavaScript.JSON.Types

357−+ -- JavaScript.JSON.Types.Class

358−+ -- JavaScript.JSON.Types.Generic

359−+ -- JavaScript.JSON.Types.Instances

360−+ -- JavaScript.JSON.Types.Internal

361− JavaScript.Number

362− JavaScript.Object

363− JavaScript.Object.Internal

364−@@ -115,11 +115,11 @@ library

365− JavaScript.Web.Storage

366− JavaScript.Web.Storage.Internal

367− JavaScript.Web.StorageEvent

368−- JavaScript.Web.XMLHttpRequest

369−+ -- JavaScript.Web.XMLHttpRequest

370− JavaScript.Web.WebSocket

371− JavaScript.Web.Worker

372−- other-modules: GHCJS.Internal.Types

373− Data.JSString.Internal.Type

374−+ other-modules: GHCJS.Internal.Types

375− JavaScript.TypedArray.Internal.Types

376− JavaScript.TypedArray.ArrayBuffer.Internal

377− JavaScript.TypedArray.DataView.Internal

378−@@ -144,15 +144,15 @@ library

379− integer-gmp,

380− binary >= 0.8 && < 0.11,

381− bytestring >= 0.10 && < 0.11,

382−- text >= 1.1 && < 1.3,

383−- aeson >= 0.8 && < 1.6,

384−- scientific >= 0.3 && < 0.4,

385−+ -- text >= 1.1 && < 1.3,

386−+ -- aeson >= 0.8 && < 1.6,

387−+ -- scientific >= 0.3 && < 0.4,

388− vector >= 0.10 && < 0.13,

389− containers >= 0.5 && < 0.7,

390− time >= 1.5 && < 1.10,

391−- hashable >= 1.2 && < 1.4,

392−- unordered-containers >= 0.2 && < 0.3,

393−- attoparsec >= 0.11 && < 0.15,

394−+ -- hashable >= 1.2 && < 1.4,

395−+ -- unordered-containers >= 0.2 && < 0.3,

396−+ -- attoparsec >= 0.11 && < 0.15,

397− transformers >= 0.3 && < 0.6,

398− primitive >= 0.5 && < 0.8,

399− deepseq >= 1.3 && < 1.5,

400−@@ -161,37 +161,37 @@ library

401− if !impl(ghcjs) && !os(ghcjs)

402− buildable: False

403−

404−-test-suite tests

405−- type: exitcode-stdio-1.0

406−- hs-source-dirs: test

407−- main-is: Tests.hs

408−- other-modules: Tests.Marshal

409−- Tests.Properties

410−- Tests.Properties.Numeric

411−- Tests.SlowFunctions

412−- Tests.QuickCheckUtils

413−- Tests.Regressions

414−- Tests.Utils

415−- ghc-options:

416−- -Wall -rtsopts

417−- build-depends:

418−- HUnit >= 1.2,

419−- QuickCheck >= 2.7,

420−- array,

421−- text,

422−- base,

423−- bytestring,

424−- deepseq,

425−- directory,

426−- ghc-prim,

427−- ghcjs-prim,

428−- ghcjs-base,

429−- primitive,

430−- quickcheck-unicode,

431−- random,

432−- test-framework >= 0.4,

433−- test-framework-hunit >= 0.2,

434−- test-framework-quickcheck2 >= 0.2

435−- default-language: Haskell2010

436−- if !impl(ghcjs) && !os(ghcjs)

437−- buildable: False

438−+-- test-suite tests

439−+-- type: exitcode-stdio-1.0

440−+-- hs-source-dirs: test

441−+-- main-is: Tests.hs

442−+-- other-modules: Tests.Marshal

443−+-- Tests.Properties

444−+-- Tests.Properties.Numeric

445−+-- Tests.SlowFunctions

446−+-- Tests.QuickCheckUtils

447−+-- Tests.Regressions

448−+-- Tests.Utils

449−+-- ghc-options:

450−+-- -Wall -rtsopts

451−+-- build-depends:

452−+-- HUnit >= 1.2,

453−+-- QuickCheck >= 2.7,

454−+-- array,

455−+-- text,

456−+-- base,

457−+-- bytestring,

458−+-- deepseq,

459−+-- directory,

460−+-- ghc-prim,

461−+-- ghcjs-prim,

462−+-- ghcjs-base,

463−+-- primitive,

464−+-- quickcheck-unicode,

465−+-- random,

466−+-- test-framework >= 0.4,

467−+-- test-framework-hunit >= 0.2,

468−+-- test-framework-quickcheck2 >= 0.2

469−+-- default-language: Haskell2010

470−+-- if !impl(ghcjs) && !os(ghcjs)

471−+-- buildable: False

compiler/ghcjs/ghcjs810-patched-boot-packages/hashable.patchdeleted−99

@@ -1,99 +0,0 @@

1−diff --git a/hashable.cabal b/hashable.cabal

2−index 4197060..8c339b1 100755

3−--- a/hashable.cabal

4−+++ b/hashable.cabal

5−@@ -88,6 +88,8 @@ library

6− build-depends: ghc-bignum ==1.0.* || ==1.2.*

7−

8− else

9−+ if impl(ghcjs)

10−+ build-depends: ghcjs-base

11− if flag(integer-gmp)

12− build-depends: integer-gmp >=0.4 && <1.1

13−

14−diff --git a/src/Data/Hashable/Class.hs b/src/Data/Hashable/Class.hs

15−index c7dd8c5..0e3bbe7 100755

16−--- a/src/Data/Hashable/Class.hs

17−+++ b/src/Data/Hashable/Class.hs

18−@@ -5,6 +5,10 @@

19−

20− {-# LANGUAGE Trustworthy #-}

21−

22−+#ifdef __GHCJS__

23−+{-# LANGUAGE JavaScriptFFI, UnboxedTuples, GHCForeignImportPrim #-}

24−+#endif

25−+

26− #if __GLASGOW_HASKELL__ >= 801

27− {-# LANGUAGE PolyKinds #-} -- For TypeRep instances

28− #endif

29−@@ -72,7 +76,9 @@ import Data.Int (Int8, Int16, Int32, Int64)

30− import Data.List (foldl')

31− import Data.Ratio (Ratio, denominator, numerator)

32− import qualified Data.Text as T

33−+#ifndef __GHCJS__

34− import qualified Data.Text.Array as TA

35−+#endif

36− import qualified Data.Text.Internal as T

37− import qualified Data.Text.Lazy as TL

38− import Data.Version (Version(..))

39−@@ -152,7 +158,11 @@ import GHC.Exts (Int (..), sizeofByteArray#)

40− # define MIN_VERSION_integer_gmp_1_0_0

41− # endif

42−

43−+#ifndef __GHCJS__

44− import GHC.Exts (Int(..))

45−+#else

46−+import GHC.Exts (Int(..), Int#)

47−+#endif

48− import GHC.Integer.GMP.Internals (Integer(..))

49− # if defined(MIN_VERSION_integer_gmp_1_0_0)

50− import GHC.Exts (sizeofByteArray#)

51−@@ -195,6 +205,10 @@ import Data.Kind (Type)

52− import Data.Hashable.Imports

53− import Data.Hashable.LowLevel

54−

55−+#ifdef __GHCJS__

56−+import Data.JSString (JSString)

57−+#endif

58−+

59− #include "MachDeps.h"

60−

61− infixl 0 `hashWithSalt`

62−@@ -676,17 +690,18 @@ instance Hashable BSI.ShortByteString where

63− #endif

64−

65− instance Hashable T.Text where

66−+#ifndef __GHCJS__

67− hashWithSalt salt (T.Text arr off len) =

68− hashByteArrayWithSalt (TA.aBA arr) (off `shiftL` 1) (len `shiftL` 1)

69− (hashWithSalt salt len)

70−+#else

71−+ hashWithSalt salt (T.Text txt) =

72−+ let (# ba, len #) = js_textFromJSString txt

73−+ in hashByteArrayWithSalt ba (0 `shiftL` 1) (I# len `shiftL` 1) salt

74−+#endif

75−

76− instance Hashable TL.Text where

77−- hashWithSalt salt = finalise . TL.foldlChunks step (SP salt 0)

78−- where

79−- finalise (SP s l) = hashWithSalt s l

80−- step (SP s l) (T.Text arr off len) = SP

81−- (hashByteArrayWithSalt (TA.aBA arr) (off `shiftL` 1) (len `shiftL` 1) s)

82−- (l + len)

83−+ hashWithSalt = TL.foldlChunks hashWithSalt

84−

85− -- | Compute the hash of a ThreadId.

86− hashThreadId :: ThreadId -> Int

87−@@ -880,6 +895,12 @@ instance Hashable1 Option where liftHashWithSalt h salt (Option a) = liftHashWit

88− #endif

89− #endif

90−

91−+#ifdef __GHCJS__

92−+foreign import javascript unsafe

93−+ "h$textFromString"

94−+ js_textFromJSString :: JSString -> (# ByteArray#, Int# #)

95−+#endif

96−+

97− -- instances for @Data.Functor.{Product,Sum,Compose}@, present

98− -- in base-4.9 and onward.

99− #if MIN_VERSION_base(4,9,0)

compiler/ghcjs/patches/810/boot-optimization-flags.patchdeleted−14

@@ -1,14 +0,0 @@

1−diff --git a/src-bin/Boot.hs b/src-bin/Boot.hs

2−index 2e35a26..5db2f9b 100755

3−--- a/src-bin/Boot.hs

4−+++ b/src-bin/Boot.hs

5−@@ -721,6 +721,9 @@ cabalConfigureFlags = do

6− , "--prefix", T.pack (locs ^. blGhcjsTopDir)

7− , "--configure-option", "--host=js-unknown-ghcjs"

8− , "--ghcjs-options=-fwrite-ide-info"

9−+ , "--ghcjs-options=-O2"

10−+ , "--ghcjs-options=-fexpose-all-unfoldings"

11−+ , "--ghcjs-options=-fspecialise-aggressively"

12− , "--enable-debug-info"

13− , "--disable-library-stripping"

14− , "--disable-executable-stripping"

compiler/ghcjs/patches/810/fast-weak.patchdeleted−87

@@ -1,87 +0,0 @@

1−diff --git a/lib/boot/shims/src/gc.js.pp b/lib/boot/shims/src/gc.js.pp

2−index 76321b2..a2cf416 100644

3−--- a/lib/boot/shims/src/gc.js.pp

4−+++ b/lib/boot/shims/src/gc.js.pp

5−@@ -444,6 +444,50 @@ function h$follow(obj, sp) {

6− } else if(typeof c.len === 'number' && c.buf instanceof ArrayBuffer) {

7− TRACE_GC("marking ByteArray");

8− MARK_OBJ(c);

9−+ } else if(c instanceof h$FastWeak) {

10−+ MARK_OBJ(c);

11−+ if(c.ticket !== null && !IS_MARKED(c.ticket)) {

12−+ c.ticket = null; // If the ticket isn't reachable, this will let it get cleaned up by the JS gc; if it is reachable, it'll fill this back in

13−+ }

14−+ } else if(c instanceof h$FastWeakTicket) {

15−+ MARK_OBJ(c);

16−+ if(!IS_MARKED(c.val)) {

17−+ ADDW(c.val);

18−+ }

19−+ if(IS_MARKED(c.weak)) {

20−+ // In this case, the weak side has been marked first, which means it's been cleared; restore it

21−+ c.weak.ticket = c;

22−+ }

23−+ } else if(c instanceof h$FastWeakBag) {

24−+ MARK_OBJ(c);

25−+ var j = 0; // j should always be equal to the number of not-yet-necessarily-dead tickets that have been traversed; this should always be less than or equal to i

26−+ for(i = 0; i < c.tickets.length; i++) {

27−+ // Any nulls left in the array prior to checking on the tickets must be tickets that died in the last GC, so we ignore them

28−+ if(c.tickets[i] !== null) {

29−+ if(j !== i) {

30−+ c.tickets[i].pos = j;

31−+ }

32−+ if(!IS_MARKED(c.tickets[i])) {

33−+ // If the ticket isn't reachable, this will let it get cleaned up by the JS gc; if it is reachable, it'll fill this back in

34−+ c.tickets[j] = null;

35−+ } else if(j !== i) {

36−+ // We need to move the item

37−+ c.tickets[j] = c.tickets[i];

38−+ } // If it's marked and not moving, don't do anything

39−+ j++;

40−+ }

41−+ }

42−+ c.tickets.length = j; // Shrink the array if any nulls have been dropped

43−+ } else if(c instanceof h$FastWeakBagTicket) {

44−+ MARK_OBJ(c);

45−+ if(!IS_MARKED(c.val)) {

46−+ ADDW(c.val);

47−+ }

48−+ if(IS_MARKED(c.bag)) {

49−+ // In this case, the weak side has been marked first, which means it's been cleared; restore it

50−+ c.bag.tickets[c.pos] = c;

51−+ }

52−+

53− } else if(c instanceof h$Weak) {

54− MARK_OBJ(c);

55− } else if(c instanceof h$MVar) {

56−diff --git a/lib/boot/shims/src/weak.js.pp b/lib/boot/shims/src/weak.js.pp

57−index 8df313b..d537027 100644

58−--- a/lib/boot/shims/src/weak.js.pp

59−+++ b/lib/boot/shims/src/weak.js.pp

60−@@ -87,3 +87,27 @@ function h$finalizeWeak(w) {

61− RETURN_UBX_TUP2(r, 1);

62− }

63− }

64−+

65−+function h$FastWeak(ticket) {

66−+ this.ticket = ticket;

67−+ this.m = 0;

68−+}

69−+

70−+function h$FastWeakTicket(val) {

71−+ this.val = val;

72−+ this.weak = new h$FastWeak(this);

73−+ this.m = 0;

74−+}

75−+

76−+function h$FastWeakBag() {

77−+ this.tickets = [];

78−+ this.m = 0;

79−+}

80−+

81−+function h$FastWeakBagTicket(bag, val) {

82−+ this.val = val;

83−+ this.bag = bag;

84−+ this.pos = bag.tickets.length;

85−+ bag.tickets.push(this);

86−+ this.m = 0;

87−+};

docs/reference/supported-ghc-versions.md+1−1

@@ -27,7 +27,7 @@ really should use an instance of Nixpkgs provided by `haskell.nix` itself.

2727| unstable | `nixpkgs-unstable` | 8.8.4 | `ghc884` | No |

2828| unstable | `nixpkgs-unstable` | 8.10.7 | `ghc8107` | Yes |

2929| unstable | `nixpkgs-unstable` | 9.0.2 | `ghc902` | Yes |

30−| unstable | `nixpkgs-unstable` | 9.2.4 | `ghc924` | Yes |

30+| unstable | `nixpkgs-unstable` | 9.2.3 | `ghc923` | Yes |

3131

3232See [ci.nix](https://github.com/input-output-hk/haskell.nix/blob/master/ci.nix)

3333for the source of truth about what is built and tested (in the off chance this

docs/tutorials/ca-derivations.mddeleted−65

@@ -1,65 +0,0 @@

1−# Content addressed derivations

2−## Introduction

3−

4−Floating content addressed derivations (from now *CA derivations*) is an experimental feature which substantially change how the hashes in the store paths are calculated.

5−Indeed, normally derivations are input addressed i.e. the outputs store paths depends only on the derivation inputs, instead with CA derivations they depend on the content of the outputs.

6−

7−This has two main advantages:

8−

9−- The so-called "early cutoff", namely the ability of Nix to stop a build if the build outputs would be something already built.

10−For example suppose you add a comment in an Haskell source, at this point Nix will rebuild the component depending on this source but since the output will be the same (adding a comment is an "output-invariant" change for `ghc`) every other component that depends on that will not be rebuilt.

11−- Users of the same Nix store does not need to trust each other when using substituters.

12−

13−You can find more information in the [ca-derivations page on the wiki](https://nixos.wiki/wiki/Ca-derivations) (and in the other resources linked there).

14−

15−## Usage

16−### Enable CA derivations in your system

17−First of all your Nix installation must support the `ca-derivations` experimental feature, this can done by adding the following in your `nix.conf`:

18−

19−```

20−experimental-features = ca-derivations

21−```

22−

23−Or if you use NixOS:

24−```

25−nix.extraOptions = ''

26− experimental-features = ca-derivations

27−'';

28−```

29−

30−## Enable CA derivations in your project

31−At this point you can pass a new module to `project'` that tells `haskell.nix` to build every component in the project as CA derivation.

32−

33−```

34−haskell-nix.project' {

35− # ...

36−

37− modules = [{

38− contentAddressed = true;

39− # packages.project-name.components.exes.executable.contentAddressed = true;

40− }];

41−};

42−```

43−

44−Optionally you can also specify which components you don't want to be content addressed.

45−

46−## Known problems

47−### Limitation of the current CA derivations implementation

48−

49−As explained in the [RFC 62](https://github.com/tweag/rfcs/blob/cas-rfc/rfcs/0062-content-addressed-paths.md)

50−

51−> The current implementation has a naive approach that just forbids fetching a path if the local system has a different realisation for the same drv output. This approach is simple and correct, but it's possible that it might not be good-enough in practice as it can result in a totally useless binary cache in some pathological cases.

52−

53−For example, suppose that your machine builds a derivation `A` producing an output `A.out` in your store and that after that a CI machine builds the same derivation `A` but producing a different output `A.out'` and populating a cache with this output.

54−At this point, if you need to build a derivation `B` that depends on `A`, since you already have the realisation `A.out` in your local store and you can't get `B.out` from the cache and you will end up building `B` even if one of its realisation is in the cache.

55−

56−This means that, in some cases, enabling CA derivations would lead to more rebuilds than not having it.

57−

58−### Hydra

59−Hydra currently doesn't support CA derivations, efforts are being made in this direction.

60−

61−

62−### GHC is not deterministic

63−Currently `ghc` is determinstic only disabling the parallel building i.e. passing `-j1`. [Here](https://gitlab.haskell.org/ghc/ghc/-/issues/12935) the upstream issue.

64−

65−Having a deterministic `ghc` would be a dream since it will automatically fix all the pathological cases about substituters discussed above and would allow `haskell.nix` to parallel build even when using CA derivations.

flake.lock+18−35

@@ -118,11 +118,11 @@

118118 "hackage": {

119119 "flake": false,

120120 "locked": {

121− "lastModified": 1659402819,

122− "narHash": "sha256-1ghmulyIk+obGnyFeouVHBQXxUHMBmgCIRazLfEoT34=",

121+ "lastModified": 1654478164,

122+ "narHash": "sha256-yunJSaYIJwYEEm3TdKwphpn1svlPQfYZL2GbQQObTtc=",

123123 "owner": "input-output-hk",

124124 "repo": "hackage.nix",

125− "rev": "2f6f97ca3db96f91eea674ef46f4a0785d1e9d9c",

125+ "rev": "b6543396beed02768ed84cc5d24a14cd92498eec",

126126 "type": "github"

127127 },

128128 "original": {

@@ -209,11 +209,11 @@

209209 "nix-tools": {

210210 "flake": false,

211211 "locked": {

212− "lastModified": 1658968505,

213− "narHash": "sha256-UnbQ/Ig/23e9hUdDOBwYHwHgHmQawZ2uazpJ8DLIJgE=",

212+ "lastModified": 1649424170,

213+ "narHash": "sha256-XgKXWispvv5RCvZzPb+p7e6Hy3LMuRjafKMl7kXzxGw=",

214214 "owner": "input-output-hk",

215215 "repo": "nix-tools",

216− "rev": "8a754bdcf20b20e116409c2341cf69065d083053",

216+ "rev": "e109c94016e3b6e0db7ed413c793e2d4bdb24aa7",

217217 "type": "github"

218218 },

219219 "original": {

@@ -255,11 +255,11 @@

255255 },

256256 "nixpkgs-2105": {

257257 "locked": {

258− "lastModified": 1655034179,

259− "narHash": "sha256-rf1/7AbzuYDw6+8Xvvf3PtEOygymLBrFsFxvext5ZjI=",

258+ "lastModified": 1645296114,

259+ "narHash": "sha256-y53N7TyIkXsjMpOG7RhvqJFGDacLs9HlyHeSTBioqYU=",

260260 "owner": "NixOS",

261261 "repo": "nixpkgs",

262− "rev": "046ee4af7a9f016a364f8f78eeaa356ba524ac31",

262+ "rev": "530a53dcbc9437363471167a5e4762c5fcfa34a1",

263263 "type": "github"

264264 },

265265 "original": {

@@ -271,11 +271,11 @@

271271 },

272272 "nixpkgs-2111": {

273273 "locked": {

274− "lastModified": 1656782578,

275− "narHash": "sha256-1eMCBEqJplPotTo/SZ/t5HU6Sf2I8qKlZi9MX7jv9fw=",

274+ "lastModified": 1648744337,

275+ "narHash": "sha256-bYe1dFJAXovjqiaPKrmAbSBEK5KUkgwVaZcTbSoJ7hg=",

276276 "owner": "NixOS",

277277 "repo": "nixpkgs",

278− "rev": "573603b7fdb9feb0eb8efc16ee18a015c667ab1b",

278+ "rev": "0a58eebd8ec65ffdef2ce9562784123a73922052",

279279 "type": "github"

280280 },

281281 "original": {

@@ -285,22 +285,6 @@

285285 "type": "github"

286286 }

287287 },

288− "nixpkgs-2205": {

289− "locked": {

290− "lastModified": 1657876628,

291− "narHash": "sha256-URmf0O2cQ/3heg2DJOeLyU/JmfVMqG4X5t9crQXMaeY=",

292− "owner": "NixOS",

293− "repo": "nixpkgs",

294− "rev": "549d82bdd40f760a438c3c3497c1c61160f3de55",

295− "type": "github"

296− },

297− "original": {

298− "owner": "NixOS",

299− "ref": "nixpkgs-22.05-darwin",

300− "repo": "nixpkgs",

301− "type": "github"

302− }

303− },

304288 "nixpkgs-regression": {

305289 "locked": {

306290 "lastModified": 1643052045,

@@ -318,11 +302,11 @@

318302 },

319303 "nixpkgs-unstable": {

320304 "locked": {

321− "lastModified": 1657888067,

322− "narHash": "sha256-GnwJoFBTPfW3+mz7QEeJEEQ9OMHZOiIJ/qDhZxrlKh8=",

305+ "lastModified": 1648219316,

306+ "narHash": "sha256-Ctij+dOi0ZZIfX5eMhgwugfvB+WZSrvVNAyAuANOsnQ=",

323307 "owner": "NixOS",

324308 "repo": "nixpkgs",

325− "rev": "65fae659e31098ca4ac825a6fef26d890aaf3f4e",

309+ "rev": "30d3d79b7d3607d56546dd2a6b49e156ba0ec634",

326310 "type": "github"

327311 },

328312 "original": {

@@ -368,7 +352,6 @@

368352 "nixpkgs-2003": "nixpkgs-2003",

369353 "nixpkgs-2105": "nixpkgs-2105",

370354 "nixpkgs-2111": "nixpkgs-2111",

371− "nixpkgs-2205": "nixpkgs-2205",

372355 "nixpkgs-unstable": "nixpkgs-unstable",

373356 "old-ghc-nix": "old-ghc-nix",

374357 "stackage": "stackage"

@@ -377,11 +360,11 @@

377360 "stackage": {

378361 "flake": false,

379362 "locked": {

380− "lastModified": 1659402917,

381− "narHash": "sha256-zRDOtN4A2KmfzmZiqqxOAIw1YVPhnoIaszKKd+qCEcQ=",

363+ "lastModified": 1654478255,

364+ "narHash": "sha256-HJdZRznTApwbsOAxjmpLP++vCxuPrWCWvquaFJhMfvs=",

382365 "owner": "input-output-hk",

383366 "repo": "stackage.nix",

384− "rev": "778df3c4b35eac853d57fac7bafc7c9f2dde917f",

367+ "rev": "21b250dcad395664268fc733f0bd832df3cacd07",

385368 "type": "github"

386369 },

387370 "original": {

flake.nix+2−9

@@ -6,7 +6,6 @@

66 nixpkgs-2003 = { url = "github:NixOS/nixpkgs/nixpkgs-20.03-darwin"; };

77 nixpkgs-2105 = { url = "github:NixOS/nixpkgs/nixpkgs-21.05-darwin"; };

88 nixpkgs-2111 = { url = "github:NixOS/nixpkgs/nixpkgs-21.11-darwin"; };

9− nixpkgs-2205 = { url = "github:NixOS/nixpkgs/nixpkgs-22.05-darwin"; };

109 nixpkgs-unstable = { url = "github:NixOS/nixpkgs/nixpkgs-unstable"; };

1110 flake-utils = { url = "github:numtide/flake-utils"; };

1211 hydra.url = "hydra";

@@ -59,8 +58,8 @@

5958 };

6059 };

6160

62− outputs = { self, nixpkgs, nixpkgs-unstable, nixpkgs-2105, nixpkgs-2111, nixpkgs-2205, flake-utils, ... }@inputs:

63− let compiler = "ghc924";

61+ outputs = { self, nixpkgs, nixpkgs-unstable, nixpkgs-2105, flake-utils, ... }@inputs:

62+ let compiler = "ghc923";

6463 config = import ./config.nix;

6564 in {

6665 inherit config;

@@ -101,12 +100,6 @@

101100 };

102101 pkgs = import nixpkgs

103102 (nixpkgsArgs // { localSystem = { inherit system; }; });

104− pkgs-2105 = import nixpkgs-2105

105− (nixpkgsArgs // { localSystem = { inherit system; }; });

106− pkgs-2111 = import nixpkgs-2111

107− (nixpkgsArgs // { localSystem = { inherit system; }; });

108− pkgs-2205 = import nixpkgs-2205

109− (nixpkgsArgs // { localSystem = { inherit system; }; });

110103 pkgs-unstable = import nixpkgs-unstable

111104 (nixpkgsArgs // { localSystem = { inherit system; }; });

112105 hix = import ./hix/default.nix { inherit pkgs; };

hix/project.nix+5−5

@@ -56,20 +56,20 @@ let

5656 nixpkgsArgs = config.haskellNix.nixpkgsArgs // {

5757 overlays = config.haskellNix.nixpkgsArgs.overlays ++ config.overlays;

5858 };

59− _module.args.pkgs = import config.nixpkgs config.nixpkgsArgs;

60− project = pkgs.haskell-nix.project [

59+ pkgs = import config.nixpkgs config.nixpkgsArgs;

60+ project = config.pkgs.haskell-nix.project [

6161 (import ../modules/hix-project.nix)

6262 userDefaults

6363 projectDefaults

6464 commandArgs'

65− ({config, ...}: {

65+ {

6666 src =

6767 if __pathExists (toString (src.origSrcSubDir or src) + "/.git")

68− then config.evalPackages.haskell-nix.haskellLib.cleanGit {

68+ then config.pkgs.haskell-nix.haskellLib.cleanGit {

6969 inherit src name;

7070 }

7171 else src;

72− })

72+ }

7373 ];

7474 })

7575 ];

lib/cabal-project-parser.nix+11−11

@@ -122,7 +122,7 @@ let

122122 # This works because `cabal configure` does not include any of the `/nix/sore/`

123123 # paths in the `plan.json` (so materialized plan-nix will still work as expeced).

124124 # See tests/unit.nix for examples of input and output.

125− parseRepositoryBlock = evalPackages: cabalProjectFileName: sha256map: inputMap: cabal-install: nix-tools: block:

125+ parseRepositoryBlock = cabalProjectFileName: sha256map: inputMap: cabal-install: nix-tools: block:

126126 let

127127 lines = pkgs.lib.splitString "\n" block;

128128 # The first line will contain the repository name.

@@ -138,7 +138,7 @@ let

138138 # The $HOME/.cabal/packages/${name} after running `cabal v2-update` to download the repository

139139 repoContents = if inputMap ? ${attrs.url}

140140 # If there is an input use it to make `file:` url and create a suitable `.cabal/packages/${name}` directory

141− then evalPackages.runCommand name ({

141+ then pkgs.evalPackages.runCommand name ({

142142 nativeBuildInputs = [ cabal-install ];

143143 preferLocalBuild = true;

144144 }) ''

@@ -155,9 +155,9 @@ let

155155 cabal v2-update ${name}

156156 cp -r $HOME/.cabal/packages/${name} $out

157157 ''

158− else evalPackages.runCommand name ({

159− nativeBuildInputs = [ cabal-install evalPackages.curl nix-tools ];

160− LOCALE_ARCHIVE = pkgs.lib.optionalString (evalPackages.stdenv.buildPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";

158+ else pkgs.evalPackages.runCommand name ({

159+ nativeBuildInputs = [ cabal-install pkgs.evalPackages.curl nix-tools ];

160+ LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.evalPackages.stdenv.buildPlatform.libc == "glibc") "${pkgs.evalPackages.glibcLocales}/lib/locale/locale-archive";

161161 LANG = "en_US.UTF-8";

162162 preferLocalBuild = true;

163163 } // pkgs.lib.optionalAttrs (sha256 != null) {

@@ -175,15 +175,15 @@ let

175175 ${pkgs.lib.optionalString (attrs ? key-threshold) "key-threshold: ${attrs.key-threshold}"}

176176 EOF

177177

178− export SSL_CERT_FILE=${evalPackages.cacert}/etc/ssl/certs/ca-bundle.crt

178+ export SSL_CERT_FILE=${pkgs.evalPackages.cacert}/etc/ssl/certs/ca-bundle.crt

179179 cabal v2-update ${name}

180180 cp -r $HOME/.cabal/packages/${name} $out

181181 '';

182182 # Output of hackage-to-nix

183183 hackage = import (

184− evalPackages.runCommand ("hackage-to-nix-" + name) {

185− nativeBuildInputs = [ cabal-install evalPackages.curl nix-tools ];

186− LOCALE_ARCHIVE = pkgs.lib.optionalString (evalPackages.stdenv.buildPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";

184+ pkgs.evalPackages.runCommand ("hackage-to-nix-" + name) {

185+ nativeBuildInputs = [ cabal-install pkgs.evalPackages.curl nix-tools ];

186+ LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.evalPackages.stdenv.buildPlatform.libc == "glibc") "${pkgs.evalPackages.glibcLocales}/lib/locale/locale-archive";

187187 LANG = "en_US.UTF-8";

188188 preferLocalBuild = true;

189189 } ''

@@ -196,11 +196,11 @@ let

196196 };

197197 };

198198

199− parseRepositories = evalPackages: cabalProjectFileName: sha256map: inputMap: cabal-install: nix-tools: projectFile:

199+ parseRepositories = cabalProjectFileName: sha256map: inputMap: cabal-install: nix-tools: projectFile:

200200 let

201201 # This will leave the name of repository in the first line of each block

202202 blocks = pkgs.lib.splitString "\nrepository " ("\n" + projectFile);

203− repoBlocks = builtins.map (parseRepositoryBlock evalPackages cabalProjectFileName sha256map inputMap cabal-install nix-tools) (pkgs.lib.lists.drop 1 blocks);

203+ repoBlocks = builtins.map (parseRepositoryBlock cabalProjectFileName sha256map inputMap cabal-install nix-tools) (pkgs.lib.lists.drop 1 blocks);

204204 in {

205205 extra-hackages = pkgs.lib.lists.map (block: block.hackage) repoBlocks;

206206 repos = pkgs.lib.lists.foldl' (x: block: x // block.repo) {} repoBlocks;

lib/call-cabal-project-to-nix.nix+17−20

@@ -1,4 +1,4 @@

1−{ pkgs, runCommand, cacert, index-state-hashes, haskellLib }@defaults:

1+{ dotCabal, pkgs, runCommand, evalPackages, symlinkJoin, cacert, index-state-hashes, haskellLib, materialize }@defaults:

22let readIfExists = src: fileName:

33 let origSrcDir = src.origSrcSubDir or src;

44 in

@@ -64,13 +64,10 @@ in

6464 # would result in the "foo" subdirectory of

6565 # any plutus-apps input being used for a

6666 # package.

67−, evalPackages

6867, ...

6968}@args:

7069

7170let

72− inherit (evalPackages.haskell-nix) materialize dotCabal;

73−

7471 # These defaults are hear rather than in modules/cabal-project.nix to make them

7572 # lazy enough to avoid infinite recursion issues.

7673 # Using null as the default also improves performance as they are not forced by the

@@ -222,8 +219,8 @@ let

222219 in {

223220 # Download the source-repository-package commit and add it to a minimal git

224221 # repository that `cabal` will be able to access from a non fixed output derivation.

225− location = evalPackages.runCommand "source-repository-package" {

226− nativeBuildInputs = [ evalPackages.rsync evalPackages.gitMinimal ];

222+ location = pkgs.evalPackages.runCommand "source-repository-package" {

223+ nativeBuildInputs = [ pkgs.evalPackages.rsync pkgs.evalPackages.gitMinimal ];

227224 } ''

228225 mkdir $out

229226 rsync -a --prune-empty-dirs "${fetched}/" "$out/"

@@ -244,24 +241,24 @@ let

244241

245242 # Parse the `repository` blocks

246243 repoResult = pkgs.haskell-nix.haskellLib.parseRepositories

247− evalPackages cabalProjectFileName sha256map inputMap cabal-install nix-tools sourceRepoPackageResult.otherText;

244+ cabalProjectFileName sha256map inputMap cabal-install nix-tools sourceRepoPackageResult.otherText;

248245

249246 # we need the repository content twice:

250247 # * at eval time (below to build the fixed project file)

251− # Here we want to use evalPackages.fetchgit, so one can calculate

248+ # Here we want to use pkgs.evalPackages.fetchgit, so one can calculate

252249 # the build plan for any target without a remote builder

253250 # * at built time (passed out)

254251 # Here we want to use plain pkgs.fetchgit, which is what a builder

255252 # on the target system would use, so that the derivation is unaffected

256253 # and, say, a linux release build job can identify the derivation

257254 # as built by a darwin builder, and fetch it from a cache

258− sourceReposEval = builtins.map (fetchPackageRepo evalPackages.fetchgit) sourceRepoPackageResult.sourceRepos;

255+ sourceReposEval = builtins.map (fetchPackageRepo pkgs.evalPackages.fetchgit) sourceRepoPackageResult.sourceRepos;

259256 sourceReposBuild = builtins.map (x: (fetchPackageRepo pkgs.fetchgit x).fetched) sourceRepoPackageResult.sourceRepos;

260257 in {

261258 sourceRepos = sourceReposBuild;

262259 inherit (repoResult) repos extra-hackages;

263260 makeFixedProjectFile = ''

264− cp -f ${evalPackages.writeText "cabal.project" sourceRepoPackageResult.otherText} ./cabal.project

261+ cp -f ${pkgs.evalPackages.writeText "cabal.project" sourceRepoPackageResult.otherText} ./cabal.project

265262 '' +

266263 pkgs.lib.optionalString (builtins.length sourceReposEval != 0) (''

267264 chmod +w -R ./cabal.project

@@ -368,12 +365,12 @@ let

368365 '');

369366

370367 # Dummy `ghc` that uses the captured output

371− dummy-ghc = evalPackages.writeTextFile {

368+ dummy-ghc = pkgs.evalPackages.writeTextFile {

372369 name = "dummy-" + ghc.name;

373370 executable = true;

374371 destination = "/bin/${ghc.targetPrefix}ghc";

375372 text = ''

376− #!${evalPackages.runtimeShell}

373+ #!${pkgs.evalPackages.runtimeShell}

377374 case "$*" in

378375 --version*)

379376 cat ${dummy-ghc-data}/ghc/version

@@ -411,12 +408,12 @@ let

411408 };

412409

413410 # Dummy `ghc-pkg` that uses the captured output

414− dummy-ghc-pkg = evalPackages.writeTextFile {

411+ dummy-ghc-pkg = pkgs.evalPackages.writeTextFile {

415412 name = "dummy-pkg-" + ghc.name;

416413 executable = true;

417414 destination = "/bin/${ghc.targetPrefix}ghc-pkg";

418415 text = ''

419− #!${evalPackages.runtimeShell}

416+ #!${pkgs.evalPackages.runtimeShell}

420417 case "$*" in

421418 --version)

422419 cat ${dummy-ghc-data}/ghc-pkg/version

@@ -452,10 +449,10 @@ let

452449 else null;

453450 } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

454451 inherit checkMaterialization;

455− }) (evalPackages.runCommand (nameAndSuffix "plan-to-nix-pkgs") {

456− nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg cabal-install evalPackages.rsync evalPackages.gitMinimal ];

452+ }) (pkgs.evalPackages.runCommand (nameAndSuffix "plan-to-nix-pkgs") {

453+ nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg cabal-install pkgs.evalPackages.rsync pkgs.evalPackages.gitMinimal ];

457454 # Needed or stack-to-nix will die on unicode inputs

458− LOCALE_ARCHIVE = pkgs.lib.optionalString (evalPackages.stdenv.buildPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";

455+ LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.evalPackages.stdenv.buildPlatform.libc == "glibc") "${pkgs.evalPackages.glibcLocales}/lib/locale/locale-archive";

459456 LANG = "en_US.UTF-8";

460457 meta.platforms = pkgs.lib.platforms.all;

461458 preferLocalBuild = false;

@@ -477,11 +474,11 @@ let

477474 '';

478475 in {

479476 # These check for cabal configure failure

480− json = evalPackages.runCommand (nameAndSuffix "plan-json") {} ''

477+ json = pkgs.evalPackages.runCommand (nameAndSuffix "plan-json") {} ''

481478 ${checkCabalConfigure}

482479 cp ${plan-nix.maybeJson} $out

483480 '';

484− freeze = evalPackages.runCommand (nameAndSuffix "plan-freeze") {} ''

481+ freeze = pkgs.evalPackages.runCommand (nameAndSuffix "plan-freeze") {} ''

485482 ${checkCabalConfigure}

486483 cp ${plan-nix.maybeFreeze} $out

487484 '';

@@ -523,7 +520,7 @@ let

523520 ${pkgs.lib.optionalString (subDir != "") "cd ${subDir}"}

524521 ${fixedProject.makeFixedProjectFile}

525522 ${pkgs.lib.optionalString (cabalProjectFreeze != null) ''

526− cp ${evalPackages.writeText "cabal.project.freeze" cabalProjectFreeze} \

523+ cp ${pkgs.evalPackages.writeText "cabal.project.freeze" cabalProjectFreeze} \

527524 cabal.project.freeze

528525 chmod +w cabal.project.freeze

529526 ''}

lib/call-stack-to-nix.nix+11−13

@@ -5,6 +5,7 @@

55 *

66 * see also `call-cabal-project-to-nix`!

77 */

8+{ runCommand, pkgs, mkCacheFile, materialize, haskellLib }:

89{ name ? src.name or null # optional name for better error messages

910, src

1011, stackYaml ? "stack.yaml"

@@ -14,24 +15,21 @@

1415, resolverSha256 ? null

1516, materialized ? null # Location of a materialized copy of the nix files

1617, checkMaterialization ? null # If true the nix files will be generated used to check plan-sha256 and material

17−, nix-tools

18−, evalPackages

19−, ... }@args:

18+, nix-tools ? pkgs.haskell-nix.internal-nix-tools # When building stack projects we use the internal nix-tools (compiled with a fixed GHC version)

19+, ... }:

2020let

21− inherit (evalPackages) runCommand;

22− inherit (evalPackages.haskell-nix) mkCacheFile materialize haskellLib;

2321 inherit (haskellLib.fetchResolver {

2422 inherit src stackYaml resolverSha256;

2523 }) resolver fetchedResolver;

2624

2725 subDir' = src.origSubDir or "";

28− subDir = evalPackages.lib.strings.removePrefix "/" subDir';

26+ subDir = pkgs.lib.strings.removePrefix "/" subDir';

2927 cleanedSource = (haskellLib.cleanSourceWith {

3028 name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

3129 src = src.origSrc or src;

3230 filter = path: type: (!(src ? filter) || src.filter path type) && (

3331 type == "directory" ||

34− evalPackages.lib.any (i: (evalPackages.lib.hasSuffix i path)) [ stackYaml ".cabal" "package.yaml" ]); });

32+ pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ stackYaml ".cabal" "package.yaml" ]); });

3533

3634 stackToNixArgs = builtins.concatStringsSep " " [

3735 "--full"

@@ -45,12 +43,12 @@ let

4543 sha256Arg = "stack-sha256";

4644 reasonNotSafe = null;

4745 this = "project.stack-nix" + (if name != null then " for ${name}" else "");

48− } // evalPackages.lib.optionalAttrs (checkMaterialization != null) {

46+ } // pkgs.lib.optionalAttrs (checkMaterialization != null) {

4947 inherit checkMaterialization;

5048 }) (runCommand (if name == null then "stack-to-nix-pkgs" else name + "-stack-to-nix-pkgs") {

51− nativeBuildInputs = [ nix-tools evalPackages.nix-prefetch-git evalPackages.cacert evalPackages.xorg.lndir ];

49+ nativeBuildInputs = [ nix-tools pkgs.nix-prefetch-git pkgs.cacert pkgs.xorg.lndir ];

5250 # Needed or stack-to-nix will die on unicode inputs

53− LOCALE_ARCHIVE = evalPackages.lib.optionalString (evalPackages.stdenv.hostPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";

51+ LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.stdenv.hostPlatform.libc == "glibc") "${pkgs.glibcLocales}/lib/locale/locale-archive";

5452 LANG = "en_US.UTF-8";

5553 LC_ALL = "en_US.UTF-8";

5654 preferLocalBuild = false;

@@ -66,10 +64,10 @@ let

6664 echo "cleaned source is empty. Did you forget to 'git add -A'?"; exit 1;

6765 fi

6866 lndir -silent "${cleanedSource}/." $SRC

69− ${evalPackages.lib.optionalString (subDir != "") "cd ${subDir}"}

67+ ${pkgs.lib.optionalString (subDir != "") "cd ${subDir}"}

7068 ${

7169 # If a resolver was fetched use the it instead of the original stack.yaml

72− evalPackages.lib.optionalString (fetchedResolver != null)

70+ pkgs.lib.optionalString (fetchedResolver != null)

7371 # Replace the resolver path in the stack.yaml with the fetched version

7472 ''

7573 rm ${stackYaml}

@@ -77,7 +75,7 @@ let

7775 chmod +w ${stackYaml}

7876 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

7977 ''}

80− ${evalPackages.lib.optionalString (cache != null) ''

78+ ${pkgs.lib.optionalString (cache != null) ''

8179 cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

8280 ''}

8381 (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})

lib/check.nix+14−19

@@ -1,4 +1,4 @@

1−{ stdenv, lib, haskellLib }:

1+{ stdenv, lib, haskellLib, srcOnly }:

22drv:

44let

@@ -7,25 +7,13 @@ let

77# This derivation can be used to execute test component.

88# The $out of the derivation is a file containing the resulting

99# stdout output.

10−in stdenv.mkDerivation ((

11− if drv ? source

12− then {

13− src = drv.source;

14− patchPhase =

15− # This `cd` is normally done in the `prePatch` of the drv

16− lib.optionalString (drv.srcSubDir != "") ''

17− cd ${lib.removePrefix "/" drv.srcSubDir}

18− '';

19− }

20− else

21− # This makes the derivation work a bit like `srcOnly`,

22− # using the original derivation, but replacing the `buildPhase`.

23− (drv.drvAttrs or drv) // {

24− outputs = [ "out" ];

25− separateDebugInfo = false;

26− }) // {

10+in stdenv.mkDerivation ({

2711 name = (drv.name + "-check");

2812

13+ # Using `srcOnly` (rather than getting the `src` via a `drv.passthru`)

14+ # should correctly apply the patches from `drv` (if any).

15+ src = drv.source or (srcOnly drv);

16+

2917 passthru = {

3018 inherit (drv) identifier config configFiles executableToolDepends cleanSrc env exeName;

3119 };

@@ -34,12 +22,19 @@ in stdenv.mkDerivation ((

3422

3523 inherit (component) doCheck doCrossCheck;

3624

37− phases = ["unpackPhase" "patchPhase" "buildPhase"];

25+ phases = ["unpackPhase" "buildPhase"];

3826

3927 # If doCheck or doCrossCheck are false we may still build this

4028 # component and we want it to quietly succeed.

4129 buildPhase = ''

4230 mkdir $out

31+ ${

32+ # Change to the source sub directory if there is one.

33+ lib.optionalString (drv.srcSubDir or "" != "") ''

34+ cd ${lib.removePrefix "/" drv.srcSubDir}

35+ ''

36+ }

37+

4338 runHook preCheck

4439

4540 ${toString component.testWrapper} ${drv}/bin/${drv.exeName} ${lib.concatStringsSep " " component.testFlags} | tee $out/test-stdout

lib/cover-project.nix+47−44

@@ -10,12 +10,19 @@ coverageReports:

1010let

1111 toBashArray = arr: "(" + (lib.concatStringsSep " " arr) + ")";

1212

13− # Create a list element for a project coverage index page.

14− coverageListElement = coverageReport:

13+ # Create table rows for a project coverage index page that look something like:

14+ #

15+ # | Package |

16+ # |------------------|

17+ # | cardano-shell |

18+ # | cardano-launcher |

19+ coverageTableRows = coverageReport:

1520 ''

16− <li>

17− <a href="${coverageReport.passthru.name}/hpc_index.html">${coverageReport.passthru.name}</a>

18− </li>

21+ <tr>

22+ <td>

23+ <a href="${coverageReport.passthru.name}/hpc_index.html">${coverageReport.passthru.name}</href>

24+ </td>

25+ </tr>

1926 '';

2027

2128 projectIndexHtml = pkgs.writeText "index.html" ''

@@ -24,32 +31,23 @@ let

2431 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

2532 </head>

2633 <body>

27− <div>

28− WARNING: Modules with no coverage are not included in any of these reports, this is just how HPC works under the hood.

29− </div>

30− <div>

31− <h2>Union Report</h2>

32− <p>The following report shows how each module is covered by any test in the project:</p>

33− <ul>

34− <li>

35− <a href="all/hpc_index.html">all</a>

36− </li>

37− </ul>

38− </div>

39− <div>

40− <h2>Individual Reports</h2>

41− <p>The following reports show how the tests of each package cover modules in the project:</p>

42− <ul>

43− ${with lib; concatStringsSep "\n" (map coverageListElement coverageReports)}

44− </ul>

45− </div>

34+ <table border="1" width="100%">

35+ <tbody>

36+ <tr>

37+ <th>Report</th>

38+ </tr>

39+

40+ ${with lib; concatStringsSep "\n" (map coverageTableRows coverageReports)}

41+

42+ </tbody>

43+ </table>

4644 </body>

4745 </html>

4846 '';

4947

5048 ghc = project.pkg-set.config.ghc.package;

5149

52− libs = lib.unique (lib.concatMap (r: r.mixLibraries) coverageReports);

50+ libs = lib.remove null (map (r: r.library) coverageReports);

5351

5452 mixDirs =

5553 map

@@ -58,17 +56,6 @@ let

5856

5957 srcDirs = map (l: l.srcSubDirPath) libs;

6058

61− allCoverageReport = haskellLib.coverageReport {

62− name = "all";

63− checks = lib.flatten (lib.concatMap

64− (pkg: lib.optional (pkg ? checks) (lib.filter lib.isDerivation (lib.attrValues pkg.checks)))

65− (lib.attrValues (haskellLib.selectProjectPackages project.hsPkgs)));

66− mixLibraries = lib.concatMap

67− (pkg: lib.optional (pkg.components ? library) pkg.components.library)

68− (lib.attrValues (haskellLib.selectProjectPackages project.hsPkgs));

69− ghc = project.pkg-set.config.ghc.package;

70− };

71−

7259in pkgs.runCommand "project-coverage-report"

7360 ({ nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

7461 LANG = "en_US.UTF-8";

@@ -137,14 +124,30 @@ in pkgs.runCommand "project-coverage-report"

137124 cp -R $report/share/hpc/vanilla/html/* $out/share/hpc/vanilla/html/

138125 '') coverageReports)}

139126

140− # Copy out "all" coverage report

141− cp -R ${allCoverageReport}/share/hpc/vanilla/tix/all $out/share/hpc/vanilla/tix

142− cp -R ${allCoverageReport}/share/hpc/vanilla/html/all $out/share/hpc/vanilla/html

127+ if [ ''${#tixFiles[@]} -ne 0 ]; then

128+ # Create tix file with test run information for all packages

129+ tixFile="$out/share/hpc/vanilla/tix/all/all.tix"

130+ hpcSumCmd=("hpc" "sum" "--union" "--output=$tixFile")

131+ hpcSumCmd+=("''${tixFiles[@]}")

132+ echo "''${hpcSumCmd[@]}"

133+ eval "''${hpcSumCmd[@]}"

134+

135+ # Markup a HTML coverage report for the entire project

136+ cp ${projectIndexHtml} $out/share/hpc/vanilla/html/index.html

137+ echo "report coverage-per-package $out/share/hpc/vanilla/html/index.html" >> $out/nix-support/hydra-build-products

138+

139+ local markupOutDir="$out/share/hpc/vanilla/html/all"

140+ local srcDirs=${toBashArray srcDirs}

141+ local mixDirs=${toBashArray mixDirs}

142+ local allMixModules=()

143+

144+ mkdir $markupOutDir

145+ findModules allMixModules "$out/share/hpc/vanilla/mix/" "*.mix"

143146

144− # Markup a HTML coverage summary report for the entire project

145− cp ${projectIndexHtml} $out/share/hpc/vanilla/html/index.html

147+ markup srcDirs mixDirs allMixModules "$markupOutDir" "$tixFile"

146148

147− echo "report coverage $out/share/hpc/vanilla/html/index.html" >> $out/nix-support/hydra-build-products

148− ( cd $out/share/hpc/vanilla/html ; zip -r $out/share/hpc/vanilla/html.zip . )

149− echo "file zip $out/share/hpc/vanilla/html.zip" >> $out/nix-support/hydra-build-products

149+ echo "report coverage $markupOutDir/hpc_index.html" >> $out/nix-support/hydra-build-products

150+ ( cd $out/share/hpc/vanilla/html ; zip -r $out/share/hpc/vanilla/html.zip . )

151+ echo "file zip $out/share/hpc/vanilla/html.zip" >> $out/nix-support/hydra-build-products

152+ fi

150153 ''

lib/cover.nix+69−102

@@ -1,18 +1,18 @@

1−# The following collects coverage information from a set of given "checks" and

2−# provides a coverage report showing how those "checks" cover a set of given

3−# "mixLibraries".

41{ stdenv, lib, haskellLib, pkgs }:

6−# Name of the coverage report, which should be unique.

3+# Name of the coverage report, which should be unique

74{ name

8−# List of check derivations that generate coverage.

9−, checks ? []

10−# List of libraries to include in the coverage report. If one of the above

11−# checks generates coverage for a particular library, coverage will only

12−# be included if that library is in this list.

13−, mixLibraries ? []

14−# Hack for project-less projects.

15−, ghc ? if mixLibraries == [] then null else (lib.head mixLibraries).project.pkg-set.config.ghc.package

5+# Library to check coverage of

6+, library

7+# List of check derivations that generate coverage

8+, checks

9+# List of other libraries to include in the coverage report. The

10+# default value if just the derivation provided as the `library`

11+# argument. Use a larger list of libraries if you would like the tests

12+# of one local package to generate coverage for another.

13+, mixLibraries ? [library]

14+# hack for project-less projects

15+, ghc ? library.project.pkg-set.config.ghc.package

1616}:

1717

1818let

@@ -26,7 +26,7 @@ let

2626in pkgs.runCommand (name + "-coverage-report")

2727 ({nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

2828 passthru = {

29− inherit name checks mixLibraries;

29+ inherit name library checks;

3030 };

3131 # HPC will fail if the Haskell file contains non-ASCII characters,

3232 # unless our locale is set correctly. This has been fixed, but we

@@ -70,105 +70,71 @@ in pkgs.runCommand (name + "-coverage-report")

7070 local -n tixFs=$2

7171 local outFile="$3"

7272

73− if (( "''${#tixFs[@]}" > 0 )); then

74− local hpcSumCmd=("hpc" "sum" "--union" "--output=$outFile")

73+ local hpcSumCmd=("hpc" "sum" "--union" "--output=$outFile")

7574

76− for module in "''${includedModules[@]}"; do

77− hpcSumCmd+=("--include=$module")

78− done

75+ for module in "''${includedModules[@]}"; do

76+ hpcSumCmd+=("--include=$module")

77+ done

7978

80− for tixFile in "''${tixFs[@]}"; do

81− hpcSumCmd+=("$tixFile")

82− done

79+ for tixFile in "''${tixFs[@]}"; do

80+ hpcSumCmd+=("$tixFile")

81+ done

8382

84− echo "''${hpcSumCmd[@]}"

85− eval "''${hpcSumCmd[@]}"

86− else

87− # If there are no tix files we output an empty tix file so that we can

88− # markup an empty HTML coverage report. This is preferable to failing to

89− # output a HTML report.

90− echo 'Tix []' > $outFile

91− fi

83+ echo "''${hpcSumCmd[@]}"

84+ eval "''${hpcSumCmd[@]}"

9285 }

9386

9487 function findModules() {

95− local -n result=$1

96− local -n searchDirs=$2

88+ local searchDir=$2

9789 local pattern=$3

9890

99− for dir in "''${searchDirs[@]}"; do

100− pushd $dir

101− local temp=()

102− mapfile -d $'\0' temp < <(find ./ -type f \

103− -wholename "$pattern" -not -name "Paths*" \

104− -exec basename {} \; \

105− | sed "s/\.mix$//" \

106− | tr "\n" "\0")

107− result+=("''${temp[@]}")

108− popd

109− done

91+ pushd $searchDir

92+ mapfile -d $'\0' $1 < <(find ./ -type f \

93+ -wholename "$pattern" -not -name "Paths*" \

94+ -exec basename {} \; \

95+ | sed "s/\.mix$//" \

96+ | tr "\n" "\0")

97+ popd

11098 }

11199

100+ local mixDirs=${toBashArray mixDirs}

101+

112102 mkdir -p $out/nix-support

113− mkdir -p $out/share/hpc/vanilla/mix/

103+ mkdir -p $out/share/hpc/vanilla/mix/${name}

114104 mkdir -p $out/share/hpc/vanilla/tix/${name}

115105 mkdir -p $out/share/hpc/vanilla/html/${name}

116106

117− local srcDirs=${toBashArray srcDirs}

118− local mixDirs=${toBashArray mixDirs}

119−

120− # Copy out mix files used for this report

107+ # Copy over mix files verbatim

121108 for dir in "''${mixDirs[@]}"; do

122109 if [ -d "$dir" ]; then

123− cp -R "$dir" $out/share/hpc/vanilla/mix/

110+ cp -R "$dir"/* $out/share/hpc/vanilla/mix/${name}

124111 fi

125112 done

126113

127− local mixModules=()

128− # Mix modules for all packages in "mixLibraries"

129− findModules mixModules mixDirs "*.mix"

130−

131− # We need to make a distinction between library "exposed-modules" and

132− # "other-modules" used in test suites:

133− # - "exposed-modules" are addressed as "$library-$version-$hash/module"

134− # - "other-modules" are addressed as "module"

135− #

136− # This complicates the code required to find the mix modules. For a given mix directory:

137− #

138− # mix

139− # └── ntp-client-0.0.1

140− # └── ntp-client-0.0.1-gYjRsBHUCaHX7ENcjHnw5

141− # ├── Network.NTP.Client.mix

142− # ├── Network.NTP.Client.Packet.mix

143− # └── Network.NTP.Client.Query.mix

144− #

145− # Iff ntp-client uses "other-modules" in a test suite, both:

146− # - "mix/ntp-client-0.0.1", and

147− # - "mix/ntp-client-0.0.1/ntp-client-0.0.1-gYjRsBHUCaHX7ENcjHnw5"

148− # need to be provided to hpc as search directories.

149− #

150− # I'd prefer to just exclude "other-modules", but I can't think of an easy

151− # way to do that in bash.

152− #

153− # Here we expand the search dirs and modify the mix dirs accordingly:

154− for dir in "''${mixDirs[@]}"; do

155− local otherModulesSearchDirs=()

156− # Simply consider any directory with a mix file as a search directory.

157− mapfile -d $'\0' otherModulesSearchDirs < <(find $dir -type f \

158− -wholename "*.mix" \

159− -exec dirname {} \; \

160− | uniq \

161− | tr "\n" "\0")

162− mixDirs+=("''${otherModulesSearchDirs[@]}")

163− done

164−

114+ local srcDirs=${toBashArray srcDirs}

115+ local allMixModules=()

116+ local pkgMixModules=()

117+

118+ # The behaviour of stack coverage reports is to provide tix files

119+ # that include coverage information for every local package, but

120+ # to provide HTML reports that only include coverage info for the

121+ # current package. We emulate the same behaviour here. If the user

122+ # includes all local packages in the mix libraries argument, they

123+ # will get a coverage report very similar to stack.

124+

125+ # All mix modules

126+ findModules allMixModules "$out/share/hpc/vanilla/mix/${name}" "*.mix"

127+ # Only mix modules corresponding to this package

128+ findModules pkgMixModules "$out/share/hpc/vanilla/mix/${name}" "*${name}*/*.mix"

129+

130+ # For each test

165131 local tixFiles=()

166132 ${lib.concatStringsSep "\n" (builtins.map (check: ''

167133 if [ -d "${check}/share/hpc/vanilla/tix" ]; then

168134 pushd ${check}/share/hpc/vanilla/tix

169135

170136 tixFile="$(find . -iwholename "*.tix" -type f -print -quit)"

171− local newTixFile=$out/share/hpc/vanilla/tix/${check.name}/"$(basename $tixFile)"

137+ local newTixFile=$out/share/hpc/vanilla/tix/${name}/"$tixFile"

172138

173139 mkdir -p "$(dirname $newTixFile)"

174140 # Copy over the tix file verbatim

@@ -177,28 +143,29 @@ in pkgs.runCommand (name + "-coverage-report")

177143 # Add the tix file to our list

178144 tixFiles+=("$newTixFile")

179145

180− # Create a coverage report for *just that check* affecting any of the

181− # "mixLibraries"

182− markup srcDirs mixDirs mixModules "$out/share/hpc/vanilla/html/${check.name}/" "$newTixFile"

146+ # Create a coverage report for *just that test*

147+ markup srcDirs mixDirs pkgMixModules "$out/share/hpc/vanilla/html/${name}/${check.exeName}/" "$newTixFile"

183148

184149 popd

185150 fi

186151 '') checks)

187152 }

188153

189− # Sum tix files to create a tix file with tix information from all tests in

190− # the package and markup a HTML report from this info.

191− local sumTixFile="$out/share/hpc/vanilla/tix/${name}/${name}.tix"

192− local markupOutDir="$out/share/hpc/vanilla/html/${name}"

154+ # Sum tix files to create a tix file with all relevant tix

155+ # information and markup a HTML report from this info.

156+ if (( "''${#tixFiles[@]}" > 0 )); then

157+ local sumTixFile="$out/share/hpc/vanilla/tix/${name}/${name}.tix"

158+ local markupOutDir="$out/share/hpc/vanilla/html/${name}"

193159

194− # Sum all of our tix files

195− sumTix mixModules tixFiles "$sumTixFile"

160+ # Sum all of our tix file, including modules from any local package

161+ sumTix allMixModules tixFiles "$sumTixFile"

196162

197− # Markup a HTML report

198− markup srcDirs mixDirs mixModules "$markupOutDir" "$sumTixFile"

163+ # Markup a HTML report, included modules from only this package

164+ markup srcDirs mixDirs pkgMixModules "$markupOutDir" "$sumTixFile"

199165

200− # Provide a HTML zipfile and Hydra links

201− ( cd "$markupOutDir" ; zip -r $out/share/hpc/vanilla/${name}-html.zip . )

202− echo "report coverage $markupOutDir/hpc_index.html" >> $out/nix-support/hydra-build-products

203− echo "file zip $out/share/hpc/vanilla/${name}-html.zip" >> $out/nix-support/hydra-build-products

166+ # Provide a HTML zipfile and Hydra links

167+ ( cd "$markupOutDir" ; zip -r $out/share/hpc/vanilla/${name}-html.zip . )

168+ echo "report coverage $markupOutDir/hpc_index.html" >> $out/nix-support/hydra-build-products

169+ echo "file zip $out/share/hpc/vanilla/${name}-html.zip" >> $out/nix-support/hydra-build-products

170+ fi

204171 ''

lib/default.nix+15−14

@@ -4,8 +4,11 @@

44with haskellLib;

66let

7− # Why `final.buildPackages.buildPackages.gitMinimal`?

8− # Why not just final.buildPackages.gitMinimal?

7+ # Why `final.evalPackages.buildPackages.gitMinimal`?

8+ # Why not just final.evalPackages.gitMinimal?

9+ #

10+ # A problem arises when `evalPackages` is `buildPackages`.i

11+ # As may be the case in a flake.

912 #

1013 # It turns out `git` depends on `gdb` in a round about way:

1114 # git -> openssh -> libfido2 -> systemd -> python libxml -> Cython -> gdb

@@ -21,7 +24,7 @@ let

2124 # * When `gdb` does not exist for `js`, so when cross

2225 # compiling with ghcjs `final.buildPackages.git` fails

2326 # to build at all.

24− inherit (pkgs.buildPackages.buildPackages) gitMinimal;

27+ inherit (pkgs.evalPackages.buildPackages) gitMinimal;

2528

2629in {

2730 # Within the package components, these are the attribute names of

@@ -199,7 +202,7 @@ in {

199202 cleanGit = import ./clean-git.nix {

200203 inherit lib cleanSourceWith;

201204 git = gitMinimal;

202− inherit (pkgs.buildPackages.buildPackages) runCommand;

205+ inherit (pkgs.evalPackages.buildPackages) runCommand;

203206 };

204207

205208 # Some times it is handy to temporarily use a relative path between git

@@ -229,7 +232,7 @@ in {

229232

230233 # Check a test component

231234 check = import ./check.nix {

232− inherit stdenv lib haskellLib;

235+ inherit stdenv lib haskellLib srcOnly;

233236 };

234237

235238 # Do coverage of a package

@@ -257,19 +260,17 @@ in {

257260 && stdenv.buildPlatform == stdenv.hostPlatform

258261 && stdenv.hostPlatform == stdenv.targetPlatform;

259262

260− # Takes a version number, module or list of modules (for cabalProject)

261− # and converts it to an list of project modules. This allows

263+ # Takes a version number or attr set of arguments (for cabalProject)

264+ # and converts it to an attr set of arguments. This allows

262265 # the use of "1.0.0.0" or { version = "1.0.0.0"; ... }

263− versionOrModToMods = versionOrMod:

264− if lib.isString versionOrMod

265− then [{ version = versionOrMod; }]

266− else if lib.isList versionOrMod

267− then versionOrMod

268− else [versionOrMod];

266+ versionOrArgsToArgs = versionOrArgs:

267+ if lib.isAttrs versionOrArgs

268+ then versionOrArgs

269+ else { version = versionOrArgs; };

269270

270271 # Find the resolver in the stack.yaml file and fetch it if a sha256 value is provided

271272 fetchResolver = import ./fetch-resolver.nix {

272− inherit (pkgs.buildPackages) pkgs;

273+ inherit (pkgs.evalPackages) pkgs;

273274 };

274275

275276 inherit (import ./cabal-project-parser.nix {

lib/ghcjs-project.nix+6−31

@@ -50,10 +50,9 @@

5050 cabalProjectLocal = ''

5151 constraints: Cabal <3.2.1.0

5252 '';

53+ modules = [{ reinstallableLibGhc = true; }];

5354 materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

5455 }

55−, overrideBootPackages ? []

56−, patches ? []

5756, ...

5857}@args:

5958let

@@ -77,11 +76,9 @@ let

7776

7877 # Inputs needed to boot the GHCJS compiler

7978 bootInputs = with pkgs.buildPackages; [

80− # We used to pin nodejs to the 12 series, as strings can only be half the length in node 14+

81− # see https://github.com/nodejs/node/issues/33960

82− # Large TH splices are likely broken.

83− # TODO reinstate the pin of find a work around for ghcjs to send TH splice in chunks.

84− nodejs-18_x

79+ # pin nodejs to the 12 series for now, as strings can only be half the length in node 14+

80+ # see https://github.com/nodejs/node/issues/33960, this can break large TH splices for now.

81+ nodejs-12_x

8582 makeWrapper

8683 xorg.lndir

8784 gmp

@@ -91,7 +88,7 @@ let

9188 # Configured the GHCJS source

9289 configured-src = (pkgs.runCommandCC "configured-ghcjs-src" {

9390 buildInputs = configureInputs;

94− inherit src patches;

91+ inherit src;

9592 } ''

9693 export HOME=$(pwd)

9794 mkdir $HOME/.cabal

@@ -100,11 +97,6 @@ let

10097 chmod -R +w "$out"

10198 cd "$out"

10299

103− for p in $patches

104− do

105− patch -p1 <$p

106− done

107−

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

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

110102 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

@@ -137,21 +129,6 @@ let

137129 for a in integer-gmp base unix; do

138130 cp ${../overlays/patches/config.sub} lib/boot/pkg/$a/config.sub

139131 done

140− ${ # it just so happens that all existing uses of overriding boot packages

141− # need to be installed right after template-haskell

142− # if at some point we would need to insert them at different points

143− # then we will have gto come up with something more clever

144− builtins.concatStringsSep "\n" (map ({name, src}: ''

145− rm -rf $out/lib/boot/pkg/${name}

146− cp -r ${src} $out/lib/boot/pkg/${name}

147− sed -i 's/^ - ${name}$//g' $out/lib/boot/boot.yaml

148− sed -i 's/^ - template-haskell$/ - template-haskell\n - ${name}/g' $out/lib/boot/boot.yaml

149− echo "Added ${name} to boot.yaml"

150− ''

151− ) (pkgs.lib.reverseList overrideBootPackages))

152− }

153−

154− chmod -R +w $out/lib/boot/pkg

155132 '') // {

156133 # The configured source includes /nix/store paths and so filtering can fail.

157134 filterPath = { path, ... }: path;

@@ -161,8 +138,7 @@ let

161138 ghcjsProject = pkgs.haskell-nix.cabalProject' (

162139 (pkgs.lib.filterAttrs

163140 (n: _: !(builtins.any (x: x == n)

164− [ "src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"

165− "overrideBootPackages" "patches"])) args) // {

141+ ["src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"])) args) // {

166142 src = configured-src;

167143 index-state = "2021-03-20T00:00:00Z";

168144 inherit compiler-nix-name;

@@ -186,7 +162,6 @@ let

186162 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

187163 })

188164 {

189− ghcOptions = ["-O2"];

190165 packages.ghcjs.doHaddock = false;

191166 packages.haddock-ghcjs.doHaddock = false;

192167 packages.haddock-api-ghcjs.doHaddock = false;

lib/materialize.nix+5−10

@@ -24,7 +24,7 @@

2424}: derivation:

2525

2626let

27− name = derivation.name + pkgs.lib.optionalString (derivation ? version) "-${derivation.version}";

27+ inherit (derivation) name;

2828

2929 traceIgnoringSha256 = reason: x:

3030 if sha256 != null

@@ -36,15 +36,10 @@ let

3636 then builtins.trace ("Warning: ignoring materialized for " + name + " " + reason) x

3737 else x;

3838

39− traceWhenChecking = message: x:

40− if checkMaterialization

41− then builtins.trace message x

42− else x;

43−

4439 unchecked =

4540 let

46− sha256message = "${name}: To make ${this} a fixed-output derivation but not materialized, set `${sha256Arg}` to the output of the 'calculateMaterializedSha' script in 'passthru'.";

47− materializeMessage = "${name}: To materialize ${this} entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.";

41+ sha256message = "To make ${this} a fixed-output derivation but not materialized, set `${sha256Arg}` to the output of the 'calculateMaterializedSha' script in 'passthru'.";

42+ materializeMessage = "To materialize ${this} entirely, pass a writable path as the `materialized` argument and run the 'updateMaterialized' script in 'passthru'.";

4843 in if reasonNotSafe != null

4944 then

5045 # Warn the user if they tried to pin stuff down when it is not safe

@@ -55,10 +50,10 @@ let

5550 else if sha256 != null

5651 then

5752 # Let the user know how to materialize if they want to.

58− traceWhenChecking materializeMessage calculateUseHash

53+ builtins.trace materializeMessage calculateUseHash

5954 else # materialized == null && sha256 == null

6055 # Let the user know how to calculate a sha256 or materialize if they want to.

61− traceWhenChecking sha256message (traceWhenChecking materializeMessage calculateNoHash);

56+ builtins.trace sha256message (builtins.trace materializeMessage calculateNoHash);

6257

6358 # Build fully and check the hash and materialized versions

6459 checked =

lib/project-overlays.nix+97−20

@@ -2,36 +2,113 @@

22 lib

33, haskellLib

44}: {

5− # Provide a devshell profile (https://github.com/numtide/devshell),

6− # adapted from the project normal shell.

75 devshell = final: prev: {

86 devshell = let

7+ cabal-install = final.pkgs.buildPackages.haskell-nix.cabal-install.${final.args.compiler-nix-name};

8+ inherit (final.pkgs.buildPackages) runCommand runtimeShell;

9+ cabalWrapper = runCommand "cabal" { inherit (cabal-install) meta; } ''

10+ mkdir -p $out/bin

11+ cat << EOF > $out/bin/cabal

12+ #!${runtimeShell}

13+ set -euo pipefail

14+

15+ find_up() {

16+ while [[ \$PWD != / ]] ; do

17+ if [[ -e "\$1" ]]; then

18+ echo "\$PWD"

19+ return

20+ fi

21+ cd ..

22+ done

23+ }

24+

25+ toplevel=\$(find_up "cabal.project")

26+

27+ if [[ -n "\$toplevel" ]]; then

28+ cabal_project="\$toplevel/cabal.project"

29+ nix_cabal_project=\$toplevel/.nix-cabal.project

30+ extra_cabal_opts=("--project-file=\$nix_cabal_project")

31+ awk '

32+ # Add comment with explanation of file

33+ BEGIN {

34+ print "-- Generated from '"\$cabal_project"' by the wrapper script"

35+ print "-- ${placeholder "out"}/cabal"

36+ print "-- Add this file to your .gitignore\n"

37+ }

38+

39+ # Matches all section starts

40+ /^[^ ]/ {

41+ # Remember the section name (they can span multiple lines)

42+ section = \$0

43+ }

44+ # Matches every line

45+ // {

46+ # Only print the line if it is not in the section we want to omit

47+ if (section != "source-repository-package")

48+ print \$0

49+ }

50+ ' "\$cabal_project" > "\$nix_cabal_project"

51+ else

52+ extra_cabal_opts=()

53+ fi

54+

55+ cabal=${placeholder "out"}/bin/.cabal

56+ >&2 echo "\$cabal \''${extra_cabal_opts[@]} \$@"

57+ exec "\$cabal" "\''${extra_cabal_opts[@]}" "\$@"

58+ EOF

59+ cp -rn ${cabal-install}/* $out/

60+ cp ${cabal-install}/bin/cabal $out/bin/.cabal

61+ chmod +x $out/bin/*

62+ '';

963 in {

10− packages = final.shell.nativeBuildInputs

11− # devshell does not use pkgs.mkShell / pkgs.stdenv.mkDerivation,

12− # so we need to explicit required dependencies which

13− # are provided implicitely by stdenv when using the normal shell:

14− ++ (lib.filter lib.isDerivation final.shell.stdenv.defaultNativeBuildInputs)

15− ++ [ final.pkgs.buildPackages.binutils ];

64+ packages = final.shell.nativeBuildInputs;

1665 env = lib.mapAttrsToList lib.nameValuePair {

1766 inherit (final.shell) CABAL_CONFIG NIX_GHC_LIBDIR;

1867 };

68+ commands = [

69+ {

70+ package = cabalWrapper;

71+ category = "development";

72+ }

73+ ];

1974 };

2075 };

2176

22− # Provides easily accessible attrset for each type of

23− # components belonging to the project packages.

24− projectComponents = final: prev: {

25− # local project packages:

77+ projectComponents = final: prev: let

2678 packages = haskellLib.selectProjectPackages final.hsPkgs;

27− # set of all exes (as first level entries):

28− exes = lib.foldl' lib.mergeAttrs { } (map (p: p.components.exes) (lib.attrValues final.packages));

29− # `tests` are the test suites which have been built.

30− tests = haskellLib.collectComponents' "tests" final.packages;

31− # `benchmarks` (only built, not run).

32− benchmarks = haskellLib.collectComponents' "benchmarks" final.packages;

33− # `checks` collect results of executing the tests:

34− checks = haskellLib.collectChecks' final.packages;

79+ # used to materialize `packages-exes.nix` (project packages and exes list) to avoid some evaluations:

80+ packagesExes = lib.genAttrs

81+ (lib.attrNames final.packages)

82+ (name: lib.attrNames final.hsPkgs.${name}.components.exes);

83+ collectExes = packagesExes: lib.listToAttrs (lib.concatLists (lib.mapAttrsToList

84+ (p: map (exe: lib.nameValuePair exe final.hsPkgs.${p}.components.exes.${exe})) packagesExes));

85+ in {

86+ # local project packages:

87+ packages = haskellLib.selectProjectPackages final.hsPkgs;

88+ # set of all exes (as first level entries):

89+ exes = collectExes packagesExes;

90+ # set of all exes (as first level entries), mapped from a materialized set of packages and exes set (generated via `generatePackagesExes`):

91+ exesFrom = packagesExesMat: collectExes (import packagesExesMat);

92+ # `tests` are the test suites which have been built.

93+ tests = haskellLib.collectComponents' "tests" final.packages;

94+ # `benchmarks` (only built, not run).

95+ benchmarks = haskellLib.collectComponents' "benchmarks" final.packages;

96+ # `checks` collect results of executing the tests:

97+ checks = haskellLib.collectChecks' final.packages;

98+

99+ generatePackagesExesMat = let

100+ nixFile = builtins.toFile "packages-exes.nix" (lib.generators.toPretty {} packagesExes);

101+ in final.pkgs.buildPackages.writeShellScript "generate-packages-exes" ''

102+ set -euo pipefail

103+

104+ TARGET="$1"

105+ TARGET_DIR="$(dirname "$TARGET")"

106+

107+ mkdir -p "$TARGET_DIR"

108+ rm -rf "$TARGET"

109+ cp -r ${nixFile} "$TARGET"

110+ chmod -R +w "$TARGET"

111+ '';

35112 };

36113

37114}

lib/spdx/licenses.nix+5−6

@@ -1,15 +1,14 @@

11pkgs:

22with builtins; let

3− spdxJson = pkgs.buildPackages.spdx-license-list-data.json or pkgs.buildPackages.spdx-license-list-data;

4− materialized' = ../../materialized + "/spdx-${spdxJson.version}";

3+ materialized = ../../materialized + "/spdx-${pkgs.evalPackages.spdx-license-list-data.version}";

54 licensesJSON = fromJSON (replaceStrings

65 [ "\\u0026" "\\u0027" "\\u003d" ]

76 [ "&" "'" "=" ]

8− (readFile "${pkgs.buildPackages.haskell-nix.materialize {

9− materialized = if pathExists materialized' then materialized' else null;

10− } (pkgs.buildPackages.runCommand "spdx-json" { inherit (spdxJson) version; } ''

7+ (readFile "${pkgs.evalPackages.haskell-nix.materialize (pkgs.lib.optionalAttrs (pathExists materialized) {

8+ inherit materialized;

9+ }) (pkgs.evalPackages.runCommand "spdx-json" {} ''

1110 mkdir $out

12− cp ${spdxJson}/json/licenses.json $out

11+ cp ${pkgs.evalPackages.spdx-license-list-data.json or pkgs.evalPackages.spdx-license-list-data}/json/licenses.json $out

1312 '')

1413 }/licenses.json")

1514 );

lib/stack-cache-generator.nix+14−17

@@ -1,5 +1,6 @@

11# Generate cache entries for dependencies of package defined in `src`

3+{ pkgs, haskellLib }:

34{ src

45, stackYaml ? "stack.yaml"

56, sha256map ? null

@@ -16,14 +17,10 @@

1617 then { location, tag, ...}: branchMap."${location}"."${tag}" or null

1718 else _: null

1819, resolverSha256 ? null

19−, nix-tools

20−, evalPackages

20+, nix-tools ? pkgs.haskell-nix.internal-nix-tools # When building stack projects we use the internal nix-tools (compiled with a fixed GHC version)

2121, ...

22−}@args:

22+}:

2323let

24− inherit (evalPackages) runCommand;

25− inherit (evalPackages.haskell-nix) haskellLib;

26−

2724 # We only care about the stackYaml file. If src is a local directory

2825 # we want to avoid recalculating the cache unless the stack.yaml file

2926 # changes.

@@ -39,10 +36,10 @@ let

3936 let

4037 origSrc = if src ? _isLibCleanSourceWith then src.origSrc else src;

4138 origSubDir = if src ? _isLibCleanSourceWithEx then src.origSubDir else "";

42− relPath = evalPackages.lib.removePrefix (toString origSrc + origSubDir + "/") path;

39+ relPath = pkgs.lib.removePrefix (toString origSrc + origSubDir + "/") path;

4340

4441 # checks if path1 is a parent directory for path2

45− isParent = path1: path2: evalPackages.lib.hasPrefix "${path1}/" path2;

42+ isParent = path1: path2: pkgs.lib.hasPrefix "${path1}/" path2;

4643

4744 in

4845 (relPath == stackYaml)

@@ -51,9 +48,9 @@ let

5148 };

5249

5350 # All repos served via ssh or git protocols are usually private

54− private = url: evalPackages.lib.substring 0 4 url != "http";

51+ private = url: pkgs.lib.substring 0 4 url != "http";

5552

56− repos = builtins.fromJSON (builtins.readFile (evalPackages.runCommand "stack-repos" {

53+ repos = builtins.fromJSON (builtins.readFile (pkgs.runCommand "stack-repos" {

5754 buildInputs = [ nix-tools ];

5855 } ''

5956 TMP=$(mktemp -d)

@@ -61,23 +58,23 @@ let

6158 cp -r "${maybeCleanedSource}/." $TMP

6259 chmod -R +w $TMP

6360 substituteInPlace ${stackYaml} --replace "# nix-sha256:" "nix-sha256:"

64− ${evalPackages.lib.optionalString (fetchedResolver != null) ''

61+ ${pkgs.lib.optionalString (fetchedResolver != null) ''

6562 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

6663 ''}

6764 stack-repos --stack-yaml ${stackYaml}

6865 cp repos.json $out

6966 ''));

7067

71− cabalName = path: builtins.readFile (evalPackages.runCommand "cabal-name" {

68+ cabalName = path: builtins.readFile (pkgs.runCommand "cabal-name" {

7269 buildInputs = [ nix-tools ];

7370 } ''

7471 cabal-name ${path} > $out

7572 '');

7673

7774 hashPath = path:

78− builtins.readFile (evalPackages.runCommand "hash-path" { preferLocalBuild = true; }

79− "echo -n $(${evalPackages.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

80−in with evalPackages.lib;

75+ builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

76+ "echo -n $(${pkgs.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

77+in with pkgs.lib;

8178concatMap (dep:

8279 let

8380 is-private = private dep.url;

@@ -91,13 +88,13 @@ concatMap (dep:

9188 };

9289 pkgsrc =

9390 if !is-private && sha256 != null

94− then evalPackages.fetchgit {

91+ then pkgs.fetchgit {

9592 inherit (dep) url rev;

9693 inherit sha256;

9794 }

9895 else builtins.fetchGit ({

9996 inherit (dep) url rev;

100− } // evalPackages.lib.optionalAttrs (branch != null) { ref = branch; });

97+ } // pkgs.lib.optionalAttrs (branch != null) { ref = branch; });

10198 in map (subdir: {

10299 name = cabalName "${pkgsrc}/${subdir}";

103100 inherit (dep) url rev;

lib/system-nixpkgs-map.nix+1−3

@@ -11,7 +11,7 @@ let

1111 gcclibs = if pkgs.stdenv.hostPlatform.isWindows then [

1212 pkgs.windows.mcfgthreads

1313 # If we just use `pkgs.buildPackages.gcc.cc` here it breaks the `th-dlls` test. TODO figure out why exactly.

14− (pkgs.buildPackages.runCommand "gcc-only" { nativeBuildInputs = [ pkgs.buildPackages.xorg.lndir ]; } ''

14+ (pkgs.evalPackages.runCommand "gcc-only" { nativeBuildInputs = [ pkgs.evalPackages.xorg.lndir ]; } ''

1515 mkdir $out

1616 lndir ${pkgs.buildPackages.gcc.cc} $out

1717 '')

@@ -31,7 +31,6 @@ in

3131 pcap = [ libpcap ];

3232 pthread = null; # available by default

3333 GL = [ libGL ];

34− GLEW = [ glew ];

3534 GLU = [ libGLU ];

3635 alut = [ freealut ];

3736 X11 = with xorg; [ libX11 ];

@@ -129,7 +128,6 @@ in

129128 msvcrt = null; # this is the libc

130129 Crypt32 = null;

131130 mswsock = null;

132− bcrypt = null;

133131 }

134132# -- os x

135133# NB: these map almost 1:1 to the framework names

lib/system-pkgs.nix+5

@@ -12,5 +12,10 @@ pkgs:

1212 # Base packages.

1313 pkgs

1414

15+ # fetchgit should always come from the evalPackages

16+ # if it comes from the targetPackages we won't even

17+ # be able to execute it.

18+ // { fetchgit = pkgs.evalPackages.fetchgit; }

19+

1520 # Apply the mapping.

1621 // import ./system-nixpkgs-map.nix pkgs

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-9.2.4-x86_64-linux/ghc-pkg/dump-globaldeleted−1512

@@ -1,1512 +0,0 @@

1−name: Cabal

2−version: 3.6.3.0

3−visibility: public

4−id: Cabal-3.6.3.0

5−key: Cabal-3.6.3.0

6−license: BSD-3-Clause

7−copyright: 2003-2021, Cabal Development Team (see AUTHORS file)

8−maintainer: cabal-devel@haskell.org

9−author: Cabal Development Team <cabal-devel@haskell.org>

10−homepage: http://www.haskell.org/cabal/

11−synopsis: A framework for packaging Haskell software

12−description:

13− The Haskell Common Architecture for Building Applications and

14− Libraries: a framework defining a common interface for authors to more

15− easily build their Haskell applications in a portable way.

16− The Haskell Cabal is part of a larger infrastructure for distributing,

17− organizing, and cataloging Haskell libraries and tools.

18−category: Distribution

19−exposed: True

20−exposed-modules:

21− Distribution.Backpack Distribution.Backpack.ComponentsGraph

22− Distribution.Backpack.Configure

23− Distribution.Backpack.ConfiguredComponent

24− Distribution.Backpack.DescribeUnitId

25− Distribution.Backpack.FullUnitId

26− Distribution.Backpack.LinkedComponent

27− Distribution.Backpack.ModSubst Distribution.Backpack.ModuleShape

28− Distribution.Backpack.PreModuleShape Distribution.CabalSpecVersion

29− Distribution.Compat.Binary Distribution.Compat.CharParsing

30− Distribution.Compat.CreatePipe Distribution.Compat.DList

31− Distribution.Compat.Directory Distribution.Compat.Environment

32− Distribution.Compat.Exception Distribution.Compat.FilePath

33− Distribution.Compat.Graph Distribution.Compat.Internal.TempFile

34− Distribution.Compat.Lens Distribution.Compat.Newtype

35− Distribution.Compat.NonEmptySet Distribution.Compat.Parsing

36− Distribution.Compat.Prelude.Internal Distribution.Compat.Process

37− Distribution.Compat.ResponseFile Distribution.Compat.Semigroup

38− Distribution.Compat.Stack Distribution.Compat.Time

39− Distribution.Compat.Typeable Distribution.Compiler

40− Distribution.FieldGrammar Distribution.FieldGrammar.Class

41− Distribution.FieldGrammar.FieldDescrs

42− Distribution.FieldGrammar.Newtypes Distribution.FieldGrammar.Parsec

43− Distribution.FieldGrammar.Pretty Distribution.Fields

44− Distribution.Fields.ConfVar Distribution.Fields.Field

45− Distribution.Fields.Lexer Distribution.Fields.LexerMonad

46− Distribution.Fields.ParseResult Distribution.Fields.Parser

47− Distribution.Fields.Pretty Distribution.InstalledPackageInfo

48− Distribution.License Distribution.Make Distribution.ModuleName

49− Distribution.Package Distribution.PackageDescription

50− Distribution.PackageDescription.Check

51− Distribution.PackageDescription.Configuration

52− Distribution.PackageDescription.FieldGrammar

53− Distribution.PackageDescription.Parsec

54− Distribution.PackageDescription.PrettyPrint

55− Distribution.PackageDescription.Quirks

56− Distribution.PackageDescription.Utils Distribution.Parsec

57− Distribution.Parsec.Error Distribution.Parsec.FieldLineStream

58− Distribution.Parsec.Position Distribution.Parsec.Warning

59− Distribution.Pretty Distribution.ReadE Distribution.SPDX

60− Distribution.SPDX.License Distribution.SPDX.LicenseExceptionId

61− Distribution.SPDX.LicenseExpression Distribution.SPDX.LicenseId

62− Distribution.SPDX.LicenseListVersion

63− Distribution.SPDX.LicenseReference Distribution.Simple

64− Distribution.Simple.Bench Distribution.Simple.Build

65− Distribution.Simple.Build.Macros

66− Distribution.Simple.Build.PathsModule

67− Distribution.Simple.BuildPaths Distribution.Simple.BuildTarget

68− Distribution.Simple.BuildToolDepends Distribution.Simple.CCompiler

69− Distribution.Simple.Command Distribution.Simple.Compiler

70− Distribution.Simple.Configure Distribution.Simple.Flag

71− Distribution.Simple.GHC Distribution.Simple.GHCJS

72− Distribution.Simple.Glob Distribution.Simple.Haddock

73− Distribution.Simple.HaskellSuite Distribution.Simple.Hpc

74− Distribution.Simple.Install Distribution.Simple.InstallDirs

75− Distribution.Simple.InstallDirs.Internal

76− Distribution.Simple.LocalBuildInfo Distribution.Simple.PackageIndex

77− Distribution.Simple.PreProcess Distribution.Simple.PreProcess.Unlit

78− Distribution.Simple.Program Distribution.Simple.Program.Ar

79− Distribution.Simple.Program.Builtin Distribution.Simple.Program.Db

80− Distribution.Simple.Program.Find Distribution.Simple.Program.GHC

81− Distribution.Simple.Program.HcPkg Distribution.Simple.Program.Hpc

82− Distribution.Simple.Program.Internal Distribution.Simple.Program.Ld

83− Distribution.Simple.Program.ResponseFile

84− Distribution.Simple.Program.Run Distribution.Simple.Program.Script

85− Distribution.Simple.Program.Strip Distribution.Simple.Program.Types

86− Distribution.Simple.Register Distribution.Simple.Setup

87− Distribution.Simple.ShowBuildInfo Distribution.Simple.SrcDist

88− Distribution.Simple.Test Distribution.Simple.Test.ExeV10

89− Distribution.Simple.Test.LibV09 Distribution.Simple.Test.Log

90− Distribution.Simple.UHC Distribution.Simple.UserHooks

91− Distribution.Simple.Utils Distribution.System

92− Distribution.TestSuite Distribution.Text

93− Distribution.Types.AbiDependency Distribution.Types.AbiHash

94− Distribution.Types.AnnotatedId Distribution.Types.Benchmark

95− Distribution.Types.Benchmark.Lens

96− Distribution.Types.BenchmarkInterface

97− Distribution.Types.BenchmarkType Distribution.Types.BuildInfo

98− Distribution.Types.BuildInfo.Lens Distribution.Types.BuildType

99− Distribution.Types.Component Distribution.Types.ComponentId

100− Distribution.Types.ComponentInclude

101− Distribution.Types.ComponentLocalBuildInfo

102− Distribution.Types.ComponentName

103− Distribution.Types.ComponentRequestedSpec

104− Distribution.Types.CondTree Distribution.Types.Condition

105− Distribution.Types.ConfVar Distribution.Types.Dependency

106− Distribution.Types.DependencyMap Distribution.Types.ExeDependency

107− Distribution.Types.Executable Distribution.Types.Executable.Lens

108− Distribution.Types.ExecutableScope Distribution.Types.ExposedModule

109− Distribution.Types.Flag Distribution.Types.ForeignLib

110− Distribution.Types.ForeignLib.Lens

111− Distribution.Types.ForeignLibOption

112− Distribution.Types.ForeignLibType

113− Distribution.Types.GenericPackageDescription

114− Distribution.Types.GenericPackageDescription.Lens

115− Distribution.Types.GivenComponent

116− Distribution.Types.HookedBuildInfo

117− Distribution.Types.IncludeRenaming

118− Distribution.Types.InstalledPackageInfo

119− Distribution.Types.InstalledPackageInfo.FieldGrammar

120− Distribution.Types.InstalledPackageInfo.Lens

121− Distribution.Types.LegacyExeDependency Distribution.Types.Lens

122− Distribution.Types.Library Distribution.Types.Library.Lens

123− Distribution.Types.LibraryName Distribution.Types.LibraryVisibility

124− Distribution.Types.LocalBuildInfo Distribution.Types.Mixin

125− Distribution.Types.Module Distribution.Types.ModuleReexport

126− Distribution.Types.ModuleRenaming

127− Distribution.Types.MungedPackageId

128− Distribution.Types.MungedPackageName

129− Distribution.Types.PackageDescription

130− Distribution.Types.PackageDescription.Lens

131− Distribution.Types.PackageId Distribution.Types.PackageId.Lens

132− Distribution.Types.PackageName Distribution.Types.PackageName.Magic

133− Distribution.Types.PackageVersionConstraint

134− Distribution.Types.PkgconfigDependency

135− Distribution.Types.PkgconfigName

136− Distribution.Types.PkgconfigVersion

137− Distribution.Types.PkgconfigVersionRange

138− Distribution.Types.SetupBuildInfo

139− Distribution.Types.SetupBuildInfo.Lens

140− Distribution.Types.SourceRepo Distribution.Types.SourceRepo.Lens

141− Distribution.Types.TargetInfo Distribution.Types.TestSuite

142− Distribution.Types.TestSuite.Lens

143− Distribution.Types.TestSuiteInterface Distribution.Types.TestType

144− Distribution.Types.UnitId Distribution.Types.UnqualComponentName

145− Distribution.Types.Version Distribution.Types.VersionInterval

146− Distribution.Types.VersionInterval.Legacy

147− Distribution.Types.VersionRange

148− Distribution.Types.VersionRange.Internal Distribution.Utils.Generic

149− Distribution.Utils.IOData Distribution.Utils.LogProgress

150− Distribution.Utils.MD5 Distribution.Utils.MapAccum

151− Distribution.Utils.NubList Distribution.Utils.Path

152− Distribution.Utils.Progress Distribution.Utils.ShortText

153− Distribution.Utils.Structured Distribution.Verbosity

154− Distribution.Verbosity.Internal Distribution.Version

155− Language.Haskell.Extension

156−hidden-modules:

157− Distribution.Backpack.PreExistingComponent

158− Distribution.Backpack.ReadyComponent Distribution.Backpack.MixLink

159− Distribution.Backpack.ModuleScope Distribution.Backpack.UnifyM

160− Distribution.Backpack.Id Distribution.Utils.UnionFind

161− Distribution.Utils.Base62 Distribution.Compat.Async

162− Distribution.Compat.CopyFile Distribution.Compat.GetShortPathName

163− Distribution.Compat.MonadFail Distribution.Compat.Prelude

164− Distribution.Compat.SnocList Distribution.GetOpt Distribution.Lex

165− Distribution.Utils.String Distribution.Simple.Build.Macros.Z

166− Distribution.Simple.Build.PathsModule.Z

167− Distribution.Simple.GHC.EnvironmentParser

168− Distribution.Simple.GHC.Internal Distribution.Simple.GHC.ImplInfo

169− Distribution.Simple.Utils.Json Distribution.ZinzaPrelude

170− Paths_Cabal

171−import-dirs:

172−library-dirs:

173−dynamic-library-dirs:

174−data-dir:

175−hs-libraries: HSCabal-3.6.3.0

176−depends:

177− array-0.5.4.0 base-4.16.3.0 binary-0.8.9.0 bytestring-0.11.3.1

178− containers-0.6.5.1 deepseq-1.4.6.1 directory-1.3.6.2

179− filepath-1.4.2.2 mtl-2.2.2 parsec-3.1.15.0 pretty-1.1.3.6

180− process-1.6.13.2 text-1.2.5.0 time-1.11.1.1 transformers-0.5.6.2

181− unix-2.7.2.2

182−haddock-interfaces:

183−haddock-html:

184−---

185−name: array

186−version: 0.5.4.0

187−visibility: public

188−id: array-0.5.4.0

189−key: array-0.5.4.0

190−license: BSD-3-Clause

191−maintainer: libraries@haskell.org

192−synopsis: Mutable and immutable arrays

193−description:

194− In addition to providing the "Data.Array" module

195− <http://www.haskell.org/onlinereport/haskell2010/haskellch14.html as specified in the Haskell 2010 Language Report>,

196− this package also defines the classes 'IArray' of

197− immutable arrays and 'MArray' of arrays mutable within appropriate

198− monads, as well as some instances of these classes.

199−category: Data Structures

200−exposed: True

201−exposed-modules:

202− Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO

203− Data.Array.IO.Internals Data.Array.IO.Safe Data.Array.MArray

204− Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe

205− Data.Array.Storable Data.Array.Storable.Internals

206− Data.Array.Storable.Safe Data.Array.Unboxed Data.Array.Unsafe

207−import-dirs:

208−library-dirs:

209−dynamic-library-dirs:

210−data-dir:

211−hs-libraries: HSarray-0.5.4.0

212−depends: base-4.16.3.0

213−haddock-interfaces:

214−haddock-html:

215−---

216−name: base

217−version: 4.16.3.0

218−visibility: public

219−id: base-4.16.3.0

220−key: base-4.16.3.0

221−license: BSD-3-Clause

222−maintainer: libraries@haskell.org

223−synopsis: Basic libraries

224−description:

225− This package contains the Standard Haskell "Prelude" and its support libraries,

226− and a large collection of useful libraries ranging from data

227− structures to parsing combinators and debugging utilities.

228−category: Prelude

229−exposed: True

230−exposed-modules:

231− Control.Applicative, Control.Arrow, Control.Category,

232− Control.Concurrent, Control.Concurrent.Chan,

233− Control.Concurrent.MVar, Control.Concurrent.QSem,

234− Control.Concurrent.QSemN, Control.Exception,

235− Control.Exception.Base, Control.Monad, Control.Monad.Fail,

236− Control.Monad.Fix, Control.Monad.IO.Class, Control.Monad.Instances,

237− Control.Monad.ST, Control.Monad.ST.Lazy,

238− Control.Monad.ST.Lazy.Safe, Control.Monad.ST.Lazy.Unsafe,

239− Control.Monad.ST.Safe, Control.Monad.ST.Strict,

240− Control.Monad.ST.Unsafe, Control.Monad.Zip, Data.Bifoldable,

241− Data.Bifunctor, Data.Bitraversable, Data.Bits, Data.Bool,

242− Data.Char, Data.Coerce, Data.Complex, Data.Data, Data.Dynamic,

243− Data.Either, Data.Eq, Data.Fixed, Data.Foldable, Data.Function,

244− Data.Functor, Data.Functor.Classes, Data.Functor.Compose,

245− Data.Functor.Const, Data.Functor.Contravariant,

246− Data.Functor.Identity, Data.Functor.Product, Data.Functor.Sum,

247− Data.IORef, Data.Int, Data.Ix, Data.Kind, Data.List,

248− Data.List.NonEmpty, Data.Maybe, Data.Monoid, Data.Ord, Data.Proxy,

249− Data.Ratio, Data.STRef, Data.STRef.Lazy, Data.STRef.Strict,

250− Data.Semigroup, Data.String, Data.Traversable, Data.Tuple,

251− Data.Type.Bool, Data.Type.Coercion, Data.Type.Equality,

252− Data.Type.Ord, Data.Typeable, Data.Unique, Data.Version, Data.Void,

253− Data.Word, Debug.Trace, Foreign, Foreign.C, Foreign.C.Error,

254− Foreign.C.String, Foreign.C.Types, Foreign.Concurrent,

255− Foreign.ForeignPtr, Foreign.ForeignPtr.Safe,

256− Foreign.ForeignPtr.Unsafe, Foreign.Marshal, Foreign.Marshal.Alloc,

257− Foreign.Marshal.Array, Foreign.Marshal.Error, Foreign.Marshal.Pool,

258− Foreign.Marshal.Safe, Foreign.Marshal.Unsafe,

259− Foreign.Marshal.Utils, Foreign.Ptr, Foreign.Safe,

260− Foreign.StablePtr, Foreign.Storable, GHC.Arr, GHC.Base, GHC.Bits,

261− GHC.ByteOrder, GHC.Char, GHC.Clock, GHC.Conc, GHC.Conc.IO,

262− GHC.Conc.Signal, GHC.Conc.Sync, GHC.ConsoleHandler, GHC.Constants,

263− GHC.Desugar, GHC.Enum, GHC.Environment, GHC.Err, GHC.Event,

264− GHC.Event.TimeOut, GHC.Exception, GHC.Exception.Type,

265− GHC.ExecutionStack, GHC.ExecutionStack.Internal, GHC.Exts,

266− GHC.Fingerprint, GHC.Fingerprint.Type, GHC.Float,

267− GHC.Float.ConversionUtils, GHC.Float.RealFracMethods, GHC.Foreign,

268− GHC.ForeignPtr, GHC.GHCi, GHC.GHCi.Helpers, GHC.Generics, GHC.IO,

269− GHC.IO.Buffer, GHC.IO.BufferedIO, GHC.IO.Device, GHC.IO.Encoding,

270− GHC.IO.Encoding.CodePage, GHC.IO.Encoding.Failure,

271− GHC.IO.Encoding.Iconv, GHC.IO.Encoding.Latin1,

272− GHC.IO.Encoding.Types, GHC.IO.Encoding.UTF16,

273− GHC.IO.Encoding.UTF32, GHC.IO.Encoding.UTF8, GHC.IO.Exception,

274− GHC.IO.FD, GHC.IO.Handle, GHC.IO.Handle.FD,

275− GHC.IO.Handle.Internals, GHC.IO.Handle.Lock, GHC.IO.Handle.Text,

276− GHC.IO.Handle.Types, GHC.IO.IOMode, GHC.IO.StdHandles,

277− GHC.IO.SubSystem, GHC.IO.Unsafe, GHC.IOArray, GHC.IOPort,

278− GHC.IORef, GHC.Int, GHC.Integer, GHC.Integer.Logarithms, GHC.Ix,

279− GHC.List, GHC.MVar, GHC.Maybe, GHC.Natural, GHC.Num,

280− GHC.Num.BigNat from ghc-bignum-1.2:GHC.Num.BigNat,

281− GHC.Num.Integer from ghc-bignum-1.2:GHC.Num.Integer,

282− GHC.Num.Natural from ghc-bignum-1.2:GHC.Num.Natural, GHC.OldList,

283− GHC.OverloadedLabels, GHC.Pack, GHC.Profiling, GHC.Ptr,

284− GHC.RTS.Flags, GHC.Read, GHC.Real, GHC.Records, GHC.ResponseFile,

285− GHC.ST, GHC.STRef, GHC.Show, GHC.Stable, GHC.StableName, GHC.Stack,

286− GHC.Stack.CCS, GHC.Stack.Types, GHC.StaticPtr, GHC.Stats,

287− GHC.Storable, GHC.TopHandler, GHC.TypeLits, GHC.TypeLits.Internal,

288− GHC.TypeNats, GHC.TypeNats.Internal, GHC.Unicode, GHC.Weak,

289− GHC.Word, Numeric, Numeric.Natural, Prelude, System.CPUTime,

290− System.Console.GetOpt, System.Environment,

291− System.Environment.Blank, System.Exit, System.IO, System.IO.Error,

292− System.IO.Unsafe, System.Info, System.Mem, System.Mem.StableName,

293− System.Mem.Weak, System.Posix.Internals, System.Posix.Types,

294− System.Timeout, Text.ParserCombinators.ReadP,

295− Text.ParserCombinators.ReadPrec, Text.Printf, Text.Read,

296− Text.Read.Lex, Text.Show, Text.Show.Functions, Type.Reflection,

297− Type.Reflection.Unsafe, Unsafe.Coerce

298−hidden-modules:

299− Control.Monad.ST.Imp Control.Monad.ST.Lazy.Imp Data.Functor.Utils

300− Data.OldList Data.Semigroup.Internal Data.Typeable.Internal

301− Foreign.ForeignPtr.Imp GHC.IO.Handle.Lock.Common

302− GHC.IO.Handle.Lock.Flock GHC.IO.Handle.Lock.LinuxOFD

303− GHC.IO.Handle.Lock.NoOp GHC.IO.Handle.Lock.Windows

304− GHC.StaticPtr.Internal GHC.Event.Arr GHC.Event.Array

305− GHC.Event.Internal GHC.Event.Internal.Types GHC.Event.IntTable

306− GHC.Event.IntVar GHC.Event.PSQ GHC.Event.Unique

307− System.Environment.ExecutablePath System.CPUTime.Utils

308− GHC.Event.Control GHC.Event.EPoll GHC.Event.KQueue

309− GHC.Event.Manager GHC.Event.Poll GHC.Event.Thread

310− GHC.Event.TimerManager System.CPUTime.Posix.ClockGetTime

311− System.CPUTime.Posix.Times System.CPUTime.Posix.RUsage

312− System.CPUTime.Unsupported

313−import-dirs:

314−library-dirs:

315−dynamic-library-dirs:

316−data-dir:

317−hs-libraries: HSbase-4.16.3.0

318−include-dirs:

319−includes: HsBase.h

320−depends: ghc-bignum-1.2 ghc-prim-0.8.0 rts

321−haddock-interfaces:

322−haddock-html:

323−---

324−name: binary

325−version: 0.8.9.0

326−visibility: public

327−id: binary-0.8.9.0

328−key: binary-0.8.9.0

329−license: BSD-3-Clause

330−maintainer: Lennart Kolmodin, Don Stewart <dons00@gmail.com>

331−author: Lennart Kolmodin <kolmodin@gmail.com>

332−stability: provisional

333−homepage: https://github.com/kolmodin/binary

334−synopsis:

335− Binary serialisation for Haskell values using lazy ByteStrings

336−description:

337− Efficient, pure binary serialisation using lazy ByteStrings.

338− Haskell values may be encoded to and from binary formats,

339− written to disk as binary, or sent over the network.

340− The format used can be automatically generated, or

341− you can choose to implement a custom format if needed.

342− Serialisation speeds of over 1 G\/sec have been observed,

343− so this library should be suitable for high performance

344− scenarios.

345−category: Data, Parsing

346−exposed: True

347−exposed-modules:

348− Data.Binary Data.Binary.Builder Data.Binary.Get

349− Data.Binary.Get.Internal Data.Binary.Put

350−hidden-modules:

351− Data.Binary.Class Data.Binary.Internal Data.Binary.Generic

352− Data.Binary.FloatCast

353−import-dirs:

354−library-dirs:

355−dynamic-library-dirs:

356−data-dir:

357−hs-libraries: HSbinary-0.8.9.0

358−depends:

359− array-0.5.4.0 base-4.16.3.0 bytestring-0.11.3.1 containers-0.6.5.1

360−haddock-interfaces:

361−haddock-html:

362−---

363−name: bytestring

364−version: 0.11.3.1

365−visibility: public

366−id: bytestring-0.11.3.1

367−key: bytestring-0.11.3.1

368−license: BSD-3-Clause

369−copyright:

370− Copyright (c) Don Stewart 2005-2009,

371− (c) Duncan Coutts 2006-2015,

372− (c) David Roundy 2003-2005,

373− (c) Jasper Van der Jeugt 2010,

374− (c) Simon Meier 2010-2013.

375−maintainer:

376− Haskell Bytestring Team <andrew.lelechenko@gmail.com>, Core Libraries Committee

377−author:

378− Don Stewart,

379− Duncan Coutts

380−homepage: https://github.com/haskell/bytestring

381−synopsis:

382− Fast, compact, strict and lazy byte strings with a list interface

383−description:

384− An efficient compact, immutable byte string type (both strict and lazy)

385− suitable for binary or 8-bit character data.

386− The 'ByteString' type represents sequences of bytes or 8-bit characters.

387− It is suitable for high performance use, both in terms of large data

388− quantities, or high speed requirements. The 'ByteString' functions follow

389− the same style as Haskell\'s ordinary lists, so it is easy to convert code

390− from using 'String' to 'ByteString'.

391− Two 'ByteString' variants are provided:

392− * Strict 'ByteString's keep the string as a single large array. This

393− makes them convenient for passing data between C and Haskell.

394− * Lazy 'ByteString's use a lazy list of strict chunks which makes it

395− suitable for I\/O streaming tasks.

396− The @Char8@ modules provide a character-based view of the same

397− underlying 'ByteString' types. This makes it convenient to handle mixed

398− binary and 8-bit character content (which is common in many file formats

399− and network protocols).

400− The 'Builder' module provides an efficient way to build up 'ByteString's

401− in an ad-hoc way by repeated concatenation. This is ideal for fast

402− serialisation or pretty printing.

403− There is also a 'ShortByteString' type which has a lower memory overhead

404− and can be converted to or from a 'ByteString'. It is suitable for keeping

405− many short strings in memory.

406− 'ByteString's are not designed for Unicode. For Unicode strings you should

407− use the 'Text' type from the @text@ package.

408− These modules are intended to be imported qualified, to avoid name clashes

409− with "Prelude" functions, e.g.

410− > import qualified Data.ByteString as BS

411−category: Data

412−exposed: True

413−exposed-modules:

414− Data.ByteString Data.ByteString.Builder

415− Data.ByteString.Builder.Extra Data.ByteString.Builder.Internal

416− Data.ByteString.Builder.Prim Data.ByteString.Builder.Prim.Internal

417− Data.ByteString.Builder.RealFloat Data.ByteString.Char8

418− Data.ByteString.Internal Data.ByteString.Lazy

419− Data.ByteString.Lazy.Char8 Data.ByteString.Lazy.Internal

420− Data.ByteString.Short Data.ByteString.Short.Internal

421− Data.ByteString.Unsafe

422−hidden-modules:

423− Data.ByteString.Builder.ASCII Data.ByteString.Builder.Prim.ASCII

424− Data.ByteString.Builder.Prim.Binary

425− Data.ByteString.Builder.Prim.Internal.Base16

426− Data.ByteString.Builder.Prim.Internal.Floating

427− Data.ByteString.Builder.RealFloat.F2S

428− Data.ByteString.Builder.RealFloat.D2S

429− Data.ByteString.Builder.RealFloat.Internal

430− Data.ByteString.Builder.RealFloat.TableGenerator

431− Data.ByteString.Lazy.Internal.Deque

432−import-dirs:

433−library-dirs:

434−dynamic-library-dirs:

435−data-dir:

436−hs-libraries: HSbytestring-0.11.3.1

437−include-dirs:

438−includes: fpstring.h

439−depends:

440− base-4.16.3.0 deepseq-1.4.6.1 ghc-prim-0.8.0

441− template-haskell-2.18.0.0

442−haddock-interfaces:

443−haddock-html:

444−---

445−name: containers

446−version: 0.6.5.1

447−visibility: public

448−id: containers-0.6.5.1

449−key: containers-0.6.5.1

450−license: BSD-3-Clause

451−maintainer: libraries@haskell.org

452−synopsis: Assorted concrete container types

453−description:

454− This package contains efficient general-purpose implementations

455− of various immutable container types including sets, maps, sequences,

456− trees, and graphs.

457− For a walkthrough of what this package provides with examples of common

458− operations see the [containers

459− introduction](https://haskell-containers.readthedocs.io).

460− The declared cost of each operation is either worst-case or amortized, but

461− remains valid even if structures are shared.

462−category: Data Structures

463−exposed: True

464−exposed-modules:

465− Data.Containers.ListUtils Data.Graph Data.IntMap

466− Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy

467− Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict

468− Data.IntMap.Strict.Internal Data.IntSet Data.IntSet.Internal

469− Data.Map Data.Map.Internal Data.Map.Internal.Debug Data.Map.Lazy

470− Data.Map.Merge.Lazy Data.Map.Merge.Strict Data.Map.Strict

471− Data.Map.Strict.Internal Data.Sequence Data.Sequence.Internal

472− Data.Sequence.Internal.Sorting Data.Set Data.Set.Internal Data.Tree

473− Utils.Containers.Internal.BitQueue

474− Utils.Containers.Internal.BitUtil

475− Utils.Containers.Internal.StrictPair

476−hidden-modules:

477− Utils.Containers.Internal.State

478− Utils.Containers.Internal.StrictMaybe

479− Utils.Containers.Internal.PtrEquality

480− Utils.Containers.Internal.Coercions

481− Utils.Containers.Internal.TypeError

482− Data.Map.Internal.DeprecatedShowTree

483− Data.IntMap.Internal.DeprecatedDebug

484−import-dirs:

485−library-dirs:

486−dynamic-library-dirs:

487−data-dir:

488−hs-libraries: HScontainers-0.6.5.1

489−depends: array-0.5.4.0 base-4.16.3.0 deepseq-1.4.6.1

490−haddock-interfaces:

491−haddock-html:

492−---

493−name: deepseq

494−version: 1.4.6.1

495−visibility: public

496−id: deepseq-1.4.6.1

497−key: deepseq-1.4.6.1

498−license: BSD-3-Clause

499−maintainer: libraries@haskell.org

500−synopsis: Deep evaluation of data structures

501−description:

502− This package provides methods for fully evaluating data structures

503− (\"deep evaluation\"). Deep evaluation is often used for adding

504− strictness to a program, e.g. in order to force pending exceptions,

505− remove space leaks, or force lazy I/O to happen. It is also useful

506− in parallel programs, to ensure pending work does not migrate to the

507− wrong thread.

508− The primary use of this package is via the 'deepseq' function, a

509− \"deep\" version of 'seq'. It is implemented on top of an 'NFData'

510− typeclass (\"Normal Form Data\", data structures with no unevaluated

511− components) which defines strategies for fully evaluating different

512− data types. See module documentation in "Control.DeepSeq" for more

513− details.

514−category: Control

515−exposed: True

516−exposed-modules: Control.DeepSeq

517−hidden-modules: Control.DeepSeq.BackDoor

518−import-dirs:

519−library-dirs:

520−dynamic-library-dirs:

521−data-dir:

522−hs-libraries: HSdeepseq-1.4.6.1

523−depends: array-0.5.4.0 base-4.16.3.0

524−haddock-interfaces:

525−haddock-html:

526−---

527−name: directory

528−version: 1.3.6.2

529−visibility: public

530−id: directory-1.3.6.2

531−key: directory-1.3.6.2

532−license: BSD-3-Clause

533−maintainer: libraries@haskell.org

534−synopsis: Platform-agnostic library for filesystem operations

535−description:

536− This library provides a basic set of operations for manipulating files and

537− directories in a portable way.

538−category: System

539−exposed: True

540−exposed-modules:

541− System.Directory System.Directory.Internal

542− System.Directory.Internal.Prelude

543−hidden-modules:

544− System.Directory.Internal.C_utimensat

545− System.Directory.Internal.Common System.Directory.Internal.Config

546− System.Directory.Internal.Posix System.Directory.Internal.Windows

547−import-dirs:

548−library-dirs:

549−dynamic-library-dirs:

550−data-dir:

551−hs-libraries: HSdirectory-1.3.6.2

552−depends:

553− base-4.16.3.0 filepath-1.4.2.2 time-1.11.1.1 unix-2.7.2.2

554−haddock-interfaces:

555−haddock-html:

556−---

557−name: exceptions

558−version: 0.10.4

559−visibility: public

560−id: exceptions-0.10.4

561−key: exceptions-0.10.4

562−license: BSD-3-Clause

563−copyright:

566−maintainer: Edward A. Kmett <ekmett@gmail.com>

567−author: Edward A. Kmett

568−stability: provisional

569−homepage: http://github.com/ekmett/exceptions/

570−synopsis: Extensible optionally-pure exceptions

571−description: Extensible optionally-pure exceptions.

572−category: Control, Exceptions, Monad

573−exposed: True

574−exposed-modules: Control.Monad.Catch Control.Monad.Catch.Pure

575−import-dirs:

576−library-dirs:

577−dynamic-library-dirs:

578−data-dir:

579−hs-libraries: HSexceptions-0.10.4

580−depends:

581− base-4.16.3.0 mtl-2.2.2 stm-2.5.0.2 template-haskell-2.18.0.0

582− transformers-0.5.6.2

583−haddock-interfaces:

584−haddock-html:

585−---

586−name: filepath

587−version: 1.4.2.2

588−visibility: public

589−id: filepath-1.4.2.2

590−key: filepath-1.4.2.2

591−license: BSD-3-Clause

592−copyright: Neil Mitchell 2005-2020

593−maintainer: Julian Ospald <hasufell@posteo.de>

594−author: Neil Mitchell <ndmitchell@gmail.com>

595−homepage: https://github.com/haskell/filepath#readme

596−synopsis: Library for manipulating FilePaths in a cross platform way.

597−description:

598− This package provides functionality for manipulating @FilePath@ values, and is shipped with both <https://www.haskell.org/ghc/ GHC> and the <https://www.haskell.org/platform/ Haskell Platform>. It provides three modules:

599− * "System.FilePath.Posix" manipulates POSIX\/Linux style @FilePath@ values (with @\/@ as the path separator).

600− * "System.FilePath.Windows" manipulates Windows style @FilePath@ values (with either @\\@ or @\/@ as the path separator, and deals with drives).

601− * "System.FilePath" is an alias for the module appropriate to your platform.

602− All three modules provide the same API, and the same documentation (calling out differences in the different variants).

603−category: System

604−exposed: True

605−exposed-modules:

606− System.FilePath System.FilePath.Posix System.FilePath.Windows

607−import-dirs:

608−library-dirs:

609−dynamic-library-dirs:

610−data-dir:

611−hs-libraries: HSfilepath-1.4.2.2

612−depends: base-4.16.3.0

613−haddock-interfaces:

614−haddock-html:

615−---

616−name: ghc-bignum

617−version: 1.2

618−visibility: public

619−id: ghc-bignum-1.2

620−key: ghc-bignum-1.2

621−license: BSD-3-Clause

622−maintainer: libraries@haskell.org

623−author: Sylvain Henry

624−synopsis: GHC BigNum library

625−description:

626− This package provides the low-level implementation of the standard

627− 'BigNat', 'Natural' and 'Integer' types.

628−category: Numeric, Algebra, GHC

629−exposed: True

630−exposed-modules:

631− GHC.Num.Backend GHC.Num.Backend.Native GHC.Num.Backend.Selected

632− GHC.Num.BigNat GHC.Num.Integer GHC.Num.Natural GHC.Num.Primitives

633− GHC.Num.WordArray

634−import-dirs:

635−library-dirs:

636−dynamic-library-dirs:

637−data-dir:

638−hs-libraries: HSghc-bignum-1.2

639−depends: ghc-prim-0.8.0

640−haddock-interfaces:

641−haddock-html:

642−---

643−name: ghc-boot

644−version: 9.2.4

645−visibility: public

646−id: ghc-boot-9.2.4

647−key: ghc-boot-9.2.4

648−license: BSD-3-Clause

649−maintainer: ghc-devs@haskell.org

650−synopsis: Shared functionality between GHC and its boot libraries

651−description:

652− This library is shared between GHC, ghc-pkg, and other boot

653− libraries.

654− .

655− A note about "GHC.Unit.Database": it only deals with the subset of

656− the package database that the compiler cares about: modules

657− paths etc and not package metadata like description, authors

658− etc. It is thus not a library interface to ghc-pkg and is *not*

659− suitable for modifying GHC package databases.

660− .

661− The package database format and this library are constructed in

662− such a way that while ghc-pkg depends on Cabal, the GHC library

663− and program do not have to depend on Cabal.

664−category: GHC

665−exposed: True

666−exposed-modules:

667− GHC.BaseDir, GHC.Data.ShortText, GHC.Data.SizedSeq,

668− GHC.ForeignSrcLang,

669− GHC.ForeignSrcLang.Type from ghc-boot-th-9.2.4:GHC.ForeignSrcLang.Type,

670− GHC.HandleEncoding, GHC.LanguageExtensions,

671− GHC.LanguageExtensions.Type from ghc-boot-th-9.2.4:GHC.LanguageExtensions.Type,

672− GHC.Lexeme from ghc-boot-th-9.2.4:GHC.Lexeme, GHC.Platform.ArchOS,

673− GHC.Platform.Host, GHC.Serialized, GHC.Settings.Utils,

674− GHC.UniqueSubdir, GHC.Unit.Database, GHC.Utils.Encoding,

675− GHC.Version

676−import-dirs:

677−library-dirs:

678−dynamic-library-dirs:

679−data-dir:

680−hs-libraries: HSghc-boot-9.2.4

681−depends:

682− base-4.16.3.0 binary-0.8.9.0 bytestring-0.11.3.1 containers-0.6.5.1

683− deepseq-1.4.6.1 directory-1.3.6.2 filepath-1.4.2.2

684− ghc-boot-th-9.2.4 unix-2.7.2.2

685−haddock-interfaces:

686−haddock-html:

687−---

688−name: ghc-boot-th

689−version: 9.2.4

690−visibility: public

691−id: ghc-boot-th-9.2.4

692−key: ghc-boot-th-9.2.4

693−license: BSD-3-Clause

694−maintainer: ghc-devs@haskell.org

695−synopsis:

696− Shared functionality between GHC and the @template-haskell@

697− library

698−description:

699− This library contains various bits shared between the @ghc@ and

700− @template-haskell@ libraries.

701− This package exists to ensure that @template-haskell@ has a

702− minimal set of transitive dependencies, since it is intended to

703− be depended upon by user code.

704−category: GHC

705−exposed: True

706−exposed-modules:

707− GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme

708−import-dirs:

709−library-dirs:

710−dynamic-library-dirs:

711−data-dir:

712−hs-libraries: HSghc-boot-th-9.2.4

713−depends: base-4.16.3.0

714−haddock-interfaces:

715−haddock-html:

716−---

717−name: ghc-compact

718−version: 0.1.0.0

719−visibility: public

720−id: ghc-compact-0.1.0.0

721−key: ghc-compact-0.1.0.0

722−license: BSD-3-Clause

723−maintainer: libraries@haskell.org

724−synopsis: In memory storage of deeply evaluated data structure

725−description:

726− This package provides minimal functionality for working with

727− "compact regions", which hold a fully evaluated Haskell object graph.

728− These regions maintain the invariant that no pointers live inside the struct

729− that point outside it, which ensures efficient garbage collection without

730− ever reading the structure contents (effectively, it works as a manually

731− managed "oldest generation" which is never freed until the whole is

732− released).

733− Internally, the struct is stored a single contiguous block of memory,

734− which allows efficient serialization and deserialization of structs

735− for distributed computing.

736− This package provides a low-level API; see also the </package/compact

737− compact package> which provides a user-facing API.

738−category: Data

739−exposed: True

740−exposed-modules: GHC.Compact GHC.Compact.Serialized

741−import-dirs:

742−library-dirs:

743−dynamic-library-dirs:

744−data-dir:

745−hs-libraries: HSghc-compact-0.1.0.0

746−depends: base-4.16.3.0 bytestring-0.11.3.1 ghc-prim-0.8.0

747−haddock-interfaces:

748−haddock-html:

749−---

750−name: ghc-heap

751−version: 9.2.4

752−visibility: public

753−id: ghc-heap-9.2.4

754−key: ghc-heap-9.2.4

755−license: BSD-3-Clause

756−maintainer: libraries@haskell.org

757−synopsis: Functions for walking GHC's heap

758−description:

759− This package provides functions for walking the GHC heap data structures

760− and retrieving information about those data structures.

761−category: GHC

762−exposed: True

763−exposed-modules:

764− GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures

765− GHC.Exts.Heap.Constants GHC.Exts.Heap.FFIClosures

766− GHC.Exts.Heap.FFIClosures_ProfilingDisabled

767− GHC.Exts.Heap.FFIClosures_ProfilingEnabled GHC.Exts.Heap.InfoTable

768− GHC.Exts.Heap.InfoTable.Types GHC.Exts.Heap.InfoTableProf

769− GHC.Exts.Heap.ProfInfo.PeekProfInfo

770− GHC.Exts.Heap.ProfInfo.PeekProfInfo_ProfilingDisabled

771− GHC.Exts.Heap.ProfInfo.PeekProfInfo_ProfilingEnabled

772− GHC.Exts.Heap.ProfInfo.Types GHC.Exts.Heap.Utils

773−import-dirs:

774−library-dirs:

775−dynamic-library-dirs:

776−data-dir:

777−hs-libraries: HSghc-heap-9.2.4

778−depends: base-4.16.3.0 containers-0.6.5.1 ghc-prim-0.8.0 rts

779−haddock-interfaces:

780−haddock-html:

781−---

782−name: ghc-prim

783−version: 0.8.0

784−visibility: public

785−id: ghc-prim-0.8.0

786−key: ghc-prim-0.8.0

787−license: BSD-3-Clause

788−maintainer: libraries@haskell.org

789−synopsis: GHC primitives

790−description:

791− This package contains the primitive types and operations supplied by GHC.

792−category: GHC

793−exposed: True

794−exposed-modules:

795− GHC.CString GHC.Classes GHC.Debug GHC.Magic GHC.Prim.Exception

796− GHC.Prim.Ext GHC.Prim.Panic GHC.PrimopWrappers GHC.Tuple GHC.Types

797− GHC.Prim

798−import-dirs:

799−library-dirs:

800−dynamic-library-dirs:

801−data-dir:

802−hs-libraries: HSghc-prim-0.8.0

803−extra-libraries: gcc c m

804−depends: rts

805−haddock-interfaces:

806−haddock-html:

807−---

808−name: ghci

809−version: 9.2.4

810−visibility: public

811−id: ghci-9.2.4

812−key: ghci-9.2.4

813−license: BSD-3-Clause

814−maintainer: ghc-devs@haskell.org

815−synopsis: The library supporting GHC's interactive interpreter

816−description:

817− This library offers interfaces which mediate interactions between the

818− @ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter

819− backend.

820−category: GHC

821−exposed: True

822−exposed-modules:

823− GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI

824− GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes

825− GHCi.ResolvedBCO GHCi.Run GHCi.Signals GHCi.StaticPtrTable GHCi.TH

826− GHCi.TH.Binary

827−import-dirs:

828−library-dirs:

829−dynamic-library-dirs:

830−data-dir:

831−hs-libraries: HSghci-9.2.4

832−depends:

833− array-0.5.4.0 base-4.16.3.0 binary-0.8.9.0 bytestring-0.11.3.1

834− containers-0.6.5.1 deepseq-1.4.6.1 filepath-1.4.2.2 ghc-boot-9.2.4

835− ghc-heap-9.2.4 ghc-prim-0.8.0 rts template-haskell-2.18.0.0

836− transformers-0.5.6.2 unix-2.7.2.2

837−haddock-interfaces:

838−haddock-html:

839−---

840−name: haskeline

841−version: 0.8.2

842−visibility: public

843−id: haskeline-0.8.2

844−key: haskeline-0.8.2

845−license: BSD-3-Clause

846−copyright: (c) Judah Jacobson

847−maintainer: Judah Jacobson <judah.jacobson@gmail.com>

848−author: Judah Jacobson

849−stability: Stable

850−homepage: https://github.com/judah/haskeline

851−synopsis:

852− A command-line interface for user input, written in Haskell.

853−description:

854− Haskeline provides a user interface for line input in command-line

855− programs. This library is similar in purpose to readline, but since

856− it is written in Haskell it is (hopefully) more easily used in other

857− Haskell programs.

858− Haskeline runs both on POSIX-compatible systems and on Windows.

859−category: User Interfaces

860−exposed: True

861−exposed-modules:

862− System.Console.Haskeline System.Console.Haskeline.Completion

863− System.Console.Haskeline.History System.Console.Haskeline.IO

864− System.Console.Haskeline.Internal

865−hidden-modules:

866− System.Console.Haskeline.Backend

867− System.Console.Haskeline.Backend.WCWidth

868− System.Console.Haskeline.Command

869− System.Console.Haskeline.Command.Completion

870− System.Console.Haskeline.Command.History

871− System.Console.Haskeline.Command.KillRing

872− System.Console.Haskeline.Directory System.Console.Haskeline.Emacs

873− System.Console.Haskeline.InputT System.Console.Haskeline.Key

874− System.Console.Haskeline.LineState System.Console.Haskeline.Monads

875− System.Console.Haskeline.Prefs System.Console.Haskeline.Recover

876− System.Console.Haskeline.RunCommand System.Console.Haskeline.Term

877− System.Console.Haskeline.Command.Undo System.Console.Haskeline.Vi

878− System.Console.Haskeline.Backend.Posix

879− System.Console.Haskeline.Backend.Posix.Encoder

880− System.Console.Haskeline.Backend.DumbTerm

881−import-dirs:

882−library-dirs:

883−dynamic-library-dirs:

884−data-dir:

885−hs-libraries: HShaskeline-0.8.2

886−depends:

887− base-4.16.3.0 bytestring-0.11.3.1 containers-0.6.5.1

888− directory-1.3.6.2 exceptions-0.10.4 filepath-1.4.2.2

889− process-1.6.13.2 stm-2.5.0.2 transformers-0.5.6.2 unix-2.7.2.2

890−haddock-interfaces:

891−haddock-html:

892−---

893−name: hpc

894−version: 0.6.1.0

895−visibility: public

896−id: hpc-0.6.1.0

897−key: hpc-0.6.1.0

898−license: BSD-3-Clause

899−maintainer: ghc-devs@haskell.org

900−author: Andy Gill

901−synopsis: Code Coverage Library for Haskell

902−description:

903− This package provides the code coverage library for Haskell.

904− See <http://www.haskell.org/haskellwiki/Haskell_program_coverage> for more

905− information.

906−category: Control

907−exposed: True

908−exposed-modules:

909− Trace.Hpc.Mix Trace.Hpc.Reflect Trace.Hpc.Tix Trace.Hpc.Util

910−import-dirs:

911−library-dirs:

912−dynamic-library-dirs:

913−data-dir:

914−hs-libraries: HShpc-0.6.1.0

915−depends:

916− base-4.16.3.0 containers-0.6.5.1 deepseq-1.4.6.1 directory-1.3.6.2

917− filepath-1.4.2.2 time-1.11.1.1

918−haddock-interfaces:

919−haddock-html:

920−---

921−name: integer-gmp

922−version: 1.1

923−visibility: public

924−id: integer-gmp-1.1

925−key: integer-gmp-1.1

926−license: BSD-3-Clause

927−maintainer: hvr@gnu.org

928−author: Herbert Valerio Riedel

929−synopsis: Integer library based on GMP

930−description:

931− This package used to provide an implementation of the standard 'Integer'

932− type based on the

933− <http://gmplib.org/ GNU Multiple Precision Arithmetic Library (GMP)>.

934− It is now deprecated in favor of the 'ghc-bignum' package.

935− Its purpose is to provide backward compatibility for codes directly

936− depending on the `integer-gmp` package.

937−category: Numeric, Algebra

938−exposed: True

939−exposed-modules: GHC.Integer.GMP.Internals

940−import-dirs:

941−library-dirs:

942−dynamic-library-dirs:

943−data-dir:

944−hs-libraries: HSinteger-gmp-1.1

945−depends: base-4.16.3.0 ghc-bignum-1.2 ghc-prim-0.8.0

946−haddock-interfaces:

947−haddock-html:

948−---

949−name: libiserv

950−version: 9.2.4

951−visibility: public

952−id: libiserv-9.2.4

953−key: libiserv-9.2.4

954−license: BSD-3-Clause

955−copyright: XXX

956−maintainer: XXX

957−author: XXX

958−synopsis:

959− Provides shared functionality between iserv and iserv-proxy.

960−description:

961− Provides shared functionality between iserv and iserv-proxy.

962−category: Development

963−exposed: True

964−exposed-modules: GHCi.Utils Lib

965−import-dirs:

966−library-dirs:

967−dynamic-library-dirs:

968−data-dir:

969−hs-libraries: HSlibiserv-9.2.4

970−depends:

971− base-4.16.3.0 binary-0.8.9.0 bytestring-0.11.3.1 containers-0.6.5.1

972− deepseq-1.4.6.1 ghci-9.2.4 unix-2.7.2.2

973−haddock-interfaces:

974−haddock-html:

975−---

976−name: mtl

977−version: 2.2.2

978−visibility: public

979−id: mtl-2.2.2

980−key: mtl-2.2.2

981−license: BSD-3-Clause

982−maintainer: Edward Kmett <ekmett@gmail.com>

983−author: Andy Gill

984−homepage: http://github.com/haskell/mtl

985−synopsis: Monad classes, using functional dependencies

986−description:

987− Monad classes using functional dependencies, with instances

988− for various monad transformers, inspired by the paper

989− /Functional Programming with Overloading and Higher-Order Polymorphism/,

990− by Mark P Jones, in /Advanced School of Functional Programming/, 1995

991− (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

992−category: Control

993−exposed: True

994−exposed-modules:

995− Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error

996− Control.Monad.Error.Class Control.Monad.Except

997− Control.Monad.Identity Control.Monad.List Control.Monad.RWS

998− Control.Monad.RWS.Class Control.Monad.RWS.Lazy

999− Control.Monad.RWS.Strict Control.Monad.Reader

1000− Control.Monad.Reader.Class Control.Monad.State

1001− Control.Monad.State.Class Control.Monad.State.Lazy

1002− Control.Monad.State.Strict Control.Monad.Trans Control.Monad.Writer

1003− Control.Monad.Writer.Class Control.Monad.Writer.Lazy

1004− Control.Monad.Writer.Strict

1005−import-dirs:

1006−library-dirs:

1007−dynamic-library-dirs:

1008−data-dir:

1009−hs-libraries: HSmtl-2.2.2

1010−depends: base-4.16.3.0 transformers-0.5.6.2

1011−haddock-interfaces:

1012−haddock-html:

1013−---

1014−name: parsec

1015−version: 3.1.15.0

1016−visibility: public

1017−id: parsec-3.1.15.0

1018−key: parsec-3.1.15.0

1019−license: BSD-2-Clause

1020−maintainer:

1021− Oleg Grenrus <oleg.grenrus@iki.fi>, Herbert Valerio Riedel <hvr@gnu.org>

1022−author:

1023− Daan Leijen <daan@microsoft.com>, Paolo Martini <paolo@nemail.it>, Antoine Latter <aslatter@gmail.com>

1024−homepage: https://github.com/haskell/parsec

1025−synopsis: Monadic parser combinators

1026−description:

1027− Parsec is designed from scratch as an industrial-strength parser

1028− library. It is simple, safe, well documented (on the package

1029− homepage), has extensive libraries, good error messages,

1030− and is fast. It is defined as a monad transformer that can be

1031− stacked on arbitrary monads, and it is also parametric in the

1032− input stream type.

1033− The main entry point is the "Text.Parsec" module which provides

1034− defaults for parsing 'Char'acter data.

1035− The "Text.ParserCombinators.Parsec" module hierarchy contains

1036− the legacy @parsec-2@ API and may be removed at some point in

1037− the future.

1038−category: Parsing

1039−exposed: True

1040−exposed-modules:

1041− Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy

1042− Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error

1043− Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm

1044− Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String

1045− Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token

1046− Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char

1047− Text.ParserCombinators.Parsec.Combinator

1048− Text.ParserCombinators.Parsec.Error

1049− Text.ParserCombinators.Parsec.Expr

1050− Text.ParserCombinators.Parsec.Language

1051− Text.ParserCombinators.Parsec.Perm

1052− Text.ParserCombinators.Parsec.Pos

1053− Text.ParserCombinators.Parsec.Prim

1054− Text.ParserCombinators.Parsec.Token

1055−import-dirs:

1056−library-dirs:

1057−dynamic-library-dirs:

1058−data-dir:

1059−hs-libraries: HSparsec-3.1.15.0

1060−depends:

1061− base-4.16.3.0 bytestring-0.11.3.1 mtl-2.2.2 text-1.2.5.0

1062−haddock-interfaces:

1063−haddock-html:

1064−---

1065−name: pretty

1066−version: 1.1.3.6

1067−visibility: public

1068−id: pretty-1.1.3.6

1069−key: pretty-1.1.3.6

1070−license: BSD-3-Clause

1071−maintainer: David Terei <code@davidterei.com>

1072−stability: Stable

1073−homepage: http://github.com/haskell/pretty

1074−synopsis: Pretty-printing library

1075−description:

1076− This package contains a pretty-printing library, a set of API's

1077− that provides a way to easily print out text in a consistent

1078− format of your choosing. This is useful for compilers and related

1079− tools.

1080− This library was originally designed by John Hughes's and has since

1081− been heavily modified by Simon Peyton Jones.

1082−category: Text

1083−exposed: True

1084−exposed-modules:

1085− Text.PrettyPrint Text.PrettyPrint.Annotated

1086− Text.PrettyPrint.Annotated.HughesPJ

1087− Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ

1088− Text.PrettyPrint.HughesPJClass

1089−import-dirs:

1090−library-dirs:

1091−dynamic-library-dirs:

1092−data-dir:

1093−hs-libraries: HSpretty-1.1.3.6

1094−depends: base-4.16.3.0 deepseq-1.4.6.1 ghc-prim-0.8.0

1095−haddock-interfaces:

1096−haddock-html:

1097−---

1098−name: process

1099−version: 1.6.13.2

1100−visibility: public

1101−id: process-1.6.13.2

1102−key: process-1.6.13.2

1103−license: BSD-3-Clause

1104−maintainer: libraries@haskell.org

1105−synopsis: Process libraries

1106−description:

1107− This package contains libraries for dealing with system processes.

1108− The typed-process package is a more recent take on a process API,

1109− which uses this package internally. It features better binary

1110− support, easier concurrency, and a more composable API. You can

1111− read more about it at

1112− <https://github.com/fpco/typed-process/#readme>.

1113−category: System

1114−exposed: True

1115−exposed-modules: System.Cmd System.Process System.Process.Internals

1116−hidden-modules: System.Process.Common System.Process.Posix

1117−import-dirs:

1118−library-dirs:

1119−dynamic-library-dirs:

1120−data-dir:

1121−hs-libraries: HSprocess-1.6.13.2

1122−include-dirs:

1123−includes: runProcess.h

1124−depends:

1125− base-4.16.3.0 deepseq-1.4.6.1 directory-1.3.6.2 filepath-1.4.2.2

1126− unix-2.7.2.2

1127−haddock-interfaces:

1128−haddock-html:

1129−---

1130−name: stm

1131−version: 2.5.0.2

1132−visibility: public

1133−id: stm-2.5.0.2

1134−key: stm-2.5.0.2

1135−license: BSD-3-Clause

1136−maintainer: libraries@haskell.org

1137−homepage: https://wiki.haskell.org/Software_transactional_memory

1138−synopsis: Software Transactional Memory

1139−description:

1140− Software Transactional Memory, or STM, is an abstraction for

1141− concurrent communication. The main benefits of STM are

1142− /composability/ and /modularity/. That is, using STM you can write

1143− concurrent abstractions that can be easily composed with any other

1144− abstraction built using STM, without exposing the details of how

1145− your abstraction ensures safety. This is typically not the case

1146− with other forms of concurrent communication, such as locks or

1147− 'MVar's.

1148−category: Concurrency

1149−exposed: True

1150−exposed-modules:

1151− Control.Concurrent.STM Control.Concurrent.STM.TArray

1152− Control.Concurrent.STM.TBQueue Control.Concurrent.STM.TChan

1153− Control.Concurrent.STM.TMVar Control.Concurrent.STM.TQueue

1154− Control.Concurrent.STM.TSem Control.Concurrent.STM.TVar

1155− Control.Monad.STM

1156−hidden-modules: Control.Sequential.STM

1157−import-dirs:

1158−library-dirs:

1159−dynamic-library-dirs:

1160−data-dir:

1161−hs-libraries: HSstm-2.5.0.2

1162−depends: array-0.5.4.0 base-4.16.3.0

1163−haddock-interfaces:

1164−haddock-html:

1165−---

1166−name: template-haskell

1167−version: 2.18.0.0

1168−visibility: public

1169−id: template-haskell-2.18.0.0

1170−key: template-haskell-2.18.0.0

1171−license: BSD-3-Clause

1172−maintainer: libraries@haskell.org

1173−synopsis: Support library for Template Haskell

1174−description:

1175− This package provides modules containing facilities for manipulating

1176− Haskell source code using Template Haskell.

1177− See <http://www.haskell.org/haskellwiki/Template_Haskell> for more

1178− information.

1179−category: Template Haskell

1180−exposed: True

1181−exposed-modules:

1182− Language.Haskell.TH Language.Haskell.TH.CodeDo

1183− Language.Haskell.TH.LanguageExtensions Language.Haskell.TH.Lib

1184− Language.Haskell.TH.Lib.Internal Language.Haskell.TH.Ppr

1185− Language.Haskell.TH.PprLib Language.Haskell.TH.Quote

1186− Language.Haskell.TH.Syntax

1187−hidden-modules: Language.Haskell.TH.Lib.Map

1188−import-dirs:

1189−library-dirs:

1190−dynamic-library-dirs:

1191−data-dir:

1192−hs-libraries: HStemplate-haskell-2.18.0.0

1193−depends:

1194− base-4.16.3.0 ghc-boot-th-9.2.4 ghc-prim-0.8.0 pretty-1.1.3.6

1195−haddock-interfaces:

1196−haddock-html:

1197−---

1198−name: text

1199−version: 1.2.5.0

1200−visibility: public

1201−id: text-1.2.5.0

1202−key: text-1.2.5.0

1203−license: BSD-2-Clause

1204−copyright: 2009-2011 Bryan O'Sullivan, 2008-2009 Tom Harper

1205−maintainer:

1206− Haskell Text Team <andrew.lelechenko@gmail.com>, Core Libraries Committee

1207−author: Bryan O'Sullivan <bos@serpentine.com>

1208−homepage: https://github.com/haskell/text

1209−synopsis: An efficient packed Unicode text type.

1210−description:

1211− An efficient packed, immutable Unicode text type (both strict and

1212− lazy), with a powerful loop fusion optimization framework.

1213− The 'Text' type represents Unicode character strings, in a time and

1214− space-efficient manner. This package provides text processing

1215− capabilities that are optimized for performance critical use, both

1216− in terms of large data quantities and high speed.

1217− The 'Text' type provides character-encoding, type-safe case

1218− conversion via whole-string case conversion functions (see "Data.Text").

1219− It also provides a range of functions for converting 'Text' values to

1220− and from 'ByteStrings', using several standard encodings

1221− (see "Data.Text.Encoding").

1222− Efficient locale-sensitive support for text IO is also supported

1223− (see "Data.Text.IO").

1224− These modules are intended to be imported qualified, to avoid name

1225− clashes with Prelude functions, e.g.

1226− > import qualified Data.Text as T

1227− == ICU Support

1228− To use an extended and very rich family of functions for working

1229− with Unicode text (including normalization, regular expressions,

1230− non-standard encodings, text breaking, and locales), see

1231− the [text-icu package](https://hackage.haskell.org/package/text-icu)

1232− based on the well-respected and liberally

1233− licensed [ICU library](http://site.icu-project.org/).

1234− == Internal Representation: UTF-16 vs. UTF-8

1235− Currently the @text@ library uses UTF-16 as its internal representation

1236− which is [neither a fixed-width nor always the most dense representation](http://utf8everywhere.org/)

1237− for Unicode text. We're currently investigating the feasibility

1238− of [changing Text's internal representation to UTF-8](https://github.com/text-utf8)

1239− and if you need such a 'Text' type right now you might be interested in using the spin-off

1240− packages <https://hackage.haskell.org/package/text-utf8 text-utf8> and

1241− <https://hackage.haskell.org/package/text-short text-short>.

1242−category: Data, Text

1243−exposed: True

1244−exposed-modules:

1245− Data.Text Data.Text.Array Data.Text.Encoding

1246− Data.Text.Encoding.Error Data.Text.Foreign Data.Text.IO

1247− Data.Text.Internal Data.Text.Internal.Builder

1248− Data.Text.Internal.Builder.Functions

1249− Data.Text.Internal.Builder.Int.Digits

1250− Data.Text.Internal.Builder.RealFloat.Functions

1251− Data.Text.Internal.ByteStringCompat

1252− Data.Text.Internal.Encoding.Fusion

1253− Data.Text.Internal.Encoding.Fusion.Common

1254− Data.Text.Internal.Encoding.Utf16 Data.Text.Internal.Encoding.Utf32

1255− Data.Text.Internal.Encoding.Utf8 Data.Text.Internal.Functions

1256− Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping

1257− Data.Text.Internal.Fusion.Common Data.Text.Internal.Fusion.Size

1258− Data.Text.Internal.Fusion.Types Data.Text.Internal.IO

1259− Data.Text.Internal.Lazy Data.Text.Internal.Lazy.Encoding.Fusion

1260− Data.Text.Internal.Lazy.Fusion Data.Text.Internal.Lazy.Search

1261− Data.Text.Internal.PrimCompat Data.Text.Internal.Private

1262− Data.Text.Internal.Read Data.Text.Internal.Search

1263− Data.Text.Internal.Unsafe Data.Text.Internal.Unsafe.Char

1264− Data.Text.Internal.Unsafe.Shift Data.Text.Lazy

1265− Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int

1266− Data.Text.Lazy.Builder.RealFloat Data.Text.Lazy.Encoding

1267− Data.Text.Lazy.IO Data.Text.Lazy.Internal Data.Text.Lazy.Read

1268− Data.Text.Read Data.Text.Unsafe

1269−hidden-modules: Data.Text.Show

1270−import-dirs:

1271−library-dirs:

1272−dynamic-library-dirs:

1273−data-dir:

1274−hs-libraries: HStext-1.2.5.0

1275−depends:

1276− array-0.5.4.0 base-4.16.3.0 binary-0.8.9.0 bytestring-0.11.3.1

1277− deepseq-1.4.6.1 ghc-prim-0.8.0 template-haskell-2.18.0.0

1278−haddock-interfaces:

1279−haddock-html:

1280−---

1281−name: time

1282−version: 1.11.1.1

1283−visibility: public

1284−id: time-1.11.1.1

1285−key: time-1.11.1.1

1286−license: BSD-3-Clause

1287−maintainer: <ashley@semantic.org>

1288−author: Ashley Yakeley

1289−stability: stable

1290−homepage: https://github.com/haskell/time

1291−synopsis: A time library

1292−description: Time, clocks and calendars

1293−category: Time

1294−exposed: True

1295−exposed-modules:

1296− Data.Time Data.Time.Calendar Data.Time.Calendar.Easter

1297− Data.Time.Calendar.Julian Data.Time.Calendar.Month

1298− Data.Time.Calendar.MonthDay Data.Time.Calendar.OrdinalDate

1299− Data.Time.Calendar.Quarter Data.Time.Calendar.WeekDate

1300− Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System

1301− Data.Time.Clock.TAI Data.Time.Format Data.Time.Format.ISO8601

1302− Data.Time.Format.Internal Data.Time.LocalTime

1303−hidden-modules:

1304− Data.Format Data.Time.Calendar.Types Data.Time.Calendar.Private

1305− Data.Time.Calendar.Days Data.Time.Calendar.Gregorian

1306− Data.Time.Calendar.CalendarDiffDays Data.Time.Calendar.Week

1307− Data.Time.Calendar.JulianYearDay Data.Time.Clock.Internal.DiffTime

1308− Data.Time.Clock.Internal.AbsoluteTime

1309− Data.Time.Clock.Internal.NominalDiffTime

1310− Data.Time.Clock.Internal.POSIXTime

1311− Data.Time.Clock.Internal.UniversalTime

1312− Data.Time.Clock.Internal.SystemTime

1313− Data.Time.Clock.Internal.UTCTime Data.Time.Clock.Internal.CTimeval

1314− Data.Time.Clock.Internal.CTimespec Data.Time.Clock.Internal.UTCDiff

1315− Data.Time.LocalTime.Internal.TimeZone

1316− Data.Time.LocalTime.Internal.TimeOfDay

1317− Data.Time.LocalTime.Internal.CalendarDiffTime

1318− Data.Time.LocalTime.Internal.LocalTime

1319− Data.Time.LocalTime.Internal.ZonedTime Data.Time.Format.Parse

1320− Data.Time.Format.Locale Data.Time.Format.Format.Class

1321− Data.Time.Format.Format.Instances Data.Time.Format.Parse.Class

1322− Data.Time.Format.Parse.Instances

1323−import-dirs:

1324−library-dirs:

1325−dynamic-library-dirs:

1326−data-dir:

1327−hs-libraries: HStime-1.11.1.1

1328−include-dirs:

1329−depends: base-4.16.3.0 deepseq-1.4.6.1

1330−haddock-interfaces:

1331−haddock-html:

1332−---

1333−name: transformers

1334−version: 0.5.6.2

1335−visibility: public

1336−id: transformers-0.5.6.2

1337−key: transformers-0.5.6.2

1338−license: BSD-3-Clause

1339−maintainer: Ross Paterson <R.Paterson@city.ac.uk>

1340−author: Andy Gill, Ross Paterson

1341−synopsis: Concrete functor and monad transformers

1342−description:

1343− A portable library of functor and monad transformers, inspired by

1344− the paper

1345− * \"Functional Programming with Overloading and Higher-Order

1346− Polymorphism\", by Mark P Jones,

1347− in /Advanced School of Functional Programming/, 1995

1348− (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1349− This package contains:

1350− * the monad transformer class (in "Control.Monad.Trans.Class")

1351− * concrete functor and monad transformers, each with associated

1352− operations and functions to lift operations associated with other

1353− transformers.

1354− The package can be used on its own in portable Haskell code, in

1355− which case operations need to be manually lifted through transformer

1356− stacks (see "Control.Monad.Trans.Class" for some examples).

1357− Alternatively, it can be used with the non-portable monad classes in

1358− the @mtl@ or @monads-tf@ packages, which automatically lift operations

1359− introduced by monad transformers through other transformers.

1360−category: Control

1361−exposed: True

1362−exposed-modules:

1363− Control.Applicative.Backwards Control.Applicative.Lift

1364− Control.Monad.Signatures Control.Monad.Trans.Accum

1365− Control.Monad.Trans.Class Control.Monad.Trans.Cont

1366− Control.Monad.Trans.Error Control.Monad.Trans.Except

1367− Control.Monad.Trans.Identity Control.Monad.Trans.List

1368− Control.Monad.Trans.Maybe Control.Monad.Trans.RWS

1369− Control.Monad.Trans.RWS.CPS Control.Monad.Trans.RWS.Lazy

1370− Control.Monad.Trans.RWS.Strict Control.Monad.Trans.Reader

1371− Control.Monad.Trans.Select Control.Monad.Trans.State

1372− Control.Monad.Trans.State.Lazy Control.Monad.Trans.State.Strict

1373− Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS

1374− Control.Monad.Trans.Writer.Lazy Control.Monad.Trans.Writer.Strict

1375− Data.Functor.Constant Data.Functor.Reverse

1376−import-dirs:

1377−library-dirs:

1378−dynamic-library-dirs:

1379−data-dir:

1380−hs-libraries: HStransformers-0.5.6.2

1381−depends: base-4.16.3.0

1382−haddock-interfaces:

1383−haddock-html:

1384−---

1385−name: unix

1386−version: 2.7.2.2

1387−visibility: public

1388−id: unix-2.7.2.2

1389−key: unix-2.7.2.2

1390−license: BSD-3-Clause

1391−maintainer: libraries@haskell.org

1392−homepage: https://github.com/haskell/unix

1393−synopsis: POSIX functionality

1394−description:

1395− This package gives you access to the set of operating system

1396− services standardised by

1397− <http://pubs.opengroup.org/onlinepubs/9699919799/ POSIX.1-2008>

1398− (or the IEEE Portable Operating System Interface for Computing

1399− Environments - IEEE Std. 1003.1).

1400− The package is not supported under Windows.

1401−category: System

1402−exposed: True

1403−exposed-modules:

1404− System.Posix System.Posix.ByteString

1405− System.Posix.ByteString.FilePath System.Posix.Directory

1406− System.Posix.Directory.ByteString System.Posix.DynamicLinker

1407− System.Posix.DynamicLinker.ByteString

1408− System.Posix.DynamicLinker.Module

1409− System.Posix.DynamicLinker.Module.ByteString

1410− System.Posix.DynamicLinker.Prim System.Posix.Env

1411− System.Posix.Env.ByteString System.Posix.Error System.Posix.Fcntl

1412− System.Posix.Files System.Posix.Files.ByteString System.Posix.IO

1413− System.Posix.IO.ByteString System.Posix.Process

1414− System.Posix.Process.ByteString System.Posix.Process.Internals

1415− System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem

1416− System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp

1417− System.Posix.Temp.ByteString System.Posix.Terminal

1418− System.Posix.Terminal.ByteString System.Posix.Time

1419− System.Posix.Unistd System.Posix.User

1420−hidden-modules:

1421− System.Posix.Directory.Common System.Posix.DynamicLinker.Common

1422− System.Posix.Files.Common System.Posix.IO.Common

1423− System.Posix.Process.Common System.Posix.Terminal.Common

1424−import-dirs:

1425−library-dirs:

1426−dynamic-library-dirs:

1427−data-dir:

1428−hs-libraries: HSunix-2.7.2.2

1429−include-dirs:

1430−includes: HsUnix.h execvpe.h

1431−depends: base-4.16.3.0 bytestring-0.11.3.1 time-1.11.1.1

1432−haddock-interfaces:

1433−haddock-html:

1434−---

1435−name: rts

1436−version: 1.0.2

1437−visibility: public

1438−id: rts

1439−key: rts

1440−license: BSD-3-Clause

1441−maintainer: glasgow-haskell-users@haskell.org

1442−exposed: True

1443−library-dirs:

1444−hs-libraries: HSrts

1445−extra-libraries: m rt dl ffi numa

1446−include-dirs:

1447−includes: Stg.h

1448−ld-options:

1449− "-Wl,-u,base_GHCziTopHandler_runIO_closure"

1450− "-Wl,-u,base_GHCziTopHandler_runNonIO_closure"

1451− "-Wl,-u,ghczmprim_GHCziTuple_Z0T_closure"

1452− "-Wl,-u,ghczmprim_GHCziTypes_True_closure"

1453− "-Wl,-u,ghczmprim_GHCziTypes_False_closure"

1454− "-Wl,-u,base_GHCziPack_unpackCString_closure"

1455− "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure"

1456− "-Wl,-u,base_GHCziIOziException_stackOverflow_closure"

1457− "-Wl,-u,base_GHCziIOziException_heapOverflow_closure"

1458− "-Wl,-u,base_GHCziIOziException_allocationLimitExceeded_closure"

1459− "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"

1460− "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"

1461− "-Wl,-u,base_GHCziIOziException_cannotCompactFunction_closure"

1462− "-Wl,-u,base_GHCziIOziException_cannotCompactPinned_closure"

1463− "-Wl,-u,base_GHCziIOziException_cannotCompactMutable_closure"

1464− "-Wl,-u,base_GHCziIOPort_doubleReadException_closure"

1465− "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure"

1466− "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure"

1467− "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure"

1468− "-Wl,-u,base_GHCziExceptionziType_divZZeroException_closure"

1469− "-Wl,-u,base_GHCziExceptionziType_underflowException_closure"

1470− "-Wl,-u,base_GHCziExceptionziType_overflowException_closure"

1471− "-Wl,-u,base_GHCziConcziSync_runSparks_closure"

1472− "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure"

1473− "-Wl,-u,base_GHCziConcziIO_interruptIOManager_closure"

1474− "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"

1475− "-Wl,-u,base_GHCziConcziSignal_runHandlersPtr_closure"

1476− "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure"

1477− "-Wl,-u,base_GHCziTopHandler_runMainIO_closure"

1478− "-Wl,-u,ghczmprim_GHCziTypes_Czh_con_info"

1479− "-Wl,-u,ghczmprim_GHCziTypes_Izh_con_info"

1480− "-Wl,-u,ghczmprim_GHCziTypes_Fzh_con_info"

1481− "-Wl,-u,ghczmprim_GHCziTypes_Dzh_con_info"

1482− "-Wl,-u,ghczmprim_GHCziTypes_Wzh_con_info"

1483− "-Wl,-u,base_GHCziPtr_Ptr_con_info"

1484− "-Wl,-u,base_GHCziPtr_FunPtr_con_info"

1485− "-Wl,-u,base_GHCziInt_I8zh_con_info"

1486− "-Wl,-u,base_GHCziInt_I16zh_con_info"

1487− "-Wl,-u,base_GHCziInt_I32zh_con_info"

1488− "-Wl,-u,base_GHCziInt_I64zh_con_info"

1489− "-Wl,-u,base_GHCziWord_W8zh_con_info"

1490− "-Wl,-u,base_GHCziWord_W16zh_con_info"

1491− "-Wl,-u,base_GHCziWord_W32zh_con_info"

1492− "-Wl,-u,base_GHCziWord_W64zh_con_info"

1493− "-Wl,-u,base_GHCziStable_StablePtr_con_info"

1494− "-Wl,-u,hs_atomic_add8" "-Wl,-u,hs_atomic_add16"

1495− "-Wl,-u,hs_atomic_add32" "-Wl,-u,hs_atomic_add64"

1496− "-Wl,-u,hs_atomic_sub8" "-Wl,-u,hs_atomic_sub16"

1497− "-Wl,-u,hs_atomic_sub32" "-Wl,-u,hs_atomic_sub64"

1498− "-Wl,-u,hs_atomic_and8" "-Wl,-u,hs_atomic_and16"

1499− "-Wl,-u,hs_atomic_and32" "-Wl,-u,hs_atomic_and64"

1500− "-Wl,-u,hs_atomic_nand8" "-Wl,-u,hs_atomic_nand16"

1501− "-Wl,-u,hs_atomic_nand32" "-Wl,-u,hs_atomic_nand64"

1502− "-Wl,-u,hs_atomic_or8" "-Wl,-u,hs_atomic_or16"

1503− "-Wl,-u,hs_atomic_or32" "-Wl,-u,hs_atomic_or64"

1504− "-Wl,-u,hs_atomic_xor8" "-Wl,-u,hs_atomic_xor16"

1505− "-Wl,-u,hs_atomic_xor32" "-Wl,-u,hs_atomic_xor64"

1506− "-Wl,-u,hs_cmpxchg8" "-Wl,-u,hs_cmpxchg16" "-Wl,-u,hs_cmpxchg32"

1507− "-Wl,-u,hs_cmpxchg64" "-Wl,-u,hs_xchg8" "-Wl,-u,hs_xchg16"

1508− "-Wl,-u,hs_xchg32" "-Wl,-u,hs_xchg64" "-Wl,-u,hs_atomicread8"

1509− "-Wl,-u,hs_atomicread16" "-Wl,-u,hs_atomicread32"

1510− "-Wl,-u,hs_atomicread64" "-Wl,-u,hs_atomicwrite8"

1511− "-Wl,-u,hs_atomicwrite16" "-Wl,-u,hs_atomicwrite32"

1512− "-Wl,-u,hs_atomicwrite64"

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-9.2.4-x86_64-linux/ghc-pkg/versiondeleted−1

@@ -1 +0,0 @@

1−GHC package manager version 9.2.4

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-9.2.4-x86_64-linux/ghc/infodeleted−66

@@ -1,66 +0,0 @@

1− [("Project name","The Glorious Glasgow Haskell Compilation System")

2− ,("GCC extra via C opts","")

3− ,("C compiler flags","")

4− ,("C++ compiler flags","")

5− ,("C compiler link flags","-Wl,-z,noexecstack")

6− ,("C compiler supports -no-pie","YES")

7− ,("Haskell CPP flags","-E -undef -traditional")

8− ,("ld flags","-z noexecstack")

9− ,("ld supports compact unwind","NO")

10− ,("ld supports build-id","YES")

11− ,("ld supports filelist","NO")

12− ,("ld is GNU ld","YES")

13− ,("Merge objects flags","-r")

14− ,("ar flags","q")

15− ,("ar supports at file","YES")

16− ,("otool command","otool")

17− ,("install_name_tool command","install_name_tool")

18− ,("touch command","touch")

19− ,("dllwrap command","/bin/false")

20− ,("windres command","/bin/false")

21− ,("libtool command","libtool")

22− ,("cross compiling","YES")

23− ,("target platform string","aarch64-unknown-linux")

24− ,("target os","OSLinux")

25− ,("target arch","ArchAArch64")

26− ,("target word size","8")

27− ,("target word big endian","NO")

28− ,("target has GNU nonexec stack","YES")

29− ,("target has .ident directive","YES")

30− ,("target has subsections via symbols","NO")

31− ,("target has RTS linker","YES")

32− ,("Unregisterised","NO")

33− ,("LLVM target","aarch64-unknown-linux")

34− ,("LLVM llc command","llc")

35− ,("LLVM opt command","opt")

36− ,("LLVM clang command","clang")

37− ,("Use interpreter","YES")

38− ,("Support SMP","YES")

39− ,("RTS ways","l debug thr thr_debug thr_l thr_p thr_debug_p debug_p")

40− ,("Tables next to code","YES")

41− ,("Leading underscore","NO")

42− ,("Use LibFFI","YES")

43− ,("RTS expects libdw","NO")

44− ,("Project version","9.2.4")

45− ,("Project Git commit id","a54827e0b48af33fa9cfde6ad131c6751c2fe321")

46− ,("Booter version","8.10.7")

47− ,("Stage","1")

48− ,("Build platform","x86_64-unknown-linux")

49− ,("Host platform","x86_64-unknown-linux")

50− ,("Target platform","aarch64-unknown-linux")

51− ,("Have interpreter","YES")

52− ,("Object splitting supported","NO")

53− ,("Have native code generator","YES")

54− ,("Target default backend","NCG")

55− ,("Support dynamic-too","YES")

56− ,("Support parallel --make","YES")

57− ,("Support reexported-modules","YES")

58− ,("Support thinning and renaming package flags","YES")

59− ,("Support Backpack","YES")

60− ,("Requires unified installed package IDs","YES")

61− ,("Uses package keys","YES")

62− ,("Uses unit IDs","YES")

63− ,("GHC Dynamic","NO")

64− ,("GHC Profiled","NO")

65− ,("Debug on","NO")

66− ]

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-9.2.4-x86_64-linux/ghc/numeric-versiondeleted−1

@@ -1 +0,0 @@

1−9.2.4

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-9.2.4-x86_64-linux/ghc/supported-languagesdeleted−268

@@ -1,268 +0,0 @@

1−Haskell98

2−Haskell2010

3−GHC2021

4−Unsafe

5−Trustworthy

6−Safe

7−AllowAmbiguousTypes

8−NoAllowAmbiguousTypes

9−AlternativeLayoutRule

10−NoAlternativeLayoutRule

11−AlternativeLayoutRuleTransitional

12−NoAlternativeLayoutRuleTransitional

13−Arrows

14−NoArrows

15−AutoDeriveTypeable

16−NoAutoDeriveTypeable

17−BangPatterns

18−NoBangPatterns

19−BinaryLiterals

20−NoBinaryLiterals

21−CApiFFI

22−NoCApiFFI

23−CPP

24−NoCPP

25−CUSKs

26−NoCUSKs

27−ConstrainedClassMethods

28−NoConstrainedClassMethods

29−ConstraintKinds

30−NoConstraintKinds

31−DataKinds

32−NoDataKinds

33−DatatypeContexts

34−NoDatatypeContexts

35−DefaultSignatures

36−NoDefaultSignatures

37−DeriveAnyClass

38−NoDeriveAnyClass

39−DeriveDataTypeable

40−NoDeriveDataTypeable

41−DeriveFoldable

42−NoDeriveFoldable

43−DeriveFunctor

44−NoDeriveFunctor

45−DeriveGeneric

46−NoDeriveGeneric

47−DeriveLift

48−NoDeriveLift

49−DeriveTraversable

50−NoDeriveTraversable

51−DerivingStrategies

52−NoDerivingStrategies

53−DerivingVia

54−NoDerivingVia

55−DisambiguateRecordFields

56−NoDisambiguateRecordFields

57−DoAndIfThenElse

58−NoDoAndIfThenElse

59−BlockArguments

60−NoBlockArguments

61−DoRec

62−NoDoRec

63−DuplicateRecordFields

64−NoDuplicateRecordFields

65−FieldSelectors

66−NoFieldSelectors

67−EmptyCase

68−NoEmptyCase

69−EmptyDataDecls

70−NoEmptyDataDecls

71−EmptyDataDeriving

72−NoEmptyDataDeriving

73−ExistentialQuantification

74−NoExistentialQuantification

75−ExplicitForAll

76−NoExplicitForAll

77−ExplicitNamespaces

78−NoExplicitNamespaces

79−ExtendedDefaultRules

80−NoExtendedDefaultRules

81−FlexibleContexts

82−NoFlexibleContexts

83−FlexibleInstances

84−NoFlexibleInstances

85−ForeignFunctionInterface

86−NoForeignFunctionInterface

87−FunctionalDependencies

88−NoFunctionalDependencies

89−GADTSyntax

90−NoGADTSyntax

91−GADTs

92−NoGADTs

93−GHCForeignImportPrim

94−NoGHCForeignImportPrim

95−GeneralizedNewtypeDeriving

96−NoGeneralizedNewtypeDeriving

97−GeneralisedNewtypeDeriving

98−NoGeneralisedNewtypeDeriving

99−ImplicitParams

100−NoImplicitParams

101−ImplicitPrelude

102−NoImplicitPrelude

103−ImportQualifiedPost

104−NoImportQualifiedPost

105−ImpredicativeTypes

106−NoImpredicativeTypes

107−IncoherentInstances

108−NoIncoherentInstances

109−TypeFamilyDependencies

110−NoTypeFamilyDependencies

111−InstanceSigs

112−NoInstanceSigs

113−ApplicativeDo

114−NoApplicativeDo

115−InterruptibleFFI

116−NoInterruptibleFFI

117−JavaScriptFFI

118−NoJavaScriptFFI

119−KindSignatures

120−NoKindSignatures

121−LambdaCase

122−NoLambdaCase

123−LexicalNegation

124−NoLexicalNegation

125−LiberalTypeSynonyms

126−NoLiberalTypeSynonyms

127−LinearTypes

128−NoLinearTypes

129−MagicHash

130−NoMagicHash

131−MonadComprehensions

132−NoMonadComprehensions

133−MonoLocalBinds

134−NoMonoLocalBinds

135−DeepSubsumption

136−NoDeepSubsumption

137−MonomorphismRestriction

138−NoMonomorphismRestriction

139−MultiParamTypeClasses

140−NoMultiParamTypeClasses

141−MultiWayIf

142−NoMultiWayIf

143−NumericUnderscores

144−NoNumericUnderscores

145−NPlusKPatterns

146−NoNPlusKPatterns

147−NamedFieldPuns

148−NoNamedFieldPuns

149−NamedWildCards

150−NoNamedWildCards

151−NegativeLiterals

152−NoNegativeLiterals

153−HexFloatLiterals

154−NoHexFloatLiterals

155−NondecreasingIndentation

156−NoNondecreasingIndentation

157−NullaryTypeClasses

158−NoNullaryTypeClasses

159−NumDecimals

160−NoNumDecimals

161−OverlappingInstances

162−NoOverlappingInstances

163−OverloadedLabels

164−NoOverloadedLabels

165−OverloadedLists

166−NoOverloadedLists

167−OverloadedStrings

168−NoOverloadedStrings

169−PackageImports

170−NoPackageImports

171−ParallelArrays

172−NoParallelArrays

173−ParallelListComp

174−NoParallelListComp

175−PartialTypeSignatures

176−NoPartialTypeSignatures

177−PatternGuards

178−NoPatternGuards

179−PatternSignatures

180−NoPatternSignatures

181−PatternSynonyms

182−NoPatternSynonyms

183−PolyKinds

184−NoPolyKinds

185−PolymorphicComponents

186−NoPolymorphicComponents

187−QuantifiedConstraints

188−NoQuantifiedConstraints

189−PostfixOperators

190−NoPostfixOperators

191−QuasiQuotes

192−NoQuasiQuotes

193−QualifiedDo

194−NoQualifiedDo

195−Rank2Types

196−NoRank2Types

197−RankNTypes

198−NoRankNTypes

199−RebindableSyntax

200−NoRebindableSyntax

201−OverloadedRecordDot

202−NoOverloadedRecordDot

203−OverloadedRecordUpdate

204−NoOverloadedRecordUpdate

205−RecordPuns

206−NoRecordPuns

207−RecordWildCards

208−NoRecordWildCards

209−RecursiveDo

210−NoRecursiveDo

211−RelaxedLayout

212−NoRelaxedLayout

213−RelaxedPolyRec

214−NoRelaxedPolyRec

215−RoleAnnotations

216−NoRoleAnnotations

217−ScopedTypeVariables

218−NoScopedTypeVariables

219−StandaloneDeriving

220−NoStandaloneDeriving

221−StarIsType

222−NoStarIsType

223−StaticPointers

224−NoStaticPointers

225−Strict

226−NoStrict

227−StrictData

228−NoStrictData

229−TemplateHaskell

230−NoTemplateHaskell

231−TemplateHaskellQuotes

232−NoTemplateHaskellQuotes

233−StandaloneKindSignatures

234−NoStandaloneKindSignatures

235−TraditionalRecordSyntax

236−NoTraditionalRecordSyntax

237−TransformListComp

238−NoTransformListComp

239−TupleSections

240−NoTupleSections

241−TypeApplications

242−NoTypeApplications

243−TypeInType

244−NoTypeInType

245−TypeFamilies

246−NoTypeFamilies

247−TypeOperators

248−NoTypeOperators

249−TypeSynonymInstances

250−NoTypeSynonymInstances

251−UnboxedTuples

252−NoUnboxedTuples

253−UnboxedSums

254−NoUnboxedSums

255−UndecidableInstances

256−NoUndecidableInstances

257−UndecidableSuperClasses

258−NoUndecidableSuperClasses

259−UnicodeSyntax

260−NoUnicodeSyntax

261−UnliftedDatatypes

262−NoUnliftedDatatypes

263−UnliftedFFITypes

264−NoUnliftedFFITypes

265−UnliftedNewtypes

266−NoUnliftedNewtypes

267−ViewPatterns

268−NoViewPatterns

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-9.2.4-x86_64-linux/ghc/versiondeleted−1

@@ -1 +0,0 @@

1−The Glorious Glasgow Haskell Compilation System, version 9.2.4

materialized/dummy-ghc/ghc-8.10.7-aarch64-linux/ghc-pkg/dump-global+2−1

@@ -1520,6 +1520,7 @@ library-dirs:

15201520dynamic-library-dirs:

15211521data-dir:

15221522hs-libraries: HSunix-2.7.2.2

1523+extra-libraries: rt util dl pthread

15231524include-dirs:

15241525includes: HsUnix.h execvpe.h

15251526depends: base-4.14.3.0 bytestring-0.10.12.0 time-1.9.3

@@ -1573,7 +1574,7 @@ maintainer: glasgow-haskell-users@haskell.org

15731574exposed: True

15741575library-dirs:

15751576hs-libraries: HSrts

1576−extra-libraries: m rt dl ffi numa

1577+extra-libraries: m rt dl ffi numa pthread

15771578include-dirs:

15781579includes: Stg.h

15791580ld-options:

materialized/dummy-ghc/ghc-8.10.7-aarch64-linux/ghc/info+1−1

@@ -9,7 +9,7 @@

99 ,("Haskell CPP flags","-E -undef -traditional")

1010 ,("ld command","ld")

1111 ,("ld flags","-z noexecstack")

12− ,("ld supports compact unwind","NO")

12+ ,("ld supports compact unwind","YES")

1313 ,("ld supports build-id","YES")

1414 ,("ld supports filelist","NO")

1515 ,("ld is GNU ld","YES")

materialized/dummy-ghc/ghc-8.10.7-x86_64-linux/ghc-pkg/dump-global+2−1

@@ -1520,6 +1520,7 @@ library-dirs:

15201520dynamic-library-dirs:

15211521data-dir:

15221522hs-libraries: HSunix-2.7.2.2

1523+extra-libraries: rt util dl pthread

15231524include-dirs:

15241525includes: HsUnix.h execvpe.h

15251526depends: base-4.14.3.0 bytestring-0.10.12.0 time-1.9.3

@@ -1573,7 +1574,7 @@ maintainer: glasgow-haskell-users@haskell.org

15731574exposed: True

15741575library-dirs:

15751576hs-libraries: HSrts

1576−extra-libraries: m rt dl ffi numa

1577+extra-libraries: m rt dl ffi numa pthread

15771578include-dirs:

15781579includes: Stg.h

15791580ld-options:

materialized/dummy-ghc/ghc-8.10.7-x86_64-linux/ghc/info+1−1

@@ -9,7 +9,7 @@

99 ,("Haskell CPP flags","-E -undef -traditional")

1010 ,("ld command","ld")

1111 ,("ld flags","")

12− ,("ld supports compact unwind","NO")

12+ ,("ld supports compact unwind","YES")

1313 ,("ld supports build-id","YES")

1414 ,("ld supports filelist","NO")

1515 ,("ld is GNU ld","YES")

materialized/dummy-ghc/ghc-9.2.4-aarch64-darwin/ghc-pkg/dump-globaldeleted−1834

@@ -1,1834 +0,0 @@