git.iko.soy/haskell.nix

on iko/ghcjs-patch-master help sign in

from

swap

to9755ab7293 ahead, 0 behind

compare

.buildkite/pipeline.yml+12

@@ -38,3 +38,15 @@ steps:

3838 command:

3939 - nix-build build.nix -A maintainer-scripts.check-path-support --argstr compiler-nix-name ghc8107 -o check-path-support.sh

4040 - ./check-path-support.sh

41+

42+ - label: 'Check that the haskell.nix roots do not require IFDs'

43+ command:

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

45+ agents:

46+ 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.yamlnew file+28

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

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

.github/workflows/windows-secp256k1.ymlnew file+51

@@ -0,0 +1,51 @@

1+name: "Test secp256k1 on windows"

2+on: workflow_dispatch

3+jobs:

4+ tests:

5+ runs-on: windows-latest

6+

7+ defaults:

8+ run:

9+ shell: bash

10+

11+ steps:

12+

13+ - uses: haskell/actions/setup@v1

14+ id: setup-haskell

15+ with:

16+ ghc-version: 8.10.7

17+ cabal-version: 3.6.2.0

18+

19+ - name: Install pkgconfiglite

20+ run: choco install -y pkgconfiglite

21+

22+ - name: Install libsecp256k1

23+ run: |

24+ curl -Ls \

25+ --connect-timeout 5 \

26+ --max-time 10 \

27+ --retry 5 \

28+ --retry-delay 0 \

29+ --retry-max-time 40 \

30+ https://hydra.iohk.io/job/Cardano/haskell-nix/windows-secp256k1/latest/download/1 -o secp256k1.zip

31+ mkdir secp256k1

32+ cd secp256k1

33+ unzip ../secp256k1.zip

34+ cd ..

35+ export PKG_CONFIG_PATH="$PKG_CONFIG_PATH;$(readlink -f secp256k1/lib/pkgconfig | sed 's|^/d|D:|g' | tr / '\\')"

36+ echo "PKG_CONFIG_PATH=$PKG_CONFIG_PATH"

37+ echo "PKG_CONFIG_PATH=$PKG_CONFIG_PATH" >> $GITHUB_ENV

38+ export SECP256K1_PATH="$(readlink -f secp256k1/bin | sed 's|^/d|D:|g' | tr / '\\')"

39+ echo "SECP256K1_PATH=$SECP256K1_PATH"

40+ echo "$SECP256K1_PATH" >> $GITHUB_PATH

41+

42+ - name: Cabal update

43+ run: cabal update

44+

45+ - name: Build and run haskell-secp256k1 tests

46+ run: |

47+ cabal unpack secp256k1-haskell

48+ cd secp256k1-haskell-*

49+ cabal build --enable-tests

50+ cabal test

51+

README.md+16

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

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+

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

218

319[](https://buildkite.com/input-output-hk/haskell-dot-nix)

build.nix+21−8

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

88{ nixpkgs ? haskellNix.sources.nixpkgs-2111

99, nixpkgsArgs ? haskellNix.nixpkgsArgs

1010, pkgs ? import nixpkgs nixpkgsArgs

11+, evalPackages ? import nixpkgs nixpkgsArgs

1112, nixpkgsForHydra ? haskellNix.sources.nixpkgs-2105

12−, pkgsForHydra ? import nixpkgsForHydra nixpkgsArgs

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

1314, ifdLevel ? 1000

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

1516}:

@@ -19,14 +20,22 @@ let

1920 buildHaskell = pkgs.buildPackages.haskell-nix;

2021 tool = buildHaskell.tool;

2122in rec {

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

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

2324

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

2526 pkgs.recurseIntoAttrs ({

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

27− } // pkgs.lib.optionalAttrs (!__elem compiler-nix-name ["ghc901" "ghc902" "ghc921"]) {

28− hls-latest = tool compiler-nix-name "haskell-language-server" "latest";

29− hlint-latest = tool compiler-nix-name "hlint" (if compiler-nix-name == "ghc865" then "3.2.7" else "latest");

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

28+ hlint-latest = tool compiler-nix-name "hlint" {

29+ inherit evalPackages;

30+ version = {

31+ "ghc865" = "3.2.8";

32+ "ghc882" = "3.3.6";

33+ "ghc883" = "3.3.6";

34+ "ghc884" = "3.3.6";

35+ }.compiler-nix-name or "latest";

36+ };

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

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

3039 })

3140 );

3241

@@ -68,13 +77,17 @@ in rec {

6877 ];

6978 };

7079 check-materialization-concurrency = pkgs.buildPackages.callPackage ./scripts/check-materialization-concurrency/check.nix {};

71− check-path-support = pkgs.buildPackages.callPackage ./scripts/check-path-support.nix {};

80+ check-path-support = pkgs.buildPackages.callPackage ./scripts/check-path-support.nix {

81+ # TODO remove this when nixpkgs-2205 is released and used for `pkgs`

82+ # check-path-support fails unless we have nix 2.4 or newer.

83+ inherit (import haskellNix.sources.nixpkgs-unstable {}) nix;

84+ };

7285 };

7386

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

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

7689 maintainer-script-cache = pkgs.recurseIntoAttrs (

77− (pkgs.lib.optionalAttrs pkgs.stdenv.hostPlatform.isLinux {

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

7891 inherit (maintainer-scripts) check-hydra;

7992 })

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

builder/comp-builder.nix+74−29

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

1−{ pkgs, stdenv, buildPackages, ghc, lib, gobject-introspection ? null, haskellLib, makeConfigFiles, haddockBuilder, ghcForComponent, hsPkgs, compiler, runCommand, libffi, gmp, zlib, ncurses, numactl, nodejs }@defaults:

1+{ pkgs, stdenv, buildPackages, ghc, lib, gobject-introspection ? null, haskellLib, makeConfigFiles, haddockBuilder, ghcForComponent, hsPkgs, compiler, runCommand, libffi, gmp, zlib, ncurses, nodejs }@defaults:

22lib.makeOverridable (

33let self =

44{ componentId

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

5050, writeHieFiles ? component.writeHieFiles

5151

5252, ghcOptions ? component.ghcOptions

53+, contentAddressed ? component.contentAddressed

5354

5455# Options for Haddock generation

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

@@ -99,9 +100,10 @@ let

99100 && !stdenv.hostPlatform.isMusl

100101 && builtins.compareVersions defaults.ghc.version "8.10.2" >= 0;

101102

102− ghc = if enableDWARF then defaults.ghc.dwarf else

103− if smallAddressSpace then defaults.ghc.smallAddressSpace else defaults.ghc;

104− setup = if enableDWARF then drvArgs.setup.dwarf else drvArgs.setup;

103+ ghc = (if enableDWARF then (x: x.dwarf) else (x: x)) (

104+ (if smallAddressSpace then (x: x.smallAddressSpace) else (x: x)) defaults.ghc);

105+ setup = (if enableDWARF then (x: x.dwarf) else (x: x)) (

106+ (if smallAddressSpace then (x: x.smallAddressSpace) else (x: x)) drvArgs.setup);

105107

106108 # TODO fix cabal wildcard support so hpack wildcards can be mapped to cabal wildcards

107109 canCleanSource = !(cabal-generator == "hpack" && !(package.cleanHpack or false));

@@ -203,7 +205,7 @@ let

203205 ] ++ lib.optionals (stdenv.hostPlatform.isMusl && (haskellLib.isExecutableType componentId)) [

204206 # These flags will make sure the resulting executable is statically linked.

205207 # If it uses other libraries it may be necessary for to add more

206− # `--ghc-option=-optl=-L` options to the `configurationFlags` of the

208+ # `--ghc-option=-optl=-L` options to the `configureFlags` of the

207209 # component.

208210 "--disable-executable-dynamic"

209211 "--ghc-option=-optl=-pthread"

@@ -223,6 +225,14 @@ let

223225 "--ghc-option=-fPIC" "--gcc-option=-fPIC"

224226 ]

225227 ++ map (o: ''--ghc${lib.optionalString (stdenv.hostPlatform.isGhcjs) "js"}-options="${o}"'') ghcOptions

228+ ++ lib.optional (

229+ # GHC 9.2 cross compiler built with older versions of GHC seem to have problems

230+ # with unique conters. Perhaps because the name changed for the counters.

231+ # TODO This work around to use `-j1` should be removed once we are able to build 9.2 with 9.2.

232+ haskellLib.isCrossHost

233+ && builtins.compareVersions defaults.ghc.version "9.2.1" >= 0

234+ && builtins.compareVersions defaults.ghc.version "9.3" < 0)

235+ "--ghc-options=-j1"

226236 );

227237

228238 executableToolDepends =

@@ -236,6 +246,7 @@ let

236246 shellWrappers = ghcForComponent {

237247 componentName = fullName;

238248 inherit configFiles enableDWARF;

249+ inherit (component) plugins;

239250 };

240251

241252 # In order to let shell hooks make package-specific things like Hoogle databases

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

306317 componentDrv = drv;

307318 };

308319

309− drv = stdenv.mkDerivation (commonAttrs // {

320+ contentAddressedAttrs = lib.optionalAttrs contentAddressed {

321+ __contentAddressed = true;

322+ outputHashMode = "recursive";

323+ outputHashAlgo = "sha256";

324+ };

325+

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

310327 pname = nameOnly;

311328 inherit (package.identifier) version;

312329

@@ -339,16 +356,28 @@ let

339356 description = package.synopsis or "";

340357 license = haskellLib.cabalToNixpkgsLicense package.license;

341358 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;

342367 };

343368

344369 propagatedBuildInputs =

345370 frameworks # Frameworks will be needed at link time

346371 # Not sure why pkgconfig needs to be propagatedBuildInputs but

347372 # for gi-gtk-hs it seems to help.

348− ++ builtins.concatLists pkgconfig;

373+ ++ builtins.concatLists pkgconfig

374+ ++ lib.optionals (stdenv.hostPlatform.isWindows)

375+ (lib.flatten component.libs

376+ ++ map haskellLib.dependToLib component.depends);

349377

350− buildInputs = component.libs

351− ++ map haskellLib.dependToLib component.depends;

378+ buildInputs = lib.optionals (!stdenv.hostPlatform.isWindows)

379+ (lib.flatten component.libs

380+ ++ map haskellLib.dependToLib component.depends);

352381

353382 nativeBuildInputs =

354383 [shellWrappers buildPackages.removeReferencesTo]

@@ -382,18 +411,36 @@ let

382411 runHook postConfigure

383412 '';

384413

385− buildPhase = if stdenv.hostPlatform.isGhcjs then ''

386− runHook preBuild

387− # https://gitlab.haskell.org/ghc/ghc/issues/9221

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

389− runHook postBuild

390− '' else ''

391− runHook preBuild

392− # https://gitlab.haskell.org/ghc/ghc/issues/9221

393− $SETUP_HS build ${haskellLib.componentTarget componentId} -j$(($NIX_BUILD_CORES > 4 ? 4 : $NIX_BUILD_CORES)) ${lib.concatStringsSep " " setupBuildFlags}

394− runHook postBuild

395− ''

396− ;

414+ buildPhase =

415+ # It seems that by the time the iserv wrapper specifiec by `--ghc-option=-pgmi` runs

416+ # all the array environment variables are removed from the environment. To get a list

417+ # of all the locations a DLLs might be present we need access to pkgsHostTarget.

418+ # Adding a string version of the list array of nix store paths allows us to get that

419+ # list when we need it.

420+ (lib.optionalString stdenv.hostPlatform.isWindows ''

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

422+ '') +

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 ''

434+ runHook preBuild

435+ # https://gitlab.haskell.org/ghc/ghc/issues/9221

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

437+ runHook postBuild

438+ '' else ''

439+ runHook preBuild

440+ # https://gitlab.haskell.org/ghc/ghc/issues/9221

441+ $SETUP_HS build ${haskellLib.componentTarget componentId} -j$(($NIX_BUILD_CORES > 4 ? 4 : $NIX_BUILD_CORES)) ${lib.concatStringsSep " " setupBuildFlags}

442+ runHook postBuild

443+ '');

397444

398445 # Note: Cabal does *not* copy test executables during the `install` phase.

399446 #

@@ -473,7 +520,9 @@ let

473520 fi

474521 '')

475522 # In case `setup copy` did not create this

476− + (lib.optionalString enableSeparateDataOutput "mkdir -p $data")

523+ + (lib.optionalString enableSeparateDataOutput ''

524+ mkdir -p $data

525+ '')

477526 + (lib.optionalString (stdenv.hostPlatform.isWindows && (haskellLib.mayHaveExecutable componentId)) (''

478527 echo "Symlink libffi and gmp .dlls ..."

479528 for p in ${lib.concatStringsSep " " [ libffi gmp ]}; do

@@ -481,14 +530,10 @@ let

481530 done

482531 ''

483532 # symlink all .dlls into the local directory.

484− # we ask ghc-pkg for *all* dynamic-library-dirs and then iterate over the unique set

485− # to symlink over dlls as needed.

486533 + ''

487− echo "Symlink library dependencies..."

488− for libdir in $(${stdenv.hostPlatform.config}-ghc-pkg field "*" dynamic-library-dirs --simple-output|xargs|sed 's/ /\n/g'|sort -u); do

489− if [ -d "$libdir" ]; then

490− find "$libdir" -iname '*.dll' -exec ln -s {} $out/bin \;

491− fi

534+ for p in $pkgsHostTargetAsString; do

535+ find "$p" -iname '*.dll' -exec ln -s {} $out/bin \;

536+ find "$p" -iname '*.dll.a' -exec ln -s {} $out/bin \;

492537 done

493538 ''))

494539 + (lib.optionalString doCoverage ''

builder/default.nix+17−10

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

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

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

22

33let

44 # Builds a single component of a package.

@@ -46,21 +46,28 @@ 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− version = "5.0.18.2";

49+ inherit evalPackages;

50+ version = "5.0.18.3";

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

5152 }

5253 }:

53− haskellLib.weakCallPackage pkgs nixpkgsHoogle {

54− # For musl we can use haddock from the buildGHC

55− ghc = if stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && !haskellLib.isNativeMusl

56− then ghc.buildGHC

57− else ghc;

58− inherit packages hoogle;

59− };

54+ let

55+ haskellPackages = {

56+ # For musl we can use haddock from the buildGHC

57+ ghc = if stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && !haskellLib.isNativeMusl

58+ then ghc.buildGHC

59+ else ghc;

60+ inherit packages hoogle;

61+ };

62+ in if lib.versionAtLeast lib.trivial.release "22.05"

63+ then haskellLib.weakCallPackage pkgs nixpkgsHoogle {

64+ inherit haskellPackages;

65+ } (p: p.packages)

66+ else haskellLib.weakCallPackage pkgs nixpkgsHoogle haskellPackages;

6067

6168 # Same as haskellPackages.shellFor in nixpkgs.

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

63− inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib buildPackages compiler;

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

6471 inherit (buildPackages) glibcLocales;

6572 };

6673

builder/ghc-for-component-wrapper.nix+60−15

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

1313, configFiles # The component's "config" derivation

1414, postInstall ? ""

1515, enableDWARF

16+, plugins

1617}:

1718

1819let

@@ -37,31 +38,70 @@ in runCommand "${componentName}-${ghc.name}-env" {

3738 ''

3839 . ${makeWrapper}/nix-support/setup-hook

3940

40− # Start with a ghc...

41+ ''

42+ # Start with a ghc and remove all of the package directories

43+ + ''

4144 mkdir -p $out/bin

4245 ${lndir}/bin/lndir -silent ${ghc} $out

43− # ... remove all of the package directories

4446 rm -rf ${libDir}/*/

45− # ... but retain the lib/ghc/bin directory. This contains `unlit' and friends.

47+ ''

48+ # ... but retain the lib/ghc/bin directory. This contains `unlit' and friends.

49+ + ''

4650 ln -s ${ghc}/lib/${ghcCommand}-${ghc.version}/bin ${libDir}

47− # ... and the ghcjs shim's if they are available ...

51+ ''

52+ # ... and the ghcjs shim's if they are available ...

53+ + ''

4854 if [ -d ${ghc}/lib/${ghcCommand}-${ghc.version}/shims ]; then

4955 ln -s ${ghc}/lib/${ghcCommand}-${ghc.version}/shims ${libDir}

5056 fi

51− # ... and node modules ...

57+ ''

58+ # ... and node modules ...

59+ + ''

5260 if [ -d ${ghc}/lib/${ghcCommand}-${ghc.version}/ghcjs-node ]; then

5361 ln -s ${ghc}/lib/${ghcCommand}-${ghc.version}/ghcjs-node ${libDir}

5462 fi

55− # Replace the package database with the one from target package config.

63+ ''

64+ # Replace the package database with the one from target package config.

65+ + ''

5666 ln -s ${configFiles}/${packageCfgDir} $out/${packageCfgDir}

5767

58− # now the tricky bit. For GHCJS (to make plugins work), we need a special

59− # file called ghc_libdir. That points to the build ghc's lib.

60− echo "${ghc.buildGHC or ghc}/lib/${(ghc.buildGHC or ghc).name}" > "${libDir}/ghc_libdir"

68+ ''

69+ # Set the GHC_PLUGINS environment variable according to the plugins for the component.

70+ # GHC will automatically load the relevant symbols from the given libraries and

71+ # initialize them with the given arguments.

72+ #

73+ # GHC_PLUGINS is a `read`able [(FilePath,String,String,[String])], where the

74+ # first component is a path to the shared library, the second is the package ID,

75+ # the third is the module name, and the fourth is the plugin arguments.

76+ + ''

77+ GHC_PLUGINS="["

78+ LIST_PREFIX=""

79+ ${builtins.concatStringsSep "\n" (map (plugin: ''

80+ id=$(${ghc}/bin/ghc-pkg --package-db ${plugin.library}/package.conf.d field ${plugin.library.package.identifier.name} id --simple-output)

81+ lib_dir=$(${ghc}/bin/ghc-pkg --package-db ${plugin.library}/package.conf.d field ${plugin.library.package.identifier.name} dynamic-library-dirs --simple-output)

82+ lib_base=$(${ghc}/bin/ghc-pkg --package-db ${plugin.library}/package.conf.d field ${plugin.library.package.identifier.name} hs-libraries --simple-output)

83+ lib="$(echo ''${lib_dir}/lib''${lib_base}*)"

84+ GHC_PLUGINS="''${GHC_PLUGINS}''${LIST_PREFIX}(\"''${lib}\",\"''${id}\",\"${plugin.moduleName}\",["

85+ LIST_PREFIX=""

86+ ${builtins.concatStringsSep "\n" (map (arg: ''

87+ GHC_PLUGINS="''${GHC_PLUGINS}''${LIST_PREFIX}\"${arg}\""

88+ LIST_PREFIX=","

89+ '') plugin.args)}

90+ GHC_PLUGINS="''${GHC_PLUGINS}])"

91+ LIST_PREFIX=","

92+ '') plugins)}

93+ GHC_PLUGINS="''${GHC_PLUGINS}]"

6194

62− # Wrap compiler executables with correct env variables.

63− # The NIX_ variables are used by the patched Paths_ghc module.

95+ ''

96+ # now the tricky bit. For GHCJS (to make plugins work), we need a special

97+ # file called ghc_libdir. That points to the build ghc's lib.

98+ + ''

99+ echo "${ghc.buildGHC or ghc}/lib/${(ghc.buildGHC or ghc).name}" > "${libDir}/ghc_libdir"

64100

101+ ''

102+ # Wrap compiler executables with correct env variables.

103+ # The NIX_ variables are used by the patched Paths_ghc module.

104+ + ''

65105 for prg in ${ghcCommand} ${ghcCommand}i ${ghcCommand}-${ghc.version} ${ghcCommand}i-${ghc.version}; do

66106 if [[ -x "${ghc}/bin/$prg" ]]; then

67107 rm -f $out/bin/$prg

@@ -70,6 +110,7 @@ in runCommand "${componentName}-${ghc.name}-env" {

70110 --set "NIX_${ghcCommandCaps}" "$out/bin/${ghcCommand}" \

71111 --set "NIX_${ghcCommandCaps}PKG" "$out/bin/${ghcCommand}-pkg" \

72112 --set "NIX_${ghcCommandCaps}_DOCDIR" "${docDir}" \

113+ --set "GHC_PLUGINS" "$GHC_PLUGINS" \

73114 --set "NIX_${ghcCommandCaps}_LIBDIR" "${libDir}"

74115 fi

75116 done

@@ -82,11 +123,14 @@ in runCommand "${componentName}-${ghc.name}-env" {

82123 --set "NIX_${ghcCommandCaps}" "$out/bin/${ghcCommand}" \

83124 --set "NIX_${ghcCommandCaps}PKG" "$out/bin/${ghcCommand}-pkg" \

84125 --set "NIX_${ghcCommandCaps}_DOCDIR" "${docDir}" \

126+ --set "GHC_PLUGINS" "$GHC_PLUGINS" \

85127 --set "NIX_${ghcCommandCaps}_LIBDIR" "${libDir}"

86128 fi

87129 done

88130

89− # Wrap haddock, if the base GHC provides it.

131+ ''

132+ # Wrap haddock, if the base GHC provides it.

133+ + ''

90134 if [[ -x "${haddock}/bin/haddock" ]]; then

91135 rm -f $out/bin/haddock

92136 makeWrapper ${haddock}/bin/haddock $out/bin/haddock \

@@ -94,9 +138,10 @@ in runCommand "${componentName}-${ghc.name}-env" {

94138 --set "NIX_${ghcCommandCaps}_LIBDIR" "${libDir}"

95139 fi

96140

97− # Point ghc-pkg to the package database of the component using the

98− # --global-package-db flag.

99−

141+ ''

142+ # Point ghc-pkg to the package database of the component using the

143+ # --global-package-db flag.

144+ + ''

100145 for prg in ${ghcCommand}-pkg ${ghcCommand}-pkg-${ghc.version}; do

101146 if [[ -x "${ghc}/bin/$prg" ]]; then

102147 rm -f $out/bin/$prg

builder/haddock-builder.nix+2

@@ -41,6 +41,7 @@ let

4141 inherit (package) identifier;

4242 inherit component fullName flags needsProfiling;

4343 chooseDrv = p: p.haddock;

44+ inherit (componentDrv) enableDWARF;

4445 };

4546

4647 finalConfigureFlags = lib.concatStringsSep " " (

@@ -55,6 +56,7 @@ let

5556 componentName = fullName;

5657 configFiles = docsConfigFiles;

5758 inherit (componentDrv) enableDWARF;

59+ inherit (component) plugins;

5860 };

5961

6062 drv = stdenv.mkDerivation (commonAttrs // {

builder/hspkg-builder.nix+32−31

@@ -23,7 +23,14 @@ assert (if ghc.isHaskellNixCompiler or false then true

2323 + pkgs.lib.optionalString (name != null) (" for " + name)));

2424

2525let

26− cabalFile = if revision == null || revision == 0 then null else

26+ # Some packages bundled with GHC are not the same as they are in hackage.

27+ bundledSrc = {

28+ # These are problematic because the hackage versions will not install and are part of LTS.

29+ "ghc902/stm-2.5.0.0" = "/libraries/stm";

30+ "ghc902/filepath-1.4.2.1" = "/libraries/filepath";

31+ }."${compiler-nix-name}/${name}" or null;

32+ src = if bundledSrc == null then pkg.src else ghc.configured-src + bundledSrc;

33+ cabalFile = if revision == null || revision == 0 || bundledSrc != null then null else

2734 fetchurl {

2835 name = "${name}-${toString revision}.cabal";

2936 url = "https://hackage.haskell.org/package/${name}/revision/${toString revision}.cabal";

@@ -32,41 +39,28 @@ let

3239

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

3441

35− # Get the Cabal lib used to build `cabal-install`.

36− # To avoid infinite recursion we have to leave this out for packages

37− # needed to build `cabal-install`.

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

39− cabalLibDepends = lib.optional (

40− stdenv.hostPlatform.isGhcjs || (

41− builtins.elem compiler-nix-name["ghc865" "ghc884"]

42− &&

43− !builtins.elem package.identifier.name

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

45− "filepath" "base-compat-batteries" "base-compat" "unix" "directory" "transformers"

46− "containers" "binary" "mtl" "text" "process" "parsec"]

47− )

48− )

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

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;

5047

51− # This logic is needed so that we don't get duplicate packages if we

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

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

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

55− nonReinstallablePkgs = if (

56− stdenv.hostPlatform.isGhcjs || (

57− builtins.elem compiler-nix-name["ghc865" "ghc884"]

58− &&

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`

5955 !builtins.elem package.identifier.name

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

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

62− "containers" "binary" "mtl" "text" "process" "parsec"]

63− )

64− ) then [] else null;

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

6559

6660 defaultSetup = setup-builder ({

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

6862 component = {

69− depends = config.setup-depends ++ cabalLibDepends;

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

7064 libs = [];

7165 frameworks = [];

7266 doExactConfig = false;

@@ -94,12 +88,19 @@ let

9488 synopsis = null;

9589 license = "MIT";

9690 };

97− src = null; cleanSrc = buildPackages.runCommand "default-Setup-src" {} ''

91+ src = null;

92+ cleanSrc = buildPackages.runCommand "default-Setup-src" {} ''

9893 mkdir $out

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

10095 '';

10196 inherit defaultSetupSrc;

102− } // (if nonReinstallablePkgs == null then {} else { inherit nonReinstallablePkgs; }));

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+ });

103104

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

105106 # cat ${defaultSetupSrc} > Setup.hs

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

130131 checks = pkgs.recurseIntoAttrs (builtins.mapAttrs

131132 (_: d: haskellLib.check d)

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

133− inherit (package) identifier detailLevel isLocal isProject;

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

134135 inherit setup cabalFile;

135136 isHaskell = true;

136137 inherit src;

builder/make-config-files.nix+15−7

@@ -3,6 +3,10 @@

33{ identifier, component, fullName, flags ? {}, needsProfiling ? false, enableDWARF ? false, chooseDrv ? drv: drv, nonReinstallablePkgs ? defaults.nonReinstallablePkgs }:

44

55let

6+ # Sort and remove duplicates from nonReinstallablePkgs.

7+ # That way changes to the order of nonReinstallablePkgs does not require rebuilds.

8+ nonReinstallablePkgs' = __attrNames (lib.genAttrs nonReinstallablePkgs (x: x));

9+

610 ghc = if enableDWARF then defaults.ghc.dwarf else defaults.ghc;

711

812 flagsAndConfig = field: xs: lib.optionalString (xs != []) ''

@@ -81,16 +85,20 @@ let

8185 ${target-pkg} init $out/${packageCfgDir}

8286

8387 ${lib.concatStringsSep "\n" (lib.mapAttrsToList flagsAndConfig {

84− "extra-lib-dirs" = map (p: "${lib.getLib p}/lib") component.libs

85− ++ lib.optionals (stdenv.hostPlatform.isWindows) (map (p: "${lib.getBin p}/bin") component.libs);

86− "extra-include-dirs" = map (p: "${lib.getDev p}/include") component.libs;

87− "extra-framework-dirs" = map (p: "${p}/Library/Frameworks") component.frameworks;

88+ "extra-lib-dirs" = map (p: "${lib.getLib p}/lib") (lib.flatten component.libs)

89+ # On windows also include `bin` directories that may contain DLLs

90+ ++ lib.optionals (stdenv.hostPlatform.isWindows)

91+ (map (p: "${lib.getBin p}/bin")

92+ (lib.flatten component.libs ++ lib.concatLists component.pkgconfig));

93+ "extra-include-dirs" = map (p: "${lib.getDev p}/include") (lib.flatten component.libs);

94+ "extra-framework-dirs" = lib.optionals (stdenv.hostPlatform.isDarwin)

95+ (map (p: "${p}/Library/Frameworks") component.frameworks);

8896 })}

8997

9098 ghc=${ghc}

9199 ${ # Copy over the nonReinstallablePkgs from the global package db.

92100 ''

93− for p in ${lib.concatStringsSep " " nonReinstallablePkgs}; do

101+ for p in ${lib.concatStringsSep " " nonReinstallablePkgs'}; do

94102 find $ghc/lib/${ghc.name}/package.conf.d -name $p'*.conf' -exec cp -f {} $out/${packageCfgDir} \;

95103 done

96104 ''}

@@ -149,13 +157,13 @@ let

149157 cat $p/exactDep/cabal.config >> $out/cabal.config

150158 ''}

151159 done

152− for p in ${lib.concatStringsSep " " (lib.remove "ghc" nonReinstallablePkgs)}; do

160+ for p in ${lib.concatStringsSep " " (lib.remove "ghc" nonReinstallablePkgs')}; do

153161 if [ -e $ghc/envDeps/$p ]; then

154162 cat $ghc/envDeps/$p >> $out/ghc-environment

155163 fi

156164 done

157165 '' + lib.optionalString component.doExactConfig ''

158− for p in ${lib.concatStringsSep " " nonReinstallablePkgs}; do

166+ for p in ${lib.concatStringsSep " " nonReinstallablePkgs'}; do

159167 if [ -e $ghc/exactDeps/$p ]; then

160168 cat $ghc/exactDeps/$p/configure-flags >> $out/configure-flags

161169 cat $ghc/exactDeps/$p/cabal.config >> $out/cabal.config

builder/setup-builder.nix+8−4

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

88, preInstall ? component.preInstall , postInstall ? component.postInstall

99, cleanSrc ? haskellLib.cleanCabalComponent package component "setup" src

1010, nonReinstallablePkgs ? defaults.nonReinstallablePkgs

11+, smallAddressSpace ? false

1112}@drvArgs:

1213

1314let

15+ ghc = (if enableDWARF then (x: x.dwarf) else (x: x)) (

16+ (if smallAddressSpace then (x: x.smallAddressSpace) else (x: x)) defaults.ghc);

17+

1418 cleanSrc' = haskellLib.rootAndSubDir cleanSrc;

1519

1620 fullName = "${name}-setup";

@@ -53,6 +57,7 @@ let

5357 cleanSrc = cleanSrc';

5458 inherit configFiles;

5559 dwarf = self (drvArgs // { enableDWARF = true; });

60+ smallAddressSpace = self (drvArgs // { smallAddressSpace = true; });

5661 };

5762

5863 meta = {

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

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

7277 if [ -f $f ]; then

7378 echo Compiling package $f

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

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

76− setup=$(pwd)/Setup

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

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

7781 fi

7882 done

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

80− runHook preBuild

84+ runHook postBuild

8185 '';

8286

8387 installPhase = ''

builder/shell-for.nix+16−6

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

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

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

22

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,9 +71,12 @@ let

7171 removeSelectedInputs =

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

7373

74− # The configs of all the selected components

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.

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

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

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

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

7780

7881 name = if lib.length selectedPackages == 1

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

@@ -96,13 +99,14 @@ let

9699 component = {

97100 depends = packageInputs;

98101 libs = [];

102+ pkgconfig = [];

99103 frameworks = [];

100104 doExactConfig = false;

101105 };

102106 configFiles = makeConfigFiles {

103107 fullName = args.name or name;

104108 identifier.name = name;

105− inherit component;

109+ inherit component enableDWARF;

106110 chooseDrv = p: if withHaddock && p ? haddock then p.haddock else p;

107111 };

108112 ghcEnv = ghcForComponent {

@@ -112,6 +116,7 @@ let

112116 ln -s ${hoogleIndex}/bin/hoogle $out/bin

113117 '';

114118 inherit enableDWARF;

119+ plugins = [];

115120 };

116121

117122 hoogleIndex = let

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

128133 # inherit (hsPkgs) hoogle;

129134 } // (

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

131− hoogle = buildPackages.haskell-nix.tool compiler.nix-name "hoogle" 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+ }]);

132142 }

133143 ));

134144

@@ -142,7 +152,7 @@ in

142152 nativeBuildInputs = [ ghcEnv ]

143153 ++ nativeBuildInputs

144154 ++ mkDrvArgs.nativeBuildInputs or []

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

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

146156 # If this shell is a cross compilation shell include

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

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

changelog.md+33

@@ -1,6 +1,39 @@

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

22that will impact users.

33

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+

30+## Feb 16, 2022

31+* Removed lookupSha256 argument from project functions.

32+ Pass a `sha256map` instead.

33+* Added better support for `repository` in `cabal.project`. These

34+ blocks should now work without the need for passing `extra-hackages` and

35+ `extra-hackage-tarballs`.

36+

437## Aug 6, 2021

538* Included dependencies of haskell.nix that were tracked in `nix/sources.json`

639 as flake inputs (`flake.lock` replaces `nix/sources.json`).

ci.nix+39−28

@@ -10,12 +10,18 @@

1010 inherit (import ./ci-lib.nix { inherit pkgs; }) dimension platformFilterGeneric filterAttrsOnlyRecursive;

1111 inherit (pkgs.haskell-nix) sources;

1212 nixpkgsVersions = {

13− "R2105" = "nixpkgs-2105";

1413 "R2111" = "nixpkgs-2111";

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

1515 "unstable" = "nixpkgs-unstable";

1616 };

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+ };

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

18− inherit (import ./default.nix { inherit checkMaterialization; }) nixpkgsArgs;

1925 inherit runTests;

2026 }) (

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

@@ -24,40 +30,46 @@

2430 # cabal-install and nix-tools plans. When removing a ghc version

2531 # from here (so that is no longer cached) also remove ./materialized/ghcXXX.

2632 # Update supported-ghc-versions.md to reflect any changes made here.

27− nixpkgs.lib.optionalAttrs (nixpkgsName == "R2105") {

33+ nixpkgs.lib.optionalAttrs (nixpkgsName == "R2111") {

2834 ghc865 = false;

29− ghc8107 = false;

30− } // nixpkgs.lib.optionalAttrs (nixpkgsName == "R2111") {

35+ ghc8107 = true;

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

3137 ghc865 = false;

3238 ghc8107 = true;

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

3440 ghc865 = false;

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

36− ghc8104 = false;

37− ghc8105 = false;

38− ghc8106 = false;

3942 ghc8107 = true;

40− ghc901 = false;

4143 ghc902 = true;

42− ghc921 = true;

43− ghc810420210212 = false;

44+ ghc924 = true;

4445 });

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

46− nixpkgs.lib.filter (v: v != "aarch64-darwin" || (

47− # aarch64-darwin requires ghc 8.10.7 and does not work on older nixpkgs

48− !__elem compiler-nix-name ["ghc865" "ghc884" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901"]

49− && !__elem nixpkgsName ["R2105"])) supportedSystems) (v: v);

47+ nixpkgs.lib.filter (v:

48+ # We have less x86_64-darwin build capacity so build fewer GhC versions

49+ (v != "x86_64-darwin" || (

50+ !__elem compiler-nix-name ["ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]))

51+ &&

52+ # aarch64-darwin requires ghc 8.10.7

53+ (v != "aarch64-darwin" || (

54+ !__elem compiler-nix-name ["ghc865" "ghc884" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]))

55+ &&

56+ # aarch64-linux requires ghc 8.8.4

57+ (v != "aarch64-linux" || (

58+ !__elem compiler-nix-name ["ghc865" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]

59+ ))) supportedSystems) (v: v);

5060 crossSystems = nixpkgsName: nixpkgs: compiler-nix-name: system:

5161 # We need to use the actual nixpkgs version we're working with here, since the values

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

5363 let lib = nixpkgs.lib;

54− in lib.optionalAttrs (nixpkgsName == "unstable" && (__elem compiler-nix-name ["ghc8107"]) && system != "aarch64-darwin") {

64+ in lib.optionalAttrs (nixpkgsName == "unstable"

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

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

5567 inherit (lib.systems.examples) ghcjs;

56− } // lib.optionalAttrs (system == "x86_64-linux" &&

57− nixpkgsName == "unstable" && (__elem compiler-nix-name ["ghc8107"])) {

58− # Windows cross compilation is currently broken on macOS

68+ } // lib.optionalAttrs (nixpkgsName == "unstable"

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

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

5971 inherit (lib.systems.examples) mingwW64;

60− } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && compiler-nix-name == "ghc8107") {

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

6173 # Musl cross only works on linux

6274 # aarch64 cross only works on linux

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

@@ -66,12 +78,11 @@

6678in

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

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

69− # We need this for generic nixpkgs stuff at the right version

70− genericPkgs = import pinnedNixpkgsSrc {};

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

72− dimension "System" (systems nixpkgsName genericPkgs compiler-nix-name) (systemName: system:

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:

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

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

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

7586 platformFilter = platformFilterGeneric pkgs system;

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

7788 # Native builds

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

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

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

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

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

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

8899 });

89100 }

90101 //

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

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

92103 # Cross builds

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

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

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

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

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

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

compiler/ghc/configured-src.nixdeleted−132

@@ -1,132 +0,0 @@

1−{ stdenv, lib, fetchurl

2−, ghc-version, ghc-version-date, ghc-patches, src-spec

3−, targetPrefix

4−, targetPlatform, hostPlatform

5−, targetPackages

6−, perl, autoconf, automake, m4, python3, sphinx, ghc, bootPkgs

7−, autoreconfHook, toolsForTarget, bash

8−, libDeps

9−, useLLVM, llvmPackages

10−, targetCC

11−, enableIntegerSimple, targetGmp

12−, enableDWARF, elfutils

13−, ncurses, targetLibffi, libiconv, targetIconv

14−, disableLargeAddressSpace

15−, buildMK

16−}:

17−stdenv.mkDerivation (rec {

18−

19− version = ghc-version;

20− patches = ghc-patches;

21− name = "${targetPrefix}ghc-${ghc-version}-configured-src";

22−

23− # Make sure we never relax`$PATH` and hooks support for compatability.

24− strictDeps = true;

25−

26− nativeBuildInputs = [

27− perl autoconf automake m4 python3 sphinx

28− ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

29− ] ++ lib.optional (patches != []) autoreconfHook;

30−

31− # For building runtime libs

32− depsBuildTarget = toolsForTarget;

33−

34− buildInputs = [ perl bash ] ++ (libDeps hostPlatform);

35−

36− depsTargetTarget = map lib.getDev (libDeps targetPlatform);

37− depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);

38−

39− postPatch = "patchShebangs .";

40−

41− src = if src-spec ? file

42− then src-spec.file

43− else fetchurl { inherit (src-spec) url sha256; };

44−

45− # GHC is a bit confused on its cross terminology.

46− preConfigure = ''

47− for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do

48− export "''${env#TARGET_}=''${!env}"

49− done

50− # GHC is a bit confused on its cross terminology, as these would normally be

51− # the *host* tools.

52− export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"

53− export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

54− # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177

55− export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString targetPlatform.isAarch32 ".gold"}"

56− export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

57− export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

58− export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

59− export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"

60− export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"

61− export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"

62−

63− echo -n "${buildMK}" > mk/build.mk

64− sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure

65− '' + lib.optionalString useLLVM ''

66− export LLC="${llvmPackages.llvm}/bin/llc"

67− export OPT="${llvmPackages.llvm}/bin/opt"

68− '' + lib.optionalString (!stdenv.isDarwin) ''

69− export NIX_LDFLAGS+=" -rpath $out/lib/${targetPrefix}ghc-${version}"

70− '' + lib.optionalString stdenv.isDarwin ''

71− export NIX_LDFLAGS+=" -no_dtrace_dof"

72− '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''

73− sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets

74− '' + lib.optionalString targetPlatform.isMusl ''

75− echo "patching llvm-targets for musl targets..."

76− echo "Cloning these existing '*-linux-gnu*' targets:"

77− grep linux-gnu llvm-targets | sed 's/^/ /'

78− echo "(go go gadget sed)"

79− sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets

80− echo "llvm-targets now contains these '*-linux-musl*' targets:"

81− grep linux-musl llvm-targets | sed 's/^/ /'

82−

83− echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"

84− # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)

85− for x in configure aclocal.m4; do

86− substituteInPlace $x \

87− --replace '*-android*|*-gnueabi*)' \

88− '*-android*|*-gnueabi*|*-musleabi*)'

89− done

90− '' + lib.optionalString (src-spec.version != ghc-version) ''

91− substituteInPlace configure --replace 'RELEASE=YES' 'RELEASE=NO'

92− echo '${ghc-version}' > VERSION

93− '' + lib.optionalString (ghc-version-date != null) ''

94− substituteInPlace configure --replace 'RELEASE=YES' 'RELEASE=NO'

95− echo '${ghc-version-date}' > VERSION_DATE

96− '';

97−

98− configurePlatforms = [ "build" "host" "target" ];

99− # `--with` flags for libraries needed for RTS linker

100− configureFlags = [

101− "--datadir=$doc/share/doc/ghc"

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

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

104− ] ++ lib.optional (!enableIntegerSimple) [

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

106− ] ++ lib.optional (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [

107− "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"

108− ] ++ lib.optional (targetPlatform != hostPlatform) [

109− "--with-iconv-includes=${targetIconv}/include" "--with-iconv-libraries=${targetIconv}/lib"

110− ] ++ lib.optionals (targetPlatform != hostPlatform) [

111− "--enable-bootstrap-with-devel-snapshot"

112− ] ++ lib.optionals (disableLargeAddressSpace) [

113− "--disable-large-address-space"

114− ] ++ lib.optionals (targetPlatform.isAarch32) [

115− "CFLAGS=-fuse-ld=gold"

116− "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"

117− "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"

118− ] ++ lib.optionals enableDWARF [

119− "--enable-dwarf-unwind"

120− "--with-libdw-includes=${lib.getDev elfutils}/include"

121− "--with-libdw-libraries=${lib.getLib elfutils}/lib"

122− ];

123−

124− outputs = [ "out" "doc" ];

125− phases = [ "unpackPhase" "patchPhase" ]

126− ++ lib.optional (ghc-patches != []) "autoreconfPhase"

127− ++ [ "configurePhase" "installPhase" ];

128− installPhase = ''

129− cp -r . $out

130− mkdir $doc

131− '';

132−})

compiler/ghc/default.nix+199−61

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

1313, autoreconfHook

1414, bash

1515

16−, libiconv ? null, ncurses

16+, libiconv ? null

17+

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

1719

1820, installDeps

1921

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

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

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

3133 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)

3237

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

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

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

4146

4247, enableDWARF ? false

4348

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

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)

4652

4753, # Wheter to build in NUMA support

4854 enableNUMA ? true

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

6874, extra-passthru ? {}

6975}@args:

7076

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

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;

7282

7383let

7484 inherit (stdenv) buildPlatform hostPlatform targetPlatform;

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

7686

7787 inherit (bootPkgs) ghc;

7888

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+

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

80101 targetLibffi =

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

@@ -90,6 +111,8 @@ let

90111

91112 targetIconv = targetPackages.libiconv or libiconv;

92113

114+ targetNumactl = targetPackages.numactl or numactl;

115+

93116 # TODO(@Ericson2314) Make unconditional

94117 targetPrefix = lib.optionalString

95118 (targetPlatform != hostPlatform)

@@ -101,7 +124,7 @@ let

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

102125 endif

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

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

127+ '' + bignumSpec + ''

105128 EXTRA_HADDOCK_OPTS += --quickjump --hyperlinked-source

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

107130 CrossCompilePrefix = ${targetPrefix}

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

116139 '' + lib.optionalString enableRelocatedStaticLibs ''

117140 GhcLibHcOpts += -fPIC

118141 GhcRtsHcOpts += -fPIC

142+ GhcRtsCcOpts += -fPIC

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

144+ GhcLibHcOpts += -fexternal-dynamic-refs

145+ GhcRtsHcOpts += -fexternal-dynamic-refs

119146 '' + lib.optionalString enableDWARF ''

120147 GhcLibHcOpts += -g3

121148 GhcRtsHcOpts += -g3

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

142169 '';

143170

144171 # Splicer will pull out correct variations

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

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

146173 ++ [targetLibffi]

147174 ++ lib.optional (!enableIntegerSimple) gmp

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

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

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;

150179

151180 toolsForTarget =

152181 if hostPlatform == buildPlatform then

@@ -156,24 +185,6 @@ let

156185

157186 targetCC = builtins.head toolsForTarget;

158187

159− configured-src = import ./configured-src.nix {

160− inherit stdenv lib fetchurl

161− ghc-version ghc-version-date ghc-patches src-spec

162− targetPrefix

163− targetPlatform hostPlatform

164− targetPackages

165− perl autoconf automake m4 python3 sphinx ghc bootPkgs

166− autoreconfHook toolsForTarget bash

167− libDeps

168− useLLVM llvmPackages

169− targetCC

170− enableIntegerSimple targetGmp

171− enableDWARF elfutils

172− ncurses targetLibffi libiconv targetIconv

173− disableLargeAddressSpace

174− buildMK

175− ;

176− };

177188in

178189stdenv.mkDerivation (rec {

179190 version = ghc-version;

@@ -181,45 +192,102 @@ stdenv.mkDerivation (rec {

181192

182193 patches = ghc-patches;

183194

184− # for this to properly work (with inheritance of patches, postPatch, ...)

185− # this needs to be a function over the values we want to inherit and then called

186− # accordingly. Most trivial might be to just have args, and mash them into the

187− # attrset.

188− src = configured-src;

195+ src = if src-spec ? file

196+ then src-spec.file

197+ else fetchurl { inherit (src-spec) url sha256; };

189198

190199 # configure was run by configured-src already.

191− phases = [ "unpackPhase" "buildPhase"

200+ phases = [ "unpackPhase" "patchPhase" ]

201+ ++ lib.optional (ghc-patches != []) "autoreconfPhase"

202+ ++ [ "configurePhase" "buildPhase"

192203 "checkPhase" "installPhase"

193204 "fixupPhase"

194205 "installCheckPhase"

195206 "distPhase"

196207 ];

197208

198− # ghc hardcodes the TOP dir during config, this breaks when

199− # splitting the configured src from the build process.

200− postUnpack = ''

201− (cd $sourceRoot

202− TOP=$(cat mk/config.mk|grep ^TOP|awk -F\ '{ print $3 }')

203− PREFIX=$(cat mk/install.mk|grep ^prefix|awk -F\ '{ print $3 }')

204−

205− # these two are required

206− substituteInPlace mk/config.mk --replace "$TOP" "$PWD" \

207− --replace "$PREFIX" "$out" \

208− --replace "${configured-src.doc}" "$doc"

209−

210− substituteInPlace mk/install.mk --replace "$TOP" "$PWD" \

211− --replace "$PREFIX" "$out" \

212− --replace "${configured-src.doc}" "$doc"

213−

214− # these two only for convencience.

215− substituteInPlace config.log --replace "$TOP" "$PWD" \

216− --replace "$PREFIX" "$out" \

217− --replace "${configured-src.doc}" "$doc"

218−

219− substituteInPlace config.status --replace "$TOP" "$PWD" \

220− --replace "$PREFIX" "$out" \

221− --replace "${configured-src.doc}" "$doc")

222− '';

209+ # GHC is a bit confused on its cross terminology.

210+ preConfigure =

211+ # This code is only included when cross compiling as it breaks aarch64-darwin native compilation

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

213+ for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do

214+ export "''${env#TARGET_}=''${!env}"

215+ done

216+ # GHC is a bit confused on its cross terminology, as these would normally be

217+ # the *host* tools.

218+ export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"

219+ export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

220+ # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177

221+ export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString targetPlatform.isAarch32 ".gold"}"

222+ export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

223+ export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

224+ export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

225+ export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"

226+ export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"

227+ export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"

228+ '' + ''

229+ echo -n "${buildMK}" > mk/build.mk

230+ sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure

231+ '' + lib.optionalString useLLVM ''

232+ export LLC="${llvmPackages.llvm}/bin/llc"

233+ export OPT="${llvmPackages.llvm}/bin/opt"

234+ '' + lib.optionalString (!stdenv.isDarwin) ''

235+ export NIX_LDFLAGS+=" -rpath $out/lib/${targetPrefix}ghc-${ghc-version}"

236+ '' + lib.optionalString stdenv.isDarwin ''

237+ export NIX_LDFLAGS+=" -no_dtrace_dof"

238+ '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''

239+ sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets

240+ '' + lib.optionalString targetPlatform.isMusl ''

241+ echo "patching llvm-targets for musl targets..."

242+ echo "Cloning these existing '*-linux-gnu*' targets:"

243+ grep linux-gnu llvm-targets | sed 's/^/ /'

244+ echo "(go go gadget sed)"

245+ sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets

246+ echo "llvm-targets now contains these '*-linux-musl*' targets:"

247+ grep linux-musl llvm-targets | sed 's/^/ /'

248+

249+ echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"

250+ # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)

251+ for x in configure aclocal.m4; do

252+ substituteInPlace $x \

253+ --replace '*-android*|*-gnueabi*)' \

254+ '*-android*|*-gnueabi*|*-musleabi*)'

255+ done

256+ '' + lib.optionalString (src-spec.version != ghc-version) ''

257+ substituteInPlace configure --replace 'RELEASE=YES' 'RELEASE=NO'

258+ echo '${ghc-version}' > VERSION

259+ '' + lib.optionalString (ghc-version-date != null) ''

260+ substituteInPlace configure --replace 'RELEASE=YES' 'RELEASE=NO'

261+ echo '${ghc-version-date}' > VERSION_DATE

262+ '' + lib.optionalString (builtins.compareVersions ghc-version "9.2.3" >= 0) ''

263+ ./boot

264+ '';

265+

266+ configurePlatforms = [ "build" "host" "target" ];

267+ # `--with` flags for libraries needed for RTS linker

268+ configureFlags = [

269+ "--datadir=$doc/share/doc/ghc"

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

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

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

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

274+ ] ++ lib.optional (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [

275+ "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"

276+ ] ++ lib.optional (targetPlatform != hostPlatform) [

277+ "--with-iconv-includes=${targetIconv}/include" "--with-iconv-libraries=${targetIconv}/lib"

278+ ] ++ lib.optionals (targetPlatform != hostPlatform) [

279+ "--enable-bootstrap-with-devel-snapshot"

280+ ] ++ lib.optionals (disableLargeAddressSpace) [

281+ "--disable-large-address-space"

282+ ] ++ lib.optionals (targetPlatform.isAarch32) [

283+ "CFLAGS=-fuse-ld=gold"

284+ "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"

285+ "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"

286+ ] ++ lib.optionals enableDWARF [

287+ "--enable-dwarf-unwind"

288+ "--with-libdw-includes=${lib.getDev elfutils}/include"

289+ "--with-libdw-libraries=${lib.getLib elfutils}/lib"

290+ ];

223291

224292 enableParallelBuilding = true;

225293 postPatch = "patchShebangs .";

@@ -259,7 +327,18 @@ stdenv.mkDerivation (rec {

259327 ++ lib.optional stdenv.targetPlatform.isAarch32 "pic"

260328 ++ lib.optional stdenv.targetPlatform.isMusl "pie";

261329

262− postInstall = ''

330+ postInstall = lib.optionalString (enableNUMA && targetPlatform.isLinux) ''

331+ # Patch rts.conf to ensure libnuma can be found

332+

333+ for file in $(find "$out/lib" -name "rts*.conf"); do

334+ if grep -q numa $file; then

335+ substituteInPlace $file \

336+ --replace "library-dirs:" "library-dirs: ${targetNumactl}/lib" \

337+ --replace "include-dirs:" "include-dirs: ${targetNumactl}/include"

338+ "$out/bin/${targetPrefix}ghc-pkg" recache

339+ fi

340+ done

341+ '' + ''

263342 # Install the bash completion file.

264343 install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

265344

@@ -275,7 +354,7 @@ stdenv.mkDerivation (rec {

275354 $i

276355 done

277356

278− # Save generated files for needed when building ghcjs

357+ # Save generated files for needed when building ghc and ghcjs

279358 mkdir -p $generated/includes/dist-derivedconstants/header

280359 cp includes/dist-derivedconstants/header/GHCConstantsHaskell*.hs \

281360 $generated/includes/dist-derivedconstants/header

@@ -286,6 +365,15 @@ stdenv.mkDerivation (rec {

286365 fi

287366 mkdir -p $generated/compiler/stage2/build

288367 cp compiler/stage2/build/Config.hs $generated/compiler/stage2/build || true

368+ if [[ -f compiler/stage2/build/GHC/Platform/Constants.hs ]]; then

369+ mkdir -p $generated/compiler/stage2/build/GHC/Platform

370+ cp compiler/stage2/build/GHC/Platform/Constants.hs $generated/compiler/stage2/build/GHC/Platform

371+ fi

372+ if [[ -f compiler/stage2/build/GHC/Settings/Config.hs ]]; then

373+ mkdir -p $generated/compiler/stage2/build/GHC/Settings

374+ cp compiler/stage2/build/GHC/Settings/Config.hs $generated/compiler/stage2/build/GHC/Settings

375+ fi

376+ cp compiler/stage2/build/*.hs-incl $generated/compiler/stage2/build || true

289377 mkdir -p $generated/rts/build

290378 cp rts/build/config.hs-incl $generated/rts/build || true

291379

@@ -329,7 +417,40 @@ stdenv.mkDerivation (rec {

329417 # Our Cabal compiler name

330418 haskellCompilerName = "ghc-${version}";

331419

332− configured-src = configured-src;

420+ # This uses a similar trick to `pkgs.srcOnly` to get the configured src

421+ # We could add `configured-src` as an output of the ghc derivation, but

422+ # having it as its own derivation means it can be accessed quickly without

423+ # building GHC.

424+ configured-src = stdenv.mkDerivation ({

425+ name = name + "-configured-src";

426+ inherit

427+ buildInputs

428+ version

429+ nativeBuildInputs

430+ patches

431+ src

432+ strictDeps

433+ depsBuildTarget

434+ depsTargetTarget

435+ depsTargetTargetPropagated

436+ postPatch

437+ preConfigure

438+ configurePlatforms

439+ configureFlags

440+ outputs

441+ ;

442+

443+ # Including all the outputs (not just $out) causes `mkDerivation` to use the nixpkgs multiple-outputs.sh hook.

444+ # This hook changes the arguments passed to `configure`.

445+ installPhase = ''

446+ cp -r . $out

447+ mkdir $doc

448+ mkdir $generated

449+ '';

450+ phases = [ "unpackPhase" "patchPhase" ]

451+ ++ lib.optional (ghc-patches != []) "autoreconfPhase"

452+ ++ [ "configurePhase" "installPhase"];

453+ });

333454

334455 # Used to detect non haskell-nix compilers (accidental use of nixpkgs compilers can lead to unexpected errors)

335456 isHaskellNixCompiler = true;

@@ -362,13 +483,30 @@ stdenv.mkDerivation (rec {

362483 dontStrip = true;

363484 dontPatchELF = true;

364485 noAuditTmpdir = true;

365−} // lib.optionalAttrs stdenv.buildPlatform.isDarwin {

486+} // lib.optionalAttrs (stdenv.buildPlatform.isDarwin || stdenv.targetPlatform.isWindows) {

366487 # ghc install on macOS wants to run `xattr -r -c`

367488 # The macOS version fails because it wants python 2.

368489 # The nix version of xattr does not support those args.

369490 # Luckily setting the path to something that does not exist will skip the step.

370− preBuild = ''

491+ preBuild = lib.optionalString stdenv.buildPlatform.isDarwin ''

371492 export XATTR=$(mktemp -d)/nothing

493+ ''

494+ # We need to point at a stand in `windows.h` header file so that the RTS headers can

495+ # work on the hostPlatform. We also need to work around case sensitve file system issues.

496+ + lib.optionalString stdenv.targetPlatform.isWindows ''

497+ export NIX_CFLAGS_COMPILE_${

498+ # We want this only to apply to the non windows hostPlatform (the

499+ # windows gcc cross compiler has a full `windows.h`).

500+ # This matches the way `suffixSalt` is calculated in nixpkgs.

501+ # See https://github.com/NixOS/nixpkgs/blob/8411006d6bcd7f6e6a8a1a80ce8fcdccdd16c6ab/pkgs/build-support/cc-wrapper/default.nix#L58

502+ lib.replaceStrings ["-" "."] ["_" "_"] stdenv.hostPlatform.config

503+ }+=" -I${../windows/include}"

504+ if [[ -f libraries/base/include/winio_structs.h ]]; then

505+ substituteInPlace libraries/base/include/winio_structs.h --replace Windows.h windows.h

506+ fi

507+ if [[ -f rts/win32/ThrIOManager.c ]]; then

508+ substituteInPlace rts/win32/ThrIOManager.c --replace rts\\OSThreads.h rts/OSThreads.h

509+ fi

372510 '';

373511});

374512in self

compiler/ghcjs/ghcjs.nix+8−1

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

77 then "ghc884"

88 else "ghc865"

99, ghc ? pkgs.buildPackages.ghc

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

1011}:

1112let

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

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

1415

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

1617 src = ghcjsSrc;

17− inherit ghcjsVersion compiler-nix-name;

18+ inherit ghcjsVersion compiler-nix-name overrideBootPackages;

1819 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 [];

1926# plan-sha256 = "1wy2lr08maxyi7r8jiwf2gj6pdayk5vxxwh42bj4s2gg4035z0yc";

2027# materialized = ../../materialized/ghcjs;

2128 };

compiler/ghcjs/ghcjs810-patched-boot-packages/aeson.patchnew file+13

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

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.nixnew file+176

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

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.patchnew file+471

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

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.patchnew file+99

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

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.patchnew file+14

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

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.patchnew file+87

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

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++};

compiler/windows/include/synchapi.hnew file+1

@@ -0,0 +1 @@

1+#include <windows.h>

compiler/windows/include/windows.hnew file+18

@@ -0,0 +1,18 @@

1+// Just enoough windows.h stuff to make rts headers usable when building GHC cross compiler.

2+// See compiler/ghc/default.nix for where this is used.

3+#ifndef _WINDOWS_

4+#define _WINDOWS_

5+

6+#define __stdcall

7+

8+typedef unsigned long DWORD;

9+typedef void * PVOID;

10+

11+typedef struct _RTL_CONDITION_VARIABLE { PVOID Ptr; } RTL_CONDITION_VARIABLE;

12+typedef RTL_CONDITION_VARIABLE CONDITION_VARIABLE;

13+

14+typedef struct _RTL_SRWLOCK { PVOID Ptr; } RTL_SRWLOCK;

15+typedef RTL_SRWLOCK SRWLOCK;

16+

17+#endif

18+

config.nix−4

@@ -2,11 +2,7 @@

22 # allow building for windows

33 allowUnsupportedSystem = true;

44 # we want the 64bit wine version

5− # See overlays/wine.nix as well!

65 wine.build = "wine64";

76 wine.release = "stable";

8−

9− # This is marked insecure on 20.03, but many packages still depend on it

10− permittedInsecurePackages = [ "openssl-1.0.2u" ];

117}

128

docs/reference/library.md+1

@@ -167,6 +167,7 @@ Then feeding its result into [mkCabalProjectPkgSet](#mkcabalprojectpkgset) passi

167167| `ghcWithPackages` | Function | [`ghcWithPackages`](#ghcwithpackages) |

168168| `projectCross` | Attrset | Like `pkgs.pkgsCross.<system>` from nixpkgs `p.projectCross.<system>` returns the project results for cross compilation (where system is a member of nixpkgs lib.systems.examples). So `p.projectCross.ghcjs.hsPkgs` is the same as `hsPkgs` but compiled with ghcjs |

169169| `appendModule` | Function | Re-eval the project with an extra module (or module list). |

170+| `extend` and `appendOverlays` | Function | Modify a project, or add attributes, through overlays: `p.extend(final: prev: { })`. The overlays are carried-over `projectCross` and `appendModule` invocations. |

170171

171172## project, cabalProject and stackProject

172173

docs/reference/supported-ghc-versions.md+5−9

@@ -8,6 +8,7 @@ for each, though not all are cached or tested by CI):

88- 8.10.{1,2,3,4,5}

99- 9.0.1

1010- 9.2.1

11+- 9.2.2

1112

1213The following table shows the Nixpkgs/GHC versions which are built/cached, and

1314which of those are further tested. If you use a combination of Nixpkgs version

@@ -20,18 +21,13 @@ really should use an instance of Nixpkgs provided by `haskell.nix` itself.

2021

2122| Nixpkgs version | Nixpkgs pinning | GHC version | `compiler-nix-name` | Tested in CI? |

2223|------------------|--------------------|-------------|-----------------------|---------------|

23−| 21.05 | `nixpkgs-2105` | 8.6.5 | `ghc865` | No |

24−| 21.05 | `nixpkgs-2105` | 8.10.7 | `ghc8107` | No |

25−| 21.11 | `nixpkgs-2105` | 8.6.5 | `ghc865` | No |

26−| 21.11 | `nixpkgs-2105` | 8.10.7 | `ghc8107` | Yes |

24+| 21.11 | `nixpkgs-2111` | 8.6.5 | `ghc865` | No |

25+| 21.11 | `nixpkgs-2111` | 8.10.7 | `ghc8107` | Yes |

2726| unstable | `nixpkgs-unstable` | 8.6.5 | `ghc865` | No |

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

29−| unstable | `nixpkgs-unstable` | 8.10.4 | `ghc8104` | No |

30−| unstable | `nixpkgs-unstable` | 8.10.5 | `ghc8105` | No |

31−| unstable | `nixpkgs-unstable` | 8.10.6 | `ghc8106` | No |

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

33−| unstable | `nixpkgs-unstable` | 9.0.1 | `ghc901` | No |

34−| unstable | `nixpkgs-unstable` | 9.2.1 | `ghc921` | Yes |

29+| unstable | `nixpkgs-unstable` | 9.0.2 | `ghc902` | Yes |

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

3531

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

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

docs/tutorials/ca-derivations.mdnew file+65

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

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.

docs/tutorials/getting-started-flakes.md+28−4

@@ -22,10 +22,34 @@ You need to add the following sections to `/etc/nix/nix.conf` or, if you are a t

2222

2323```

2424trusted-public-keys = [...] hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= [...]

25−substituters = [...] https://hydra.iohk.io [...]

25+substituters = [...] https://cache.iog.io [...]

2626```

2727

28−This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../reference/troubleshooting#why-am-i-building-ghc).

28+If you're running NixOS, you need to add/update the following in your `/etc/nixos/configuration.nix` files instead.

29+

30+```

31+# Binary Cache for Haskell.nix

32+nix.settings.trusted-public-keys = [

33+ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

34+];

35+nix.settings.substituters = [

36+ "https://cache.iog.io"

37+];

38+```

39+

40+NixOS-21.11 and older use slightly different settings.

41+

42+```

43+# Binary Cache for Haskell.nix

44+nix.binaryCachePublicKeys = [

45+ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

46+];

47+nix.binaryCaches = [

48+ "https://cache.iog.io"

49+];

50+```

51+

52+This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../troubleshooting.md#why-am-i-building-ghc).

2953

3054## Scaffolding

3155

@@ -62,14 +86,14 @@ Add `flake.nix`:

6286 nixpkgs-fmt

6387 ];

6488 # This adds `js-unknown-ghcjs-cabal` to the shell.

65− shell.crossPlatform = p: [p.ghcjs];

89+ # shell.crossPlatforms = p: [p.ghcjs];

6690 };

6791 })

6892 ];

6993 pkgs = import nixpkgs { inherit system overlays; inherit (haskellNix) config; };

7094 flake = pkgs.helloProject.flake {

7195 # This adds support for `nix build .#js-unknown-ghcjs-cabal:hello:exe:hello`

72− crossPlatforms = p: [p.ghcjs];

96+ # crossPlatforms = p: [p.ghcjs];

7397 };

7498 in flake // {

7599 # Built by `nix build .`

docs/tutorials/getting-started-hix.md+26−2

@@ -29,10 +29,34 @@ You need to add the following sections to `/etc/nix/nix.conf` or, if you are a t

2929

3030```

3131trusted-public-keys = [...] hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= [...]

32−substituters = [...] https://hydra.iohk.io [...]

32+substituters = [...] https://cache.iog.io [...]

3333```

3434

35−This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../reference/troubleshooting#why-am-i-building-ghc).

35+If you're running NixOS, you need to add/update the following in your `/etc/nixos/configuration.nix` files instead.

36+

37+```

38+# Binary Cache for Haskell.nix

39+nix.settings.trusted-public-keys = [

40+ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

41+];

42+nix.settings.substituters = [

43+ "https://cache.iog.io"

44+];

45+```

46+

47+NixOS-21.11 and older use slightly different settings.

48+

49+```

50+# Binary Cache for Haskell.nix

51+nix.binaryCachePublicKeys = [

52+ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

53+];

54+nix.binaryCaches = [

55+ "https://cache.iog.io"

56+];

57+```

58+

59+This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../troubleshooting.md#why-am-i-building-ghc).

3660

3761## Installing Hix

3862

docs/tutorials/getting-started.md+16−4

@@ -18,22 +18,34 @@ You need to add the following sections to `/etc/nix/nix.conf` or, if you are a t

1818

1919```

2020trusted-public-keys = [...] hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= [...]

21−substituters = [...] https://hydra.iohk.io [...]

21+substituters = [...] https://cache.iog.io [...]

2222```

2323

2424If you're running NixOS, you need to add/update the following in your `/etc/nixos/configuration.nix` files instead.

2525

2626```

2727# Binary Cache for Haskell.nix

28+nix.settings.trusted-public-keys = [

29+ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

30+];

31+nix.settings.substituters = [

32+ "https://cache.iog.io"

33+];

34+```

35+

36+NixOS-21.11 and older use slightly different settings.

37+

38+```

39+# Binary Cache for Haskell.nix

2840nix.binaryCachePublicKeys = [

2941 "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="

3042];

3143nix.binaryCaches = [

32− "https://hydra.iohk.io"

33−];

44+ "https://cache.iog.io"

45+];

3446```

3547

36−This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../../troubleshooting#why-am-i-building-ghc).

48+This can be tricky to get setup properly. If you're still having trouble getting cache hits, consult the corresponding [troubleshooting section](../troubleshooting.md#why-am-i-building-ghc).

3749

3850## Niv

3951

flake.lock+137−30

@@ -20,10 +20,10 @@

2020 "flake": false,

2121 "locked": {

2222 "lastModified": 1603716527,

23− "narHash": "sha256-sDbrmur9Zfp4mPKohCD8IDZfXJ0Tjxpmr2R+kg5PpSY=",

23+ "narHash": "sha256-X0TFfdD4KZpwl0Zr6x+PLxUt/VyKQfX7ylXHdmZIL+w=",

2424 "owner": "haskell",

2525 "repo": "cabal",

26− "rev": "94aaa8e4720081f9c75497e2735b90f6a819b08e",

26+ "rev": "48bf10787e27364730dd37a42b603cee8d6af7ee",

2727 "type": "github"

2828 },

2929 "original": {

@@ -36,11 +36,11 @@

3636 "cabal-34": {

3737 "flake": false,

3838 "locked": {

39− "lastModified": 1622475795,

40− "narHash": "sha256-chwTL304Cav+7p38d9mcb+egABWmxo2Aq+xgVBgEb/U=",

39+ "lastModified": 1640353650,

40+ "narHash": "sha256-N1t6M3/wqj90AEdRkeC8i923gQYUpzSr8b40qVOZ1Rk=",

4141 "owner": "haskell",

4242 "repo": "cabal",

43− "rev": "b086c1995cdd616fc8d91f46a21e905cc50a1049",

43+ "rev": "942639c18c0cd8ec53e0a6f8d120091af35312cd",

4444 "type": "github"

4545 },

4646 "original": {

@@ -53,11 +53,11 @@

5353 "cabal-36": {

5454 "flake": false,

5555 "locked": {

56− "lastModified": 1640163203,

57− "narHash": "sha256-TwDWP2CffT0j40W6zr0J1Qbu+oh3nsF1lUx9446qxZM=",

56+ "lastModified": 1641652457,

57+ "narHash": "sha256-BlFPKP4C4HRUJeAbdembX1Rms1LD380q9s0qVDeoAak=",

5858 "owner": "haskell",

5959 "repo": "cabal",

60− "rev": "ecf418050c1821f25e2e218f1be94c31e0465df1",

60+ "rev": "f27667f8ec360c475027dcaee0138c937477b070",

6161 "type": "github"

6262 },

6363 "original": {

@@ -85,11 +85,11 @@

8585 },

8686 "flake-utils": {

8787 "locked": {

88− "lastModified": 1623875721,

89− "narHash": "sha256-A8BU7bjS5GirpAUv4QA+QnJ4CceLHkcXdRp4xITDB0s=",

88+ "lastModified": 1644229661,

89+ "narHash": "sha256-1YdnJAsNy69bpcjuoKdOYQX0YxZBiCYZo4Twxerqv7k=",

9090 "owner": "numtide",

9191 "repo": "flake-utils",

92− "rev": "f7e004a55b120c02ecb6219596820fcd32ca8772",

92+ "rev": "3cecb5b042f7f209c56ffd8371b2711a290ec797",

9393 "type": "github"

9494 },

9595 "original": {

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

118118 "hackage": {

119119 "flake": false,

120120 "locked": {

121− "lastModified": 1643937230,

122− "narHash": "sha256-G1oZXEKm+Z6fSzrXLeY9BSK5MJdzEFeGHKQpaXiokmc=",

121+ "lastModified": 1659402819,

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

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

124124 "repo": "hackage.nix",

125− "rev": "204d96c5cdeab48dc8e5ccb8773df2df9a909901",

125+ "rev": "2f6f97ca3db96f91eea674ef46f4a0785d1e9d9c",

126126 "type": "github"

127127 },

128128 "original": {

@@ -147,14 +147,73 @@

147147 "type": "github"

148148 }

149149 },

150+ "hydra": {

151+ "inputs": {

152+ "nix": "nix",

153+ "nixpkgs": [

154+ "hydra",

155+ "nix",

156+ "nixpkgs"

157+ ]

158+ },

159+ "locked": {

160+ "lastModified": 1646878427,

161+ "narHash": "sha256-KtbrofMtN8GlM7D+n90kixr7QpSlVmdN+vK5CA/aRzc=",

162+ "owner": "NixOS",

163+ "repo": "hydra",

164+ "rev": "28b682b85b7efc5cf7974065792a1f22203a5927",

165+ "type": "github"

166+ },

167+ "original": {

168+ "id": "hydra",

169+ "type": "indirect"

170+ }

171+ },

172+ "lowdown-src": {

173+ "flake": false,

174+ "locked": {

175+ "lastModified": 1633514407,

176+ "narHash": "sha256-Dw32tiMjdK9t3ETl5fzGrutQTzh2rufgZV4A/BbxuD4=",

177+ "owner": "kristapsdz",

178+ "repo": "lowdown",

179+ "rev": "d2c2b44ff6c27b936ec27358a2653caaef8f73b8",

180+ "type": "github"

181+ },

182+ "original": {

183+ "owner": "kristapsdz",

184+ "repo": "lowdown",

185+ "type": "github"

186+ }

187+ },

188+ "nix": {

189+ "inputs": {

190+ "lowdown-src": "lowdown-src",

191+ "nixpkgs": "nixpkgs",

192+ "nixpkgs-regression": "nixpkgs-regression"

193+ },

194+ "locked": {

195+ "lastModified": 1643066034,

196+ "narHash": "sha256-xEPeMcNJVOeZtoN+d+aRwolpW8mFSEQx76HTRdlhPhg=",

197+ "owner": "NixOS",

198+ "repo": "nix",

199+ "rev": "a1cd7e58606a41fcf62bf8637804cf8306f17f62",

200+ "type": "github"

201+ },

202+ "original": {

203+ "owner": "NixOS",

204+ "ref": "2.6.0",

205+ "repo": "nix",

206+ "type": "github"

207+ }

208+ },

150209 "nix-tools": {

151210 "flake": false,

152211 "locked": {

153− "lastModified": 1636018067,

154− "narHash": "sha256-ng306fkuwr6V/malWtt3979iAC4yMVDDH2ViwYB6sQE=",

212+ "lastModified": 1658968505,

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

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

156215 "repo": "nix-tools",

157− "rev": "ed5bd7215292deba55d6ab7a4e8c21f8b1564dda",

216+ "rev": "8a754bdcf20b20e116409c2341cf69065d083053",

158217 "type": "github"

159218 },

160219 "original": {

@@ -163,6 +222,21 @@

163222 "type": "github"

164223 }

165224 },

225+ "nixpkgs": {

226+ "locked": {

227+ "lastModified": 1632864508,

228+ "narHash": "sha256-d127FIvGR41XbVRDPVvozUPQ/uRHbHwvfyKHwEt5xFM=",

229+ "owner": "NixOS",

230+ "repo": "nixpkgs",

231+ "rev": "82891b5e2c2359d7e58d08849e4c89511ab94234",

232+ "type": "github"

233+ },

234+ "original": {

235+ "id": "nixpkgs",

236+ "ref": "nixos-21.05-small",

237+ "type": "indirect"

238+ }

239+ },

166240 "nixpkgs-2003": {

167241 "locked": {

168242 "lastModified": 1620055814,

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

181255 },

182256 "nixpkgs-2105": {

183257 "locked": {

184− "lastModified": 1640283157,

185− "narHash": "sha256-6Ddfop+rKE+Gl9Tjp9YIrkfoYPzb8F80ergdjcq3/MY=",

258+ "lastModified": 1655034179,

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

186260 "owner": "NixOS",

187261 "repo": "nixpkgs",

188− "rev": "dde1557825c5644c869c5efc7448dc03722a8f09",

262+ "rev": "046ee4af7a9f016a364f8f78eeaa356ba524ac31",

189263 "type": "github"

190264 },

191265 "original": {

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

197271 },

198272 "nixpkgs-2111": {

199273 "locked": {

200− "lastModified": 1640283207,

201− "narHash": "sha256-SCwl7ZnCfMDsuSYvwIroiAlk7n33bW8HFfY8NvKhcPA=",

274+ "lastModified": 1656782578,

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

202276 "owner": "NixOS",

203277 "repo": "nixpkgs",

204− "rev": "64c7e3388bbd9206e437713351e814366e0c3284",

278+ "rev": "573603b7fdb9feb0eb8efc16ee18a015c667ab1b",

205279 "type": "github"

206280 },

207281 "original": {

@@ -211,13 +285,44 @@

211285 "type": "github"

212286 }

213287 },

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+ },

304+ "nixpkgs-regression": {

305+ "locked": {

306+ "lastModified": 1643052045,

307+ "narHash": "sha256-uGJ0VXIhWKGXxkeNnq4TvV3CIOkUJ3PAoLZ3HMzNVMw=",

308+ "owner": "NixOS",

309+ "repo": "nixpkgs",

310+ "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",

311+ "type": "github"

312+ },

313+ "original": {

314+ "id": "nixpkgs",

315+ "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",

316+ "type": "indirect"

317+ }

318+ },

214319 "nixpkgs-unstable": {

215320 "locked": {

216− "lastModified": 1641285291,

217− "narHash": "sha256-KYaOBNGar3XWTxTsYPr9P6u74KAqNq0wobEC236U+0c=",

321+ "lastModified": 1657888067,

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

218323 "owner": "NixOS",

219324 "repo": "nixpkgs",

220− "rev": "0432195a4b8d68faaa7d3d4b355260a3120aeeae",

325+ "rev": "65fae659e31098ca4ac825a6fef26d890aaf3f4e",

221326 "type": "github"

222327 },

223328 "original": {

@@ -255,13 +360,15 @@

255360 "ghc-8.6.5-iohk": "ghc-8.6.5-iohk",

256361 "hackage": "hackage",

257362 "hpc-coveralls": "hpc-coveralls",

363+ "hydra": "hydra",

258364 "nix-tools": "nix-tools",

259365 "nixpkgs": [

260− "nixpkgs-2111"

366+ "nixpkgs-unstable"

261367 ],

262368 "nixpkgs-2003": "nixpkgs-2003",

263369 "nixpkgs-2105": "nixpkgs-2105",

264370 "nixpkgs-2111": "nixpkgs-2111",

371+ "nixpkgs-2205": "nixpkgs-2205",

265372 "nixpkgs-unstable": "nixpkgs-unstable",

266373 "old-ghc-nix": "old-ghc-nix",

267374 "stackage": "stackage"

@@ -270,11 +377,11 @@

270377 "stackage": {

271378 "flake": false,

272379 "locked": {

273− "lastModified": 1643937352,

274− "narHash": "sha256-dOMDnNYXmUgJEG1ucgb33R8Q0qvwQ1UTA4MeYzCz/7I=",

380+ "lastModified": 1659402917,

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

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

276383 "repo": "stackage.nix",

277− "rev": "0f598eb78f1ab10f91a1077bbc1fbd569ee6568d",

384+ "rev": "778df3c4b35eac853d57fac7bafc7c9f2dde917f",

278385 "type": "github"

279386 },

280387 "original": {

flake.nix+14−4

@@ -2,12 +2,14 @@

22 description = "Alternative Haskell Infrastructure for Nixpkgs";

33

44 inputs = {

5− nixpkgs.follows = "nixpkgs-2111";

5+ nixpkgs.follows = "nixpkgs-unstable";

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"; };

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

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

12+ hydra.url = "hydra";

1113 hackage = {

1214 url = "github:input-output-hk/hackage.nix";

1315 flake = false;

@@ -57,8 +59,8 @@

5759 };

5860 };

5961

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

61− let compiler = "ghc884";

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

63+ let compiler = "ghc924";

6264 config = import ./config.nix;

6365 in {

6466 inherit config;

@@ -99,6 +101,12 @@

99101 };

100102 pkgs = import nixpkgs

101103 (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; }; });

102110 pkgs-unstable = import nixpkgs-unstable

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

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

@@ -110,7 +118,7 @@

110118 # supported by haskell.nix, e.g. with remote builders, in order to check this flake.

111119 # If you want to run the tests for just your platform, run `./test/tests.sh` or

112120 # `nix-build -A checks.$PLATFORM`

113− } // flake-utils.lib.eachSystem [ "x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin" ] (system: {

121+ } // flake-utils.lib.eachSystem [ "x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin" ] (system: rec {

114122 legacyPackages = (self.internal.compat { inherit system; }).pkgs;

115123 legacyPackagesUnstable = (self.internal.compat { inherit system; }).pkgs-unstable;

116124

@@ -124,6 +132,8 @@

124132 compiler-nix-name = compiler;

125133 pkgs = haskellNix.pkgs;

126134 })));

135+ # Exposed so that buildkite can check that `allow-import-from-derivation=false` works for core of haskell.nix

136+ roots = legacyPackagesUnstable.haskell-nix.roots compiler;

127137

128138 devShell = with self.legacyPackages.${system};

129139 mkShell {

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− pkgs = import config.nixpkgs config.nixpkgsArgs;

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

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

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

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

6262 userDefaults

6363 projectDefaults

6464 commandArgs'

65− {

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

6666 src =

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

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

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

6969 inherit src name;

7070 }

7171 else src;

72− }

72+ })

7373 ];

7474 })

7575 ];

lib/cabal-project-parser.nix+114−5

@@ -74,17 +74,21 @@ let

7474 # --shar256: 003lm3pm0000hbfmii7xcdd9v20000flxf7gdl2pyxia7p014i8z

7575 # will be trated like a field and returned here

7676 # (used in call-cabal-project-to-nix.nix to create a fixed-output derivation)

77− extractRepoData = cabalProjectFileName: lookupSha256: repo: {

77+ extractSourceRepoPackageData = cabalProjectFileName: sha256map: repo: {

7878 url = repo.location;

7979 ref = repo.tag;

80− sha256 = repo."--sha256" or (lookupSha256 repo);

80+ sha256 = repo."--sha256" or (

81+ if sha256map != null

82+ then sha256map."${repo.location}"."${repo.tag}"

83+ else null);

8184 subdirs = if repo ? subdir

8285 then pkgs.lib.filter (x: x != "") (pkgs.lib.splitString " " repo.subdir)

8386 else ["."];

8487 };

8588

8689 # Parse a source-repository-package and return data of `type: git` repositories

87− parseBlock = cabalProjectFileName: lookupSha256: block:

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

91+ parseSourceRepositoryPackageBlock = cabalProjectFileName: sha256map: block:

8892 let

8993 x = span (pkgs.lib.strings.hasPrefix " ") (pkgs.lib.splitString "\n" block);

9094 attrs = parseBlockLines x.fst;

@@ -95,10 +99,115 @@ let

9599 otherText = "\nsource-repository-package\n" + block;

96100 }

97101 else {

98− sourceRepo = extractRepoData cabalProjectFileName lookupSha256 attrs;

102+ sourceRepo = extractSourceRepoPackageData cabalProjectFileName sha256map attrs;

99103 otherText = pkgs.lib.strings.concatStringsSep "\n" x.snd;

100104 };

101105

106+ parseSourceRepositoryPackages = cabalProjectFileName: sha256map: source-repo-override: projectFile:

107+ let

108+ blocks = pkgs.lib.splitString "\nsource-repository-package\n" ("\n" + projectFile);

109+ initialText = pkgs.lib.lists.take 1 blocks;

110+ repoBlocks = builtins.map (parseSourceRepositoryPackageBlock cabalProjectFileName sha256map) (pkgs.lib.lists.drop 1 blocks);

111+ overrideSourceRepo = sourceRepo: (source-repo-override.${sourceRepo.url} or (pkgs.lib.id)) sourceRepo;

112+ in {

113+ sourceRepos = pkgs.lib.lists.map (block: overrideSourceRepo block.sourceRepo) repoBlocks;

114+ otherText = pkgs.lib.strings.concatStringsSep "\n" (

115+ initialText

116+ ++ (builtins.map (x: x.otherText) repoBlocks));

117+ };

118+

119+ # Parse and replace repository

120+ # This works in a similar way to the `source-repository-package` but we are

121+ # able to simply replace the `repository` blocks with local `file:/nix/store` ones.

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

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

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

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

126+ let

127+ lines = pkgs.lib.splitString "\n" block;

128+ # The first line will contain the repository name.

129+ x = span (pkgs.lib.strings.hasPrefix " ") (__tail lines);

130+ attrs = parseBlockLines x.fst;

131+ sha256 = attrs."--sha256" or (

132+ if sha256map != null

133+ then sha256map."${attrs.url}"

134+ else null);

135+ in rec {

136+ # This is `some-name` from the `repository some-name` line in the `cabal.project` file.

137+ name = __head lines;

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

139+ repoContents = if inputMap ? ${attrs.url}

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

141+ then evalPackages.runCommand name ({

142+ nativeBuildInputs = [ cabal-install ];

143+ preferLocalBuild = true;

144+ }) ''

145+ HOME=$(mktemp -d)

146+ mkdir -p $HOME/.cabal/packages/${name}

147+ cat <<EOF > $HOME/.cabal/config

148+ repository ${name}

149+ url: file:${inputMap.${attrs.url}}

150+ ${pkgs.lib.optionalString (attrs ? secure) "secure: ${attrs.secure}"}

151+ ${pkgs.lib.optionalString (attrs ? root-keys) "root-keys: ${attrs.root-keys}"}

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

153+ EOF

154+

155+ cabal v2-update ${name}

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

157+ ''

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";

161+ LANG = "en_US.UTF-8";

162+ preferLocalBuild = true;

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

164+ outputHashMode = "recursive";

165+ outputHashAlgo = "sha256";

166+ outputHash = sha256;

167+ }) ''

168+ HOME=$(mktemp -d)

169+ mkdir -p $HOME/.cabal/packages/${name}

170+ cat <<EOF > $HOME/.cabal/config

171+ repository ${name}

172+ url: ${attrs.url}

173+ ${pkgs.lib.optionalString (attrs ? secure) "secure: ${attrs.secure}"}

174+ ${pkgs.lib.optionalString (attrs ? root-keys) "root-keys: ${attrs.root-keys}"}

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

176+ EOF

177+

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

179+ cabal v2-update ${name}

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

181+ '';

182+ # Output of hackage-to-nix

183+ 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";

187+ LANG = "en_US.UTF-8";

188+ preferLocalBuild = true;

189+ } ''

190+ mkdir -p $out

191+ hackage-to-nix $out ${repoContents}/01-index.tar ${attrs.url}

192+ '');

193+ # Directory to `lndir` when constructing a suitable $HOME/.cabal dir

194+ repo = {

195+ ${name} = repoContents;

196+ };

197+ };

198+

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

200+ let

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

202+ 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);

204+ in {

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

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

207+ };

208+

102209in {

103− inherit parseIndexState parseBlockLines parseBlock;

210+ inherit parseIndexState parseSourceRepositoryPackages parseRepositories

211+ # These are only exposed for tests

212+ parseSourceRepositoryPackageBlock parseRepositoryBlock;

104213}

lib/call-cabal-project-to-nix.nix+74−56

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

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

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

22let readIfExists = src: fileName:

33 let origSrcDir = src.origSrcSubDir or src;

44 in

@@ -30,13 +30,22 @@ in

3030 # An alternative to adding `--sha256` comments into the

3131 # cabal.project file:

3232 # sha256map =

33− # { "https://github.com/jgm/pandoc-citeproc"."0.17"

34− # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };

35−, lookupSha256 ?

36− if sha256map != null

37− then { location, tag, ...}: sha256map."${location}"."${tag}"

38− else _: null

39−, extra-hackage-tarballs ? []

33+ # { # For a `source-repository-package` use the `location` and `tag` as the key

34+ # "https://github.com/jgm/pandoc-citeproc"."0.17"

35+ # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q";

36+ # # For a `repository` use the `url` as the key

37+ # "https://raw.githubusercontent.com/input-output-hk/hackage-overlay-ghcjs/bfc363b9f879c360e0a0460ec0c18ec87222ec32"

38+ # = "sha256-g9xGgJqYmiczjxjQ5JOiK5KUUps+9+nlNGI/0SpSOpg=";

39+ # };

40+, inputMap ? {}

41+ # An alternative to providing a `sha256` handy for flakes

42+ # cabal.project file:

43+ # inputs.pandoc-citeproc.url = "github:jgm/pandoc-citeproc/0.17";

44+ # inputs.pandoc-citeproc.flake = false;

45+ # outputs = inputs:

46+ # ...

47+ # inputMap."https://github.com/jgm/pandoc-citeproc" = inputs.inputs.pandoc-citeproc;

48+, extra-hackage-tarballs ? {}

4049, source-repo-override ? {} # Cabal seems to behave incoherently when

4150 # two source-repository-package entries

4251 # provide the same packages, making it

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

5564 # would result in the "foo" subdirectory of

5665 # any plutus-apps input being used for a

5766 # package.

67+, evalPackages

5868, ...

5969}@args:

6070

6171let

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

73+

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

6375 # lazy enough to avoid infinite recursion issues.

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

@@ -102,15 +114,13 @@ let

102114 ghc = ghc';

103115 subDir' = src.origSubDir or "";

104116 subDir = pkgs.lib.strings.removePrefix "/" subDir';

105− maybeCleanedSource =

106− if haskellLib.canCleanSource src

107− then (haskellLib.cleanSourceWith {

108− name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

109− src = src.origSrc or src;

110− filter = path: type: (!(src ? filter) || src.filter path type) && (

111− type == "directory" ||

112− pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ ".cabal" "package.yaml" ]); })

113− else src.origSrc or src;

117+

118+ cleanedSource = haskellLib.cleanSourceWith {

119+ name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

120+ src = src.origSrc or src;

121+ filter = path: type: (!(src ? filter) || src.filter path type) && (

122+ type == "directory" ||

123+ pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ ".cabal" "package.yaml" ]); };

114124

115125 # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when

116126 # access to the store is restricted. If origSrc was already in the store

@@ -192,21 +202,28 @@ let

192202

193203 replaceSourceRepos = projectFile:

194204 let

195− fetchRepo = fetchgit: repoData:

205+ fetchPackageRepo = fetchgit: repoData:

196206 let

197207 fetched =

198− if repoData.sha256 != null

199− then fetchgit { inherit (repoData) url sha256; rev = repoData.ref; }

208+ if inputMap ? "${repoData.url}/${repoData.ref}"

209+ then inputMap."${repoData.url}/${repoData.ref}"

210+ else if inputMap ? ${repoData.url}

211+ then

212+ (if inputMap.${repoData.url}.rev != repoData.ref

213+ then throw "${inputMap.${repoData.url}.rev} may not match ${repoData.ref} for ${repoData.url} use \"${repoData.url}/${repoData.ref}\" as the inputMap key if ${repoData.ref} is a branch or tag that points to ${inputMap.${repoData.url}.rev}."

214+ else inputMap.${repoData.url})

215+ else if repoData.sha256 != null

216+ then fetchgit { inherit (repoData) url sha256; rev = repoData.ref; }

200217 else

201218 let drv = builtins.fetchGit { inherit (repoData) url ref; };

202219 in __trace "WARNING: No sha256 found for source-repository-package ${repoData.url} ${repoData.ref} download may fail in restricted mode (hydra)"

203− (__trace "Consider adding `--sha256: ${hashPath drv}` to the ${cabalProjectFileName} file or passing in a lookupSha256 argument"

220+ (__trace "Consider adding `--sha256: ${hashPath drv}` to the ${cabalProjectFileName} file or passing in a sha256map argument"

204221 drv);

205222 in {

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

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

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

209− nativeBuildInputs = [ pkgs.evalPackages.rsync pkgs.evalPackages.git ];

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

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

210227 } ''

211228 mkdir $out

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

@@ -221,30 +238,30 @@ let

221238 tag = "minimal";

222239 };

223240

224− blocks = pkgs.lib.splitString "\nsource-repository-package\n" ("\n" + projectFile);

225− initialText = pkgs.lib.lists.take 1 blocks;

226− repoBlocks = builtins.map (pkgs.haskell-nix.haskellLib.parseBlock cabalProjectFileName lookupSha256) (pkgs.lib.lists.drop 1 blocks);

227− overrideSourceRepo = sourceRepo: (source-repo-override.${sourceRepo.url} or (pkgs.lib.id)) sourceRepo;

228− sourceRepoData = pkgs.lib.lists.map (x: overrideSourceRepo x.sourceRepo) repoBlocks;

229− otherText = pkgs.evalPackages.writeText "cabal.project" (pkgs.lib.strings.concatStringsSep "\n" (

230− initialText

231− ++ (builtins.map (x: x.otherText) repoBlocks)));

241+ # Parse the `source-repository-package` blocks

242+ sourceRepoPackageResult = pkgs.haskell-nix.haskellLib.parseSourceRepositoryPackages

243+ cabalProjectFileName sha256map source-repo-override projectFile;

244+

245+ # Parse the `repository` blocks

246+ repoResult = pkgs.haskell-nix.haskellLib.parseRepositories

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

232248

233249 # we need the repository content twice:

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

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

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

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

237253 # * at built time (passed out)

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

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

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

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

242− sourceReposEval = builtins.map (fetchRepo pkgs.evalPackages.fetchgit) sourceRepoData;

243− sourceReposBuild = builtins.map (x: (fetchRepo pkgs.fetchgit x).fetched) sourceRepoData;

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

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

244260 in {

245261 sourceRepos = sourceReposBuild;

262+ inherit (repoResult) repos extra-hackages;

246263 makeFixedProjectFile = ''

247− cp -f ${otherText} ./cabal.project

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

248265 '' +

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

250267 chmod +w -R ./cabal.project

@@ -279,7 +296,7 @@ let

279296

280297 fixedProject =

281298 if rawCabalProject == null

282− then { sourceRepos = []; makeFixedProjectFile = ""; replaceLocations = ""; }

299+ then { sourceRepos = []; repos = {}; extra-hackages = []; makeFixedProjectFile = ""; replaceLocations = ""; }

283300 else replaceSourceRepos rawCabalProject;

284301

285302 # The use of the actual GHC can cause significant problems:

@@ -351,12 +368,12 @@ let

351368 '');

352369

353370 # Dummy `ghc` that uses the captured output

354− dummy-ghc = pkgs.evalPackages.writeTextFile {

371+ dummy-ghc = evalPackages.writeTextFile {

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

356373 executable = true;

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

358375 text = ''

359− #!${pkgs.evalPackages.runtimeShell}

376+ #!${evalPackages.runtimeShell}

360377 case "$*" in

361378 --version*)

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

@@ -394,12 +411,12 @@ let

394411 };

395412

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

397− dummy-ghc-pkg = pkgs.evalPackages.writeTextFile {

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

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

399416 executable = true;

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

401418 text = ''

402− #!${pkgs.evalPackages.runtimeShell}

419+ #!${evalPackages.runtimeShell}

403420 case "$*" in

404421 --version)

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

@@ -435,10 +452,10 @@ let

435452 else null;

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

437454 inherit checkMaterialization;

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

439− nativeBuildInputs = [ nix-tools dummy-ghc dummy-ghc-pkg cabal-install pkgs.evalPackages.rsync pkgs.evalPackages.git ];

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

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

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

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

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

442459 LANG = "en_US.UTF-8";

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

444461 preferLocalBuild = false;

@@ -460,11 +477,11 @@ let

460477 '';

461478 in {

462479 # These check for cabal configure failure

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

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

464481 ${checkCabalConfigure}

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

466483 '';

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

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

468485 ${checkCabalConfigure}

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

470487 '';

@@ -472,17 +489,17 @@ let

472489 } ''

473490 tmp=$(mktemp -d)

474491 cd $tmp

475− # if maybeCleanedSource is empty, this means it's a new

492+ # if cleanedSource is empty, this means it's a new

476493 # project where the files haven't been added to the git

477494 # repo yet. We fail early and provide a useful error

478495 # message to prevent headaches (#290).

479− if [ -z "$(ls -A ${maybeCleanedSource})" ]; then

496+ if [ -z "$(ls -A ${cleanedSource})" ]; then

480497 echo "cleaned source is empty. Did you forget to 'git add -A'?"

481498 ${pkgs.lib.optionalString (__length fixedProject.sourceRepos == 0) ''

482499 exit 1

483500 ''}

484501 else

485− cp -r ${maybeCleanedSource}/* .

502+ cp -r ${cleanedSource}/* .

486503 fi

487504 chmod +w -R .

488505 # Decide what to do for each `package.yaml` file.

@@ -506,7 +523,7 @@ let

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

507524 ${fixedProject.makeFixedProjectFile}

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

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

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

510527 cabal.project.freeze

511528 chmod +w cabal.project.freeze

512529 ''}

@@ -525,15 +542,16 @@ let

525542 # which is used by cabal (cached-index-state >= index-state-found).

526543 dotCabal {

527544 inherit cabal-install nix-tools extra-hackage-tarballs;

545+ extra-hackage-repos = fixedProject.repos;

528546 index-state = cached-index-state;

529547 sha256 = index-sha256-found;

530548 }

531− } cabal v2-freeze \

532− --index-state=${

533− # Setting the desired `index-state` here in case it was not

534− # from the cabal.project file. This will further restrict the

535− # packages used by the solver (cached-index-state >= index-state-found).

536− index-state-found} \

549+ } cabal v2-freeze ${

550+ # Setting the desired `index-state` here in case it is not

551+ # in the cabal.project file. This will further restrict the

552+ # packages used by the solver (cached-index-state >= index-state-found).

553+ pkgs.lib.optionalString (index-state != null) "--index-state=${index-state}"

554+ } \

537555 -w ${

538556 # We are using `-w` rather than `--with-ghc` here to override

539557 # the `with-compiler:` in the `cabal.project` file.

@@ -610,5 +628,5 @@ in {

610628 projectNix = plan-nix;

611629 index-state = index-state-found;

612630 inherit src;

613− inherit (fixedProject) sourceRepos;

631+ inherit (fixedProject) sourceRepos extra-hackages;

614632}

lib/call-stack-to-nix.nix+21−22

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

55 *

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

77 */

8−{ runCommand, pkgs, mkCacheFile, materialize, haskellLib }:

98{ name ? src.name or null # optional name for better error messages

109, src

1110, stackYaml ? "stack.yaml"

@@ -15,24 +14,24 @@

1514, resolverSha256 ? null

1615, materialized ? null # Location of a materialized copy of the nix files

1716, checkMaterialization ? null # If true the nix files will be generated used to check plan-sha256 and material

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−, ... }:

17+, nix-tools

18+, evalPackages

19+, ... }@args:

2020let

21+ inherit (evalPackages) runCommand;

22+ inherit (evalPackages.haskell-nix) mkCacheFile materialize haskellLib;

2123 inherit (haskellLib.fetchResolver {

2224 inherit src stackYaml resolverSha256;

2325 }) resolver fetchedResolver;

2426

2527 subDir' = src.origSubDir or "";

26− subDir = pkgs.lib.strings.removePrefix "/" subDir';

27− maybeCleanedSource =

28− if haskellLib.canCleanSource src

29− then (haskellLib.cleanSourceWith {

30− name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

31− src = src.origSrc or src;

32− filter = path: type: (!(src ? filter) || src.filter path type) && (

33− type == "directory" ||

34− pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ stackYaml ".cabal" "package.yaml" ]); })

35− else src.origSrc or src;

28+ subDir = evalPackages.lib.strings.removePrefix "/" subDir';

29+ cleanedSource = (haskellLib.cleanSourceWith {

30+ name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

31+ src = src.origSrc or src;

32+ filter = path: type: (!(src ? filter) || src.filter path type) && (

33+ type == "directory" ||

34+ evalPackages.lib.any (i: (evalPackages.lib.hasSuffix i path)) [ stackYaml ".cabal" "package.yaml" ]); });

3635

3736 stackToNixArgs = builtins.concatStringsSep " " [

3837 "--full"

@@ -46,12 +45,12 @@ let

4645 sha256Arg = "stack-sha256";

4746 reasonNotSafe = null;

4847 this = "project.stack-nix" + (if name != null then " for ${name}" else "");

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

48+ } // evalPackages.lib.optionalAttrs (checkMaterialization != null) {

5049 inherit checkMaterialization;

5150 }) (runCommand (if name == null then "stack-to-nix-pkgs" else name + "-stack-to-nix-pkgs") {

52− nativeBuildInputs = [ nix-tools pkgs.nix-prefetch-git pkgs.cacert pkgs.xorg.lndir ];

51+ nativeBuildInputs = [ nix-tools evalPackages.nix-prefetch-git evalPackages.cacert evalPackages.xorg.lndir ];

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

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

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

5554 LANG = "en_US.UTF-8";

5655 LC_ALL = "en_US.UTF-8";

5756 preferLocalBuild = false;

@@ -59,18 +58,18 @@ let

5958 mkdir -p $out${subDir'}

6059 SRC=$(mktemp -d)

6160 cd $SRC

62− # if maybeCleanedSource is empty, this means it's a new

61+ # if cleanedSource is empty, this means it's a new

6362 # project where the files haven't been added to the git

6463 # repo yet. We fail early and provide a useful error

6564 # message to prevent headaches (#290).

66− if [ -z "$(ls -A ${maybeCleanedSource})" ]; then

65+ if [ -z "$(ls -A ${cleanedSource})" ]; then

6766 echo "cleaned source is empty. Did you forget to 'git add -A'?"; exit 1;

6867 fi

69− lndir -silent "${maybeCleanedSource}/." $SRC

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

68+ lndir -silent "${cleanedSource}/." $SRC

69+ ${evalPackages.lib.optionalString (subDir != "") "cd ${subDir}"}

7170 ${

7271 # If a resolver was fetched use the it instead of the original stack.yaml

73− pkgs.lib.optionalString (fetchedResolver != null)

72+ evalPackages.lib.optionalString (fetchedResolver != null)

7473 # Replace the resolver path in the stack.yaml with the fetched version

7574 ''

7675 rm ${stackYaml}

@@ -78,7 +77,7 @@ let

7877 chmod +w ${stackYaml}

7978 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

8079 ''}

81− ${pkgs.lib.optionalString (cache != null) ''

80+ ${evalPackages.lib.optionalString (cache != null) ''

8281 cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

8382 ''}

8483 (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})

lib/check.nix+19−14

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

1−{ stdenv, lib, haskellLib, srcOnly }:

1+{ stdenv, lib, haskellLib }:

22drv:

33

44let

@@ -7,13 +7,25 @@ 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 ({

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+ }) // {

1127 name = (drv.name + "-check");

1228

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−

1729 passthru = {

1830 inherit (drv) identifier config configFiles executableToolDepends cleanSrc env exeName;

1931 };

@@ -22,19 +34,12 @@ in stdenv.mkDerivation ({

2234

2335 inherit (component) doCheck doCrossCheck;

2436

25− phases = ["unpackPhase" "buildPhase"];

37+ phases = ["unpackPhase" "patchPhase" "buildPhase"];

2638

2739 # If doCheck or doCrossCheck are false we may still build this

2840 # component and we want it to quietly succeed.

2941 buildPhase = ''

3042 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−

3843 runHook preCheck

3944

4045 ${toString component.testWrapper} ${drv}/bin/${drv.exeName} ${lib.concatStringsSep " " component.testFlags} | tee $out/test-stdout

lib/clean-cabal-component.nix+2−2

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

11# Use cleanSourceWith to filter just the files needed for a particular

22# component of the package

3−{ lib, cleanSourceWith, canCleanSource }: package: component: componentName: src:

3+{ lib, cleanSourceWith }: package: component: componentName: src:

44let

55 srcStr' = src.origSrc or null;

66 subDir = if src.origSubDir or "" == ""

@@ -56,7 +56,7 @@ let

5656 then p

5757 else p + "/";

5858in

59− if srcStr' == null || package.detailLevel != "FullDetails" || !canCleanSource src

59+ if srcStr' == null || package.detailLevel != "FullDetails"

6060 then src

6161 else

6262 let

lib/clean-git.nix+8−4

@@ -65,9 +65,13 @@ then

6565 first_line = head git_content;

6666 prefix = "gitdir: ";

6767 ok = length git_content == 1 && lib.hasPrefix prefix first_line;

68+ raw_path = remove_prefix prefix first_line;

6869 in

6970 if ok

70− then /. + remove_prefix prefix first_line

71+ then

72+ if lib.hasPrefix "/" raw_path

73+ then /. + raw_path

74+ else /. + builtins.toPath (origSrcSubDir + "/" + raw_path)

7175 else abort "gitSource.nix: Cannot parse ${origSrcSubDir + "/.git"}";

7276 }));

7377

@@ -112,7 +116,7 @@ then

112116 # `git ls-files --recurse-submodules` to give us an accurate list

113117 # of all the files in the index.

114118 whitelist_files = knownSubmoduleDirs:

115− runCommand "git-ls-files" {} ''

119+ runCommand "git-ls-files" { preferLocalBuild = true; } ''

116120 tmp=$(mktemp -d)

117121 cd $tmp

118122 ${ lib.optionalString hasSubmodules ''

@@ -135,7 +139,7 @@ then

135139 ${git}/bin/git ls-files --recurse-submodules > $out/files

136140 '';

137141

138− # Find the submodules

142+ # Find the submodules

139143 whitelist_recursive = knownSubmoduleDirs:

140144 let

141145 # Get the new list of submoduleDirs and files

@@ -176,7 +180,7 @@ then

176180 );

177181

178182 # Identify files in the `.git` dir

179− isGitDirPath = path:

183+ isGitDirPath = path:

180184 path == origSrcSubDir + "/.git"

181185 || lib.hasPrefix (origSrcSubDir + "/.git/") path;

182186

lib/clean-source-with.nix+35−8

@@ -50,6 +50,33 @@

5050 # (and forward a `name` argument) can use this to make

5151 # the message to the use more meaningful.

5252 #

53+ # Nix <2.4 Suport with filterPath

54+ #

55+ # As of Nix >=2.4 filtering is now possible on all paths (including those in the store).

56+ # If you still need to support older versions of Nix and want to maximise cache hits for your project

57+ # you may want to consider using setting the `filterPath` attribute on `src` (must be done on

58+ # the original src not the output of another `cleanSourceWith`).

59+ #

60+ # To disable filtering completely replace:

61+ #

62+ # src = ./.;

63+ #

64+ # with:

65+ #

66+ # src = { outPath = ./.; filterPath = { path, ... }: path; };

67+ #

68+ # To disable filtering only when the path is in the store use (when Nix <2.4 is unable to filter it):

69+ #

70+ # src = {

71+ # outPath = ./.;

72+ # filterPath = { path, ... }@args:

73+ # if builtins.hasContext (toString path) then path else builtins.path args;

74+ # };

75+ #

76+ # Currently `haskell-nix.hackage-project` (used by `hackage-package`, `tool` and `tools`) disables

77+ # filtering. See `overlays/haskell.nix` for details.

78+ #

79+ # For more see https://github.com/input-output-hk/haskell.nix/pull/1418

5380 cleanSourceWith = { filter ? _path: _type: true, src, subDir ? "", name ? null

5481 , caller ? "cleanSourceWith", includeSiblings ? false }:

5582 let

@@ -103,21 +130,21 @@

103130 __trace (

104131 "WARNING: `${caller}` called on ${toString src} without a `name`. "

105132 + "Consider adding `name = \"${baseNameOf src}\";`") "source";

133+ filterPath = origSrc.filterPath or (

134+ if builtins.compareVersions builtins.nixVersion "2.4" >= 0

135+ then builtins.path

136+ else __trace "WARNING: Using nix <2.4 will result in inconsistent filtering of ${toString origSrc} (see lib/clean-source-with.nix)"

137+ (if builtins.hasContext or (lib.hasPrefix builtins.storeDir) (toString origSrc)

138+ then { path, ... }: path

139+ else builtins.path));

106140 in {

107141 inherit origSrc origSubDir origSrcSubDir;

108142 filter = filter';

109− outPath = (builtins.path { filter = filter'; path = origSrc; name = name'; }) + origSubDir;

143+ outPath = (filterPath { filter = filter'; path = origSrc; name = name'; }) + origSubDir;

110144 _isLibCleanSourceWithEx = true;

111145 # It is only safe for older cleanSourceWith to filter this one

112146 # if the we are still looking at the root of origSrc

113147 _isLibCleanSourceWith = origSubDir == "";

114148 name = name';

115149 };

116−

117− pathHasContext = builtins.hasContext or (lib.hasPrefix builtins.storeDir);

118−

119− canCleanSource = src:

120− src ? _isLibCleanSourceWithEx

121− || src ? _isLibCleanSourceWith

122− || !(pathHasContext (toString src));

123150}

lib/cover-project.nix+44−47

@@ -10,19 +10,12 @@ coverageReports:

1010let

1111 toBashArray = arr: "(" + (lib.concatStringsSep " " arr) + ")";

1212

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:

13+ # Create a list element for a project coverage index page.

14+ coverageListElement = coverageReport:

2015 ''

21− <tr>

22− <td>

23− <a href="${coverageReport.passthru.name}/hpc_index.html">${coverageReport.passthru.name}</href>

24− </td>

25− </tr>

16+ <li>

17+ <a href="${coverageReport.passthru.name}/hpc_index.html">${coverageReport.passthru.name}</a>

18+ </li>

2619 '';

2720

2821 projectIndexHtml = pkgs.writeText "index.html" ''

@@ -31,23 +24,32 @@ let

3124 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

3225 </head>

3326 <body>

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>

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>

4446 </body>

4547 </html>

4648 '';

4749

4850 ghc = project.pkg-set.config.ghc.package;

4951

50− libs = lib.remove null (map (r: r.library) coverageReports);

52+ libs = lib.unique (lib.concatMap (r: r.mixLibraries) coverageReports);

5153

5254 mixDirs =

5355 map

@@ -56,6 +58,17 @@ let

5658

5759 srcDirs = map (l: l.srcSubDirPath) libs;

5860

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+

5972in pkgs.runCommand "project-coverage-report"

6073 ({ nativeBuildInputs = [ (ghc.buildGHC or ghc) pkgs.buildPackages.zip ];

6174 LANG = "en_US.UTF-8";

@@ -124,30 +137,14 @@ in pkgs.runCommand "project-coverage-report"

124137 cp -R $report/share/hpc/vanilla/html/* $out/share/hpc/vanilla/html/

125138 '') coverageReports)}

126139

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"

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

146143

147− markup srcDirs mixDirs allMixModules "$markupOutDir" "$tixFile"

144+ # Markup a HTML coverage summary report for the entire project

145+ cp ${projectIndexHtml} $out/share/hpc/vanilla/html/index.html

148146

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

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

153150 ''

lib/cover.nix+102−69

@@ -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".

14{ stdenv, lib, haskellLib, pkgs }:

25

3−# Name of the coverage report, which should be unique

6+# Name of the coverage report, which should be unique.

47{ name

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

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

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 library checks;

29+ inherit name checks mixLibraries;

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,71 +70,105 @@ in pkgs.runCommand (name + "-coverage-report")

7070 local -n tixFs=$2

7171 local outFile="$3"

7272

73− local hpcSumCmd=("hpc" "sum" "--union" "--output=$outFile")

73+ if (( "''${#tixFs[@]}" > 0 )); then

74+ local hpcSumCmd=("hpc" "sum" "--union" "--output=$outFile")

7475

75− for module in "''${includedModules[@]}"; do

76− hpcSumCmd+=("--include=$module")

77− done

76+ for module in "''${includedModules[@]}"; do

77+ hpcSumCmd+=("--include=$module")

78+ done

7879

79− for tixFile in "''${tixFs[@]}"; do

80− hpcSumCmd+=("$tixFile")

81− done

80+ for tixFile in "''${tixFs[@]}"; do

81+ hpcSumCmd+=("$tixFile")

82+ done

8283

83− echo "''${hpcSumCmd[@]}"

84− eval "''${hpcSumCmd[@]}"

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

8592 }

8693

8794 function findModules() {

88− local searchDir=$2

95+ local -n result=$1

96+ local -n searchDirs=$2

8997 local pattern=$3

9098

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

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

98110 }

99111

100− local mixDirs=${toBashArray mixDirs}

101−

102112 mkdir -p $out/nix-support

103− mkdir -p $out/share/hpc/vanilla/mix/${name}

113+ mkdir -p $out/share/hpc/vanilla/mix/

104114 mkdir -p $out/share/hpc/vanilla/tix/${name}

105115 mkdir -p $out/share/hpc/vanilla/html/${name}

106116

107− # Copy over mix files verbatim

117+ local srcDirs=${toBashArray srcDirs}

118+ local mixDirs=${toBashArray mixDirs}

119+

120+ # Copy out mix files used for this report

108121 for dir in "''${mixDirs[@]}"; do

109122 if [ -d "$dir" ]; then

110− cp -R "$dir"/* $out/share/hpc/vanilla/mix/${name}

123+ cp -R "$dir" $out/share/hpc/vanilla/mix/

111124 fi

112125 done

113126

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

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+

131165 local tixFiles=()

132166 ${lib.concatStringsSep "\n" (builtins.map (check: ''

133167 if [ -d "${check}/share/hpc/vanilla/tix" ]; then

134168 pushd ${check}/share/hpc/vanilla/tix

135169

136170 tixFile="$(find . -iwholename "*.tix" -type f -print -quit)"

137− local newTixFile=$out/share/hpc/vanilla/tix/${name}/"$tixFile"

171+ local newTixFile=$out/share/hpc/vanilla/tix/${check.name}/"$(basename $tixFile)"

138172

139173 mkdir -p "$(dirname $newTixFile)"

140174 # Copy over the tix file verbatim

@@ -143,29 +177,28 @@ in pkgs.runCommand (name + "-coverage-report")

143177 # Add the tix file to our list

144178 tixFiles+=("$newTixFile")

145179

146− # Create a coverage report for *just that test*

147− markup srcDirs mixDirs pkgMixModules "$out/share/hpc/vanilla/html/${name}/${check.exeName}/" "$newTixFile"

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"

148183

149184 popd

150185 fi

151186 '') checks)

152187 }

153188

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}"

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}"

159193

160− # Sum all of our tix file, including modules from any local package

161− sumTix allMixModules tixFiles "$sumTixFile"

194+ # Sum all of our tix files

195+ sumTix mixModules tixFiles "$sumTixFile"

162196

163− # Markup a HTML report, included modules from only this package

164− markup srcDirs mixDirs pkgMixModules "$markupOutDir" "$sumTixFile"

197+ # Markup a HTML report

198+ markup srcDirs mixDirs mixModules "$markupOutDir" "$sumTixFile"

165199

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

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

171204 ''

lib/default.nix+24−38

@@ -4,11 +4,8 @@

44with haskellLib;

55

66let

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.

7+ # Why `final.buildPackages.buildPackages.gitMinimal`?

8+ # Why not just final.buildPackages.gitMinimal?

129 #

1310 # It turns out `git` depends on `gdb` in a round about way:

1411 # git -> openssh -> libfido2 -> systemd -> python libxml -> Cython -> gdb

@@ -24,7 +21,7 @@ let

2421 # * When `gdb` does not exist for `js`, so when cross

2522 # compiling with ghcjs `final.buildPackages.git` fails

2623 # to build at all.

27− inherit (pkgs.evalPackages.buildPackages) gitMinimal;

24+ inherit (pkgs.buildPackages.buildPackages) gitMinimal;

2825

2926in {

3027 # Within the package components, these are the attribute names of

@@ -192,17 +189,17 @@ in {

192189 collectChecks' = collectChecks (_: true);

193190

194191 # Replacement for lib.cleanSourceWith that has a subDir argument.

195− inherit (import ./clean-source-with.nix { inherit lib; }) cleanSourceWith canCleanSource;

192+ inherit (import ./clean-source-with.nix { inherit lib; }) cleanSourceWith;

196193

197194 # Use cleanSourceWith to filter just the files needed for a particular

198195 # component of a package

199− cleanCabalComponent = import ./clean-cabal-component.nix { inherit lib cleanSourceWith canCleanSource; };

196+ cleanCabalComponent = import ./clean-cabal-component.nix { inherit lib cleanSourceWith; };

200197

201198 # Clean git directory based on `git ls-files --recurse-submodules`

202199 cleanGit = import ./clean-git.nix {

203200 inherit lib cleanSourceWith;

204201 git = gitMinimal;

205− inherit (pkgs.evalPackages.buildPackages) runCommand;

202+ inherit (pkgs.buildPackages.buildPackages) runCommand;

206203 };

207204

208205 # Some times it is handy to temporarily use a relative path between git

@@ -232,7 +229,7 @@ in {

232229

233230 # Check a test component

234231 check = import ./check.nix {

235− inherit stdenv lib haskellLib srcOnly;

232+ inherit stdenv lib haskellLib;

236233 };

237234

238235 # Do coverage of a package

@@ -260,22 +257,24 @@ in {

260257 && stdenv.buildPlatform == stdenv.hostPlatform

261258 && stdenv.hostPlatform == stdenv.targetPlatform;

262259

263− # Takes a version number or attr set of arguments (for cabalProject)

264− # and converts it to an attr set of arguments. This allows

260+ # Takes a version number, module or list of modules (for cabalProject)

261+ # and converts it to an list of project modules. This allows

265262 # the use of "1.0.0.0" or { version = "1.0.0.0"; ... }

266− versionOrArgsToArgs = versionOrArgs:

267− if lib.isAttrs versionOrArgs

268− then versionOrArgs

269− else { version = versionOrArgs; };

263+ versionOrModToMods = versionOrMod:

264+ if lib.isString versionOrMod

265+ then [{ version = versionOrMod; }]

266+ else if lib.isList versionOrMod

267+ then versionOrMod

268+ else [versionOrMod];

270269

271270 # Find the resolver in the stack.yaml file and fetch it if a sha256 value is provided

272271 fetchResolver = import ./fetch-resolver.nix {

273− inherit (pkgs.evalPackages) pkgs;

272+ inherit (pkgs.buildPackages) pkgs;

274273 };

275274

276275 inherit (import ./cabal-project-parser.nix {

277276 inherit pkgs;

278− }) parseIndexState parseBlock;

277+ }) parseIndexState parseSourceRepositoryPackages parseRepositories parseSourceRepositoryPackageBlock parseRepositoryBlock;

279278

280279

281280 cabalToNixpkgsLicense = import ./spdx/cabal.nix pkgs;

@@ -290,26 +289,9 @@ in {

290289 if subDir == ""

291290 then src

292291 else

293− if haskellLib.canCleanSource src

294− then haskellLib.cleanSourceWith {

295− inherit src subDir includeSiblings;

296− }

297− else let name = src.name or "source" + "-" + __replaceStrings ["/"] ["-"] subDir;

298− in if includeSiblings

299− then rec {

300− # Keep `src.origSrc` so it can be used to allow references

301− # to other parts of that root.

302− inherit name;

303− origSrc = src.origSrc or src;

304− origSubDir = src.origSubDir or "" + "/" + subDir;

305− outPath = origSrc + origSubDir;

306− }

307− else {

308− # We are not going to need other parts of `origSrc` if there

309− # was one and we can ignore it

310− inherit name;

311− outPath = src + "/" + subDir;

312− };

292+ haskellLib.cleanSourceWith {

293+ inherit src subDir includeSiblings;

294+ };

313295

314296 # Givin a `src` split it into a `root` path (based on `src.origSrc` if

315297 # present) and `subDir` (based on `src.origSubDir). The

@@ -357,4 +339,8 @@ in {

357339 # Converts from a `compoent.depends` value to a library derivation.

358340 # In the case of sublibs the `depends` value should already be the derivation.

359341 dependToLib = d: d.components.library or d;

342+

343+ projectOverlays = import ./project-overlays.nix {

344+ inherit lib haskellLib;

345+ };

360346}

lib/ghcjs-project.nix+36−7

@@ -52,6 +52,8 @@

5252 '';

5353 materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

5454 }

55+, overrideBootPackages ? []

56+, patches ? []

5557, ...

5658}@args:

5759let

@@ -75,9 +77,11 @@ let

7577

7678 # Inputs needed to boot the GHCJS compiler

7779 bootInputs = with pkgs.buildPackages; [

78− # pin nodejs to the 12 series for now, as strings can only be half the length in node 14+

79− # see https://github.com/nodejs/node/issues/33960, this can break large TH splices for now.

80− nodejs-12_x

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

8185 makeWrapper

8286 xorg.lndir

8387 gmp

@@ -85,9 +89,9 @@ let

8589 ]

8690 ++ [ ghc cabal-install emsdk ];

8791 # Configured the GHCJS source

88− configured-src = pkgs.runCommandCC "configured-ghcjs-src" {

92+ configured-src = (pkgs.runCommandCC "configured-ghcjs-src" {

8993 buildInputs = configureInputs;

90− inherit src;

94+ inherit src patches;

9195 } ''

9296 export HOME=$(pwd)

9397 mkdir $HOME/.cabal

@@ -96,6 +100,11 @@ let

96100 chmod -R +w "$out"

97101 cd "$out"

98102

103+ for p in $patches

104+ do

105+ patch -p1 <$p

106+ done

107+

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

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

101110 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

@@ -128,13 +137,32 @@ let

128137 for a in integer-gmp base unix; do

129138 cp ${../overlays/patches/config.sub} lib/boot/pkg/$a/config.sub

130139 done

131− '';

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

155+ '') // {

156+ # The configured source includes /nix/store paths and so filtering can fail.

157+ filterPath = { path, ... }: path;

158+ };

132159 # see https://github.com/ghcjs/ghcjs/issues/751 for the happy upper bound.

133160

134161 ghcjsProject = pkgs.haskell-nix.cabalProject' (

135162 (pkgs.lib.filterAttrs

136163 (n: _: !(builtins.any (x: x == n)

137− ["src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"])) args) // {

164+ [ "src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"

165+ "overrideBootPackages" "patches"])) args) // {

138166 src = configured-src;

139167 index-state = "2021-03-20T00:00:00Z";

140168 inherit compiler-nix-name;

@@ -158,6 +186,7 @@ let

158186 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

159187 })

160188 {

189+ ghcOptions = ["-O2"];

161190 packages.ghcjs.doHaddock = false;

162191 packages.haddock-ghcjs.doHaddock = false;

163192 packages.haddock-api-ghcjs.doHaddock = false;

lib/import-and-filter-project.nix+7−10

@@ -6,14 +6,11 @@

66let

77 # Full source including possible relative paths form the

88 # project directory.

9− srcRoot =

10− if haskellLib.canCleanSource src

11− then haskellLib.cleanSourceWith {

12− name = if src ? name then "${src.name}-root" else "source-root";

13− src = src.origSrc or src;

14− filter = src.filter or (_: _: true);

15− }

16− else src.origSrc or src;

9+ srcRoot = haskellLib.cleanSourceWith {

10+ name = if src ? name then "${src.name}-root" else "source-root";

11+ src = src.origSrc or src;

12+ filter = src.filter or (_: _: true);

13+ };

1714 # The sub directory containing the cabal.project or stack.yaml file

1815 projectSubDir' = src.origSubDir or ""; # With leading /

1916 projectSubDir = pkgs.lib.strings.removePrefix "/" projectSubDir'; # Without /

@@ -36,7 +33,7 @@ in project // {

3633 isProject = false;

3734 packageSrc = pkgs.lib.lists.elemAt sourceRepos (toInt oldPkg.src.url);

3835 }

39− else if !hasPrefix (toString projectNix) (toString oldPkg.src.content)

36+ else if !hasPrefix "${projectNix}" (toString oldPkg.src.content)

4037 then {

4138 # Source location does not match project prefix

4239 isProject = false;

@@ -47,7 +44,7 @@ in project // {

4744 isProject = true;

4845 packageSrc = haskellLib.appendSubDir {

4946 src = srcRoot;

50− subDir = removePrefix "/" (removePrefix (toString projectNix)

47+ subDir = removePrefix "/" (removePrefix "${projectNix}"

5148 (toString oldPkg.src.content));

5249 includeSiblings = true; # Filtering sibling dirs of the package dir is done in the

5350 # component builder so that relative paths can be used to

lib/materialize.nix+12−10

@@ -24,7 +24,7 @@

2424}: derivation:

2525

2626let

27− inherit (derivation) name;

27+ name = derivation.name + pkgs.lib.optionalString (derivation ? version) "-${derivation.version}";

2828

2929 traceIgnoringSha256 = reason: x:

3030 if sha256 != null

@@ -36,10 +36,15 @@ 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+

3944 unchecked =

4045 let

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'.";

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'.";

4348 in if reasonNotSafe != null

4449 then

4550 # Warn the user if they tried to pin stuff down when it is not safe

@@ -50,10 +55,10 @@ let

5055 else if sha256 != null

5156 then

5257 # Let the user know how to materialize if they want to.

53− builtins.trace materializeMessage calculateUseHash

58+ traceWhenChecking materializeMessage calculateUseHash

5459 else # materialized == null && sha256 == null

5560 # Let the user know how to calculate a sha256 or materialize if they want to.

56− builtins.trace sha256message (builtins.trace materializeMessage calculateNoHash);

61+ traceWhenChecking sha256message (traceWhenChecking materializeMessage calculateNoHash);

5762

5863 # Build fully and check the hash and materialized versions

5964 checked =

@@ -123,11 +128,7 @@ let

123128 calculateUseMaterialized =

124129 assert materialized != null;

125130 assert __pathExists materialized;

126− runCommand name (pkgs.lib.optionalAttrs (sha256 == null) hashArgs) ''

127− cp -Lr ${materialized} $out

128− # Make sure output files can be removed from the sandbox

129− chmod -R +w $out

130− '';

131+ { outPath = materialized; inherit name; };

131132 calculateMaterializedSha =

132133 writeShellScript "calculateSha" ''${nix}/bin/nix-hash --base32 --type sha256 ${calculateNoHash}'';

133134

@@ -143,6 +144,7 @@ let

143144 fi

144145

145146 # Generate the files

147+ mkdir -p $TARGET

146148 rm -rf $TARGET

147149 cp -r ${calculateNoHash} "$TARGET"

148150 chmod -R +w "$TARGET"

lib/pkgconf-nixpkgs-map.nix+7−1

@@ -27,11 +27,12 @@ pkgs:

2727 "dl" = []; # provided by glibc

2828 "fftw3" = [ pkgs."fftw" ];

2929 "fftw3f" = [ pkgs."fftwFloat" ];

30+ "freetype2" = [ pkgs."freetype" ];

3031 "gconf" = [ pkgs."GConf" ];

3132 "gconf-2.0" = [ pkgs."GConf" ];

3233 "gdk-2.0" = [ pkgs."gtk2" ];

3334 "gdk-3.0" = [ pkgs."gtk3" ];

34− "gdk-pixbuf-2.0" = [ pkgs."gdk_pixbuf" ];

35+ "gdk-pixbuf-2.0" = [ (pkgs."gdk-pixbuf" or pkgs."gdk_pixbuf") ];

3536 "gdk-x11-2.0" = [ pkgs."gdk_x11" ];

3637 "gdk-x11-3.0" = [ pkgs."gtk3" ];

3738 "gio-2.0" = [ pkgs."glib" ];

@@ -46,6 +47,7 @@ pkgs:

4647 "gobject-2.0" = [ pkgs."glib" ];

4748 "gmodule-2.0" = [ pkgs."glib" ];

4849 "gobject-introspection-1.0" = [ pkgs."gobject-introspection" ];

50+ "graphene-gobject-1.0" = [ pkgs."graphene" ];

4951 "gstreamer-audio-0.10" = [ pkgs."gst-plugins-base" ];

5052 "gstreamer-audio-1.0" = [ pkgs."gst-plugins-base" ];

5153 "gstreamer-base-0.10" = [ pkgs."gst-plugins-base" ];

@@ -65,6 +67,7 @@ pkgs:

6567 "hidapi-libusb" = [ pkgs."hidapi" ];

6668 "icudata" = [ pkgs."icu" ];

6769 "icui18n" = [ pkgs."icu" ];

70+ "icu-i18n" = [ pkgs."icu" ];

6871 "icuuc" = [ pkgs."icu" ];

6972 "idn" = [ pkgs."libidn" ];

7073 "IL" = [ pkgs."libdevil" ];

@@ -81,7 +84,9 @@ pkgs:

8184 "ldap" = [ pkgs."openldap" ];

8285 "libavutil" = [ pkgs."ffmpeg" ];

8386 "libcrypto" = [ pkgs."openssl".dev ];

87+ "libfreenect" = [ pkgs."freenect" ];

8488 "libgsasl" = [ pkgs."gsasl" ];

89+ "liboath" = [ pkgs."liboauth" ];

8590 "libpcre" = [ pkgs."pcre" ];

8691 "libqrencode" = [ pkgs."qrencode" ];

8792 "libR" = [ pkgs."R" ];

@@ -117,6 +122,7 @@ pkgs:

117122 "pfs-1.2" = [ pkgs."pfstools" ];

118123 "png" = [ pkgs."libpng" ];

119124 "poppler-glib" = [ pkgs."poppler" ];

125+ "poppler-cpp" = [ pkgs."poppler" ];

120126 "pq" = [ pkgs."postgresql" ];

121127 "libpq" = [ pkgs."postgresql" ];

122128 "pthread" = [];

lib/project-overlays.nixnew file+37

@@ -0,0 +1,37 @@

1+{

2+ lib

3+, haskellLib

4+}: {

5+ # Provide a devshell profile (https://github.com/numtide/devshell),

6+ # adapted from the project normal shell.

7+ devshell = final: prev: {

8+ devshell = let

9+ 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 ];

16+ env = lib.mapAttrsToList lib.nameValuePair {

17+ inherit (final.shell) CABAL_CONFIG NIX_GHC_LIBDIR;

18+ };

19+ };

20+ };

21+

22+ # Provides easily accessible attrset for each type of

23+ # components belonging to the project packages.

24+ projectComponents = final: prev: {

25+ # local project packages:

26+ 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;

35+ };

36+

37+}

lib/spdx/licenses.nix+9−1

@@ -1,9 +1,17 @@

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}";

35 licensesJSON = fromJSON (replaceStrings

46 [ "\\u0026" "\\u0027" "\\u003d" ]

57 [ "&" "'" "=" ]

6− (readFile "${pkgs.evalPackages.spdx-license-list-data}/json/licenses.json")

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; } ''

11+ mkdir $out

12+ cp ${spdxJson}/json/licenses.json $out

13+ '')

14+ }/licenses.json")

715 );

816 dropFour = s: substring 0 (stringLength s - 4) s;

917 toSpdx = lic: with lic;

lib/stack-cache-generator.nix+33−39

@@ -1,6 +1,5 @@

11# Generate cache entries for dependencies of package defined in `src`

22

3−{ pkgs, haskellLib }:

43{ src

54, stackYaml ? "stack.yaml"

65, sha256map ? null

@@ -9,10 +8,6 @@

98 # sha256map =

109 # { "https://github.com/jgm/pandoc-citeproc"."0.17"

1110 # = "0dxx8cp2xndpw3jwiawch2dkrkp15mil7pyx7dvd810pwc22pm2q"; };

12−, lookupSha256 ?

13− if sha256map != null

14− then { location, tag, ...}: sha256map."${location}"."${tag}"

15− else _: null

1611, branchMap ? null

1712 # A way to specify in which branch a git commit can

1813 # be found

@@ -21,10 +16,14 @@

2116 then { location, tag, ...}: branchMap."${location}"."${tag}" or null

2217 else _: null

2318, resolverSha256 ? null

24−, 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+, nix-tools

20+, evalPackages

2521, ...

26−}:

22+}@args:

2723let

24+ inherit (evalPackages) runCommand;

25+ inherit (evalPackages.haskell-nix) haskellLib;

26+

2827 # We only care about the stackYaml file. If src is a local directory

2928 # we want to avoid recalculating the cache unless the stack.yaml file

3029 # changes.

@@ -34,30 +33,27 @@ let

3433 }) resolver fetchedResolver;

3534

3635 # Filter just the stack yaml file and any resolver yaml file it points to.

37− maybeCleanedSource =

38− if haskellLib.canCleanSource src

39− then haskellLib.cleanSourceWith {

40− inherit src;

41− filter = path: type:

42− let

43− origSrc = if src ? _isLibCleanSourceWith then src.origSrc else src;

44− origSubDir = if src ? _isLibCleanSourceWithEx then src.origSubDir else "";

45− relPath = pkgs.lib.removePrefix (toString origSrc + origSubDir + "/") path;

36+ maybeCleanedSource = haskellLib.cleanSourceWith {

37+ inherit src;

38+ filter = path: type:

39+ let

40+ origSrc = if src ? _isLibCleanSourceWith then src.origSrc else src;

41+ origSubDir = if src ? _isLibCleanSourceWithEx then src.origSubDir else "";

42+ relPath = evalPackages.lib.removePrefix (toString origSrc + origSubDir + "/") path;

4643

47− # checks if path1 is a parent directory for path2

48− isParent = path1: path2: pkgs.lib.hasPrefix "${path1}/" path2;

44+ # checks if path1 is a parent directory for path2

45+ isParent = path1: path2: evalPackages.lib.hasPrefix "${path1}/" path2;

4946

50− in

51− (relPath == stackYaml)

52− || (resolver != null && (relPath == resolver || isParent relPath resolver))

53− ;

54− }

55− else src;

47+ in

48+ (relPath == stackYaml)

49+ || (resolver != null && (relPath == resolver || isParent relPath resolver))

50+ ;

51+ };

5652

5753 # All repos served via ssh or git protocols are usually private

58− private = url: pkgs.lib.substring 0 4 url != "http";

54+ private = url: evalPackages.lib.substring 0 4 url != "http";

5955

60− repos = builtins.fromJSON (builtins.readFile (pkgs.runCommand "stack-repos" {

56+ repos = builtins.fromJSON (builtins.readFile (evalPackages.runCommand "stack-repos" {

6157 buildInputs = [ nix-tools ];

6258 } ''

6359 TMP=$(mktemp -d)

@@ -65,45 +61,43 @@ let

6561 cp -r "${maybeCleanedSource}/." $TMP

6662 chmod -R +w $TMP

6763 substituteInPlace ${stackYaml} --replace "# nix-sha256:" "nix-sha256:"

68− ${pkgs.lib.optionalString (fetchedResolver != null) ''

64+ ${evalPackages.lib.optionalString (fetchedResolver != null) ''

6965 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

7066 ''}

7167 stack-repos --stack-yaml ${stackYaml}

7268 cp repos.json $out

7369 ''));

7470

75− cabalName = path: builtins.readFile (pkgs.runCommand "cabal-name" {

71+ cabalName = path: builtins.readFile (evalPackages.runCommand "cabal-name" {

7672 buildInputs = [ nix-tools ];

7773 } ''

7874 cabal-name ${path} > $out

7975 '');

8076

8177 hashPath = path:

82− builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

83− "echo -n $(${pkgs.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

84−in with pkgs.lib;

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;

8581concatMap (dep:

8682 let

8783 is-private = private dep.url;

88− sha256 = if dep.sha256 != null

89− then dep.sha256

90− else lookupSha256 {

91− location = dep.url;

92− tag = dep.rev;

93− };

84+ sha256 =

85+ if dep.sha256 != null then dep.sha256

86+ else if sha256map != null then sha256map."${dep.url}"."${dep.rev}"

87+ else null;

9488 branch = lookupBranch {

9589 location = dep.url;

9690 tag = dep.rev;

9791 };

9892 pkgsrc =

9993 if !is-private && sha256 != null

100− then pkgs.fetchgit {

94+ then evalPackages.fetchgit {

10195 inherit (dep) url rev;

10296 inherit sha256;

10397 }

10498 else builtins.fetchGit ({

10599 inherit (dep) url rev;

106− } // pkgs.lib.optionalAttrs (branch != null) { ref = branch; });

100+ } // evalPackages.lib.optionalAttrs (branch != null) { ref = branch; });

107101 in map (subdir: {

108102 name = cabalName "${pkgsrc}/${subdir}";

109103 inherit (dep) url rev;

lib/system-nixpkgs-map.nix+32−5

@@ -6,16 +6,32 @@ pkgs:

66

77with pkgs;

88

9+let

10+ # On windows systems we need these to be propagatedBuildInputs so that the DLLs will be found.

11+ gcclibs = if pkgs.stdenv.hostPlatform.isWindows then [

12+ pkgs.windows.mcfgthreads

13+ # 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 ]; } ''

15+ mkdir $out

16+ lndir ${pkgs.buildPackages.gcc.cc} $out

17+ '')

18+ ] else [];

19+in

920# -- linux

1021{ crypto = [ openssl ];

11− "c++" = null; # no libc++

12− "stdc++" = null;

13− "stdc++-6" = null;

22+ "c++" = []; # no libc++

23+ "stdc++" = gcclibs;

24+ "stdc++-6" = gcclibs;

25+ gcc_s_seh-1 = gcclibs;

26+ gcc_s = gcclibs;

27+ gcc = gcclibs;

1428 ssl = [ openssl ];

1529 z = [ zlib ];

30+ m = []; # Included with ghc

1631 pcap = [ libpcap ];

1732 pthread = null; # available by default

1833 GL = [ libGL ];

34+ GLEW = [ glew ];

1935 GLU = [ libGLU ];

2036 alut = [ freealut ];

2137 X11 = with xorg; [ libX11 ];

@@ -35,6 +51,7 @@ with pkgs;

3551 util = [ utillinux ];

3652 magic = [ file ];

3753 pq = [ postgresql ];

54+ libpq = [ postgresql ];

3855 iconv = [ libiconv ];

3956 lapack = [ liblapack ];

4057 boost_atomic = [ boost ];

@@ -80,12 +97,23 @@ with pkgs;

8097 opencv = [ opencv3 ];

8198 icuuc = [ icu ];

8299 icui18n = [ icu ];

100+ icu-i18n = [ icu ];

83101 icudata = [ icu ];

84102 vulkan = [ vulkan-loader ];

85103 sodium = [ libsodium ];

86104 gfortran = [ gfortran.cc.lib ];

87105 ssh2 = [ libssh2 ];

88106 gpiod = [ libgpiod ];

107+ png = [ libpng ];

108+ jpeg = [ libjpeg ];

109+ freenect_sync = [ freenect ];

110+ FLAC = [ flac ];

111+ mp3lame = [ lame ];

112+ tag_c = [ taglib ];

113+ jwt = [ libjwt ];

114+ GeoIP = [ geoip ];

115+ pulse-simple = [ libpulseaudio ];

116+ oath = [ liboauth ];

89117}

90118# -- windows

91119// { advapi32 = null; gdi32 = null; imm32 = null; msimg32 = null;

@@ -96,13 +124,12 @@ with pkgs;

96124 # this should be bundled with gcc.

97125 # if it's not we have more severe

98126 # issues anyway.

99− gcc_s_seh-1 = null;

100− gcc_s = null;

101127 ssl32 = null; eay32 = [ openssl ];

102128 iphlpapi = null; # IP Help API

103129 msvcrt = null; # this is the libc

104130 Crypt32 = null;

105131 mswsock = null;

132+ bcrypt = null;

106133 }

107134# -- os x

108135# NB: these map almost 1:1 to the framework names

lib/system-pkgs.nix+1−18

@@ -9,25 +9,8 @@

99

1010pkgs:

1111

12−let

13− buildEnvMaybe = name: paths:

14− if builtins.length paths == 1

15− then builtins.head paths

16− else pkgs.buildEnv { name = "${name}-env"; inherit paths; };

17−

18− mapPackages = name: ps:

19− if builtins.typeOf ps == "list"

20− then buildEnvMaybe name ps

21− else ps;

22−

23−in

2412 # Base packages.

2513 pkgs

2614

27− # fetchgit should always come from the evalPackages

28− # if it comes from the targetPackages we won't even

29− # be able to execute it.

30− // { fetchgit = pkgs.evalPackages.fetchgit; }

31−

3215 # Apply the mapping.

33− // builtins.mapAttrs mapPackages (import ./system-nixpkgs-map.nix pkgs)

16+ // import ./system-nixpkgs-map.nix pkgs

materialized/bootstrap/ghc883/alex/.plan.nix/alex.nixnew file+160

@@ -0,0 +1,160 @@

1+{ system

2+ , compiler

3+ , flags

4+ , pkgs

5+ , hsPkgs

6+ , pkgconfPkgs

7+ , errorHandler

8+ , config

9+ , ... }:

10+ {

11+ flags = { small_base = true; };

12+ package = {

13+ specVersion = "1.8";

14+ identifier = { name = "alex"; version = "3.2.4"; };

15+ license = "BSD-3-Clause";

16+ copyright = "(c) Chis Dornan, Simon Marlow";

17+ maintainer = "Simon Marlow <marlowsd@gmail.com>";

18+ author = "Chris Dornan and Simon Marlow";

19+ homepage = "http://www.haskell.org/alex/";

20+ url = "";

21+ synopsis = "Alex is a tool for generating lexical analysers in Haskell";

22+ description = "Alex is a tool for generating lexical analysers in Haskell.\nIt takes a description of tokens based on regular\nexpressions and generates a Haskell module containing code\nfor scanning text efficiently. It is similar to the tool\nlex or flex for C/C++.";

23+ buildType = "Simple";

24+ isLocal = true;

25+ detailLevel = "FullDetails";

26+ licenseFiles = [ "LICENSE" ];

27+ dataDir = "data/";

28+ dataFiles = [

29+ "AlexTemplate"

30+ "AlexTemplate-ghc"

31+ "AlexTemplate-ghc-nopred"

32+ "AlexTemplate-ghc-debug"

33+ "AlexTemplate-debug"

34+ "AlexWrapper-basic"

35+ "AlexWrapper-basic-bytestring"

36+ "AlexWrapper-strict-bytestring"

37+ "AlexWrapper-posn"

38+ "AlexWrapper-posn-bytestring"

39+ "AlexWrapper-monad"

40+ "AlexWrapper-monad-bytestring"

41+ "AlexWrapper-monadUserState"

42+ "AlexWrapper-monadUserState-bytestring"

43+ "AlexWrapper-gscan"

44+ ];

45+ extraSrcFiles = [

46+ "CHANGELOG.md"

47+ "README.md"

48+ "TODO"

49+ "alex.spec"

50+ "doc/Makefile"

51+ "doc/aclocal.m4"

52+ "doc/alex.1.in"

53+ "doc/alex.xml"

54+ "doc/config.mk.in"

55+ "doc/configure.ac"

56+ "doc/docbook-xml.mk"

57+ "doc/fptools.css"

58+ "examples/Makefile"

59+ "examples/Tokens.x"

60+ "examples/Tokens_gscan.x"

61+ "examples/Tokens_posn.x"

62+ "examples/examples.x"

63+ "examples/haskell.x"

64+ "examples/lit.x"

65+ "examples/pp.x"

66+ "examples/state.x"

67+ "examples/tiny.y"

68+ "examples/words.x"

69+ "examples/words_monad.x"

70+ "examples/words_posn.x"

71+ "src/Parser.y.boot"

72+ "src/Scan.x.boot"

73+ "src/ghc_hooks.c"

74+ "templates/GenericTemplate.hs"

75+ "templates/wrappers.hs"

76+ "tests/Makefile"

77+ "tests/simple.x"

78+ "tests/null.x"

79+ "tests/tokens.x"

80+ "tests/tokens_gscan.x"

81+ "tests/tokens_posn.x"

82+ "tests/tokens_bytestring.x"

83+ "tests/tokens_posn_bytestring.x"

84+ "tests/tokens_scan_user.x"

85+ "tests/tokens_strict_bytestring.x"

86+ "tests/tokens_monad_bytestring.x"

87+ "tests/tokens_monadUserState_bytestring.x"

88+ "tests/tokens_bytestring_unicode.x"

89+ "tests/basic_typeclass.x"

90+ "tests/basic_typeclass_bytestring.x"

91+ "tests/default_typeclass.x"

92+ "tests/gscan_typeclass.x"

93+ "tests/posn_typeclass.x"

94+ "tests/monad_typeclass.x"

95+ "tests/monad_typeclass_bytestring.x"

96+ "tests/monadUserState_typeclass.x"

97+ "tests/monadUserState_typeclass_bytestring.x"

98+ "tests/posn_typeclass_bytestring.x"

99+ "tests/strict_typeclass.x"

100+ "tests/unicode.x"

101+ ];

102+ extraTmpFiles = [];

103+ extraDocFiles = [];

104+ };

105+ components = {

106+ exes = {

107+ "alex" = {

108+ depends = [

109+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

110+ ] ++ (if flags.small_base

111+ then [

112+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

113+ (hsPkgs."array" or (errorHandler.buildDepError "array"))

114+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

115+ (hsPkgs."directory" or (errorHandler.buildDepError "directory"))

116+ ]

117+ else [ (hsPkgs."base" or (errorHandler.buildDepError "base")) ]);

118+ buildable = true;

119+ modules = [

120+ "AbsSyn"

121+ "CharSet"

122+ "DFA"

123+ "DFAMin"

124+ "DFS"

125+ "Info"

126+ "Map"

127+ "NFA"

128+ "Output"

129+ "Paths_alex"

130+ "Parser"

131+ "ParseMonad"

132+ "Scan"

133+ "Set"

134+ "Sort"

135+ "Util"

136+ "UTF8"

137+ "Data/Ranged"

138+ "Data/Ranged/Boundaries"

139+ "Data/Ranged/RangedSet"

140+ "Data/Ranged/Ranges"

141+ ];

142+ hsSourceDirs = [ "src" ];

143+ mainPath = [ "Main.hs" ] ++ [ "" ];

144+ };

145+ };

146+ tests = {

147+ "tests" = {

148+ depends = [

149+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

150+ (hsPkgs."process" or (errorHandler.buildDepError "process"))

151+ ];

152+ build-tools = [

153+ (hsPkgs.buildPackages.alex.components.exes.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex:alex")))

154+ ];

155+ buildable = true;

156+ mainPath = [ "test.hs" ];

157+ };

158+ };

159+ };

160+ } // rec { src = (pkgs.lib).mkDefault ../.; }

materialized/bootstrap/ghc883/alex/default.nixnew file+65

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

1+{

2+ pkgs = hackage:

3+ {

4+ packages = {

5+ "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

6+ "bytestring".revision = (((hackage."bytestring")."0.10.10.0").revisions).default;

7+ "filepath".revision = (((hackage."filepath")."1.4.2.1").revisions).default;

8+ "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;

9+ "base".revision = (((hackage."base")."4.13.0.0").revisions).default;

10+ "time".revision = (((hackage."time")."1.9.3").revisions).default;

11+ "directory".revision = (((hackage."directory")."1.3.6.0").revisions).default;

12+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

13+ "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

14+ "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

15+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

16+ "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;

17+ };

18+ compiler = {

19+ version = "8.8.3";

20+ nix-name = "ghc883";

21+ packages = {

22+ "array" = "0.5.4.0";

23+ "bytestring" = "0.10.10.0";

24+ "filepath" = "1.4.2.1";

25+ "ghc-prim" = "0.5.3";

26+ "base" = "4.13.0.0";

27+ "time" = "1.9.3";

28+ "directory" = "1.3.6.0";

29+ "rts" = "1.0";

30+ "deepseq" = "1.4.4.0";

31+ "unix" = "2.7.2.2";

32+ "integer-gmp" = "1.0.2.0";

33+ "containers" = "0.6.2.1";

34+ };

35+ };

36+ };

37+ extras = hackage:

38+ { packages = { alex = ./.plan.nix/alex.nix; }; };

39+ modules = [

40+ ({ lib, ... }:

41+ {

42+ packages = {

43+ "alex" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

44+ };

45+ })

46+ ({ lib, ... }:

47+ {

48+ packages = {

49+ "filepath".components.library.planned = lib.mkOverride 900 true;

50+ "bytestring".components.library.planned = lib.mkOverride 900 true;

51+ "ghc-prim".components.library.planned = lib.mkOverride 900 true;

52+ "array".components.library.planned = lib.mkOverride 900 true;

53+ "rts".components.library.planned = lib.mkOverride 900 true;

54+ "unix".components.library.planned = lib.mkOverride 900 true;

55+ "directory".components.library.planned = lib.mkOverride 900 true;

56+ "time".components.library.planned = lib.mkOverride 900 true;

57+ "alex".components.exes."alex".planned = lib.mkOverride 900 true;

58+ "deepseq".components.library.planned = lib.mkOverride 900 true;

59+ "base".components.library.planned = lib.mkOverride 900 true;

60+ "integer-gmp".components.library.planned = lib.mkOverride 900 true;

61+ "containers".components.library.planned = lib.mkOverride 900 true;

62+ };

63+ })

64+ ];

65+ }

materialized/bootstrap/ghc883/happy-1.19.12/.plan.nix/happy.nixnew file+200

@@ -0,0 +1,200 @@

1+{ system

2+ , compiler

3+ , flags

4+ , pkgs

5+ , hsPkgs

6+ , pkgconfPkgs

7+ , errorHandler

8+ , config

9+ , ... }:

10+ {

11+ flags = { small_base = true; };

12+ package = {

13+ specVersion = "1.8";

14+ identifier = { name = "happy"; version = "1.19.12"; };

15+ license = "BSD-2-Clause";

16+ copyright = "(c) Andy Gill, Simon Marlow";

17+ maintainer = "Simon Marlow <marlowsd@gmail.com>";

18+ author = "Andy Gill and Simon Marlow";

19+ homepage = "https://www.haskell.org/happy/";

20+ url = "";

21+ synopsis = "Happy is a parser generator for Haskell";

22+ description = "Happy is a parser generator for Haskell. Given a grammar\nspecification in BNF, Happy generates Haskell code to parse the\ngrammar. Happy works in a similar way to the @yacc@ tool for C.";

23+ buildType = "Simple";

24+ isLocal = true;

25+ detailLevel = "FullDetails";

26+ licenseFiles = [ "LICENSE" ];

27+ dataDir = "data/";

28+ dataFiles = [

29+ "HappyTemplate"

30+ "HappyTemplate-arrays"

31+ "HappyTemplate-arrays-coerce"

32+ "HappyTemplate-arrays-coerce-debug"

33+ "HappyTemplate-arrays-debug"

34+ "HappyTemplate-arrays-ghc"

35+ "HappyTemplate-arrays-ghc-debug"

36+ "HappyTemplate-coerce"

37+ "HappyTemplate-ghc"

38+ "GLR_Base"

39+ "GLR_Lib"

40+ "GLR_Lib-ghc"

41+ "GLR_Lib-ghc-debug"

42+ ];

43+ extraSrcFiles = [

44+ "ANNOUNCE"

45+ "CHANGES"

46+ "Makefile"

47+ "README.md"

48+ "TODO"

49+ "doc/Makefile"

50+ "doc/aclocal.m4"

51+ "doc/config.mk.in"

52+ "doc/configure.ac"

53+ "doc/docbook-xml.mk"

54+ "doc/fptools.css"

55+ "doc/happy.1.in"

56+ "doc/happy.xml"

57+ "examples/glr/nlp/Main.lhs"

58+ "examples/glr/nlp/Makefile"

59+ "examples/glr/nlp/README"

60+ "examples/glr/nlp/English.y"

61+ "examples/glr/nlp/Hugs.lhs"

62+ "examples/glr/Makefile"

63+ "examples/glr/Makefile.defs"

64+ "examples/glr/expr-eval/Main.lhs"

65+ "examples/glr/expr-eval/Makefile"

66+ "examples/glr/expr-eval/Expr.y"

67+ "examples/glr/expr-eval/README"

68+ "examples/glr/expr-eval/Hugs.lhs"

69+ "examples/glr/expr-tree/Main.lhs"

70+ "examples/glr/expr-tree/Makefile"

71+ "examples/glr/expr-tree/Expr.y"

72+ "examples/glr/expr-tree/README"

73+ "examples/glr/expr-tree/Tree.lhs"

74+ "examples/glr/expr-tree/Hugs.lhs"

75+ "examples/glr/highly-ambiguous/Main.lhs"

76+ "examples/glr/highly-ambiguous/Makefile"

77+ "examples/glr/highly-ambiguous/Expr.y"

78+ "examples/glr/highly-ambiguous/README"

79+ "examples/glr/highly-ambiguous/Hugs.lhs"

80+ "examples/glr/hidden-leftrec/Main.lhs"

81+ "examples/glr/hidden-leftrec/Makefile"

82+ "examples/glr/hidden-leftrec/Expr.y"

83+ "examples/glr/hidden-leftrec/README"

84+ "examples/glr/hidden-leftrec/Hugs.lhs"

85+ "examples/glr/expr-monad/Main.lhs"

86+ "examples/glr/expr-monad/Makefile"

87+ "examples/glr/expr-monad/Expr.y"

88+ "examples/glr/expr-monad/README"

89+ "examples/glr/expr-monad/Hugs.lhs"

90+ "examples/glr/bio-eg/Main.lhs"

91+ "examples/glr/bio-eg/Makefile"

92+ "examples/glr/bio-eg/Bio.y"

93+ "examples/glr/bio-eg/README"

94+ "examples/glr/bio-eg/1-1200.dna"

95+ "examples/glr/bio-eg/1-600.dna"

96+ "examples/glr/common/DV_lhs"

97+ "examples/glr/common/DaVinciTypes.hs"

98+ "examples/glr/packing/Main.lhs"

99+ "examples/glr/packing/Makefile"

100+ "examples/glr/packing/Expr.y"

101+ "examples/glr/packing/README"

102+ "examples/glr/packing/Hugs.lhs"

103+ "examples/PgnParser.ly"

104+ "examples/MonadTest.ly"

105+ "examples/igloo/ParserM.hs"

106+ "examples/igloo/Makefile"

107+ "examples/igloo/Parser.y"

108+ "examples/igloo/Foo.hs"

109+ "examples/igloo/README"

110+ "examples/igloo/Lexer.x"

111+ "examples/README"

112+ "examples/Calc.ly"

113+ "examples/DavesExample.ly"

114+ "examples/ErrorTest.ly"

115+ "examples/ErlParser.ly"

116+ "examples/SimonsExample.ly"

117+ "examples/LexerTest.ly"

118+ "happy.spec"

119+ "src/ARRAY-NOTES"

120+ "tests/AttrGrammar001.y"

121+ "tests/AttrGrammar002.y"

122+ "tests/Makefile"

123+ "tests/Partial.ly"

124+ "tests/Test.ly"

125+ "tests/TestMulti.ly"

126+ "tests/TestPrecedence.ly"

127+ "tests/bogus-token.y"

128+ "tests/bug001.ly"

129+ "tests/bug002.y"

130+ "tests/error001.stderr"

131+ "tests/error001.stdout"

132+ "tests/error001.y"

133+ "tests/monad001.y"

134+ "tests/monad002.ly"

135+ "tests/monaderror.y"

136+ "tests/precedence001.ly"

137+ "tests/precedence002.y"

138+ "tests/test_rules.y"

139+ "tests/issue91.y"

140+ "tests/issue93.y"

141+ "tests/issue94.y"

142+ "tests/issue95.y"

143+ "tests/monaderror-explist.y"

144+ "tests/typeclass_monad001.y"

145+ "tests/typeclass_monad002.ly"

146+ "tests/typeclass_monad_lexer.y"

147+ "tests/rank2.y"

148+ ];

149+ extraTmpFiles = [];

150+ extraDocFiles = [];

151+ };

152+ components = {

153+ exes = {

154+ "happy" = {

155+ depends = [

156+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

157+ (hsPkgs."array" or (errorHandler.buildDepError "array"))

158+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

159+ (hsPkgs."mtl" or (errorHandler.buildDepError "mtl"))

160+ ];

161+ buildable = true;

162+ modules = [

163+ "Paths_happy"

164+ "AbsSyn"

165+ "First"

166+ "GenUtils"

167+ "Grammar"

168+ "Info"

169+ "LALR"

170+ "Lexer"

171+ "ParseMonad"

172+ "Parser"

173+ "ProduceCode"

174+ "ProduceGLRCode"

175+ "NameSet"

176+ "Target"

177+ "AttrGrammar"

178+ "AttrGrammarParser"

179+ "ParamRules"

180+ "PrettyGrammar"

181+ ];

182+ hsSourceDirs = [ "src" ];

183+ mainPath = [ "Main.lhs" ];

184+ };

185+ };

186+ tests = {

187+ "tests" = {

188+ depends = [

189+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

190+ (hsPkgs."process" or (errorHandler.buildDepError "process"))

191+ ];

192+ build-tools = [

193+ (hsPkgs.buildPackages.happy.components.exes.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy:happy")))

194+ ];

195+ buildable = true;

196+ mainPath = [ "test.hs" ];

197+ };

198+ };

199+ };

200+ } // rec { src = (pkgs.lib).mkDefault ../.; }

materialized/bootstrap/ghc883/happy-1.19.12/default.nixnew file+56

@@ -0,0 +1,56 @@

1+{

2+ pkgs = hackage:

3+ {

4+ packages = {

5+ "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

6+ "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

7+ "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;

8+ "base".revision = (((hackage."base")."4.13.0.0").revisions).default;

9+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

10+ "transformers".revision = (((hackage."transformers")."0.5.6.2").revisions).default;

11+ "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

12+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

13+ "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;

14+ };

15+ compiler = {

16+ version = "8.8.3";

17+ nix-name = "ghc883";

18+ packages = {

19+ "array" = "0.5.4.0";

20+ "mtl" = "2.2.2";

21+ "ghc-prim" = "0.5.3";

22+ "base" = "4.13.0.0";

23+ "rts" = "1.0";

24+ "transformers" = "0.5.6.2";

25+ "deepseq" = "1.4.4.0";

26+ "integer-gmp" = "1.0.2.0";

27+ "containers" = "0.6.2.1";

28+ };

29+ };

30+ };

31+ extras = hackage:

32+ { packages = { happy = ./.plan.nix/happy.nix; }; };

33+ modules = [

34+ ({ lib, ... }:

35+ {

36+ packages = {

37+ "happy" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

38+ };

39+ })

40+ ({ lib, ... }:

41+ {

42+ packages = {

43+ "ghc-prim".components.library.planned = lib.mkOverride 900 true;

44+ "array".components.library.planned = lib.mkOverride 900 true;

45+ "rts".components.library.planned = lib.mkOverride 900 true;

46+ "happy".components.exes."happy".planned = lib.mkOverride 900 true;

47+ "mtl".components.library.planned = lib.mkOverride 900 true;

48+ "transformers".components.library.planned = lib.mkOverride 900 true;

49+ "deepseq".components.library.planned = lib.mkOverride 900 true;

50+ "base".components.library.planned = lib.mkOverride 900 true;

51+ "integer-gmp".components.library.planned = lib.mkOverride 900 true;

52+ "containers".components.library.planned = lib.mkOverride 900 true;

53+ };

54+ })

55+ ];

56+ }

materialized/bootstrap/ghc883/hscolour/.plan.nix/hscolour.nixnew file+70

@@ -0,0 +1,70 @@

1+{ system

2+ , compiler

3+ , flags

4+ , pkgs

5+ , hsPkgs

6+ , pkgconfPkgs

7+ , errorHandler

8+ , config

9+ , ... }:

10+ {

11+ flags = {};

12+ package = {

13+ specVersion = "1.6";

14+ identifier = { name = "hscolour"; version = "1.24.4"; };

15+ license = "LicenseRef-LGPL";

16+ copyright = "2003-2017 Malcolm Wallace; 2006 Bjorn Bringert";

17+ maintainer = "Malcolm Wallace";

18+ author = "Malcolm Wallace";

19+ homepage = "http://code.haskell.org/~malcolm/hscolour/";

20+ url = "";

21+ synopsis = "Colourise Haskell code.";

22+ description = "hscolour is a small Haskell script to colourise Haskell code. It currently\nhas six output formats:\nANSI terminal codes (optionally XTerm-256colour codes),\nHTML 3.2 with <font> tags,\nHTML 4.01 with CSS,\nHTML 4.01 with CSS and mouseover annotations,\nXHTML 1.0 with inline CSS styling,\nLaTeX,\nand mIRC chat codes.";

23+ buildType = "Simple";

24+ isLocal = true;

25+ detailLevel = "FullDetails";

26+ licenseFiles = [ "LICENCE-LGPL" ];

27+ dataDir = ".";

28+ dataFiles = [ "hscolour.css" "data/rgb24-example-.hscolour" ];

29+ extraSrcFiles = [];

30+ extraTmpFiles = [];

31+ extraDocFiles = [];

32+ };

33+ components = {

34+ "library" = {

35+ depends = [

36+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

37+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

38+ ];

39+ buildable = true;

40+ modules = [

41+ "Language/Haskell/HsColour"

42+ "Language/Haskell/HsColour/ANSI"

43+ "Language/Haskell/HsColour/Anchors"

44+ "Language/Haskell/HsColour/ACSS"

45+ "Language/Haskell/HsColour/CSS"

46+ "Language/Haskell/HsColour/Classify"

47+ "Language/Haskell/HsColour/ColourHighlight"

48+ "Language/Haskell/HsColour/Colourise"

49+ "Language/Haskell/HsColour/General"

50+ "Language/Haskell/HsColour/HTML"

51+ "Language/Haskell/HsColour/InlineCSS"

52+ "Language/Haskell/HsColour/LaTeX"

53+ "Language/Haskell/HsColour/MIRC"

54+ "Language/Haskell/HsColour/Options"

55+ "Language/Haskell/HsColour/Output"

56+ "Language/Haskell/HsColour/TTY"

57+ ];

58+ };

59+ exes = {

60+ "HsColour" = {

61+ depends = [

62+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

63+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

64+ ];

65+ buildable = true;

66+ mainPath = [ "HsColour.hs" ];

67+ };

68+ };

69+ };

70+ } // rec { src = (pkgs.lib).mkDefault ../.; }

materialized/bootstrap/ghc883/hscolour/default.nixnew file+47

@@ -0,0 +1,47 @@

1+{

2+ pkgs = hackage:

3+ {

4+ packages = {

5+ "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

6+ "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;

7+ "base".revision = (((hackage."base")."4.13.0.0").revisions).default;

8+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

9+ "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

10+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

11+ "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;

12+ };

13+ compiler = {

14+ version = "8.8.3";

15+ nix-name = "ghc883";

16+ packages = {

17+ "array" = "0.5.4.0";

18+ "ghc-prim" = "0.5.3";

19+ "base" = "4.13.0.0";

20+ "rts" = "1.0";

21+ "deepseq" = "1.4.4.0";

22+ "integer-gmp" = "1.0.2.0";

23+ "containers" = "0.6.2.1";

24+ };

25+ };

26+ };

27+ extras = hackage:

28+ { packages = { hscolour = ./.plan.nix/hscolour.nix; }; };

29+ modules = [

30+ ({ lib, ... }:

31+ { packages = { "hscolour" = { flags = {}; }; }; })

32+ ({ lib, ... }:

33+ {

34+ packages = {

35+ "ghc-prim".components.library.planned = lib.mkOverride 900 true;

36+ "array".components.library.planned = lib.mkOverride 900 true;

37+ "rts".components.library.planned = lib.mkOverride 900 true;

38+ "hscolour".components.library.planned = lib.mkOverride 900 true;

39+ "hscolour".components.exes."HsColour".planned = lib.mkOverride 900 true;

40+ "deepseq".components.library.planned = lib.mkOverride 900 true;

41+ "base".components.library.planned = lib.mkOverride 900 true;

42+ "integer-gmp".components.library.planned = lib.mkOverride 900 true;

43+ "containers".components.library.planned = lib.mkOverride 900 true;

44+ };

45+ })

46+ ];

47+ }

materialized/bootstrap/ghc884/alex/.plan.nix/alex.nixnew file+160

@@ -0,0 +1,160 @@

1+{ system

2+ , compiler

3+ , flags

4+ , pkgs

5+ , hsPkgs

6+ , pkgconfPkgs

7+ , errorHandler

8+ , config

9+ , ... }:

10+ {

11+ flags = { small_base = true; };

12+ package = {

13+ specVersion = "1.8";

14+ identifier = { name = "alex"; version = "3.2.4"; };

15+ license = "BSD-3-Clause";

16+ copyright = "(c) Chis Dornan, Simon Marlow";

17+ maintainer = "Simon Marlow <marlowsd@gmail.com>";

18+ author = "Chris Dornan and Simon Marlow";

19+ homepage = "http://www.haskell.org/alex/";

20+ url = "";

21+ synopsis = "Alex is a tool for generating lexical analysers in Haskell";

22+ description = "Alex is a tool for generating lexical analysers in Haskell.\nIt takes a description of tokens based on regular\nexpressions and generates a Haskell module containing code\nfor scanning text efficiently. It is similar to the tool\nlex or flex for C/C++.";

23+ buildType = "Simple";

24+ isLocal = true;

25+ detailLevel = "FullDetails";

26+ licenseFiles = [ "LICENSE" ];

27+ dataDir = "data/";

28+ dataFiles = [

29+ "AlexTemplate"

30+ "AlexTemplate-ghc"

31+ "AlexTemplate-ghc-nopred"

32+ "AlexTemplate-ghc-debug"

33+ "AlexTemplate-debug"

34+ "AlexWrapper-basic"

35+ "AlexWrapper-basic-bytestring"

36+ "AlexWrapper-strict-bytestring"

37+ "AlexWrapper-posn"

38+ "AlexWrapper-posn-bytestring"

39+ "AlexWrapper-monad"

40+ "AlexWrapper-monad-bytestring"

41+ "AlexWrapper-monadUserState"

42+ "AlexWrapper-monadUserState-bytestring"

43+ "AlexWrapper-gscan"

44+ ];

45+ extraSrcFiles = [

46+ "CHANGELOG.md"

47+ "README.md"

48+ "TODO"

49+ "alex.spec"

50+ "doc/Makefile"

51+ "doc/aclocal.m4"

52+ "doc/alex.1.in"

53+ "doc/alex.xml"

54+ "doc/config.mk.in"

55+ "doc/configure.ac"

56+ "doc/docbook-xml.mk"

57+ "doc/fptools.css"

58+ "examples/Makefile"

59+ "examples/Tokens.x"

60+ "examples/Tokens_gscan.x"

61+ "examples/Tokens_posn.x"

62+ "examples/examples.x"

63+ "examples/haskell.x"

64+ "examples/lit.x"

65+ "examples/pp.x"

66+ "examples/state.x"

67+ "examples/tiny.y"

68+ "examples/words.x"

69+ "examples/words_monad.x"

70+ "examples/words_posn.x"

71+ "src/Parser.y.boot"

72+ "src/Scan.x.boot"

73+ "src/ghc_hooks.c"

74+ "templates/GenericTemplate.hs"

75+ "templates/wrappers.hs"

76+ "tests/Makefile"

77+ "tests/simple.x"

78+ "tests/null.x"

79+ "tests/tokens.x"

80+ "tests/tokens_gscan.x"

81+ "tests/tokens_posn.x"

82+ "tests/tokens_bytestring.x"

83+ "tests/tokens_posn_bytestring.x"

84+ "tests/tokens_scan_user.x"

85+ "tests/tokens_strict_bytestring.x"

86+ "tests/tokens_monad_bytestring.x"

87+ "tests/tokens_monadUserState_bytestring.x"

88+ "tests/tokens_bytestring_unicode.x"

89+ "tests/basic_typeclass.x"

90+ "tests/basic_typeclass_bytestring.x"

91+ "tests/default_typeclass.x"

92+ "tests/gscan_typeclass.x"

93+ "tests/posn_typeclass.x"

94+ "tests/monad_typeclass.x"

95+ "tests/monad_typeclass_bytestring.x"

96+ "tests/monadUserState_typeclass.x"

97+ "tests/monadUserState_typeclass_bytestring.x"

98+ "tests/posn_typeclass_bytestring.x"

99+ "tests/strict_typeclass.x"

100+ "tests/unicode.x"

101+ ];

102+ extraTmpFiles = [];

103+ extraDocFiles = [];

104+ };

105+ components = {

106+ exes = {

107+ "alex" = {

108+ depends = [

109+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

110+ ] ++ (if flags.small_base

111+ then [

112+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

113+ (hsPkgs."array" or (errorHandler.buildDepError "array"))

114+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

115+ (hsPkgs."directory" or (errorHandler.buildDepError "directory"))

116+ ]

117+ else [ (hsPkgs."base" or (errorHandler.buildDepError "base")) ]);

118+ buildable = true;

119+ modules = [

120+ "AbsSyn"

121+ "CharSet"

122+ "DFA"

123+ "DFAMin"

124+ "DFS"

125+ "Info"

126+ "Map"

127+ "NFA"

128+ "Output"

129+ "Paths_alex"

130+ "Parser"

131+ "ParseMonad"

132+ "Scan"

133+ "Set"

134+ "Sort"

135+ "Util"

136+ "UTF8"

137+ "Data/Ranged"

138+ "Data/Ranged/Boundaries"

139+ "Data/Ranged/RangedSet"

140+ "Data/Ranged/Ranges"

141+ ];

142+ hsSourceDirs = [ "src" ];

143+ mainPath = [ "Main.hs" ] ++ [ "" ];

144+ };

145+ };

146+ tests = {

147+ "tests" = {

148+ depends = [

149+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

150+ (hsPkgs."process" or (errorHandler.buildDepError "process"))

151+ ];

152+ build-tools = [

153+ (hsPkgs.buildPackages.alex.components.exes.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex:alex")))

154+ ];

155+ buildable = true;

156+ mainPath = [ "test.hs" ];

157+ };

158+ };

159+ };

160+ } // rec { src = (pkgs.lib).mkDefault ../.; }

materialized/bootstrap/ghc884/alex/default.nixnew file+65

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

1+{

2+ pkgs = hackage:

3+ {

4+ packages = {

5+ "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

6+ "bytestring".revision = (((hackage."bytestring")."0.10.10.1").revisions).default;

7+ "filepath".revision = (((hackage."filepath")."1.4.2.1").revisions).default;

8+ "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;

9+ "base".revision = (((hackage."base")."4.13.0.0").revisions).default;

10+ "time".revision = (((hackage."time")."1.9.3").revisions).default;

11+ "directory".revision = (((hackage."directory")."1.3.6.0").revisions).default;

12+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

13+ "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

14+ "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

15+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

16+ "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;

17+ };

18+ compiler = {

19+ version = "8.8.4";

20+ nix-name = "ghc884";

21+ packages = {

22+ "array" = "0.5.4.0";

23+ "bytestring" = "0.10.10.1";

24+ "filepath" = "1.4.2.1";

25+ "ghc-prim" = "0.5.3";

26+ "base" = "4.13.0.0";

27+ "time" = "1.9.3";

28+ "directory" = "1.3.6.0";

29+ "rts" = "1.0";

30+ "deepseq" = "1.4.4.0";

31+ "unix" = "2.7.2.2";

32+ "integer-gmp" = "1.0.2.0";

33+ "containers" = "0.6.2.1";

34+ };

35+ };

36+ };

37+ extras = hackage:

38+ { packages = { alex = ./.plan.nix/alex.nix; }; };

39+ modules = [

40+ ({ lib, ... }:

41+ {

42+ packages = {

43+ "alex" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

44+ };

45+ })

46+ ({ lib, ... }:

47+ {

48+ packages = {

49+ "filepath".components.library.planned = lib.mkOverride 900 true;

50+ "bytestring".components.library.planned = lib.mkOverride 900 true;

51+ "ghc-prim".components.library.planned = lib.mkOverride 900 true;

52+ "array".components.library.planned = lib.mkOverride 900 true;

53+ "rts".components.library.planned = lib.mkOverride 900 true;

54+ "unix".components.library.planned = lib.mkOverride 900 true;

55+ "directory".components.library.planned = lib.mkOverride 900 true;

56+ "time".components.library.planned = lib.mkOverride 900 true;

57+ "alex".components.exes."alex".planned = lib.mkOverride 900 true;

58+ "deepseq".components.library.planned = lib.mkOverride 900 true;

59+ "base".components.library.planned = lib.mkOverride 900 true;

60+ "integer-gmp".components.library.planned = lib.mkOverride 900 true;

61+ "containers".components.library.planned = lib.mkOverride 900 true;

62+ };

63+ })

64+ ];

65+ }

materialized/bootstrap/ghc884/happy-1.19.12/.plan.nix/happy.nixnew file+200

@@ -0,0 +1,200 @@

1+{ system

2+ , compiler

3+ , flags

4+ , pkgs

5+ , hsPkgs

6+ , pkgconfPkgs

7+ , errorHandler

8+ , config

9+ , ... }:

10+ {

11+ flags = { small_base = true; };

12+ package = {

13+ specVersion = "1.8";

14+ identifier = { name = "happy"; version = "1.19.12"; };

15+ license = "BSD-2-Clause";

16+ copyright = "(c) Andy Gill, Simon Marlow";

17+ maintainer = "Simon Marlow <marlowsd@gmail.com>";

18+ author = "Andy Gill and Simon Marlow";

19+ homepage = "https://www.haskell.org/happy/";

20+ url = "";

21+ synopsis = "Happy is a parser generator for Haskell";

22+ description = "Happy is a parser generator for Haskell. Given a grammar\nspecification in BNF, Happy generates Haskell code to parse the\ngrammar. Happy works in a similar way to the @yacc@ tool for C.";

23+ buildType = "Simple";

24+ isLocal = true;

25+ detailLevel = "FullDetails";

26+ licenseFiles = [ "LICENSE" ];

27+ dataDir = "data/";

28+ dataFiles = [

29+ "HappyTemplate"

30+ "HappyTemplate-arrays"

31+ "HappyTemplate-arrays-coerce"

32+ "HappyTemplate-arrays-coerce-debug"

33+ "HappyTemplate-arrays-debug"

34+ "HappyTemplate-arrays-ghc"

35+ "HappyTemplate-arrays-ghc-debug"

36+ "HappyTemplate-coerce"

37+ "HappyTemplate-ghc"

38+ "GLR_Base"

39+ "GLR_Lib"

40+ "GLR_Lib-ghc"

41+ "GLR_Lib-ghc-debug"

42+ ];

43+ extraSrcFiles = [

44+ "ANNOUNCE"

45+ "CHANGES"

46+ "Makefile"

47+ "README.md"

48+ "TODO"

49+ "doc/Makefile"

50+ "doc/aclocal.m4"

51+ "doc/config.mk.in"

52+ "doc/configure.ac"

53+ "doc/docbook-xml.mk"

54+ "doc/fptools.css"

55+ "doc/happy.1.in"

56+ "doc/happy.xml"

57+ "examples/glr/nlp/Main.lhs"

58+ "examples/glr/nlp/Makefile"

59+ "examples/glr/nlp/README"

60+ "examples/glr/nlp/English.y"

61+ "examples/glr/nlp/Hugs.lhs"

62+ "examples/glr/Makefile"

63+ "examples/glr/Makefile.defs"

64+ "examples/glr/expr-eval/Main.lhs"

65+ "examples/glr/expr-eval/Makefile"

66+ "examples/glr/expr-eval/Expr.y"

67+ "examples/glr/expr-eval/README"

68+ "examples/glr/expr-eval/Hugs.lhs"

69+ "examples/glr/expr-tree/Main.lhs"

70+ "examples/glr/expr-tree/Makefile"

71+ "examples/glr/expr-tree/Expr.y"

72+ "examples/glr/expr-tree/README"

73+ "examples/glr/expr-tree/Tree.lhs"

74+ "examples/glr/expr-tree/Hugs.lhs"

75+ "examples/glr/highly-ambiguous/Main.lhs"

76+ "examples/glr/highly-ambiguous/Makefile"

77+ "examples/glr/highly-ambiguous/Expr.y"

78+ "examples/glr/highly-ambiguous/README"

79+ "examples/glr/highly-ambiguous/Hugs.lhs"

80+ "examples/glr/hidden-leftrec/Main.lhs"

81+ "examples/glr/hidden-leftrec/Makefile"

82+ "examples/glr/hidden-leftrec/Expr.y"

83+ "examples/glr/hidden-leftrec/README"

84+ "examples/glr/hidden-leftrec/Hugs.lhs"

85+ "examples/glr/expr-monad/Main.lhs"

86+ "examples/glr/expr-monad/Makefile"

87+ "examples/glr/expr-monad/Expr.y"

88+ "examples/glr/expr-monad/README"

89+ "examples/glr/expr-monad/Hugs.lhs"

90+ "examples/glr/bio-eg/Main.lhs"

91+ "examples/glr/bio-eg/Makefile"

92+ "examples/glr/bio-eg/Bio.y"

93+ "examples/glr/bio-eg/README"

94+ "examples/glr/bio-eg/1-1200.dna"

95+ "examples/glr/bio-eg/1-600.dna"

96+ "examples/glr/common/DV_lhs"

97+ "examples/glr/common/DaVinciTypes.hs"

98+ "examples/glr/packing/Main.lhs"

99+ "examples/glr/packing/Makefile"

100+ "examples/glr/packing/Expr.y"

101+ "examples/glr/packing/README"

102+ "examples/glr/packing/Hugs.lhs"

103+ "examples/PgnParser.ly"

104+ "examples/MonadTest.ly"

105+ "examples/igloo/ParserM.hs"

106+ "examples/igloo/Makefile"

107+ "examples/igloo/Parser.y"

108+ "examples/igloo/Foo.hs"

109+ "examples/igloo/README"

110+ "examples/igloo/Lexer.x"

111+ "examples/README"

112+ "examples/Calc.ly"

113+ "examples/DavesExample.ly"

114+ "examples/ErrorTest.ly"

115+ "examples/ErlParser.ly"

116+ "examples/SimonsExample.ly"

117+ "examples/LexerTest.ly"

118+ "happy.spec"

119+ "src/ARRAY-NOTES"

120+ "tests/AttrGrammar001.y"

121+ "tests/AttrGrammar002.y"

122+ "tests/Makefile"

123+ "tests/Partial.ly"

124+ "tests/Test.ly"

125+ "tests/TestMulti.ly"

126+ "tests/TestPrecedence.ly"

127+ "tests/bogus-token.y"

128+ "tests/bug001.ly"

129+ "tests/bug002.y"

130+ "tests/error001.stderr"

131+ "tests/error001.stdout"

132+ "tests/error001.y"

133+ "tests/monad001.y"

134+ "tests/monad002.ly"

135+ "tests/monaderror.y"

136+ "tests/precedence001.ly"

137+ "tests/precedence002.y"

138+ "tests/test_rules.y"

139+ "tests/issue91.y"

140+ "tests/issue93.y"

141+ "tests/issue94.y"

142+ "tests/issue95.y"

143+ "tests/monaderror-explist.y"

144+ "tests/typeclass_monad001.y"

145+ "tests/typeclass_monad002.ly"

146+ "tests/typeclass_monad_lexer.y"

147+ "tests/rank2.y"

148+ ];

149+ extraTmpFiles = [];

150+ extraDocFiles = [];

151+ };

152+ components = {

153+ exes = {

154+ "happy" = {

155+ depends = [

156+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

157+ (hsPkgs."array" or (errorHandler.buildDepError "array"))

158+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

159+ (hsPkgs."mtl" or (errorHandler.buildDepError "mtl"))

160+ ];

161+ buildable = true;

162+ modules = [

163+ "Paths_happy"

164+ "AbsSyn"

165+ "First"

166+ "GenUtils"

167+ "Grammar"

168+ "Info"

169+ "LALR"

170+ "Lexer"

171+ "ParseMonad"

172+ "Parser"

173+ "ProduceCode"

174+ "ProduceGLRCode"

175+ "NameSet"

176+ "Target"

177+ "AttrGrammar"

178+ "AttrGrammarParser"

179+ "ParamRules"

180+ "PrettyGrammar"

181+ ];

182+ hsSourceDirs = [ "src" ];

183+ mainPath = [ "Main.lhs" ];

184+ };

185+ };

186+ tests = {

187+ "tests" = {

188+ depends = [

189+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

190+ (hsPkgs."process" or (errorHandler.buildDepError "process"))

191+ ];

192+ build-tools = [

193+ (hsPkgs.buildPackages.happy.components.exes.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy:happy")))

194+ ];

195+ buildable = true;

196+ mainPath = [ "test.hs" ];

197+ };

198+ };

199+ };

200+ } // rec { src = (pkgs.lib).mkDefault ../.; }

materialized/bootstrap/ghc884/happy-1.19.12/default.nixnew file+56

@@ -0,0 +1,56 @@

1+{

2+ pkgs = hackage:

3+ {

4+ packages = {

5+ "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

6+ "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

7+ "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;

8+ "base".revision = (((hackage."base")."4.13.0.0").revisions).default;

9+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

10+ "transformers".revision = (((hackage."transformers")."0.5.6.2").revisions).default;

11+ "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

12+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

13+ "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;

14+ };

15+ compiler = {

16+ version = "8.8.4";

17+ nix-name = "ghc884";

18+ packages = {

19+ "array" = "0.5.4.0";

20+ "mtl" = "2.2.2";

21+ "ghc-prim" = "0.5.3";

22+ "base" = "4.13.0.0";

23+ "rts" = "1.0";

24+ "transformers" = "0.5.6.2";

25+ "deepseq" = "1.4.4.0";

26+ "integer-gmp" = "1.0.2.0";

27+ "containers" = "0.6.2.1";

28+ };

29+ };

30+ };

31+ extras = hackage:

32+ { packages = { happy = ./.plan.nix/happy.nix; }; };

33+ modules = [

34+ ({ lib, ... }:

35+ {

36+ packages = {

37+ "happy" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

38+ };

39+ })

40+ ({ lib, ... }:

41+ {

42+ packages = {

43+ "ghc-prim".components.library.planned = lib.mkOverride 900 true;

44+ "array".components.library.planned = lib.mkOverride 900 true;

45+ "rts".components.library.planned = lib.mkOverride 900 true;

46+ "happy".components.exes."happy".planned = lib.mkOverride 900 true;

47+ "mtl".components.library.planned = lib.mkOverride 900 true;

48+ "transformers".components.library.planned = lib.mkOverride 900 true;

49+ "deepseq".components.library.planned = lib.mkOverride 900 true;

50+ "base".components.library.planned = lib.mkOverride 900 true;

51+ "integer-gmp".components.library.planned = lib.mkOverride 900 true;

52+ "containers".components.library.planned = lib.mkOverride 900 true;

53+ };

54+ })

55+ ];

56+ }

materialized/bootstrap/ghc884/hscolour/.plan.nix/hscolour.nixnew file+70

@@ -0,0 +1,70 @@

1+{ system

2+ , compiler

3+ , flags

4+ , pkgs

5+ , hsPkgs

6+ , pkgconfPkgs

7+ , errorHandler

8+ , config

9+ , ... }:

10+ {

11+ flags = {};

12+ package = {

13+ specVersion = "1.6";

14+ identifier = { name = "hscolour"; version = "1.24.4"; };

15+ license = "LicenseRef-LGPL";

16+ copyright = "2003-2017 Malcolm Wallace; 2006 Bjorn Bringert";

17+ maintainer = "Malcolm Wallace";

18+ author = "Malcolm Wallace";

19+ homepage = "http://code.haskell.org/~malcolm/hscolour/";

20+ url = "";

21+ synopsis = "Colourise Haskell code.";

22+ description = "hscolour is a small Haskell script to colourise Haskell code. It currently\nhas six output formats:\nANSI terminal codes (optionally XTerm-256colour codes),\nHTML 3.2 with <font> tags,\nHTML 4.01 with CSS,\nHTML 4.01 with CSS and mouseover annotations,\nXHTML 1.0 with inline CSS styling,\nLaTeX,\nand mIRC chat codes.";

23+ buildType = "Simple";

24+ isLocal = true;

25+ detailLevel = "FullDetails";

26+ licenseFiles = [ "LICENCE-LGPL" ];

27+ dataDir = ".";

28+ dataFiles = [ "hscolour.css" "data/rgb24-example-.hscolour" ];

29+ extraSrcFiles = [];

30+ extraTmpFiles = [];

31+ extraDocFiles = [];

32+ };

33+ components = {

34+ "library" = {

35+ depends = [

36+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

37+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

38+ ];

39+ buildable = true;

40+ modules = [

41+ "Language/Haskell/HsColour"

42+ "Language/Haskell/HsColour/ANSI"

43+ "Language/Haskell/HsColour/Anchors"

44+ "Language/Haskell/HsColour/ACSS"

45+ "Language/Haskell/HsColour/CSS"

46+ "Language/Haskell/HsColour/Classify"

47+ "Language/Haskell/HsColour/ColourHighlight"

48+ "Language/Haskell/HsColour/Colourise"

49+ "Language/Haskell/HsColour/General"

50+ "Language/Haskell/HsColour/HTML"

51+ "Language/Haskell/HsColour/InlineCSS"

52+ "Language/Haskell/HsColour/LaTeX"

53+ "Language/Haskell/HsColour/MIRC"

54+ "Language/Haskell/HsColour/Options"

55+ "Language/Haskell/HsColour/Output"

56+ "Language/Haskell/HsColour/TTY"

57+ ];

58+ };

59+ exes = {

60+ "HsColour" = {

61+ depends = [

62+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

63+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

64+ ];

65+ buildable = true;

66+ mainPath = [ "HsColour.hs" ];

67+ };

68+ };

69+ };

70+ } // rec { src = (pkgs.lib).mkDefault ../.; }

materialized/bootstrap/ghc884/hscolour/default.nixnew file+47

@@ -0,0 +1,47 @@

1+{

2+ pkgs = hackage:

3+ {

4+ packages = {

5+ "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

6+ "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;

7+ "base".revision = (((hackage."base")."4.13.0.0").revisions).default;

8+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

9+ "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

10+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

11+ "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;

12+ };

13+ compiler = {

14+ version = "8.8.4";

15+ nix-name = "ghc884";

16+ packages = {

17+ "array" = "0.5.4.0";

18+ "ghc-prim" = "0.5.3";

19+ "base" = "4.13.0.0";

20+ "rts" = "1.0";

21+ "deepseq" = "1.4.4.0";

22+ "integer-gmp" = "1.0.2.0";

23+ "containers" = "0.6.2.1";

24+ };

25+ };

26+ };

27+ extras = hackage:

28+ { packages = { hscolour = ./.plan.nix/hscolour.nix; }; };

29+ modules = [

30+ ({ lib, ... }:

31+ { packages = { "hscolour" = { flags = {}; }; }; })

32+ ({ lib, ... }:

33+ {

34+ packages = {

35+ "ghc-prim".components.library.planned = lib.mkOverride 900 true;

36+ "array".components.library.planned = lib.mkOverride 900 true;

37+ "rts".components.library.planned = lib.mkOverride 900 true;

38+ "hscolour".components.library.planned = lib.mkOverride 900 true;

39+ "hscolour".components.exes."HsColour".planned = lib.mkOverride 900 true;

40+ "deepseq".components.library.planned = lib.mkOverride 900 true;

41+ "base".components.library.planned = lib.mkOverride 900 true;

42+ "integer-gmp".components.library.planned = lib.mkOverride 900 true;

43+ "containers".components.library.planned = lib.mkOverride 900 true;

44+ };

45+ })

46+ ];

47+ }

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.10.6-x86_64-linux/ghc/info−2

@@ -30,8 +30,6 @@

3030 ,("target has RTS linker","YES")

3131 ,("Unregisterised","NO")

3232 ,("LLVM target","aarch64-unknown-linux")

33− ,("LLVM llc command","llc")

34− ,("LLVM opt command","opt")

3533 ,("LLVM clang command","clang")

3634 ,("integer library","integer-gmp")

3735 ,("Use interpreter","YES")

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.10.7-x86_64-linux/ghc/info−2

@@ -30,8 +30,6 @@

3030 ,("target has RTS linker","YES")

3131 ,("Unregisterised","NO")

3232 ,("LLVM target","aarch64-unknown-linux")

33− ,("LLVM llc command","llc")

34− ,("LLVM opt command","opt")

3533 ,("LLVM clang command","clang")

3634 ,("integer library","integer-gmp")

3735 ,("Use interpreter","YES")

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.8.4-x86_64-linux/ghc/info+1−3

@@ -24,12 +24,10 @@

2424 ,("target has subsections via symbols","False")

2525 ,("target has RTS linker","YES")

2626 ,("Unregisterised","NO")

27− ,("LLVM llc command","llc")

28− ,("LLVM opt command","opt")

2927 ,("LLVM clang command","clang")

3028 ,("Project version","8.8.4")

3129 ,("Project Git commit id","6cf8f835267581d551ca6695b3b02c34797e2cf4")

32− ,("Booter version","8.8.2")

30+ ,("Booter version","8.8.4")

3331 ,("Stage","1")

3432 ,("Build platform","x86_64-unknown-linux")

3533 ,("Host platform","x86_64-unknown-linux")

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-9.2.4-x86_64-linux/ghc-pkg/dump-globalnew file+1512

@@ -0,0 +1,1512 @@

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:

564+ Copyright (C) 2013-2015 Edward A. Kmett

565+ Copyright (C) 2012 Google Inc.

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/versionnew file+1

@@ -0,0 +1 @@

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/infonew file+66

@@ -0,0 +1,66 @@

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-versionnew file+1

@@ -0,0 +1 @@

1+9.2.4

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-9.2.4-x86_64-linux/ghc/supported-languagesnew file+268

@@ -0,0 +1,268 @@

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/versionnew file+1

@@ -0,0 +1 @@

1+The Glorious Glasgow Haskell Compilation System, version 9.2.4

materialized/dummy-ghc/ghc-8.10.2-x86_64-linux/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","YES")

8+ ,("Haskell CPP command","gcc")

79 ,("Haskell CPP flags","-E -undef -traditional")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","YES")

1114 ,("ld supports filelist","NO")

1215 ,("ld is GNU ld","YES")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","q")

1520 ,("ar supports at file","YES")

21+ ,("ranlib command","ranlib")

1622 ,("touch command","touch")

1723 ,("dllwrap command","/bin/false")

1824 ,("windres command","/bin/false")

materialized/dummy-ghc/ghc-8.10.3-x86_64-linux/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","YES")

8+ ,("Haskell CPP command","gcc")

79 ,("Haskell CPP flags","-E -undef -traditional")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","YES")

1114 ,("ld supports filelist","NO")

1215 ,("ld is GNU ld","YES")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","q")

1520 ,("ar supports at file","YES")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-8.10.4-x86_64-darwin/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","clang")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","NO")

8+ ,("Haskell CPP command","clang")

79 ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","NO")

1114 ,("ld supports filelist","YES")

1215 ,("ld is GNU ld","NO")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","qcls")

1520 ,("ar supports at file","NO")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-8.10.4-x86_64-linux/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","YES")

8+ ,("Haskell CPP command","gcc")

79 ,("Haskell CPP flags","-E -undef -traditional")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","YES")

1114 ,("ld supports filelist","NO")

1215 ,("ld is GNU ld","YES")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","q")

1520 ,("ar supports at file","YES")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-8.10.4.20210212-x86_64-linux/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","YES")

8+ ,("Haskell CPP command","gcc")

79 ,("Haskell CPP flags","-E -undef -traditional")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","YES")

1114 ,("ld supports filelist","NO")

1215 ,("ld is GNU ld","YES")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","q")

1520 ,("ar supports at file","YES")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-8.10.5-x86_64-darwin/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","clang")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","NO")

8+ ,("Haskell CPP command","clang")

79 ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","NO")

1114 ,("ld supports filelist","YES")

1215 ,("ld is GNU ld","NO")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","qcls")

1520 ,("ar supports at file","NO")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-8.10.5-x86_64-linux/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","YES")

8+ ,("Haskell CPP command","gcc")

79 ,("Haskell CPP flags","-E -undef -traditional")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","YES")

1114 ,("ld supports filelist","NO")

1215 ,("ld is GNU ld","YES")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","q")

1520 ,("ar supports at file","YES")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-8.10.6-x86_64-darwin/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","clang")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","NO")

8+ ,("Haskell CPP command","clang")

79 ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","NO")

1114 ,("ld supports filelist","YES")

1215 ,("ld is GNU ld","NO")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","qcls")

1520 ,("ar supports at file","NO")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-8.10.6-x86_64-linux/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","YES")

8+ ,("Haskell CPP command","gcc")

79 ,("Haskell CPP flags","-E -undef -traditional")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","YES")

1114 ,("ld supports filelist","NO")

1215 ,("ld is GNU ld","YES")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","q")

1520 ,("ar supports at file","YES")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-8.10.7-aarch64-darwin/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","clang")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","NO")

8+ ,("Haskell CPP command","clang")

79 ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","NO")

1114 ,("ld supports filelist","YES")

1215 ,("ld is GNU ld","NO")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","qcls")

1520 ,("ar supports at file","NO")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-8.10.7-aarch64-linux/ghc-pkg/dump-globalnew file+1638

@@ -0,0 +1,1638 @@

1+name: Cabal

2+version: 3.2.1.0

3+visibility: public

4+id: Cabal-3.2.1.0

5+key: Cabal-3.2.1.0

6+license: BSD-3-Clause

7+copyright: 2003-2020, 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.Parsing Distribution.Compat.Prelude.Internal

36+ Distribution.Compat.Process Distribution.Compat.ResponseFile

37+ Distribution.Compat.Semigroup Distribution.Compat.Stack

38+ Distribution.Compat.Time Distribution.Compat.Typeable

39+ Distribution.Compiler Distribution.FieldGrammar

40+ Distribution.FieldGrammar.Class

41+ Distribution.FieldGrammar.FieldDescrs

42+ Distribution.FieldGrammar.Parsec Distribution.FieldGrammar.Pretty

43+ Distribution.Fields Distribution.Fields.ConfVar

44+ Distribution.Fields.Field Distribution.Fields.Lexer

45+ Distribution.Fields.LexerMonad Distribution.Fields.ParseResult

46+ Distribution.Fields.Parser Distribution.Fields.Pretty

47+ Distribution.InstalledPackageInfo Distribution.License

48+ Distribution.Make Distribution.ModuleName Distribution.Package

49+ 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.Newtypes Distribution.Parsec.Position

59+ Distribution.Parsec.Warning Distribution.Pretty Distribution.ReadE

60+ Distribution.SPDX Distribution.SPDX.License

61+ Distribution.SPDX.LicenseExceptionId

62+ Distribution.SPDX.LicenseExpression Distribution.SPDX.LicenseId

63+ Distribution.SPDX.LicenseListVersion

64+ Distribution.SPDX.LicenseReference Distribution.Simple

65+ Distribution.Simple.Bench Distribution.Simple.Build

66+ Distribution.Simple.Build.Macros

67+ Distribution.Simple.Build.PathsModule

68+ Distribution.Simple.BuildPaths Distribution.Simple.BuildTarget

69+ Distribution.Simple.BuildToolDepends Distribution.Simple.CCompiler

70+ Distribution.Simple.Command Distribution.Simple.Compiler

71+ Distribution.Simple.Configure Distribution.Simple.Doctest

72+ Distribution.Simple.Flag Distribution.Simple.GHC

73+ Distribution.Simple.GHCJS Distribution.Simple.Glob

74+ Distribution.Simple.Haddock Distribution.Simple.HaskellSuite

75+ Distribution.Simple.Hpc Distribution.Simple.Install

76+ Distribution.Simple.InstallDirs

77+ Distribution.Simple.InstallDirs.Internal

78+ Distribution.Simple.LocalBuildInfo Distribution.Simple.PackageIndex

79+ Distribution.Simple.PreProcess Distribution.Simple.PreProcess.Unlit

80+ Distribution.Simple.Program Distribution.Simple.Program.Ar

81+ Distribution.Simple.Program.Builtin Distribution.Simple.Program.Db

82+ Distribution.Simple.Program.Find Distribution.Simple.Program.GHC

83+ Distribution.Simple.Program.HcPkg Distribution.Simple.Program.Hpc

84+ Distribution.Simple.Program.Internal Distribution.Simple.Program.Ld

85+ Distribution.Simple.Program.ResponseFile

86+ Distribution.Simple.Program.Run Distribution.Simple.Program.Script

87+ Distribution.Simple.Program.Strip Distribution.Simple.Program.Types

88+ Distribution.Simple.Register Distribution.Simple.Setup

89+ Distribution.Simple.ShowBuildInfo Distribution.Simple.SrcDist

90+ Distribution.Simple.Test Distribution.Simple.Test.ExeV10

91+ Distribution.Simple.Test.LibV09 Distribution.Simple.Test.Log

92+ Distribution.Simple.UHC Distribution.Simple.UserHooks

93+ Distribution.Simple.Utils Distribution.System

94+ Distribution.TestSuite Distribution.Text

95+ Distribution.Types.AbiDependency Distribution.Types.AbiHash

96+ Distribution.Types.AnnotatedId Distribution.Types.Benchmark

97+ Distribution.Types.Benchmark.Lens

98+ Distribution.Types.BenchmarkInterface

99+ Distribution.Types.BenchmarkType Distribution.Types.BuildInfo

100+ Distribution.Types.BuildInfo.Lens Distribution.Types.BuildType

101+ Distribution.Types.Component Distribution.Types.ComponentId

102+ Distribution.Types.ComponentInclude

103+ Distribution.Types.ComponentLocalBuildInfo

104+ Distribution.Types.ComponentName

105+ Distribution.Types.ComponentRequestedSpec

106+ Distribution.Types.CondTree Distribution.Types.Condition

107+ Distribution.Types.ConfVar Distribution.Types.Dependency

108+ Distribution.Types.DependencyMap Distribution.Types.ExeDependency

109+ Distribution.Types.Executable Distribution.Types.Executable.Lens

110+ Distribution.Types.ExecutableScope Distribution.Types.ExposedModule

111+ Distribution.Types.Flag Distribution.Types.ForeignLib

112+ Distribution.Types.ForeignLib.Lens

113+ Distribution.Types.ForeignLibOption

114+ Distribution.Types.ForeignLibType

115+ Distribution.Types.GenericPackageDescription

116+ Distribution.Types.GenericPackageDescription.Lens

117+ Distribution.Types.GivenComponent

118+ Distribution.Types.HookedBuildInfo

119+ Distribution.Types.IncludeRenaming

120+ Distribution.Types.InstalledPackageInfo

121+ Distribution.Types.InstalledPackageInfo.FieldGrammar

122+ Distribution.Types.InstalledPackageInfo.Lens

123+ Distribution.Types.LegacyExeDependency Distribution.Types.Lens

124+ Distribution.Types.Library Distribution.Types.Library.Lens

125+ Distribution.Types.LibraryName Distribution.Types.LibraryVisibility

126+ Distribution.Types.LocalBuildInfo Distribution.Types.Mixin

127+ Distribution.Types.Module Distribution.Types.ModuleReexport

128+ Distribution.Types.ModuleRenaming

129+ Distribution.Types.MungedPackageId

130+ Distribution.Types.MungedPackageName

131+ Distribution.Types.PackageDescription

132+ Distribution.Types.PackageDescription.Lens

133+ Distribution.Types.PackageId Distribution.Types.PackageId.Lens

134+ Distribution.Types.PackageName Distribution.Types.PackageName.Magic

135+ Distribution.Types.PackageVersionConstraint

136+ Distribution.Types.PkgconfigDependency

137+ Distribution.Types.PkgconfigName

138+ Distribution.Types.PkgconfigVersion

139+ Distribution.Types.PkgconfigVersionRange

140+ Distribution.Types.SetupBuildInfo

141+ Distribution.Types.SetupBuildInfo.Lens

142+ Distribution.Types.SourceRepo Distribution.Types.SourceRepo.Lens

143+ Distribution.Types.TargetInfo Distribution.Types.TestSuite

144+ Distribution.Types.TestSuite.Lens

145+ Distribution.Types.TestSuiteInterface Distribution.Types.TestType

146+ Distribution.Types.UnitId Distribution.Types.UnqualComponentName

147+ Distribution.Types.Version Distribution.Types.VersionInterval

148+ Distribution.Types.VersionRange

149+ Distribution.Types.VersionRange.Internal Distribution.Utils.Generic

150+ Distribution.Utils.IOData Distribution.Utils.LogProgress

151+ Distribution.Utils.MD5 Distribution.Utils.MapAccum

152+ Distribution.Utils.NubList Distribution.Utils.Progress

153+ Distribution.Utils.ShortText Distribution.Utils.Structured

154+ Distribution.Verbosity Distribution.Verbosity.Internal

155+ Distribution.Version 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.GHC.EnvironmentParser

166+ Distribution.Simple.GHC.Internal Distribution.Simple.GHC.ImplInfo

167+ Distribution.Simple.Utils.Json Paths_Cabal

168+import-dirs:

169+library-dirs:

170+dynamic-library-dirs:

171+data-dir:

172+hs-libraries: HSCabal-3.2.1.0

173+depends:

174+ array-0.5.4.0 base-4.14.3.0 binary-0.8.8.0 bytestring-0.10.12.0

175+ containers-0.6.5.1 deepseq-1.4.4.0 directory-1.3.6.0

176+ filepath-1.4.2.1 mtl-2.2.2 parsec-3.1.14.0 pretty-1.1.3.6

177+ process-1.6.13.2 text-1.2.4.1 time-1.9.3 transformers-0.5.6.2

178+ unix-2.7.2.2

179+haddock-interfaces:

180+haddock-html:

181+---

182+name: array

183+version: 0.5.4.0

184+visibility: public

185+id: array-0.5.4.0

186+key: array-0.5.4.0

187+license: BSD-3-Clause

188+maintainer: libraries@haskell.org

189+synopsis: Mutable and immutable arrays

190+description:

191+ In addition to providing the "Data.Array" module

192+ <http://www.haskell.org/onlinereport/haskell2010/haskellch14.html as specified in the Haskell 2010 Language Report>,

193+ this package also defines the classes 'IArray' of

194+ immutable arrays and 'MArray' of arrays mutable within appropriate

195+ monads, as well as some instances of these classes.

196+category: Data Structures

197+exposed: True

198+exposed-modules:

199+ Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO

200+ Data.Array.IO.Internals Data.Array.IO.Safe Data.Array.MArray

201+ Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe

202+ Data.Array.Storable Data.Array.Storable.Internals

203+ Data.Array.Storable.Safe Data.Array.Unboxed Data.Array.Unsafe

204+import-dirs:

205+library-dirs:

206+dynamic-library-dirs:

207+data-dir:

208+hs-libraries: HSarray-0.5.4.0

209+depends: base-4.14.3.0

210+haddock-interfaces:

211+haddock-html:

212+---

213+name: base

214+version: 4.14.3.0

215+visibility: public

216+id: base-4.14.3.0

217+key: base-4.14.3.0

218+license: BSD-3-Clause

219+maintainer: libraries@haskell.org

220+synopsis: Basic libraries

221+description:

222+ This package contains the Standard Haskell "Prelude" and its support libraries,

223+ and a large collection of useful libraries ranging from data

224+ structures to parsing combinators and debugging utilities.

225+category: Prelude

226+exposed: True

227+exposed-modules:

228+ Control.Applicative Control.Arrow Control.Category

229+ Control.Concurrent Control.Concurrent.Chan Control.Concurrent.MVar

230+ Control.Concurrent.QSem Control.Concurrent.QSemN Control.Exception

231+ Control.Exception.Base Control.Monad Control.Monad.Fail

232+ Control.Monad.Fix Control.Monad.IO.Class Control.Monad.Instances

233+ Control.Monad.ST Control.Monad.ST.Lazy Control.Monad.ST.Lazy.Safe

234+ Control.Monad.ST.Lazy.Unsafe Control.Monad.ST.Safe

235+ Control.Monad.ST.Strict Control.Monad.ST.Unsafe Control.Monad.Zip

236+ Data.Bifoldable Data.Bifunctor Data.Bitraversable Data.Bits

237+ Data.Bool Data.Char Data.Coerce Data.Complex Data.Data Data.Dynamic

238+ Data.Either Data.Eq Data.Fixed Data.Foldable Data.Function

239+ Data.Functor Data.Functor.Classes Data.Functor.Compose

240+ Data.Functor.Const Data.Functor.Contravariant Data.Functor.Identity

241+ Data.Functor.Product Data.Functor.Sum Data.IORef Data.Int Data.Ix

242+ Data.Kind Data.List Data.List.NonEmpty Data.Maybe Data.Monoid

243+ Data.Ord Data.Proxy Data.Ratio Data.STRef Data.STRef.Lazy

244+ Data.STRef.Strict Data.Semigroup Data.String Data.Traversable

245+ Data.Tuple Data.Type.Bool Data.Type.Coercion Data.Type.Equality

246+ Data.Typeable Data.Unique Data.Version Data.Void Data.Word

247+ Debug.Trace Foreign Foreign.C Foreign.C.Error Foreign.C.String

248+ Foreign.C.Types Foreign.Concurrent Foreign.ForeignPtr

249+ Foreign.ForeignPtr.Safe Foreign.ForeignPtr.Unsafe Foreign.Marshal

250+ Foreign.Marshal.Alloc Foreign.Marshal.Array Foreign.Marshal.Error

251+ Foreign.Marshal.Pool Foreign.Marshal.Safe Foreign.Marshal.Unsafe

252+ Foreign.Marshal.Utils Foreign.Ptr Foreign.Safe Foreign.StablePtr

253+ Foreign.Storable GHC.Arr GHC.Base GHC.ByteOrder GHC.Char GHC.Clock

254+ GHC.Conc GHC.Conc.IO GHC.Conc.Signal GHC.Conc.Sync

255+ GHC.ConsoleHandler GHC.Constants GHC.Desugar GHC.Enum

256+ GHC.Environment GHC.Err GHC.Event GHC.Exception GHC.Exception.Type

257+ GHC.ExecutionStack GHC.ExecutionStack.Internal GHC.Exts

258+ GHC.Fingerprint GHC.Fingerprint.Type GHC.Float

259+ GHC.Float.ConversionUtils GHC.Float.RealFracMethods GHC.Foreign

260+ GHC.ForeignPtr GHC.GHCi GHC.GHCi.Helpers GHC.Generics GHC.IO

261+ GHC.IO.Buffer GHC.IO.BufferedIO GHC.IO.Device GHC.IO.Encoding

262+ GHC.IO.Encoding.CodePage GHC.IO.Encoding.Failure

263+ GHC.IO.Encoding.Iconv GHC.IO.Encoding.Latin1 GHC.IO.Encoding.Types

264+ GHC.IO.Encoding.UTF16 GHC.IO.Encoding.UTF32 GHC.IO.Encoding.UTF8

265+ GHC.IO.Exception GHC.IO.FD GHC.IO.Handle GHC.IO.Handle.FD

266+ GHC.IO.Handle.Internals GHC.IO.Handle.Lock GHC.IO.Handle.Text

267+ GHC.IO.Handle.Types GHC.IO.IOMode GHC.IO.Unsafe GHC.IOArray

268+ GHC.IORef GHC.Int GHC.Ix GHC.List GHC.MVar GHC.Maybe GHC.Natural

269+ GHC.Num GHC.OldList GHC.OverloadedLabels GHC.Pack GHC.Profiling

270+ GHC.Ptr GHC.RTS.Flags GHC.Read GHC.Real GHC.Records

271+ GHC.ResponseFile GHC.ST GHC.STRef GHC.Show GHC.Stable

272+ GHC.StableName GHC.Stack GHC.Stack.CCS GHC.Stack.Types

273+ GHC.StaticPtr GHC.Stats GHC.Storable GHC.TopHandler GHC.TypeLits

274+ GHC.TypeNats GHC.Unicode GHC.Weak GHC.Word Numeric Numeric.Natural

275+ Prelude System.CPUTime System.Console.GetOpt System.Environment

276+ System.Environment.Blank System.Exit System.IO System.IO.Error

277+ System.IO.Unsafe System.Info System.Mem System.Mem.StableName

278+ System.Mem.Weak System.Posix.Internals System.Posix.Types

279+ System.Timeout Text.ParserCombinators.ReadP

280+ Text.ParserCombinators.ReadPrec Text.Printf Text.Read Text.Read.Lex

281+ Text.Show Text.Show.Functions Type.Reflection

282+ Type.Reflection.Unsafe Unsafe.Coerce

283+hidden-modules:

284+ Control.Monad.ST.Imp Control.Monad.ST.Lazy.Imp Data.Functor.Utils

285+ Data.OldList Data.Semigroup.Internal Data.Typeable.Internal

286+ Foreign.ForeignPtr.Imp GHC.IO.Handle.Lock.Common

287+ GHC.IO.Handle.Lock.Flock GHC.IO.Handle.Lock.LinuxOFD

288+ GHC.IO.Handle.Lock.NoOp GHC.IO.Handle.Lock.Windows

289+ GHC.StaticPtr.Internal System.Environment.ExecutablePath

290+ System.CPUTime.Utils GHC.Event.Arr GHC.Event.Array

291+ GHC.Event.Control GHC.Event.EPoll GHC.Event.IntTable

292+ GHC.Event.Internal GHC.Event.KQueue GHC.Event.Manager GHC.Event.PSQ

293+ GHC.Event.Poll GHC.Event.Thread GHC.Event.TimerManager

294+ GHC.Event.Unique System.CPUTime.Posix.ClockGetTime

295+ System.CPUTime.Posix.Times System.CPUTime.Posix.RUsage

296+ System.CPUTime.Unsupported

297+import-dirs:

298+library-dirs:

299+dynamic-library-dirs:

300+data-dir:

301+hs-libraries: HSbase-4.14.3.0

302+include-dirs:

303+includes: HsBase.h

304+depends: ghc-prim-0.6.1 integer-gmp-1.0.3.0 rts

305+haddock-interfaces:

306+haddock-html:

307+---

308+name: binary

309+version: 0.8.8.0

310+visibility: public

311+id: binary-0.8.8.0

312+key: binary-0.8.8.0

313+license: BSD-3-Clause

314+maintainer: Lennart Kolmodin, Don Stewart <dons00@gmail.com>

315+author: Lennart Kolmodin <kolmodin@gmail.com>

316+stability: provisional

317+homepage: https://github.com/kolmodin/binary

318+synopsis:

319+ Binary serialisation for Haskell values using lazy ByteStrings

320+description:

321+ Efficient, pure binary serialisation using lazy ByteStrings.

322+ Haskell values may be encoded to and from binary formats,

323+ written to disk as binary, or sent over the network.

324+ The format used can be automatically generated, or

325+ you can choose to implement a custom format if needed.

326+ Serialisation speeds of over 1 G\/sec have been observed,

327+ so this library should be suitable for high performance

328+ scenarios.

329+category: Data, Parsing

330+exposed: True

331+exposed-modules:

332+ Data.Binary Data.Binary.Builder Data.Binary.Get

333+ Data.Binary.Get.Internal Data.Binary.Put

334+hidden-modules:

335+ Data.Binary.Class Data.Binary.Internal Data.Binary.Generic

336+ Data.Binary.FloatCast

337+import-dirs:

338+library-dirs:

339+dynamic-library-dirs:

340+data-dir:

341+hs-libraries: HSbinary-0.8.8.0

342+depends:

343+ array-0.5.4.0 base-4.14.3.0 bytestring-0.10.12.0 containers-0.6.5.1

344+haddock-interfaces:

345+haddock-html:

346+---

347+name: bytestring

348+version: 0.10.12.0

349+visibility: public

350+id: bytestring-0.10.12.0

351+key: bytestring-0.10.12.0

352+license: BSD-3-Clause

353+copyright:

354+ Copyright (c) Don Stewart 2005-2009,

355+ (c) Duncan Coutts 2006-2015,

356+ (c) David Roundy 2003-2005,

357+ (c) Jasper Van der Jeugt 2010,

358+ (c) Simon Meier 2010-2013.

359+maintainer: Duncan Coutts <duncan@community.haskell.org>

360+author:

361+ Don Stewart,

362+ Duncan Coutts

363+homepage: https://github.com/haskell/bytestring

364+synopsis:

365+ Fast, compact, strict and lazy byte strings with a list interface

366+description:

367+ An efficient compact, immutable byte string type (both strict and lazy)

368+ suitable for binary or 8-bit character data.

369+ The 'ByteString' type represents sequences of bytes or 8-bit characters.

370+ It is suitable for high performance use, both in terms of large data

371+ quantities, or high speed requirements. The 'ByteString' functions follow

372+ the same style as Haskell\'s ordinary lists, so it is easy to convert code

373+ from using 'String' to 'ByteString'.

374+ Two 'ByteString' variants are provided:

375+ * Strict 'ByteString's keep the string as a single large array. This

376+ makes them convenient for passing data between C and Haskell.

377+ * Lazy 'ByteString's use a lazy list of strict chunks which makes it

378+ suitable for I\/O streaming tasks.

379+ The @Char8@ modules provide a character-based view of the same

380+ underlying 'ByteString' types. This makes it convenient to handle mixed

381+ binary and 8-bit character content (which is common in many file formats

382+ and network protocols).

383+ The 'Builder' module provides an efficient way to build up 'ByteString's

384+ in an ad-hoc way by repeated concatenation. This is ideal for fast

385+ serialisation or pretty printing.

386+ There is also a 'ShortByteString' type which has a lower memory overhead

387+ and can can be converted to or from a 'ByteString', but supports very few

388+ other operations. It is suitable for keeping many short strings in memory.

389+ 'ByteString's are not designed for Unicode. For Unicode strings you should

390+ use the 'Text' type from the @text@ package.

391+ These modules are intended to be imported qualified, to avoid name clashes

392+ with "Prelude" functions, e.g.

393+ > import qualified Data.ByteString as BS

394+category: Data

395+exposed: True

396+exposed-modules:

397+ Data.ByteString Data.ByteString.Builder

398+ Data.ByteString.Builder.Extra Data.ByteString.Builder.Internal

399+ Data.ByteString.Builder.Prim Data.ByteString.Builder.Prim.Internal

400+ Data.ByteString.Char8 Data.ByteString.Internal Data.ByteString.Lazy

401+ Data.ByteString.Lazy.Builder Data.ByteString.Lazy.Builder.ASCII

402+ Data.ByteString.Lazy.Builder.Extras Data.ByteString.Lazy.Char8

403+ Data.ByteString.Lazy.Internal Data.ByteString.Short

404+ Data.ByteString.Short.Internal Data.ByteString.Unsafe

405+hidden-modules:

406+ Data.ByteString.Builder.ASCII Data.ByteString.Builder.Prim.Binary

407+ Data.ByteString.Builder.Prim.ASCII

408+ Data.ByteString.Builder.Prim.Internal.Floating

409+ Data.ByteString.Builder.Prim.Internal.UncheckedShifts

410+ Data.ByteString.Builder.Prim.Internal.Base16

411+import-dirs:

412+library-dirs:

413+dynamic-library-dirs:

414+data-dir:

415+hs-libraries: HSbytestring-0.10.12.0

416+include-dirs:

417+includes: fpstring.h

418+depends:

419+ base-4.14.3.0 deepseq-1.4.4.0 ghc-prim-0.6.1 integer-gmp-1.0.3.0

420+haddock-interfaces:

421+haddock-html:

422+---

423+name: containers

424+version: 0.6.5.1

425+visibility: public

426+id: containers-0.6.5.1

427+key: containers-0.6.5.1

428+license: BSD-3-Clause

429+maintainer: libraries@haskell.org

430+synopsis: Assorted concrete container types

431+description:

432+ This package contains efficient general-purpose implementations

433+ of various immutable container types including sets, maps, sequences,

434+ trees, and graphs.

435+ For a walkthrough of what this package provides with examples of common

436+ operations see the [containers

437+ introduction](https://haskell-containers.readthedocs.io).

438+ The declared cost of each operation is either worst-case or amortized, but

439+ remains valid even if structures are shared.

440+category: Data Structures

441+exposed: True

442+exposed-modules:

443+ Data.Containers.ListUtils Data.Graph Data.IntMap

444+ Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy

445+ Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict

446+ Data.IntMap.Strict.Internal Data.IntSet Data.IntSet.Internal

447+ Data.Map Data.Map.Internal Data.Map.Internal.Debug Data.Map.Lazy

448+ Data.Map.Merge.Lazy Data.Map.Merge.Strict Data.Map.Strict

449+ Data.Map.Strict.Internal Data.Sequence Data.Sequence.Internal

450+ Data.Sequence.Internal.Sorting Data.Set Data.Set.Internal Data.Tree

451+ Utils.Containers.Internal.BitQueue

452+ Utils.Containers.Internal.BitUtil

453+ Utils.Containers.Internal.StrictPair

454+hidden-modules:

455+ Utils.Containers.Internal.State

456+ Utils.Containers.Internal.StrictMaybe

457+ Utils.Containers.Internal.PtrEquality

458+ Utils.Containers.Internal.Coercions

459+ Utils.Containers.Internal.TypeError

460+ Data.Map.Internal.DeprecatedShowTree

461+ Data.IntMap.Internal.DeprecatedDebug

462+import-dirs:

463+library-dirs:

464+dynamic-library-dirs:

465+data-dir:

466+hs-libraries: HScontainers-0.6.5.1

467+depends: array-0.5.4.0 base-4.14.3.0 deepseq-1.4.4.0

468+haddock-interfaces:

469+haddock-html:

470+---

471+name: deepseq

472+version: 1.4.4.0

473+visibility: public

474+id: deepseq-1.4.4.0

475+key: deepseq-1.4.4.0

476+license: BSD-3-Clause

477+maintainer: libraries@haskell.org

478+synopsis: Deep evaluation of data structures

479+description:

480+ This package provides methods for fully evaluating data structures

481+ (\"deep evaluation\"). Deep evaluation is often used for adding

482+ strictness to a program, e.g. in order to force pending exceptions,

483+ remove space leaks, or force lazy I/O to happen. It is also useful

484+ in parallel programs, to ensure pending work does not migrate to the

485+ wrong thread.

486+ The primary use of this package is via the 'deepseq' function, a

487+ \"deep\" version of 'seq'. It is implemented on top of an 'NFData'

488+ typeclass (\"Normal Form Data\", data structures with no unevaluated

489+ components) which defines strategies for fully evaluating different

490+ data types. See module documentation in "Control.DeepSeq" for more

491+ details.

492+category: Control

493+exposed: True

494+exposed-modules: Control.DeepSeq

495+hidden-modules: Control.DeepSeq.BackDoor

496+import-dirs:

497+library-dirs:

498+dynamic-library-dirs:

499+data-dir:

500+hs-libraries: HSdeepseq-1.4.4.0

501+depends: array-0.5.4.0 base-4.14.3.0

502+haddock-interfaces:

503+haddock-html:

504+---

505+name: directory

506+version: 1.3.6.0

507+visibility: public

508+id: directory-1.3.6.0

509+key: directory-1.3.6.0

510+license: BSD-3-Clause

511+maintainer: libraries@haskell.org

512+synopsis: Platform-agnostic library for filesystem operations

513+description:

514+ This library provides a basic set of operations for manipulating files and

515+ directories in a portable way.

516+category: System

517+exposed: True

518+exposed-modules:

519+ System.Directory System.Directory.Internal

520+ System.Directory.Internal.Prelude

521+hidden-modules:

522+ System.Directory.Internal.C_utimensat

523+ System.Directory.Internal.Common System.Directory.Internal.Config

524+ System.Directory.Internal.Posix System.Directory.Internal.Windows

525+import-dirs:

526+library-dirs:

527+dynamic-library-dirs:

528+data-dir:

529+hs-libraries: HSdirectory-1.3.6.0

530+depends:

531+ base-4.14.3.0 filepath-1.4.2.1 time-1.9.3 unix-2.7.2.2

532+haddock-interfaces:

533+haddock-html:

534+---

535+name: exceptions

536+version: 0.10.4

537+visibility: public

538+id: exceptions-0.10.4

539+key: exceptions-0.10.4

540+license: BSD-3-Clause

541+copyright:

542+ Copyright (C) 2013-2015 Edward A. Kmett

543+ Copyright (C) 2012 Google Inc.

544+maintainer: Edward A. Kmett <ekmett@gmail.com>

545+author: Edward A. Kmett

546+stability: provisional

547+homepage: http://github.com/ekmett/exceptions/

548+synopsis: Extensible optionally-pure exceptions

549+description: Extensible optionally-pure exceptions.

550+category: Control, Exceptions, Monad

551+exposed: True

552+exposed-modules: Control.Monad.Catch Control.Monad.Catch.Pure

553+import-dirs:

554+library-dirs:

555+dynamic-library-dirs:

556+data-dir:

557+hs-libraries: HSexceptions-0.10.4

558+depends:

559+ base-4.14.3.0 mtl-2.2.2 stm-2.5.0.1 template-haskell-2.16.0.0

560+ transformers-0.5.6.2

561+haddock-interfaces:

562+haddock-html:

563+---

564+name: filepath

565+version: 1.4.2.1

566+visibility: public

567+id: filepath-1.4.2.1

568+key: filepath-1.4.2.1

569+license: BSD-3-Clause

570+copyright: Neil Mitchell 2005-2018

571+maintainer: Neil Mitchell <ndmitchell@gmail.com>

572+author: Neil Mitchell <ndmitchell@gmail.com>

573+homepage: https://github.com/haskell/filepath#readme

574+synopsis: Library for manipulating FilePaths in a cross platform way.

575+description:

576+ 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:

577+ * "System.FilePath.Posix" manipulates POSIX\/Linux style @FilePath@ values (with @\/@ as the path separator).

578+ * "System.FilePath.Windows" manipulates Windows style @FilePath@ values (with either @\\@ or @\/@ as the path separator, and deals with drives).

579+ * "System.FilePath" is an alias for the module appropriate to your platform.

580+ All three modules provide the same API, and the same documentation (calling out differences in the different variants).

581+category: System

582+exposed: True

583+exposed-modules:

584+ System.FilePath System.FilePath.Posix System.FilePath.Windows

585+import-dirs:

586+library-dirs:

587+dynamic-library-dirs:

588+data-dir:

589+hs-libraries: HSfilepath-1.4.2.1

590+depends: base-4.14.3.0

591+haddock-interfaces:

592+haddock-html:

593+---

594+name: ghc

595+version: 8.10.7

596+visibility: public

597+id: ghc-8.10.7

598+key: ghc-8.10.7

599+license: BSD-3-Clause

600+maintainer: glasgow-haskell-users@haskell.org

601+author: The GHC Team

602+homepage: http://www.haskell.org/ghc/

603+synopsis: The GHC API

604+description:

605+ GHC's functionality can be useful for more things than just

606+ compiling Haskell programs. Important use cases are programs

607+ that analyse (and perhaps transform) Haskell code. Others

608+ include loading Haskell code dynamically in a GHCi-like manner.

609+ For this reason, a lot of GHC's functionality is made available

610+ through this package.

611+category: Development

612+exposed-modules:

613+ Annotations ApiAnnotation Ar AsmCodeGen AsmUtils Avail Bag

614+ BasicTypes BinFingerprint BinIface Binary Bitmap BkpSyn BlockId

615+ BlockLayout BooleanFormula BufWrite BuildTyCl ByteCodeAsm

616+ ByteCodeGen ByteCodeInstr ByteCodeItbls ByteCodeLink ByteCodeTypes

617+ CFG CLabel CPrim CSE CallArity Class CliOption ClsInst

618+ CmdLineParser Cmm CmmBuildInfoTables CmmCallConv CmmCommonBlockElim

619+ CmmContFlowOpt CmmExpr CmmImplementSwitchPlans CmmInfo

620+ CmmLayoutStack CmmLex CmmLint CmmLive CmmMachOp CmmMonad CmmNode

621+ CmmOpt CmmParse CmmPipeline CmmProcPoint CmmSink CmmSwitch CmmType

622+ CmmUtils CoAxiom CodeOutput Coercion ConLike Config Constants

623+ Constraint CoreArity CoreFVs CoreLint CoreMap CoreMonad CoreOpt

624+ CorePrep CoreSeq CoreStats CoreSubst CoreSyn CoreTidy CoreToStg

625+ CoreUnfold CoreUtils CostCentre CostCentreState Coverage Ctype

626+ DataCon Debug Debugger Demand Desugar Digraph DmdAnal Dominators

627+ DriverBkp DriverMkDepend DriverPhases DriverPipeline DsArrows

628+ DsBinds DsCCall DsExpr DsForeign DsGRHSs DsListComp DsMeta DsMonad

629+ DsUsage DsUtils Dwarf Dwarf.Constants Dwarf.Types DynFlags

630+ DynamicLoading Elf Encoding EnumSet ErrUtils Exception Exitify

631+ ExtractDocs FV FamInst FamInstEnv FastFunctions FastMutInt

632+ FastString FastStringEnv FieldLabel FileCleanup FileSettings Finder

633+ Fingerprint FiniteMap FlagChecker FloatIn FloatOut ForeignCall

634+ Format FunDeps GHC GHC.Hs GHC.Hs.Binds GHC.Hs.Decls GHC.Hs.Doc

635+ GHC.Hs.Dump GHC.Hs.Expr GHC.Hs.Extension GHC.Hs.ImpExp

636+ GHC.Hs.Instances GHC.Hs.Lit GHC.Hs.Pat GHC.Hs.PlaceHolder

637+ GHC.Hs.Types GHC.Hs.Utils GHC.HsToCore.PmCheck

638+ GHC.HsToCore.PmCheck.Oracle GHC.HsToCore.PmCheck.Ppr

639+ GHC.HsToCore.PmCheck.Types GHC.Platform.AArch64 GHC.Platform.ARM

640+ GHC.Platform.NoRegs GHC.Platform.PPC GHC.Platform.Regs

641+ GHC.Platform.S390X GHC.Platform.SPARC GHC.Platform.X86

642+ GHC.Platform.X86_64 GHC.StgToCmm GHC.StgToCmm.ArgRep

643+ GHC.StgToCmm.Bind GHC.StgToCmm.CgUtils GHC.StgToCmm.Closure

644+ GHC.StgToCmm.DataCon GHC.StgToCmm.Env GHC.StgToCmm.Expr

645+ GHC.StgToCmm.ExtCode GHC.StgToCmm.Foreign GHC.StgToCmm.Heap

646+ GHC.StgToCmm.Hpc GHC.StgToCmm.Layout GHC.StgToCmm.Monad

647+ GHC.StgToCmm.Prim GHC.StgToCmm.Prof GHC.StgToCmm.Ticky

648+ GHC.StgToCmm.Utils GHC.ThToHs GHCi GhcMake GhcMonad GhcNameVersion

649+ GhcPlugins GhcPrelude GraphBase GraphColor GraphOps GraphPpr

650+ HaddockUtils HeaderInfo HieAst HieBin HieDebug HieTypes HieUtils

651+ Hooks Hoopl.Block Hoopl.Collections Hoopl.Dataflow Hoopl.Graph

652+ Hoopl.Label HscMain HscStats HscTypes IOEnv Id IdInfo IfaceEnv

653+ IfaceSyn IfaceType Inst InstEnv Instruction InteractiveEval

654+ InteractiveEvalTypes Json KnownUniques Lexeme Lexer LiberateCase

655+ Linker LinkerTypes ListSetOps Literal Llvm Llvm.AbsSyn

656+ Llvm.MetaData Llvm.PpLlvm Llvm.Types LlvmCodeGen LlvmCodeGen.Base

657+ LlvmCodeGen.CodeGen LlvmCodeGen.Data LlvmCodeGen.Ppr

658+ LlvmCodeGen.Regs LlvmMangler LoadIface Match MatchCon MatchLit

659+ Maybes MkCore MkGraph MkId MkIface Module MonadUtils NCGMonad Name

660+ NameCache NameEnv NameSet NameShape OccName OccurAnal OptCoercion

661+ OrdList Outputable PIC PPC.CodeGen PPC.Cond PPC.Instr PPC.Ppr

662+ PPC.RegInfo PPC.Regs PackageConfig Packages Pair Panic Parser

663+ PatSyn PipelineMonad PlainPanic PlatformConstants Plugins PprBase

664+ PprC PprCmm PprCmmDecl PprCmmExpr PprColour PprCore PprTyThing

665+ Predicate PrelInfo PrelNames PrelRules Pretty PrimOp ProfInit

666+ RdrHsSyn RdrName Reg RegAlloc.Graph.ArchBase RegAlloc.Graph.ArchX86

667+ RegAlloc.Graph.Coalesce RegAlloc.Graph.Main RegAlloc.Graph.Spill

668+ RegAlloc.Graph.SpillClean RegAlloc.Graph.SpillCost

669+ RegAlloc.Graph.Stats RegAlloc.Graph.TrivColorable

670+ RegAlloc.Linear.Base RegAlloc.Linear.FreeRegs

671+ RegAlloc.Linear.JoinToTargets RegAlloc.Linear.Main

672+ RegAlloc.Linear.PPC.FreeRegs RegAlloc.Linear.SPARC.FreeRegs

673+ RegAlloc.Linear.StackMap RegAlloc.Linear.State

674+ RegAlloc.Linear.Stats RegAlloc.Linear.X86.FreeRegs

675+ RegAlloc.Linear.X86_64.FreeRegs RegAlloc.Liveness RegClass RepType

676+ RnBinds RnEnv RnExpr RnFixity RnHsDoc RnModIface RnNames RnPat

677+ RnSource RnSplice RnTypes RnUnbound RnUtils RtClosureInspect Rules

678+ SAT SMRep SPARC.AddrMode SPARC.Base SPARC.CodeGen

679+ SPARC.CodeGen.Amode SPARC.CodeGen.Base SPARC.CodeGen.CondCode

680+ SPARC.CodeGen.Expand SPARC.CodeGen.Gen32 SPARC.CodeGen.Gen64

681+ SPARC.CodeGen.Sanity SPARC.Cond SPARC.Imm SPARC.Instr SPARC.Ppr

682+ SPARC.Regs SPARC.ShortcutJump SPARC.Stack SetLevels Settings

683+ SimplCore SimplEnv SimplMonad SimplStg SimplUtils Simplify

684+ SpecConstr Specialise SrcLoc State StaticPtrTable StgCse StgFVs

685+ StgLiftLams StgLiftLams.Analysis StgLiftLams.LiftM

686+ StgLiftLams.Transformation StgLint StgStats StgSubst StgSyn Stream

687+ StringBuffer SysTools SysTools.BaseDir SysTools.ExtraObj

688+ SysTools.Info SysTools.Process SysTools.Settings SysTools.Tasks

689+ SysTools.Terminal THNames TargetReg TcAnnotations TcArrows

690+ TcBackpack TcBinds TcCanonical TcClassDcl TcDefaults TcDeriv

691+ TcDerivInfer TcDerivUtils TcEnv TcErrors TcEvTerm TcEvidence TcExpr

692+ TcFlatten TcForeign TcGenDeriv TcGenFunctor TcGenGenerics

693+ TcHoleErrors TcHoleFitTypes TcHsSyn TcHsType TcIface TcInstDcls

694+ TcInteract TcMType TcMatches TcOrigin TcPat TcPatSyn TcPluginM

695+ TcRnDriver TcRnExports TcRnMonad TcRnTypes TcRules TcSMonad TcSigs

696+ TcSimplify TcSplice TcTyClsDecls TcTyDecls TcType TcTypeNats

697+ TcTypeable TcUnify TcValidity TidyPgm ToIface ToolSettings TrieMap

698+ TyCoFVs TyCoPpr TyCoRep TyCoSubst TyCoTidy TyCon Type TysPrim

699+ TysWiredIn UnVarGraph UnariseStg Unify UniqDFM UniqDSet UniqFM

700+ UniqMap UniqSet UniqSupply Unique Util Var VarEnv VarSet WorkWrap

701+ WwLib X86.CodeGen X86.Cond X86.Instr X86.Ppr X86.RegInfo X86.Regs

702+import-dirs:

703+library-dirs:

704+dynamic-library-dirs:

705+data-dir:

706+hs-libraries: HSghc-8.10.7

707+include-dirs:

708+depends:

709+ array-0.5.4.0 base-4.14.3.0 binary-0.8.8.0 bytestring-0.10.12.0

710+ containers-0.6.5.1 deepseq-1.4.4.0 directory-1.3.6.0

711+ filepath-1.4.2.1 ghc-boot-8.10.7 ghc-boot-th-8.10.7 ghc-heap-8.10.7

712+ ghci-8.10.7 hpc-0.6.1.0 integer-gmp-1.0.3.0 process-1.6.13.2

713+ template-haskell-2.16.0.0 terminfo-0.4.1.4 time-1.9.3

714+ transformers-0.5.6.2 unix-2.7.2.2

715+haddock-interfaces:

716+haddock-html:

717+---

718+name: ghc-boot

719+version: 8.10.7

720+visibility: public

721+id: ghc-boot-8.10.7

722+key: ghc-boot-8.10.7

723+license: BSD-3-Clause

724+maintainer: ghc-devs@haskell.org

725+synopsis: Shared functionality between GHC and its boot libraries

726+description:

727+ This library is shared between GHC, ghc-pkg, and other boot

728+ libraries.

729+ A note about "GHC.PackageDb": it only deals with the subset of

730+ the package database that the compiler cares about: modules

731+ paths etc and not package metadata like description, authors

732+ etc. It is thus not a library interface to ghc-pkg and is *not*

733+ suitable for modifying GHC package databases.

734+ The package database format and this library are constructed in

735+ such a way that while ghc-pkg depends on Cabal, the GHC library

736+ and program do not have to depend on Cabal.

737+category: GHC

738+exposed: True

739+exposed-modules:

740+ GHC.BaseDir GHC.ForeignSrcLang GHC.HandleEncoding

741+ GHC.LanguageExtensions GHC.PackageDb GHC.Platform GHC.Platform.Host

742+ GHC.Serialized GHC.Settings GHC.UniqueSubdir GHC.Version

743+import-dirs:

744+library-dirs:

745+dynamic-library-dirs:

746+data-dir:

747+hs-libraries: HSghc-boot-8.10.7

748+depends:

749+ base-4.14.3.0 binary-0.8.8.0 bytestring-0.10.12.0

750+ containers-0.6.5.1 directory-1.3.6.0 filepath-1.4.2.1

751+ ghc-boot-th-8.10.7

752+haddock-interfaces:

753+haddock-html:

754+---

755+name: ghc-boot-th

756+version: 8.10.7

757+visibility: public

758+id: ghc-boot-th-8.10.7

759+key: ghc-boot-th-8.10.7

760+license: BSD-3-Clause

761+maintainer: ghc-devs@haskell.org

762+synopsis:

763+ Shared functionality between GHC and the @template-haskell@

764+ library

765+description:

766+ This library contains various bits shared between the @ghc@ and

767+ @template-haskell@ libraries.

768+ This package exists to ensure that @template-haskell@ has a

769+ minimal set of transitive dependencies, since it is intended to

770+ be depended upon by user code.

771+category: GHC

772+exposed: True

773+exposed-modules:

774+ GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme

775+import-dirs:

776+library-dirs:

777+dynamic-library-dirs:

778+data-dir:

779+hs-libraries: HSghc-boot-th-8.10.7

780+depends: base-4.14.3.0

781+haddock-interfaces:

782+haddock-html:

783+---

784+name: ghc-compact

785+version: 0.1.0.0

786+visibility: public

787+id: ghc-compact-0.1.0.0

788+key: ghc-compact-0.1.0.0

789+license: BSD-3-Clause

790+maintainer: libraries@haskell.org

791+synopsis: In memory storage of deeply evaluated data structure

792+description:

793+ This package provides minimal functionality for working with

794+ "compact regions", which hold a fully evaluated Haskell object graph.

795+ These regions maintain the invariant that no pointers live inside the struct

796+ that point outside it, which ensures efficient garbage collection without

797+ ever reading the structure contents (effectively, it works as a manually

798+ managed "oldest generation" which is never freed until the whole is

799+ released).

800+ Internally, the struct is stored a single contiguous block of memory,

801+ which allows efficient serialization and deserialization of structs

802+ for distributed computing.

803+category: Data

804+exposed: True

805+exposed-modules: GHC.Compact GHC.Compact.Serialized

806+import-dirs:

807+library-dirs:

808+dynamic-library-dirs:

809+data-dir:

810+hs-libraries: HSghc-compact-0.1.0.0

811+depends: base-4.14.3.0 bytestring-0.10.12.0 ghc-prim-0.6.1

812+haddock-interfaces:

813+haddock-html:

814+---

815+name: ghc-heap

816+version: 8.10.7

817+visibility: public

818+id: ghc-heap-8.10.7

819+key: ghc-heap-8.10.7

820+license: BSD-3-Clause

821+maintainer: libraries@haskell.org

822+synopsis: Functions for walking GHC's heap

823+description:

824+ This package provides functions for walking the GHC heap data structures

825+ and retrieving information about those data structures.

826+category: GHC

827+exposed: True

828+exposed-modules:

829+ GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures

830+ GHC.Exts.Heap.Constants GHC.Exts.Heap.InfoTable

831+ GHC.Exts.Heap.InfoTable.Types GHC.Exts.Heap.InfoTableProf

832+ GHC.Exts.Heap.Utils

833+import-dirs:

834+library-dirs:

835+dynamic-library-dirs:

836+data-dir:

837+hs-libraries: HSghc-heap-8.10.7

838+depends: base-4.14.3.0 ghc-prim-0.6.1 rts

839+haddock-interfaces:

840+haddock-html:

841+---

842+name: ghc-prim

843+version: 0.6.1

844+visibility: public

845+id: ghc-prim-0.6.1

846+key: ghc-prim-0.6.1

847+license: BSD-3-Clause

848+maintainer: libraries@haskell.org

849+synopsis: GHC primitives

850+description:

851+ This package contains the primitive types and operations supplied by GHC.

852+category: GHC

853+exposed: True

854+exposed-modules:

855+ GHC.CString GHC.Classes GHC.Debug GHC.IntWord64 GHC.Magic

856+ GHC.Prim.Ext GHC.PrimopWrappers GHC.Tuple GHC.Types GHC.Prim

857+import-dirs:

858+library-dirs:

859+dynamic-library-dirs:

860+data-dir:

861+hs-libraries: HSghc-prim-0.6.1

862+extra-libraries: gcc c m

863+depends: rts

864+haddock-interfaces:

865+haddock-html:

866+---

867+name: ghci

868+version: 8.10.7

869+visibility: public

870+id: ghci-8.10.7

871+key: ghci-8.10.7

872+license: BSD-3-Clause

873+maintainer: ghc-devs@haskell.org

874+synopsis: The library supporting GHC's interactive interpreter

875+description:

876+ This library offers interfaces which mediate interactions between the

877+ @ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter

878+ backend.

879+category: GHC

880+exposed: True

881+exposed-modules:

882+ GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI

883+ GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes

884+ GHCi.ResolvedBCO GHCi.Run GHCi.Signals GHCi.StaticPtrTable GHCi.TH

885+ GHCi.TH.Binary SizedSeq

886+import-dirs:

887+library-dirs:

888+dynamic-library-dirs:

889+data-dir:

890+hs-libraries: HSghci-8.10.7

891+include-dirs:

892+depends:

893+ array-0.5.4.0 base-4.14.3.0 binary-0.8.8.0 bytestring-0.10.12.0

894+ containers-0.6.5.1 deepseq-1.4.4.0 filepath-1.4.2.1 ghc-boot-8.10.7

895+ ghc-boot-th-8.10.7 ghc-heap-8.10.7 rts template-haskell-2.16.0.0

896+ transformers-0.5.6.2 unix-2.7.2.2

897+haddock-interfaces:

898+haddock-html:

899+---

900+name: haskeline

901+version: 0.8.2

902+visibility: public

903+id: haskeline-0.8.2

904+key: haskeline-0.8.2

905+license: BSD-3-Clause

906+copyright: (c) Judah Jacobson

907+maintainer: Judah Jacobson <judah.jacobson@gmail.com>

908+author: Judah Jacobson

909+stability: Stable

910+homepage: https://github.com/judah/haskeline

911+synopsis:

912+ A command-line interface for user input, written in Haskell.

913+description:

914+ Haskeline provides a user interface for line input in command-line

915+ programs. This library is similar in purpose to readline, but since

916+ it is written in Haskell it is (hopefully) more easily used in other

917+ Haskell programs.

918+ Haskeline runs both on POSIX-compatible systems and on Windows.

919+category: User Interfaces

920+exposed: True

921+exposed-modules:

922+ System.Console.Haskeline System.Console.Haskeline.Completion

923+ System.Console.Haskeline.History System.Console.Haskeline.IO

924+ System.Console.Haskeline.Internal

925+hidden-modules:

926+ System.Console.Haskeline.Backend

927+ System.Console.Haskeline.Backend.WCWidth

928+ System.Console.Haskeline.Command

929+ System.Console.Haskeline.Command.Completion

930+ System.Console.Haskeline.Command.History

931+ System.Console.Haskeline.Command.KillRing

932+ System.Console.Haskeline.Directory System.Console.Haskeline.Emacs

933+ System.Console.Haskeline.InputT System.Console.Haskeline.Key

934+ System.Console.Haskeline.LineState System.Console.Haskeline.Monads

935+ System.Console.Haskeline.Prefs System.Console.Haskeline.Recover

936+ System.Console.Haskeline.RunCommand System.Console.Haskeline.Term

937+ System.Console.Haskeline.Command.Undo System.Console.Haskeline.Vi

938+ System.Console.Haskeline.Backend.Posix

939+ System.Console.Haskeline.Backend.Posix.Encoder

940+ System.Console.Haskeline.Backend.DumbTerm

941+ System.Console.Haskeline.Backend.Terminfo

942+import-dirs:

943+library-dirs:

944+dynamic-library-dirs:

945+data-dir:

946+hs-libraries: HShaskeline-0.8.2

947+depends:

948+ base-4.14.3.0 bytestring-0.10.12.0 containers-0.6.5.1

949+ directory-1.3.6.0 exceptions-0.10.4 filepath-1.4.2.1

950+ process-1.6.13.2 stm-2.5.0.1 terminfo-0.4.1.4 transformers-0.5.6.2

951+ unix-2.7.2.2

952+haddock-interfaces:

953+haddock-html:

954+---

955+name: hpc

956+version: 0.6.1.0

957+visibility: public

958+id: hpc-0.6.1.0

959+key: hpc-0.6.1.0

960+license: BSD-3-Clause

961+maintainer: ghc-devs@haskell.org

962+author: Andy Gill

963+synopsis: Code Coverage Library for Haskell

964+description:

965+ This package provides the code coverage library for Haskell.

966+ See <http://www.haskell.org/haskellwiki/Haskell_program_coverage> for more

967+ information.

968+category: Control

969+exposed: True

970+exposed-modules:

971+ Trace.Hpc.Mix Trace.Hpc.Reflect Trace.Hpc.Tix Trace.Hpc.Util

972+import-dirs:

973+library-dirs:

974+dynamic-library-dirs:

975+data-dir:

976+hs-libraries: HShpc-0.6.1.0

977+depends:

978+ base-4.14.3.0 containers-0.6.5.1 deepseq-1.4.4.0 directory-1.3.6.0

979+ filepath-1.4.2.1 time-1.9.3

980+haddock-interfaces:

981+haddock-html:

982+---

983+name: integer-gmp

984+version: 1.0.3.0

985+visibility: public

986+id: integer-gmp-1.0.3.0

987+key: integer-gmp-1.0.3.0

988+license: BSD-3-Clause

989+maintainer: hvr@gnu.org

990+author: Herbert Valerio Riedel

991+synopsis: Integer library based on GMP

992+description:

993+ This package provides the low-level implementation of the standard

994+ 'Integer' type based on the

995+ <http://gmplib.org/ GNU Multiple Precision Arithmetic Library (GMP)>.

996+ This package provides access to the internal representation of

997+ 'Integer' as well as primitive operations with no proper error

998+ handling, and should only be used directly with the utmost care.

999+category: Numeric, Algebra

1000+exposed: True

1001+exposed-modules:

1002+ GHC.Integer GHC.Integer.GMP.Internals GHC.Integer.Logarithms

1003+ GHC.Integer.Logarithms.Internals

1004+hidden-modules: GHC.Integer.Type

1005+import-dirs:

1006+library-dirs:

1007+dynamic-library-dirs:

1008+data-dir:

1009+hs-libraries: HSinteger-gmp-1.0.3.0

1010+extra-libraries: gmp

1011+include-dirs:

1012+depends: ghc-prim-0.6.1

1013+haddock-interfaces:

1014+haddock-html:

1015+---

1016+name: libiserv

1017+version: 8.10.7

1018+visibility: public

1019+id: libiserv-8.10.7

1020+key: libiserv-8.10.7

1021+license: BSD-3-Clause

1022+copyright: XXX

1023+maintainer: XXX

1024+author: XXX

1025+synopsis: Provides shared functionality between iserv and iserv-proxy

1026+category: Development

1027+exposed: True

1028+exposed-modules: GHCi.Utils Lib

1029+import-dirs:

1030+library-dirs:

1031+dynamic-library-dirs:

1032+data-dir:

1033+hs-libraries: HSlibiserv-8.10.7

1034+depends:

1035+ base-4.14.3.0 binary-0.8.8.0 bytestring-0.10.12.0

1036+ containers-0.6.5.1 deepseq-1.4.4.0 ghci-8.10.7 unix-2.7.2.2

1037+haddock-interfaces:

1038+haddock-html:

1039+---

1040+name: mtl

1041+version: 2.2.2

1042+visibility: public

1043+id: mtl-2.2.2

1044+key: mtl-2.2.2

1045+license: BSD-3-Clause

1046+maintainer: Edward Kmett <ekmett@gmail.com>

1047+author: Andy Gill

1048+homepage: http://github.com/haskell/mtl

1049+synopsis: Monad classes, using functional dependencies

1050+description:

1051+ Monad classes using functional dependencies, with instances

1052+ for various monad transformers, inspired by the paper

1053+ /Functional Programming with Overloading and Higher-Order Polymorphism/,

1054+ by Mark P Jones, in /Advanced School of Functional Programming/, 1995

1055+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1056+category: Control

1057+exposed: True

1058+exposed-modules:

1059+ Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error

1060+ Control.Monad.Error.Class Control.Monad.Except

1061+ Control.Monad.Identity Control.Monad.List Control.Monad.RWS

1062+ Control.Monad.RWS.Class Control.Monad.RWS.Lazy

1063+ Control.Monad.RWS.Strict Control.Monad.Reader

1064+ Control.Monad.Reader.Class Control.Monad.State

1065+ Control.Monad.State.Class Control.Monad.State.Lazy

1066+ Control.Monad.State.Strict Control.Monad.Trans Control.Monad.Writer

1067+ Control.Monad.Writer.Class Control.Monad.Writer.Lazy

1068+ Control.Monad.Writer.Strict

1069+import-dirs:

1070+library-dirs:

1071+dynamic-library-dirs:

1072+data-dir:

1073+hs-libraries: HSmtl-2.2.2

1074+depends: base-4.14.3.0 transformers-0.5.6.2

1075+haddock-interfaces:

1076+haddock-html:

1077+---

1078+name: parsec

1079+version: 3.1.14.0

1080+visibility: public

1081+id: parsec-3.1.14.0

1082+key: parsec-3.1.14.0

1083+license: BSD-3-Clause

1084+maintainer: Herbert Valerio Riedel <hvr@gnu.org>

1085+author:

1086+ Daan Leijen <daan@microsoft.com>, Paolo Martini <paolo@nemail.it>, Antoine Latter <aslatter@gmail.com>

1087+homepage: https://github.com/haskell/parsec

1088+synopsis: Monadic parser combinators

1089+description:

1090+ Parsec is designed from scratch as an industrial-strength parser

1091+ library. It is simple, safe, well documented (on the package

1092+ homepage), has extensive libraries, good error messages,

1093+ and is fast. It is defined as a monad transformer that can be

1094+ stacked on arbitrary monads, and it is also parametric in the

1095+ input stream type.

1096+ The main entry point is the "Text.Parsec" module which provides

1097+ defaults for parsing 'Char'acter data.

1098+ The "Text.ParserCombinators.Parsec" module hierarchy contains

1099+ the legacy @parsec-2@ API and may be removed at some point in

1100+ the future.

1101+category: Parsing

1102+exposed: True

1103+exposed-modules:

1104+ Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy

1105+ Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error

1106+ Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm

1107+ Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String

1108+ Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token

1109+ Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char

1110+ Text.ParserCombinators.Parsec.Combinator

1111+ Text.ParserCombinators.Parsec.Error

1112+ Text.ParserCombinators.Parsec.Expr

1113+ Text.ParserCombinators.Parsec.Language

1114+ Text.ParserCombinators.Parsec.Perm

1115+ Text.ParserCombinators.Parsec.Pos

1116+ Text.ParserCombinators.Parsec.Prim

1117+ Text.ParserCombinators.Parsec.Token

1118+import-dirs:

1119+library-dirs:

1120+dynamic-library-dirs:

1121+data-dir:

1122+hs-libraries: HSparsec-3.1.14.0

1123+depends:

1124+ base-4.14.3.0 bytestring-0.10.12.0 mtl-2.2.2 text-1.2.4.1

1125+haddock-interfaces:

1126+haddock-html:

1127+---

1128+name: pretty

1129+version: 1.1.3.6

1130+visibility: public

1131+id: pretty-1.1.3.6

1132+key: pretty-1.1.3.6

1133+license: BSD-3-Clause

1134+maintainer: David Terei <code@davidterei.com>

1135+stability: Stable

1136+homepage: http://github.com/haskell/pretty

1137+synopsis: Pretty-printing library

1138+description:

1139+ This package contains a pretty-printing library, a set of API's

1140+ that provides a way to easily print out text in a consistent

1141+ format of your choosing. This is useful for compilers and related

1142+ tools.

1143+ This library was originally designed by John Hughes's and has since

1144+ been heavily modified by Simon Peyton Jones.

1145+category: Text

1146+exposed: True

1147+exposed-modules:

1148+ Text.PrettyPrint Text.PrettyPrint.Annotated

1149+ Text.PrettyPrint.Annotated.HughesPJ

1150+ Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ

1151+ Text.PrettyPrint.HughesPJClass

1152+import-dirs:

1153+library-dirs:

1154+dynamic-library-dirs:

1155+data-dir:

1156+hs-libraries: HSpretty-1.1.3.6

1157+depends: base-4.14.3.0 deepseq-1.4.4.0 ghc-prim-0.6.1

1158+haddock-interfaces:

1159+haddock-html:

1160+---

1161+name: process

1162+version: 1.6.13.2

1163+visibility: public

1164+id: process-1.6.13.2

1165+key: process-1.6.13.2

1166+license: BSD-3-Clause

1167+maintainer: libraries@haskell.org

1168+synopsis: Process libraries

1169+description:

1170+ This package contains libraries for dealing with system processes.

1171+ The typed-process package is a more recent take on a process API,

1172+ which uses this package internally. It features better binary

1173+ support, easier concurrency, and a more composable API. You can

1174+ read more about it at

1175+ <https://github.com/fpco/typed-process/#readme>.

1176+category: System

1177+exposed: True

1178+exposed-modules: System.Cmd System.Process System.Process.Internals

1179+hidden-modules: System.Process.Common System.Process.Posix

1180+import-dirs:

1181+library-dirs:

1182+dynamic-library-dirs:

1183+data-dir:

1184+hs-libraries: HSprocess-1.6.13.2

1185+include-dirs:

1186+includes: runProcess.h

1187+depends:

1188+ base-4.14.3.0 deepseq-1.4.4.0 directory-1.3.6.0 filepath-1.4.2.1

1189+ unix-2.7.2.2

1190+haddock-interfaces:

1191+haddock-html:

1192+---

1193+name: stm

1194+version: 2.5.0.1

1195+visibility: public

1196+id: stm-2.5.0.1

1197+key: stm-2.5.0.1

1198+license: BSD-3-Clause

1199+maintainer: libraries@haskell.org

1200+homepage: https://wiki.haskell.org/Software_transactional_memory

1201+synopsis: Software Transactional Memory

1202+description:

1203+ Software Transactional Memory, or STM, is an abstraction for

1204+ concurrent communication. The main benefits of STM are

1205+ /composability/ and /modularity/. That is, using STM you can write

1206+ concurrent abstractions that can be easily composed with any other

1207+ abstraction built using STM, without exposing the details of how

1208+ your abstraction ensures safety. This is typically not the case

1209+ with other forms of concurrent communication, such as locks or

1210+ 'MVar's.

1211+category: Concurrency

1212+exposed: True

1213+exposed-modules:

1214+ Control.Concurrent.STM Control.Concurrent.STM.TArray

1215+ Control.Concurrent.STM.TBQueue Control.Concurrent.STM.TChan

1216+ Control.Concurrent.STM.TMVar Control.Concurrent.STM.TQueue

1217+ Control.Concurrent.STM.TSem Control.Concurrent.STM.TVar

1218+ Control.Monad.STM

1219+hidden-modules: Control.Sequential.STM

1220+import-dirs:

1221+library-dirs:

1222+dynamic-library-dirs:

1223+data-dir:

1224+hs-libraries: HSstm-2.5.0.1

1225+depends: array-0.5.4.0 base-4.14.3.0

1226+haddock-interfaces:

1227+haddock-html:

1228+---

1229+name: template-haskell

1230+version: 2.16.0.0

1231+visibility: public

1232+id: template-haskell-2.16.0.0

1233+key: template-haskell-2.16.0.0

1234+license: BSD-3-Clause

1235+maintainer: libraries@haskell.org

1236+synopsis: Support library for Template Haskell

1237+description:

1238+ This package provides modules containing facilities for manipulating

1239+ Haskell source code using Template Haskell.

1240+ See <http://www.haskell.org/haskellwiki/Template_Haskell> for more

1241+ information.

1242+category: Template Haskell

1243+exposed: True

1244+exposed-modules:

1245+ Language.Haskell.TH Language.Haskell.TH.LanguageExtensions

1246+ Language.Haskell.TH.Lib Language.Haskell.TH.Lib.Internal

1247+ Language.Haskell.TH.Ppr Language.Haskell.TH.PprLib

1248+ Language.Haskell.TH.Quote Language.Haskell.TH.Syntax

1249+hidden-modules: Language.Haskell.TH.Lib.Map

1250+import-dirs:

1251+library-dirs:

1252+dynamic-library-dirs:

1253+data-dir:

1254+hs-libraries: HStemplate-haskell-2.16.0.0

1255+depends:

1256+ base-4.14.3.0 ghc-boot-th-8.10.7 ghc-prim-0.6.1 pretty-1.1.3.6

1257+haddock-interfaces:

1258+haddock-html:

1259+---

1260+name: terminfo

1261+version: 0.4.1.4

1262+visibility: public

1263+id: terminfo-0.4.1.4

1264+key: terminfo-0.4.1.4

1265+license: BSD-3-Clause

1266+copyright: (c) Judah Jacobson

1267+maintainer: Judah Jacobson <judah.jacobson@gmail.com>

1268+author: Judah Jacobson

1269+stability: Stable

1270+homepage: https://github.com/judah/terminfo

1271+synopsis: Haskell bindings to the terminfo library.

1272+description:

1273+ This library provides an interface to the terminfo database (via bindings to the

1274+ curses library). <http://en.wikipedia.org/wiki/Terminfo Terminfo> allows POSIX

1275+ systems to interact with a variety of terminals using a standard set of capabilities.

1276+category: User Interfaces

1277+exposed: True

1278+exposed-modules:

1279+ System.Console.Terminfo System.Console.Terminfo.Base

1280+ System.Console.Terminfo.Color System.Console.Terminfo.Cursor

1281+ System.Console.Terminfo.Edit System.Console.Terminfo.Effects

1282+ System.Console.Terminfo.Keys

1283+import-dirs:

1284+library-dirs:

1285+dynamic-library-dirs:

1286+data-dir:

1287+hs-libraries: HSterminfo-0.4.1.4

1288+extra-libraries: tinfo

1289+depends: base-4.14.3.0

1290+haddock-interfaces:

1291+haddock-html:

1292+---

1293+name: text

1294+version: 1.2.4.1

1295+visibility: public

1296+id: text-1.2.4.1

1297+key: text-1.2.4.1

1298+license: BSD-2-Clause

1299+copyright: 2009-2011 Bryan O'Sullivan, 2008-2009 Tom Harper

1300+maintainer:

1301+ Bryan O'Sullivan <bos@serpentine.com>, Herbert Valerio Riedel <hvr@gnu.org>

1302+author: Bryan O'Sullivan <bos@serpentine.com>

1303+homepage: https://github.com/haskell/text

1304+synopsis: An efficient packed Unicode text type.

1305+description:

1306+ An efficient packed, immutable Unicode text type (both strict and

1307+ lazy), with a powerful loop fusion optimization framework.

1308+ The 'Text' type represents Unicode character strings, in a time and

1309+ space-efficient manner. This package provides text processing

1310+ capabilities that are optimized for performance critical use, both

1311+ in terms of large data quantities and high speed.

1312+ The 'Text' type provides character-encoding, type-safe case

1313+ conversion via whole-string case conversion functions (see "Data.Text").

1314+ It also provides a range of functions for converting 'Text' values to

1315+ and from 'ByteStrings', using several standard encodings

1316+ (see "Data.Text.Encoding").

1317+ Efficient locale-sensitive support for text IO is also supported

1318+ (see "Data.Text.IO").

1319+ These modules are intended to be imported qualified, to avoid name

1320+ clashes with Prelude functions, e.g.

1321+ > import qualified Data.Text as T

1322+ == ICU Support

1323+ To use an extended and very rich family of functions for working

1324+ with Unicode text (including normalization, regular expressions,

1325+ non-standard encodings, text breaking, and locales), see

1326+ the [text-icu package](https://hackage.haskell.org/package/text-icu)

1327+ based on the well-respected and liberally

1328+ licensed [ICU library](http://site.icu-project.org/).

1329+ == Internal Representation: UTF-16 vs. UTF-8

1330+ Currently the @text@ library uses UTF-16 as its internal representation

1331+ which is [neither a fixed-width nor always the most dense representation](http://utf8everywhere.org/)

1332+ for Unicode text. We're currently investigating the feasibility

1333+ of [changing Text's internal representation to UTF-8](https://github.com/text-utf8)

1334+ and if you need such a 'Text' type right now you might be interested in using the spin-off

1335+ packages <https://hackage.haskell.org/package/text-utf8 text-utf8> and

1336+ <https://hackage.haskell.org/package/text-short text-short>.

1337+category: Data, Text

1338+exposed: True

1339+exposed-modules:

1340+ Data.Text Data.Text.Array Data.Text.Encoding

1341+ Data.Text.Encoding.Error Data.Text.Foreign Data.Text.IO

1342+ Data.Text.Internal Data.Text.Internal.Builder

1343+ Data.Text.Internal.Builder.Functions

1344+ Data.Text.Internal.Builder.Int.Digits

1345+ Data.Text.Internal.Builder.RealFloat.Functions

1346+ Data.Text.Internal.ByteStringCompat

1347+ Data.Text.Internal.Encoding.Fusion

1348+ Data.Text.Internal.Encoding.Fusion.Common

1349+ Data.Text.Internal.Encoding.Utf16 Data.Text.Internal.Encoding.Utf32

1350+ Data.Text.Internal.Encoding.Utf8 Data.Text.Internal.Functions

1351+ Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping

1352+ Data.Text.Internal.Fusion.Common Data.Text.Internal.Fusion.Size

1353+ Data.Text.Internal.Fusion.Types Data.Text.Internal.IO

1354+ Data.Text.Internal.Lazy Data.Text.Internal.Lazy.Encoding.Fusion

1355+ Data.Text.Internal.Lazy.Fusion Data.Text.Internal.Lazy.Search

1356+ Data.Text.Internal.Private Data.Text.Internal.Read

1357+ Data.Text.Internal.Search Data.Text.Internal.Unsafe

1358+ Data.Text.Internal.Unsafe.Char Data.Text.Internal.Unsafe.Shift

1359+ Data.Text.Lazy Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int

1360+ Data.Text.Lazy.Builder.RealFloat Data.Text.Lazy.Encoding

1361+ Data.Text.Lazy.IO Data.Text.Lazy.Internal Data.Text.Lazy.Read

1362+ Data.Text.Read Data.Text.Unsafe

1363+hidden-modules: Data.Text.Show

1364+import-dirs:

1365+library-dirs:

1366+dynamic-library-dirs:

1367+data-dir:

1368+hs-libraries: HStext-1.2.4.1

1369+depends:

1370+ array-0.5.4.0 base-4.14.3.0 binary-0.8.8.0 bytestring-0.10.12.0

1371+ deepseq-1.4.4.0 ghc-prim-0.6.1 integer-gmp-1.0.3.0

1372+ template-haskell-2.16.0.0

1373+haddock-interfaces:

1374+haddock-html:

1375+---

1376+name: time

1377+version: 1.9.3

1378+visibility: public

1379+id: time-1.9.3

1380+key: time-1.9.3

1381+license: BSD-3-Clause

1382+maintainer: <ashley@semantic.org>

1383+author: Ashley Yakeley

1384+stability: stable

1385+homepage: https://github.com/haskell/time

1386+synopsis: A time library

1387+description: Time, clocks and calendars

1388+category: Time

1389+exposed: True

1390+exposed-modules:

1391+ Data.Time Data.Time.Calendar Data.Time.Calendar.Easter

1392+ Data.Time.Calendar.Julian Data.Time.Calendar.MonthDay

1393+ Data.Time.Calendar.OrdinalDate Data.Time.Calendar.WeekDate

1394+ Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System

1395+ Data.Time.Clock.TAI Data.Time.Format Data.Time.Format.ISO8601

1396+ Data.Time.Format.Internal Data.Time.LocalTime

1397+hidden-modules:

1398+ Data.Format Data.Time.Calendar.Private Data.Time.Calendar.Days

1399+ Data.Time.Calendar.Gregorian Data.Time.Calendar.CalendarDiffDays

1400+ Data.Time.Calendar.Week Data.Time.Calendar.JulianYearDay

1401+ Data.Time.Clock.Internal.DiffTime

1402+ Data.Time.Clock.Internal.AbsoluteTime

1403+ Data.Time.Clock.Internal.NominalDiffTime

1404+ Data.Time.Clock.Internal.POSIXTime

1405+ Data.Time.Clock.Internal.UniversalTime

1406+ Data.Time.Clock.Internal.SystemTime

1407+ Data.Time.Clock.Internal.UTCTime Data.Time.Clock.Internal.CTimeval

1408+ Data.Time.Clock.Internal.CTimespec Data.Time.Clock.Internal.UTCDiff

1409+ Data.Time.LocalTime.Internal.TimeZone

1410+ Data.Time.LocalTime.Internal.TimeOfDay

1411+ Data.Time.LocalTime.Internal.CalendarDiffTime

1412+ Data.Time.LocalTime.Internal.LocalTime

1413+ Data.Time.LocalTime.Internal.ZonedTime Data.Time.Format.Parse

1414+ Data.Time.Format.Locale Data.Time.Format.Format.Class

1415+ Data.Time.Format.Format.Instances Data.Time.Format.Parse.Class

1416+ Data.Time.Format.Parse.Instances

1417+import-dirs:

1418+library-dirs:

1419+dynamic-library-dirs:

1420+data-dir:

1421+hs-libraries: HStime-1.9.3

1422+include-dirs:

1423+depends: base-4.14.3.0 deepseq-1.4.4.0

1424+haddock-interfaces:

1425+haddock-html:

1426+---

1427+name: transformers

1428+version: 0.5.6.2

1429+visibility: public

1430+id: transformers-0.5.6.2

1431+key: transformers-0.5.6.2

1432+license: BSD-3-Clause

1433+maintainer: Ross Paterson <R.Paterson@city.ac.uk>

1434+author: Andy Gill, Ross Paterson

1435+synopsis: Concrete functor and monad transformers

1436+description:

1437+ A portable library of functor and monad transformers, inspired by

1438+ the paper

1439+ * \"Functional Programming with Overloading and Higher-Order

1440+ Polymorphism\", by Mark P Jones,

1441+ in /Advanced School of Functional Programming/, 1995

1442+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1443+ This package contains:

1444+ * the monad transformer class (in "Control.Monad.Trans.Class")

1445+ * concrete functor and monad transformers, each with associated

1446+ operations and functions to lift operations associated with other

1447+ transformers.

1448+ The package can be used on its own in portable Haskell code, in

1449+ which case operations need to be manually lifted through transformer

1450+ stacks (see "Control.Monad.Trans.Class" for some examples).

1451+ Alternatively, it can be used with the non-portable monad classes in

1452+ the @mtl@ or @monads-tf@ packages, which automatically lift operations

1453+ introduced by monad transformers through other transformers.

1454+category: Control

1455+exposed: True

1456+exposed-modules:

1457+ Control.Applicative.Backwards Control.Applicative.Lift

1458+ Control.Monad.Signatures Control.Monad.Trans.Accum

1459+ Control.Monad.Trans.Class Control.Monad.Trans.Cont

1460+ Control.Monad.Trans.Error Control.Monad.Trans.Except

1461+ Control.Monad.Trans.Identity Control.Monad.Trans.List

1462+ Control.Monad.Trans.Maybe Control.Monad.Trans.RWS

1463+ Control.Monad.Trans.RWS.CPS Control.Monad.Trans.RWS.Lazy

1464+ Control.Monad.Trans.RWS.Strict Control.Monad.Trans.Reader

1465+ Control.Monad.Trans.Select Control.Monad.Trans.State

1466+ Control.Monad.Trans.State.Lazy Control.Monad.Trans.State.Strict

1467+ Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS

1468+ Control.Monad.Trans.Writer.Lazy Control.Monad.Trans.Writer.Strict

1469+ Data.Functor.Constant Data.Functor.Reverse

1470+import-dirs:

1471+library-dirs:

1472+dynamic-library-dirs:

1473+data-dir:

1474+hs-libraries: HStransformers-0.5.6.2

1475+depends: base-4.14.3.0

1476+haddock-interfaces:

1477+haddock-html:

1478+---

1479+name: unix

1480+version: 2.7.2.2

1481+visibility: public

1482+id: unix-2.7.2.2

1483+key: unix-2.7.2.2

1484+license: BSD-3-Clause

1485+maintainer: libraries@haskell.org

1486+homepage: https://github.com/haskell/unix

1487+synopsis: POSIX functionality

1488+description:

1489+ This package gives you access to the set of operating system

1490+ services standardised by

1491+ <http://pubs.opengroup.org/onlinepubs/9699919799/ POSIX.1-2008>

1492+ (or the IEEE Portable Operating System Interface for Computing

1493+ Environments - IEEE Std. 1003.1).

1494+ The package is not supported under Windows.

1495+category: System

1496+exposed: True

1497+exposed-modules:

1498+ System.Posix System.Posix.ByteString

1499+ System.Posix.ByteString.FilePath System.Posix.Directory

1500+ System.Posix.Directory.ByteString System.Posix.DynamicLinker

1501+ System.Posix.DynamicLinker.ByteString

1502+ System.Posix.DynamicLinker.Module

1503+ System.Posix.DynamicLinker.Module.ByteString

1504+ System.Posix.DynamicLinker.Prim System.Posix.Env

1505+ System.Posix.Env.ByteString System.Posix.Error System.Posix.Fcntl

1506+ System.Posix.Files System.Posix.Files.ByteString System.Posix.IO

1507+ System.Posix.IO.ByteString System.Posix.Process

1508+ System.Posix.Process.ByteString System.Posix.Process.Internals

1509+ System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem

1510+ System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp

1511+ System.Posix.Temp.ByteString System.Posix.Terminal

1512+ System.Posix.Terminal.ByteString System.Posix.Time

1513+ System.Posix.Unistd System.Posix.User

1514+hidden-modules:

1515+ System.Posix.Directory.Common System.Posix.DynamicLinker.Common

1516+ System.Posix.Files.Common System.Posix.IO.Common

1517+ System.Posix.Process.Common System.Posix.Terminal.Common

1518+import-dirs:

1519+library-dirs:

1520+dynamic-library-dirs:

1521+data-dir:

1522+hs-libraries: HSunix-2.7.2.2

1523+include-dirs:

1524+includes: HsUnix.h execvpe.h

1525+depends: base-4.14.3.0 bytestring-0.10.12.0 time-1.9.3

1526+haddock-interfaces:

1527+haddock-html:

1528+---

1529+name: xhtml

1530+version: 3000.2.2.1

1531+visibility: public

1532+id: xhtml-3000.2.2.1

1533+key: xhtml-3000.2.2.1

1534+license: BSD-3-Clause

1535+copyright:

1536+ Bjorn Bringert 2004-2006, Andy Gill and the Oregon

1537+ Graduate Institute of Science and Technology, 1999-2001

1538+maintainer: Chris Dornan <chris@chrisdornan.com>

1539+author: Bjorn Bringert

1540+stability: Stable

1541+homepage: https://github.com/haskell/xhtml

1542+synopsis: An XHTML combinator library

1543+description:

1544+ This package provides combinators for producing

1545+ XHTML 1.0, including the Strict, Transitional and

1546+ Frameset variants.

1547+category: Web, XML, Pretty Printer

1548+exposed: True

1549+exposed-modules:

1550+ Text.XHtml Text.XHtml.Debug Text.XHtml.Frameset Text.XHtml.Strict

1551+ Text.XHtml.Table Text.XHtml.Transitional

1552+hidden-modules:

1553+ Text.XHtml.Strict.Attributes Text.XHtml.Strict.Elements

1554+ Text.XHtml.Frameset.Attributes Text.XHtml.Frameset.Elements

1555+ Text.XHtml.Transitional.Attributes Text.XHtml.Transitional.Elements

1556+ Text.XHtml.BlockTable Text.XHtml.Extras Text.XHtml.Internals

1557+import-dirs:

1558+library-dirs:

1559+dynamic-library-dirs:

1560+data-dir:

1561+hs-libraries: HSxhtml-3000.2.2.1

1562+depends: base-4.14.3.0

1563+haddock-interfaces:

1564+haddock-html:

1565+---

1566+name: rts

1567+version: 1.0.1

1568+visibility: public

1569+id: rts

1570+key: rts

1571+license: BSD-3-Clause

1572+maintainer: glasgow-haskell-users@haskell.org

1573+exposed: True

1574+library-dirs:

1575+hs-libraries: HSrts

1576+extra-libraries: m rt dl ffi numa

1577+include-dirs:

1578+includes: Stg.h

1579+ld-options:

1580+ "-Wl,-u,base_GHCziTopHandler_runIO_closure"

1581+ "-Wl,-u,base_GHCziTopHandler_runNonIO_closure"

1582+ "-Wl,-u,ghczmprim_GHCziTuple_Z0T_closure"

1583+ "-Wl,-u,ghczmprim_GHCziTypes_True_closure"

1584+ "-Wl,-u,ghczmprim_GHCziTypes_False_closure"

1585+ "-Wl,-u,base_GHCziPack_unpackCString_closure"

1586+ "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure"

1587+ "-Wl,-u,base_GHCziIOziException_stackOverflow_closure"

1588+ "-Wl,-u,base_GHCziIOziException_heapOverflow_closure"

1589+ "-Wl,-u,base_GHCziIOziException_allocationLimitExceeded_closure"

1590+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"

1591+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"

1592+ "-Wl,-u,base_GHCziIOziException_cannotCompactFunction_closure"

1593+ "-Wl,-u,base_GHCziIOziException_cannotCompactPinned_closure"

1594+ "-Wl,-u,base_GHCziIOziException_cannotCompactMutable_closure"

1595+ "-Wl,-u,base_ControlziExceptionziBase_absentSumFieldError_closure"

1596+ "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure"

1597+ "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure"

1598+ "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure"

1599+ "-Wl,-u,base_GHCziConcziSync_runSparks_closure"

1600+ "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure"

1601+ "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"

1602+ "-Wl,-u,base_GHCziConcziSignal_runHandlersPtr_closure"

1603+ "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure"

1604+ "-Wl,-u,base_GHCziTopHandler_runMainIO_closure"

1605+ "-Wl,-u,ghczmprim_GHCziTypes_Czh_con_info"

1606+ "-Wl,-u,ghczmprim_GHCziTypes_Izh_con_info"

1607+ "-Wl,-u,ghczmprim_GHCziTypes_Fzh_con_info"

1608+ "-Wl,-u,ghczmprim_GHCziTypes_Dzh_con_info"

1609+ "-Wl,-u,ghczmprim_GHCziTypes_Wzh_con_info"

1610+ "-Wl,-u,base_GHCziPtr_Ptr_con_info"

1611+ "-Wl,-u,base_GHCziPtr_FunPtr_con_info"

1612+ "-Wl,-u,base_GHCziInt_I8zh_con_info"

1613+ "-Wl,-u,base_GHCziInt_I16zh_con_info"

1614+ "-Wl,-u,base_GHCziInt_I32zh_con_info"

1615+ "-Wl,-u,base_GHCziInt_I64zh_con_info"

1616+ "-Wl,-u,base_GHCziWord_W8zh_con_info"

1617+ "-Wl,-u,base_GHCziWord_W16zh_con_info"

1618+ "-Wl,-u,base_GHCziWord_W32zh_con_info"

1619+ "-Wl,-u,base_GHCziWord_W64zh_con_info"

1620+ "-Wl,-u,base_GHCziStable_StablePtr_con_info"

1621+ "-Wl,-u,hs_atomic_add8" "-Wl,-u,hs_atomic_add16"

1622+ "-Wl,-u,hs_atomic_add32" "-Wl,-u,hs_atomic_add64"

1623+ "-Wl,-u,hs_atomic_sub8" "-Wl,-u,hs_atomic_sub16"

1624+ "-Wl,-u,hs_atomic_sub32" "-Wl,-u,hs_atomic_sub64"

1625+ "-Wl,-u,hs_atomic_and8" "-Wl,-u,hs_atomic_and16"

1626+ "-Wl,-u,hs_atomic_and32" "-Wl,-u,hs_atomic_and64"

1627+ "-Wl,-u,hs_atomic_nand8" "-Wl,-u,hs_atomic_nand16"

1628+ "-Wl,-u,hs_atomic_nand32" "-Wl,-u,hs_atomic_nand64"

1629+ "-Wl,-u,hs_atomic_or8" "-Wl,-u,hs_atomic_or16"

1630+ "-Wl,-u,hs_atomic_or32" "-Wl,-u,hs_atomic_or64"

1631+ "-Wl,-u,hs_atomic_xor8" "-Wl,-u,hs_atomic_xor16"

1632+ "-Wl,-u,hs_atomic_xor32" "-Wl,-u,hs_atomic_xor64"

1633+ "-Wl,-u,hs_cmpxchg8" "-Wl,-u,hs_cmpxchg16" "-Wl,-u,hs_cmpxchg32"

1634+ "-Wl,-u,hs_cmpxchg64" "-Wl,-u,hs_atomicread8"

1635+ "-Wl,-u,hs_atomicread16" "-Wl,-u,hs_atomicread32"

1636+ "-Wl,-u,hs_atomicread64" "-Wl,-u,hs_atomicwrite8"

1637+ "-Wl,-u,hs_atomicwrite16" "-Wl,-u,hs_atomicwrite32"

1638+ "-Wl,-u,hs_atomicwrite64"

materialized/dummy-ghc/ghc-8.10.7-aarch64-linux/ghc-pkg/versionnew file+1

@@ -0,0 +1 @@

1+GHC package manager version 8.10.7

materialized/dummy-ghc/ghc-8.10.7-aarch64-linux/ghc/infonew file+73

@@ -0,0 +1,73 @@

1+ [("Project name","The Glorious Glasgow Haskell Compilation System")

2+ ,("GCC extra via C opts","")

3+ ,("C compiler command","gcc")

4+ ,("C compiler flags","")

5+ ,("C++ compiler flags","")

6+ ,("C compiler link flags","-Wl,-z,noexecstack")

7+ ,("C compiler supports -no-pie","YES")

8+ ,("Haskell CPP command","gcc")

9+ ,("Haskell CPP flags","-E -undef -traditional")

10+ ,("ld command","ld")

11+ ,("ld flags","-z noexecstack")

12+ ,("ld supports compact unwind","NO")

13+ ,("ld supports build-id","YES")

14+ ,("ld supports filelist","NO")

15+ ,("ld is GNU ld","YES")

16+ ,("Merge objects command","ld")

17+ ,("Merge objects flags","-r")

18+ ,("ar command","ar")

19+ ,("ar flags","q")

20+ ,("ar supports at file","YES")

21+ ,("ranlib command","ranlib")

22+ ,("otool command","otool")

23+ ,("install_name_tool command","install_name_tool")

24+ ,("touch command","touch")

25+ ,("dllwrap command","/bin/false")

26+ ,("windres command","/bin/false")

27+ ,("libtool command","libtool")

28+ ,("cross compiling","NO")

29+ ,("target platform string","aarch64-unknown-linux")

30+ ,("target os","OSLinux")

31+ ,("target arch","ArchAArch64")

32+ ,("target word size","8")

33+ ,("target has GNU nonexec stack","YES")

34+ ,("target has .ident directive","YES")

35+ ,("target has subsections via symbols","NO")

36+ ,("target has RTS linker","YES")

37+ ,("Unregisterised","NO")

38+ ,("LLVM target","aarch64-unknown-linux")

39+ ,("LLVM clang command","clang")

40+ ,("integer library","integer-gmp")

41+ ,("Use interpreter","YES")

42+ ,("Use native code generator","NO")

43+ ,("Support SMP","YES")

44+ ,("RTS ways","l debug thr thr_debug thr_l thr_p dyn debug_dyn thr_dyn thr_debug_dyn l_dyn thr_l_dyn thr_debug_p debug_p")

45+ ,("Tables next to code","YES")

46+ ,("Leading underscore","NO")

47+ ,("Use LibFFI","YES")

48+ ,("Use Threads","YES")

49+ ,("Use Debugging","NO")

50+ ,("RTS expects libdw","NO")

51+ ,("Project version","8.10.7")

52+ ,("Project Git commit id","1f02b7430b2fbab403d7ffdde9cfd006e884678e")

53+ ,("Booter version","8.8.4")

54+ ,("Stage","2")

55+ ,("Build platform","aarch64-unknown-linux")

56+ ,("Host platform","aarch64-unknown-linux")

57+ ,("Target platform","aarch64-unknown-linux")

58+ ,("Have interpreter","YES")

59+ ,("Object splitting supported","NO")

60+ ,("Have native code generator","NO")

61+ ,("Support dynamic-too","YES")

62+ ,("Support parallel --make","YES")

63+ ,("Support reexported-modules","YES")

64+ ,("Support thinning and renaming package flags","YES")

65+ ,("Support Backpack","YES")

66+ ,("Requires unified installed package IDs","YES")

67+ ,("Uses package keys","YES")

68+ ,("Uses unit IDs","YES")

69+ ,("Dynamic by default","NO")

70+ ,("GHC Dynamic","YES")

71+ ,("GHC Profiled","NO")

72+ ,("Debug on","NO")

73+ ]

materialized/dummy-ghc/ghc-8.10.7-aarch64-linux/ghc/numeric-versionnew file+1

@@ -0,0 +1 @@

1+8.10.7

materialized/dummy-ghc/ghc-8.10.7-aarch64-linux/ghc/supported-languagesnew file+255

@@ -0,0 +1,255 @@

1+Haskell98

2+Haskell2010

3+Unsafe

4+Trustworthy

5+Safe

6+AllowAmbiguousTypes

7+NoAllowAmbiguousTypes

8+AlternativeLayoutRule

9+NoAlternativeLayoutRule

10+AlternativeLayoutRuleTransitional

11+NoAlternativeLayoutRuleTransitional

12+Arrows

13+NoArrows

14+AutoDeriveTypeable

15+NoAutoDeriveTypeable

16+BangPatterns

17+NoBangPatterns

18+BinaryLiterals

19+NoBinaryLiterals

20+CApiFFI

21+NoCApiFFI

22+CPP

23+NoCPP

24+CUSKs

25+NoCUSKs

26+ConstrainedClassMethods

27+NoConstrainedClassMethods

28+ConstraintKinds

29+NoConstraintKinds

30+DataKinds

31+NoDataKinds

32+DatatypeContexts

33+NoDatatypeContexts

34+DefaultSignatures

35+NoDefaultSignatures

36+DeriveAnyClass

37+NoDeriveAnyClass

38+DeriveDataTypeable

39+NoDeriveDataTypeable

40+DeriveFoldable

41+NoDeriveFoldable

42+DeriveFunctor

43+NoDeriveFunctor

44+DeriveGeneric

45+NoDeriveGeneric

46+DeriveLift

47+NoDeriveLift

48+DeriveTraversable

49+NoDeriveTraversable

50+DerivingStrategies

51+NoDerivingStrategies

52+DerivingVia

53+NoDerivingVia

54+DisambiguateRecordFields

55+NoDisambiguateRecordFields

56+DoAndIfThenElse

57+NoDoAndIfThenElse

58+BlockArguments

59+NoBlockArguments

60+DoRec

61+NoDoRec

62+DuplicateRecordFields

63+NoDuplicateRecordFields

64+EmptyCase

65+NoEmptyCase

66+EmptyDataDecls

67+NoEmptyDataDecls

68+EmptyDataDeriving

69+NoEmptyDataDeriving

70+ExistentialQuantification

71+NoExistentialQuantification

72+ExplicitForAll

73+NoExplicitForAll

74+ExplicitNamespaces

75+NoExplicitNamespaces

76+ExtendedDefaultRules

77+NoExtendedDefaultRules

78+FlexibleContexts

79+NoFlexibleContexts

80+FlexibleInstances

81+NoFlexibleInstances

82+ForeignFunctionInterface

83+NoForeignFunctionInterface

84+FunctionalDependencies

85+NoFunctionalDependencies

86+GADTSyntax

87+NoGADTSyntax

88+GADTs

89+NoGADTs

90+GHCForeignImportPrim

91+NoGHCForeignImportPrim

92+GeneralizedNewtypeDeriving

93+NoGeneralizedNewtypeDeriving

94+GeneralisedNewtypeDeriving

95+NoGeneralisedNewtypeDeriving

96+ImplicitParams

97+NoImplicitParams

98+ImplicitPrelude

99+NoImplicitPrelude

100+ImportQualifiedPost

101+NoImportQualifiedPost

102+ImpredicativeTypes

103+NoImpredicativeTypes

104+IncoherentInstances

105+NoIncoherentInstances

106+TypeFamilyDependencies

107+NoTypeFamilyDependencies

108+InstanceSigs

109+NoInstanceSigs

110+ApplicativeDo

111+NoApplicativeDo

112+InterruptibleFFI

113+NoInterruptibleFFI

114+JavaScriptFFI

115+NoJavaScriptFFI

116+KindSignatures

117+NoKindSignatures

118+LambdaCase

119+NoLambdaCase

120+LiberalTypeSynonyms

121+NoLiberalTypeSynonyms

122+MagicHash

123+NoMagicHash

124+MonadComprehensions

125+NoMonadComprehensions

126+MonadFailDesugaring

127+NoMonadFailDesugaring

128+MonoLocalBinds

129+NoMonoLocalBinds

130+MonoPatBinds

131+NoMonoPatBinds

132+MonomorphismRestriction

133+NoMonomorphismRestriction

134+MultiParamTypeClasses

135+NoMultiParamTypeClasses

136+MultiWayIf

137+NoMultiWayIf

138+NumericUnderscores

139+NoNumericUnderscores

140+NPlusKPatterns

141+NoNPlusKPatterns

142+NamedFieldPuns

143+NoNamedFieldPuns

144+NamedWildCards

145+NoNamedWildCards

146+NegativeLiterals

147+NoNegativeLiterals

148+HexFloatLiterals

149+NoHexFloatLiterals

150+NondecreasingIndentation

151+NoNondecreasingIndentation

152+NullaryTypeClasses

153+NoNullaryTypeClasses

154+NumDecimals

155+NoNumDecimals

156+OverlappingInstances

157+NoOverlappingInstances

158+OverloadedLabels

159+NoOverloadedLabels

160+OverloadedLists

161+NoOverloadedLists

162+OverloadedStrings

163+NoOverloadedStrings

164+PackageImports

165+NoPackageImports

166+ParallelArrays

167+NoParallelArrays

168+ParallelListComp

169+NoParallelListComp

170+PartialTypeSignatures

171+NoPartialTypeSignatures

172+PatternGuards

173+NoPatternGuards

174+PatternSignatures

175+NoPatternSignatures

176+PatternSynonyms

177+NoPatternSynonyms

178+PolyKinds

179+NoPolyKinds

180+PolymorphicComponents

181+NoPolymorphicComponents

182+QuantifiedConstraints

183+NoQuantifiedConstraints

184+PostfixOperators

185+NoPostfixOperators

186+QuasiQuotes

187+NoQuasiQuotes

188+Rank2Types

189+NoRank2Types

190+RankNTypes

191+NoRankNTypes

192+RebindableSyntax

193+NoRebindableSyntax

194+RecordPuns

195+NoRecordPuns

196+RecordWildCards

197+NoRecordWildCards

198+RecursiveDo

199+NoRecursiveDo

200+RelaxedLayout

201+NoRelaxedLayout

202+RelaxedPolyRec

203+NoRelaxedPolyRec

204+RoleAnnotations

205+NoRoleAnnotations

206+ScopedTypeVariables

207+NoScopedTypeVariables

208+StandaloneDeriving

209+NoStandaloneDeriving

210+StarIsType

211+NoStarIsType

212+StaticPointers

213+NoStaticPointers

214+Strict

215+NoStrict

216+StrictData

217+NoStrictData

218+TemplateHaskell

219+NoTemplateHaskell

220+TemplateHaskellQuotes

221+NoTemplateHaskellQuotes

222+StandaloneKindSignatures

223+NoStandaloneKindSignatures

224+TraditionalRecordSyntax

225+NoTraditionalRecordSyntax

226+TransformListComp

227+NoTransformListComp

228+TupleSections

229+NoTupleSections

230+TypeApplications

231+NoTypeApplications

232+TypeInType

233+NoTypeInType

234+TypeFamilies

235+NoTypeFamilies

236+TypeOperators

237+NoTypeOperators

238+TypeSynonymInstances

239+NoTypeSynonymInstances

240+UnboxedTuples

241+NoUnboxedTuples

242+UnboxedSums

243+NoUnboxedSums

244+UndecidableInstances

245+NoUndecidableInstances

246+UndecidableSuperClasses

247+NoUndecidableSuperClasses

248+UnicodeSyntax

249+NoUnicodeSyntax

250+UnliftedFFITypes

251+NoUnliftedFFITypes

252+UnliftedNewtypes

253+NoUnliftedNewtypes

254+ViewPatterns

255+NoViewPatterns

materialized/dummy-ghc/ghc-8.10.7-aarch64-linux/ghc/versionnew file+1

@@ -0,0 +1 @@

1+The Glorious Glasgow Haskell Compilation System, version 8.10.7

materialized/dummy-ghc/ghc-8.10.7-x86_64-darwin/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","clang")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","NO")

8+ ,("Haskell CPP command","clang")

79 ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","NO")

1114 ,("ld supports filelist","YES")

1215 ,("ld is GNU ld","NO")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","qcls")

1520 ,("ar supports at file","NO")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-8.10.7-x86_64-linux/ghc-pkg/dump-global+1−2

@@ -1520,7 +1520,6 @@ library-dirs:

15201520dynamic-library-dirs:

15211521data-dir:

15221522hs-libraries: HSunix-2.7.2.2

1523−extra-libraries: rt util dl pthread

15241523include-dirs:

15251524includes: HsUnix.h execvpe.h

15261525depends: base-4.14.3.0 bytestring-0.10.12.0 time-1.9.3

@@ -1574,7 +1573,7 @@ maintainer: glasgow-haskell-users@haskell.org

15741573exposed: True

15751574library-dirs:

15761575hs-libraries: HSrts

1577−extra-libraries: m rt dl ffi numa pthread

1576+extra-libraries: m rt dl ffi numa

15781577include-dirs:

15791578includes: Stg.h

15801579ld-options:

materialized/dummy-ghc/ghc-8.10.7-x86_64-linux/ghc/info+7−1

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","YES")

8+ ,("Haskell CPP command","gcc")

79 ,("Haskell CPP flags","-E -undef -traditional")

10+ ,("ld command","ld")

811 ,("ld flags","")

9− ,("ld supports compact unwind","YES")

12+ ,("ld supports compact unwind","NO")

1013 ,("ld supports build-id","YES")

1114 ,("ld supports filelist","NO")

1215 ,("ld is GNU ld","YES")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","q")

1520 ,("ar supports at file","YES")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-8.6.5-x86_64-darwin/ghc/info+5

@@ -1,16 +1,21 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts"," -fwrapv -fno-builtin")

3+ ,("C compiler command","clang")

34 ,("C compiler flags"," -fno-stack-protector")

45 ,("C compiler link flags"," ")

56 ,("C compiler supports -no-pie","NO")

7+ ,("Haskell CPP command","clang")

68 ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

9+ ,("ld command","ld")

710 ,("ld flags","")

811 ,("ld supports compact unwind","YES")

912 ,("ld supports build-id","NO")

1013 ,("ld supports filelist","YES")

1114 ,("ld is GNU ld","NO")

15+ ,("ar command","ar")

1216 ,("ar flags","qcls")

1317 ,("ar supports at file","NO")

18+ ,("ranlib command","ranlib")

1419 ,("touch command","touch")

1520 ,("dllwrap command","/bin/false")

1621 ,("windres command","/bin/false")

materialized/dummy-ghc/ghc-8.6.5-x86_64-linux/ghc/info+5

@@ -1,16 +1,21 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts"," -fwrapv -fno-builtin")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags"," -fno-stack-protector")

45 ,("C compiler link flags"," ")

56 ,("C compiler supports -no-pie","YES")

7+ ,("Haskell CPP command","gcc")

68 ,("Haskell CPP flags","-E -undef -traditional")

9+ ,("ld command","ld")

710 ,("ld flags","")

811 ,("ld supports compact unwind","YES")

912 ,("ld supports build-id","YES")

1013 ,("ld supports filelist","NO")

1114 ,("ld is GNU ld","YES")

15+ ,("ar command","ar")

1216 ,("ar flags","q")

1317 ,("ar supports at file","YES")

18+ ,("ranlib command","ranlib")

1419 ,("touch command","touch")

1520 ,("dllwrap command","/bin/false")

1621 ,("windres command","/bin/false")

materialized/dummy-ghc/ghc-8.8.2-x86_64-darwin/ghc-pkg/dump-global+6−3

@@ -815,6 +815,7 @@ library-dirs:

815815dynamic-library-dirs:

816816data-dir:

817817hs-libraries: HSghc-prim-0.5.3

818+include-dirs:

818819depends: rts

819820haddock-interfaces:

820821haddock-html:

@@ -843,6 +844,7 @@ library-dirs:

843844dynamic-library-dirs:

844845data-dir:

845846hs-libraries: HSghci-8.8.2

847+include-dirs:

846848depends:

847849 array-0.5.4.0 base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.0

848850 containers-0.6.2.1 deepseq-1.4.4.0 filepath-1.4.2.1 ghc-boot-8.8.2

@@ -960,6 +962,7 @@ library-dirs:

960962dynamic-library-dirs:

961963data-dir:

962964hs-libraries: HSinteger-gmp-1.0.2.0

965+extra-libraries: gmp

963966include-dirs:

964967depends: ghc-prim-0.5.3

965968haddock-interfaces:

@@ -1236,7 +1239,7 @@ library-dirs:

12361239dynamic-library-dirs:

12371240data-dir:

12381241hs-libraries: HSterminfo-0.4.1.4

1239−extra-libraries: ncurses

1242+extra-libraries: tinfo

12401243depends: base-4.13.0.0

12411244haddock-interfaces:

12421245haddock-html:

@@ -1522,8 +1525,8 @@ license: BSD-3-Clause

15221525maintainer: glasgow-haskell-users@haskell.org

15231526exposed: True

15241527library-dirs:

1525−hs-libraries: HSrts Cffi

1526−extra-libraries: m dl

1528+hs-libraries: HSrts

1529+extra-libraries: m dl ffi

15271530include-dirs:

15281531includes: Stg.h

15291532ld-options:

materialized/dummy-ghc/ghc-8.8.2-x86_64-darwin/ghc/info+1−1

@@ -34,7 +34,7 @@

3434 ,("LLVM clang command","clang")

3535 ,("Project version","8.8.2")

3636 ,("Project Git commit id","86f4a56c8888d249194c38799eaec9484222fa47")

37− ,("Booter version","8.6.3")

37+ ,("Booter version","8.4.4")

3838 ,("Stage","2")

3939 ,("Build platform","x86_64-apple-darwin")

4040 ,("Host platform","x86_64-apple-darwin")

materialized/dummy-ghc/ghc-8.8.2-x86_64-linux/ghc/info+5

@@ -1,16 +1,21 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts"," -fwrapv -fno-builtin")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags","")

45 ,("C compiler link flags"," ")

56 ,("C compiler supports -no-pie","YES")

7+ ,("Haskell CPP command","gcc")

68 ,("Haskell CPP flags","-E -undef -traditional")

9+ ,("ld command","ld")

710 ,("ld flags","")

811 ,("ld supports compact unwind","YES")

912 ,("ld supports build-id","YES")

1013 ,("ld supports filelist","NO")

1114 ,("ld is GNU ld","YES")

15+ ,("ar command","ar")

1216 ,("ar flags","q")

1317 ,("ar supports at file","YES")

18+ ,("ranlib command","ranlib")

1419 ,("touch command","touch")

1520 ,("dllwrap command","/bin/false")

1621 ,("windres command","/bin/false")

materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/info+5−3

@@ -1,9 +1,12 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts"," -fwrapv -fno-builtin")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags","")

45 ,("C compiler link flags"," -Wl,-z,noexecstack")

56 ,("C compiler supports -no-pie","YES")

7+ ,("Haskell CPP command","gcc")

68 ,("Haskell CPP flags","-E -undef -traditional")

9+ ,("ld command","ld")

710 ,("ld flags"," -z noexecstack")

811 ,("ld supports compact unwind","YES")

912 ,("ld supports build-id","YES")

@@ -12,6 +15,7 @@

1215 ,("ar command","ar")

1316 ,("ar flags","q")

1417 ,("ar supports at file","YES")

18+ ,("ranlib command","ranlib")

1519 ,("touch command","touch")

1620 ,("dllwrap command","/bin/false")

1721 ,("windres command","/bin/false")

@@ -25,12 +29,10 @@

2529 ,("target has subsections via symbols","False")

2630 ,("target has RTS linker","YES")

2731 ,("Unregisterised","NO")

28− ,("LLVM llc command","llc")

29− ,("LLVM opt command","opt")

3032 ,("LLVM clang command","clang")

3133 ,("Project version","8.8.3")

3234 ,("Project Git commit id","d0bab2e3419e49cdbb1201d4650572b57f33420c")

33− ,("Booter version","8.8.2")

35+ ,("Booter version","8.8.3")

3436 ,("Stage","2")

3537 ,("Build platform","aarch64-unknown-linux")

3638 ,("Host platform","aarch64-unknown-linux")

materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/versionnew file+1

@@ -0,0 +1 @@

1+The Glorious Glasgow Haskell Compilation System, version 8.8.3

materialized/dummy-ghc/ghc-8.8.3-x86_64-darwin/ghc/info+5

@@ -1,16 +1,21 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts"," -fwrapv -fno-builtin")

3+ ,("C compiler command","clang")

34 ,("C compiler flags","")

45 ,("C compiler link flags"," ")

56 ,("C compiler supports -no-pie","NO")

7+ ,("Haskell CPP command","clang")

68 ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

9+ ,("ld command","ld")

710 ,("ld flags","")

811 ,("ld supports compact unwind","YES")

912 ,("ld supports build-id","NO")

1013 ,("ld supports filelist","YES")

1114 ,("ld is GNU ld","NO")

15+ ,("ar command","ar")

1216 ,("ar flags","qcls")

1317 ,("ar supports at file","NO")

18+ ,("ranlib command","ranlib")

1419 ,("touch command","touch")

1520 ,("dllwrap command","/bin/false")

1621 ,("windres command","/bin/false")

materialized/dummy-ghc/ghc-8.8.3-x86_64-linux/ghc/info+5

@@ -1,16 +1,21 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts"," -fwrapv -fno-builtin")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags","")

45 ,("C compiler link flags"," ")

56 ,("C compiler supports -no-pie","YES")

7+ ,("Haskell CPP command","gcc")

68 ,("Haskell CPP flags","-E -undef -traditional")

9+ ,("ld command","ld")

710 ,("ld flags","")

811 ,("ld supports compact unwind","YES")

912 ,("ld supports build-id","YES")

1013 ,("ld supports filelist","NO")

1114 ,("ld is GNU ld","YES")

15+ ,("ar command","ar")

1216 ,("ar flags","q")

1317 ,("ar supports at file","YES")

18+ ,("ranlib command","ranlib")

1419 ,("touch command","touch")

1520 ,("dllwrap command","/bin/false")

1621 ,("windres command","/bin/false")

materialized/dummy-ghc/ghc-8.8.4-aarch64-linux/ghc-pkg/dump-globalnew file+1592

@@ -0,0 +1,1592 @@

1+name: Cabal

2+version: 3.0.1.0

3+visibility: public

4+id: Cabal-3.0.1.0

5+key: Cabal-3.0.1.0

6+license: BSD-3-Clause

7+copyright: 2003-2019, 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.Parsing Distribution.Compat.Prelude.Internal

36+ Distribution.Compat.ResponseFile Distribution.Compat.Semigroup

37+ Distribution.Compat.Stack Distribution.Compat.Time

38+ Distribution.Compiler Distribution.FieldGrammar

39+ Distribution.FieldGrammar.Class

40+ Distribution.FieldGrammar.FieldDescrs

41+ Distribution.FieldGrammar.Parsec Distribution.FieldGrammar.Pretty

42+ Distribution.Fields Distribution.Fields.ConfVar

43+ Distribution.Fields.Field Distribution.Fields.Lexer

44+ Distribution.Fields.LexerMonad Distribution.Fields.ParseResult

45+ Distribution.Fields.Parser Distribution.Fields.Pretty

46+ Distribution.InstalledPackageInfo Distribution.License

47+ Distribution.Make Distribution.ModuleName Distribution.Package

48+ Distribution.PackageDescription

49+ Distribution.PackageDescription.Check

50+ Distribution.PackageDescription.Configuration

51+ Distribution.PackageDescription.FieldGrammar

52+ Distribution.PackageDescription.Parsec

53+ Distribution.PackageDescription.PrettyPrint

54+ Distribution.PackageDescription.Quirks

55+ Distribution.PackageDescription.Utils Distribution.Parsec

56+ Distribution.Parsec.Error Distribution.Parsec.FieldLineStream

57+ Distribution.Parsec.Newtypes Distribution.Parsec.Position

58+ Distribution.Parsec.Warning Distribution.Pretty Distribution.ReadE

59+ Distribution.SPDX Distribution.SPDX.License

60+ 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.Doctest

71+ Distribution.Simple.Flag Distribution.Simple.GHC

72+ Distribution.Simple.GHCJS Distribution.Simple.Glob

73+ Distribution.Simple.Haddock Distribution.Simple.HaskellSuite

74+ Distribution.Simple.Hpc Distribution.Simple.Install

75+ Distribution.Simple.InstallDirs

76+ Distribution.Simple.InstallDirs.Internal

77+ Distribution.Simple.LocalBuildInfo Distribution.Simple.PackageIndex

78+ Distribution.Simple.PreProcess Distribution.Simple.PreProcess.Unlit

79+ Distribution.Simple.Program Distribution.Simple.Program.Ar

80+ Distribution.Simple.Program.Builtin Distribution.Simple.Program.Db

81+ Distribution.Simple.Program.Find Distribution.Simple.Program.GHC

82+ Distribution.Simple.Program.HcPkg Distribution.Simple.Program.Hpc

83+ Distribution.Simple.Program.Internal Distribution.Simple.Program.Ld

84+ Distribution.Simple.Program.ResponseFile

85+ Distribution.Simple.Program.Run Distribution.Simple.Program.Script

86+ Distribution.Simple.Program.Strip Distribution.Simple.Program.Types

87+ Distribution.Simple.Register Distribution.Simple.Setup

88+ Distribution.Simple.ShowBuildInfo Distribution.Simple.SrcDist

89+ Distribution.Simple.Test Distribution.Simple.Test.ExeV10

90+ Distribution.Simple.Test.LibV09 Distribution.Simple.Test.Log

91+ Distribution.Simple.UHC Distribution.Simple.UserHooks

92+ Distribution.Simple.Utils Distribution.System

93+ Distribution.TestSuite Distribution.Text

94+ Distribution.Types.AbiDependency Distribution.Types.AbiHash

95+ Distribution.Types.AnnotatedId Distribution.Types.Benchmark

96+ Distribution.Types.Benchmark.Lens

97+ Distribution.Types.BenchmarkInterface

98+ Distribution.Types.BenchmarkType Distribution.Types.BuildInfo

99+ Distribution.Types.BuildInfo.Lens Distribution.Types.BuildType

100+ Distribution.Types.Component Distribution.Types.ComponentId

101+ Distribution.Types.ComponentInclude

102+ Distribution.Types.ComponentLocalBuildInfo

103+ Distribution.Types.ComponentName

104+ Distribution.Types.ComponentRequestedSpec

105+ Distribution.Types.CondTree Distribution.Types.Condition

106+ Distribution.Types.Dependency Distribution.Types.DependencyMap

107+ Distribution.Types.ExeDependency Distribution.Types.Executable

108+ Distribution.Types.Executable.Lens

109+ Distribution.Types.ExecutableScope Distribution.Types.ExposedModule

110+ Distribution.Types.ForeignLib 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.VersionRange

147+ Distribution.Types.VersionRange.Internal Distribution.Utils.Generic

148+ Distribution.Utils.IOData Distribution.Utils.LogProgress

149+ Distribution.Utils.MapAccum Distribution.Utils.NubList

150+ Distribution.Utils.Progress Distribution.Utils.ShortText

151+ Distribution.Verbosity Distribution.Verbosity.Internal

152+ Distribution.Version Language.Haskell.Extension

153+hidden-modules:

154+ Distribution.Backpack.PreExistingComponent

155+ Distribution.Backpack.ReadyComponent Distribution.Backpack.MixLink

156+ Distribution.Backpack.ModuleScope Distribution.Backpack.UnifyM

157+ Distribution.Backpack.Id Distribution.Utils.UnionFind

158+ Distribution.Utils.Base62 Distribution.Compat.CopyFile

159+ Distribution.Compat.GetShortPathName Distribution.Compat.MonadFail

160+ Distribution.Compat.Prelude Distribution.Compat.SnocList

161+ Distribution.GetOpt Distribution.Lex Distribution.Utils.String

162+ Distribution.Simple.GHC.EnvironmentParser

163+ Distribution.Simple.GHC.Internal Distribution.Simple.GHC.ImplInfo

164+ Distribution.Simple.Utils.Json Paths_Cabal

165+import-dirs:

166+library-dirs:

167+dynamic-library-dirs:

168+data-dir:

169+hs-libraries: HSCabal-3.0.1.0

170+depends:

171+ array-0.5.4.0 base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.1

172+ containers-0.6.2.1 deepseq-1.4.4.0 directory-1.3.6.0

173+ filepath-1.4.2.1 mtl-2.2.2 parsec-3.1.14.0 pretty-1.1.3.6

174+ process-1.6.9.0 text-1.2.4.0 time-1.9.3 transformers-0.5.6.2

175+ unix-2.7.2.2

176+haddock-interfaces:

177+haddock-html:

178+---

179+name: array

180+version: 0.5.4.0

181+visibility: public

182+id: array-0.5.4.0

183+key: array-0.5.4.0

184+license: BSD-3-Clause

185+maintainer: libraries@haskell.org

186+synopsis: Mutable and immutable arrays

187+description:

188+ In addition to providing the "Data.Array" module

189+ <http://www.haskell.org/onlinereport/haskell2010/haskellch14.html as specified in the Haskell 2010 Language Report>,

190+ this package also defines the classes 'IArray' of

191+ immutable arrays and 'MArray' of arrays mutable within appropriate

192+ monads, as well as some instances of these classes.

193+category: Data Structures

194+exposed: True

195+exposed-modules:

196+ Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO

197+ Data.Array.IO.Internals Data.Array.IO.Safe Data.Array.MArray

198+ Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe

199+ Data.Array.Storable Data.Array.Storable.Internals

200+ Data.Array.Storable.Safe Data.Array.Unboxed Data.Array.Unsafe

201+import-dirs:

202+library-dirs:

203+dynamic-library-dirs:

204+data-dir:

205+hs-libraries: HSarray-0.5.4.0

206+depends: base-4.13.0.0

207+haddock-interfaces:

208+haddock-html:

209+---

210+name: base

211+version: 4.13.0.0

212+visibility: public

213+id: base-4.13.0.0

214+key: base-4.13.0.0

215+license: BSD-3-Clause

216+maintainer: libraries@haskell.org

217+synopsis: Basic libraries

218+description:

219+ This package contains the Standard Haskell "Prelude" and its support libraries,

220+ and a large collection of useful libraries ranging from data

221+ structures to parsing combinators and debugging utilities.

222+category: Prelude

223+exposed: True

224+exposed-modules:

225+ Control.Applicative Control.Arrow Control.Category

226+ Control.Concurrent Control.Concurrent.Chan Control.Concurrent.MVar

227+ Control.Concurrent.QSem Control.Concurrent.QSemN Control.Exception

228+ Control.Exception.Base Control.Monad Control.Monad.Fail

229+ Control.Monad.Fix Control.Monad.IO.Class Control.Monad.Instances

230+ Control.Monad.ST Control.Monad.ST.Lazy Control.Monad.ST.Lazy.Safe

231+ Control.Monad.ST.Lazy.Unsafe Control.Monad.ST.Safe

232+ Control.Monad.ST.Strict Control.Monad.ST.Unsafe Control.Monad.Zip

233+ Data.Bifoldable Data.Bifunctor Data.Bitraversable Data.Bits

234+ Data.Bool Data.Char Data.Coerce Data.Complex Data.Data Data.Dynamic

235+ Data.Either Data.Eq Data.Fixed Data.Foldable Data.Function

236+ Data.Functor Data.Functor.Classes Data.Functor.Compose

237+ Data.Functor.Const Data.Functor.Contravariant Data.Functor.Identity

238+ Data.Functor.Product Data.Functor.Sum Data.IORef Data.Int Data.Ix

239+ Data.Kind Data.List Data.List.NonEmpty Data.Maybe Data.Monoid

240+ Data.Ord Data.Proxy Data.Ratio Data.STRef Data.STRef.Lazy

241+ Data.STRef.Strict Data.Semigroup Data.String Data.Traversable

242+ Data.Tuple Data.Type.Bool Data.Type.Coercion Data.Type.Equality

243+ Data.Typeable Data.Unique Data.Version Data.Void Data.Word

244+ Debug.Trace Foreign Foreign.C Foreign.C.Error Foreign.C.String

245+ Foreign.C.Types Foreign.Concurrent Foreign.ForeignPtr

246+ Foreign.ForeignPtr.Safe Foreign.ForeignPtr.Unsafe Foreign.Marshal

247+ Foreign.Marshal.Alloc Foreign.Marshal.Array Foreign.Marshal.Error

248+ Foreign.Marshal.Pool Foreign.Marshal.Safe Foreign.Marshal.Unsafe

249+ Foreign.Marshal.Utils Foreign.Ptr Foreign.Safe Foreign.StablePtr

250+ Foreign.Storable GHC.Arr GHC.Base GHC.ByteOrder GHC.Char GHC.Clock

251+ GHC.Conc GHC.Conc.IO GHC.Conc.Signal GHC.Conc.Sync

252+ GHC.ConsoleHandler GHC.Constants GHC.Desugar GHC.Enum

253+ GHC.Environment GHC.Err GHC.Event GHC.Exception GHC.Exception.Type

254+ GHC.ExecutionStack GHC.ExecutionStack.Internal GHC.Exts

255+ GHC.Fingerprint GHC.Fingerprint.Type GHC.Float

256+ GHC.Float.ConversionUtils GHC.Float.RealFracMethods GHC.Foreign

257+ GHC.ForeignPtr GHC.GHCi GHC.GHCi.Helpers GHC.Generics GHC.IO

258+ GHC.IO.Buffer GHC.IO.BufferedIO GHC.IO.Device GHC.IO.Encoding

259+ GHC.IO.Encoding.CodePage GHC.IO.Encoding.Failure

260+ GHC.IO.Encoding.Iconv GHC.IO.Encoding.Latin1 GHC.IO.Encoding.Types

261+ GHC.IO.Encoding.UTF16 GHC.IO.Encoding.UTF32 GHC.IO.Encoding.UTF8

262+ GHC.IO.Exception GHC.IO.FD GHC.IO.Handle GHC.IO.Handle.FD

263+ GHC.IO.Handle.Internals GHC.IO.Handle.Lock GHC.IO.Handle.Text

264+ GHC.IO.Handle.Types GHC.IO.IOMode GHC.IO.Unsafe GHC.IOArray

265+ GHC.IORef GHC.Int GHC.List GHC.MVar GHC.Maybe GHC.Natural GHC.Num

266+ GHC.OldList GHC.OverloadedLabels GHC.Pack GHC.Profiling GHC.Ptr

267+ GHC.RTS.Flags GHC.Read GHC.Real GHC.Records GHC.ResponseFile GHC.ST

268+ GHC.STRef GHC.Show GHC.Stable GHC.StableName GHC.Stack

269+ GHC.Stack.CCS GHC.Stack.Types GHC.StaticPtr GHC.Stats GHC.Storable

270+ GHC.TopHandler GHC.TypeLits GHC.TypeNats GHC.Unicode GHC.Weak

271+ GHC.Word Numeric Numeric.Natural Prelude System.CPUTime

272+ System.Console.GetOpt System.Environment System.Environment.Blank

273+ System.Exit System.IO System.IO.Error System.IO.Unsafe System.Info

274+ System.Mem System.Mem.StableName System.Mem.Weak

275+ System.Posix.Internals System.Posix.Types System.Timeout

276+ Text.ParserCombinators.ReadP Text.ParserCombinators.ReadPrec

277+ Text.Printf Text.Read Text.Read.Lex Text.Show Text.Show.Functions

278+ Type.Reflection Type.Reflection.Unsafe Unsafe.Coerce

279+hidden-modules:

280+ Control.Monad.ST.Imp Control.Monad.ST.Lazy.Imp Data.Functor.Utils

281+ Data.OldList Data.Semigroup.Internal Data.Typeable.Internal

282+ Foreign.ForeignPtr.Imp GHC.StaticPtr.Internal

283+ System.Environment.ExecutablePath System.CPUTime.Utils

284+ GHC.Event.Arr GHC.Event.Array GHC.Event.Control GHC.Event.EPoll

285+ GHC.Event.IntTable GHC.Event.Internal GHC.Event.KQueue

286+ GHC.Event.Manager GHC.Event.PSQ GHC.Event.Poll GHC.Event.Thread

287+ GHC.Event.TimerManager GHC.Event.Unique

288+ System.CPUTime.Posix.ClockGetTime System.CPUTime.Posix.Times

289+ System.CPUTime.Posix.RUsage System.CPUTime.Unsupported

290+import-dirs:

291+library-dirs:

292+dynamic-library-dirs:

293+data-dir:

294+hs-libraries: HSbase-4.13.0.0

295+include-dirs:

296+includes: HsBase.h

297+depends: ghc-prim-0.5.3 integer-gmp-1.0.2.0 rts

298+haddock-interfaces:

299+haddock-html:

300+---

301+name: binary

302+version: 0.8.7.0

303+visibility: public

304+id: binary-0.8.7.0

305+key: binary-0.8.7.0

306+license: BSD-3-Clause

307+maintainer: Lennart Kolmodin, Don Stewart <dons00@gmail.com>

308+author: Lennart Kolmodin <kolmodin@gmail.com>

309+stability: provisional

310+homepage: https://github.com/kolmodin/binary

311+synopsis:

312+ Binary serialisation for Haskell values using lazy ByteStrings

313+description:

314+ Efficient, pure binary serialisation using lazy ByteStrings.

315+ Haskell values may be encoded to and from binary formats,

316+ written to disk as binary, or sent over the network.

317+ The format used can be automatically generated, or

318+ you can choose to implement a custom format if needed.

319+ Serialisation speeds of over 1 G\/sec have been observed,

320+ so this library should be suitable for high performance

321+ scenarios.

322+category: Data, Parsing

323+exposed: True

324+exposed-modules:

325+ Data.Binary Data.Binary.Builder Data.Binary.Get

326+ Data.Binary.Get.Internal Data.Binary.Put

327+hidden-modules:

328+ Data.Binary.Class Data.Binary.Internal Data.Binary.Generic

329+ Data.Binary.FloatCast

330+import-dirs:

331+library-dirs:

332+dynamic-library-dirs:

333+data-dir:

334+hs-libraries: HSbinary-0.8.7.0

335+depends:

336+ array-0.5.4.0 base-4.13.0.0 bytestring-0.10.10.1 containers-0.6.2.1

337+haddock-interfaces:

338+haddock-html:

339+---

340+name: bytestring

341+version: 0.10.10.1

342+visibility: public

343+id: bytestring-0.10.10.1

344+key: bytestring-0.10.10.1

345+license: BSD-3-Clause

346+copyright:

347+ Copyright (c) Don Stewart 2005-2009,

348+ (c) Duncan Coutts 2006-2015,

349+ (c) David Roundy 2003-2005,

350+ (c) Jasper Van der Jeugt 2010,

351+ (c) Simon Meier 2010-2013.

352+maintainer: Duncan Coutts <duncan@community.haskell.org>

353+author:

354+ Don Stewart,

355+ Duncan Coutts

356+homepage: https://github.com/haskell/bytestring

357+synopsis:

358+ Fast, compact, strict and lazy byte strings with a list interface

359+description:

360+ An efficient compact, immutable byte string type (both strict and lazy)

361+ suitable for binary or 8-bit character data.

362+ The 'ByteString' type represents sequences of bytes or 8-bit characters.

363+ It is suitable for high performance use, both in terms of large data

364+ quantities, or high speed requirements. The 'ByteString' functions follow

365+ the same style as Haskell\'s ordinary lists, so it is easy to convert code

366+ from using 'String' to 'ByteString'.

367+ Two 'ByteString' variants are provided:

368+ * Strict 'ByteString's keep the string as a single large array. This

369+ makes them convenient for passing data between C and Haskell.

370+ * Lazy 'ByteString's use a lazy list of strict chunks which makes it

371+ suitable for I\/O streaming tasks.

372+ The @Char8@ modules provide a character-based view of the same

373+ underlying 'ByteString' types. This makes it convenient to handle mixed

374+ binary and 8-bit character content (which is common in many file formats

375+ and network protocols).

376+ The 'Builder' module provides an efficient way to build up 'ByteString's

377+ in an ad-hoc way by repeated concatenation. This is ideal for fast

378+ serialisation or pretty printing.

379+ There is also a 'ShortByteString' type which has a lower memory overhead

380+ and can can be converted to or from a 'ByteString', but supports very few

381+ other operations. It is suitable for keeping many short strings in memory.

382+ 'ByteString's are not designed for Unicode. For Unicode strings you should

383+ use the 'Text' type from the @text@ package.

384+ These modules are intended to be imported qualified, to avoid name clashes

385+ with "Prelude" functions, e.g.

386+ > import qualified Data.ByteString as BS

387+category: Data

388+exposed: True

389+exposed-modules:

390+ Data.ByteString Data.ByteString.Builder

391+ Data.ByteString.Builder.Extra Data.ByteString.Builder.Internal

392+ Data.ByteString.Builder.Prim Data.ByteString.Builder.Prim.Internal

393+ Data.ByteString.Char8 Data.ByteString.Internal Data.ByteString.Lazy

394+ Data.ByteString.Lazy.Builder Data.ByteString.Lazy.Builder.ASCII

395+ Data.ByteString.Lazy.Builder.Extras Data.ByteString.Lazy.Char8

396+ Data.ByteString.Lazy.Internal Data.ByteString.Short

397+ Data.ByteString.Short.Internal Data.ByteString.Unsafe

398+hidden-modules:

399+ Data.ByteString.Builder.ASCII Data.ByteString.Builder.Prim.Binary

400+ Data.ByteString.Builder.Prim.ASCII

401+ Data.ByteString.Builder.Prim.Internal.Floating

402+ Data.ByteString.Builder.Prim.Internal.UncheckedShifts

403+ Data.ByteString.Builder.Prim.Internal.Base16

404+import-dirs:

405+library-dirs:

406+dynamic-library-dirs:

407+data-dir:

408+hs-libraries: HSbytestring-0.10.10.1

409+include-dirs:

410+includes: fpstring.h

411+depends:

412+ base-4.13.0.0 deepseq-1.4.4.0 ghc-prim-0.5.3 integer-gmp-1.0.2.0

413+haddock-interfaces:

414+haddock-html:

415+---

416+name: containers

417+version: 0.6.2.1

418+visibility: public

419+id: containers-0.6.2.1

420+key: containers-0.6.2.1

421+license: BSD-3-Clause

422+maintainer: libraries@haskell.org

423+synopsis: Assorted concrete container types

424+description:

425+ This package contains efficient general-purpose implementations

426+ of various immutable container types including sets, maps, sequences,

427+ trees, and graphs.

428+ For a walkthrough of what this package provides with examples of common

429+ operations see the [containers

430+ introduction](https://haskell-containers.readthedocs.io).

431+ The declared cost of each operation is either worst-case or amortized, but

432+ remains valid even if structures are shared.

433+category: Data Structures

434+exposed: True

435+exposed-modules:

436+ Data.Containers.ListUtils Data.Graph Data.IntMap

437+ Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy

438+ Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict

439+ Data.IntMap.Strict.Internal Data.IntSet Data.IntSet.Internal

440+ Data.Map Data.Map.Internal Data.Map.Internal.Debug Data.Map.Lazy

441+ Data.Map.Merge.Lazy Data.Map.Merge.Strict Data.Map.Strict

442+ Data.Map.Strict.Internal Data.Sequence Data.Sequence.Internal

443+ Data.Sequence.Internal.Sorting Data.Set Data.Set.Internal Data.Tree

444+ Utils.Containers.Internal.BitQueue

445+ Utils.Containers.Internal.BitUtil

446+ Utils.Containers.Internal.StrictPair

447+hidden-modules:

448+ Utils.Containers.Internal.State

449+ Utils.Containers.Internal.StrictMaybe

450+ Utils.Containers.Internal.PtrEquality

451+ Utils.Containers.Internal.Coercions

452+ Utils.Containers.Internal.TypeError

453+ Data.Map.Internal.DeprecatedShowTree

454+ Data.IntMap.Internal.DeprecatedDebug

455+import-dirs:

456+library-dirs:

457+dynamic-library-dirs:

458+data-dir:

459+hs-libraries: HScontainers-0.6.2.1

460+depends: array-0.5.4.0 base-4.13.0.0 deepseq-1.4.4.0

461+haddock-interfaces:

462+haddock-html:

463+---

464+name: deepseq

465+version: 1.4.4.0

466+visibility: public

467+id: deepseq-1.4.4.0

468+key: deepseq-1.4.4.0

469+license: BSD-3-Clause

470+maintainer: libraries@haskell.org

471+synopsis: Deep evaluation of data structures

472+description:

473+ This package provides methods for fully evaluating data structures

474+ (\"deep evaluation\"). Deep evaluation is often used for adding

475+ strictness to a program, e.g. in order to force pending exceptions,

476+ remove space leaks, or force lazy I/O to happen. It is also useful

477+ in parallel programs, to ensure pending work does not migrate to the

478+ wrong thread.

479+ The primary use of this package is via the 'deepseq' function, a

480+ \"deep\" version of 'seq'. It is implemented on top of an 'NFData'

481+ typeclass (\"Normal Form Data\", data structures with no unevaluated

482+ components) which defines strategies for fully evaluating different

483+ data types. See module documentation in "Control.DeepSeq" for more

484+ details.

485+category: Control

486+exposed: True

487+exposed-modules: Control.DeepSeq

488+hidden-modules: Control.DeepSeq.BackDoor

489+import-dirs:

490+library-dirs:

491+dynamic-library-dirs:

492+data-dir:

493+hs-libraries: HSdeepseq-1.4.4.0

494+depends: array-0.5.4.0 base-4.13.0.0

495+haddock-interfaces:

496+haddock-html:

497+---

498+name: directory

499+version: 1.3.6.0

500+visibility: public

501+id: directory-1.3.6.0

502+key: directory-1.3.6.0

503+license: BSD-3-Clause

504+maintainer: libraries@haskell.org

505+synopsis: Platform-agnostic library for filesystem operations

506+description:

507+ This library provides a basic set of operations for manipulating files and

508+ directories in a portable way.

509+category: System

510+exposed: True

511+exposed-modules:

512+ System.Directory System.Directory.Internal

513+ System.Directory.Internal.Prelude

514+hidden-modules:

515+ System.Directory.Internal.C_utimensat

516+ System.Directory.Internal.Common System.Directory.Internal.Config

517+ System.Directory.Internal.Posix System.Directory.Internal.Windows

518+import-dirs:

519+library-dirs:

520+dynamic-library-dirs:

521+data-dir:

522+hs-libraries: HSdirectory-1.3.6.0

523+depends:

524+ base-4.13.0.0 filepath-1.4.2.1 time-1.9.3 unix-2.7.2.2

525+haddock-interfaces:

526+haddock-html:

527+---

528+name: filepath

529+version: 1.4.2.1

530+visibility: public

531+id: filepath-1.4.2.1

532+key: filepath-1.4.2.1

533+license: BSD-3-Clause

534+copyright: Neil Mitchell 2005-2018

535+maintainer: Neil Mitchell <ndmitchell@gmail.com>

536+author: Neil Mitchell <ndmitchell@gmail.com>

537+homepage: https://github.com/haskell/filepath#readme

538+synopsis: Library for manipulating FilePaths in a cross platform way.

539+description:

540+ 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:

541+ * "System.FilePath.Posix" manipulates POSIX\/Linux style @FilePath@ values (with @\/@ as the path separator).

542+ * "System.FilePath.Windows" manipulates Windows style @FilePath@ values (with either @\\@ or @\/@ as the path separator, and deals with drives).

543+ * "System.FilePath" is an alias for the module appropriate to your platform.

544+ All three modules provide the same API, and the same documentation (calling out differences in the different variants).

545+category: System

546+exposed: True

547+exposed-modules:

548+ System.FilePath System.FilePath.Posix System.FilePath.Windows

549+import-dirs:

550+library-dirs:

551+dynamic-library-dirs:

552+data-dir:

553+hs-libraries: HSfilepath-1.4.2.1

554+depends: base-4.13.0.0

555+haddock-interfaces:

556+haddock-html:

557+---

558+name: ghc

559+version: 8.8.4

560+visibility: public

561+id: ghc-8.8.4

562+key: ghc-8.8.4

563+license: BSD-3-Clause

564+maintainer: glasgow-haskell-users@haskell.org

565+author: The GHC Team

566+homepage: http://www.haskell.org/ghc/

567+synopsis: The GHC API

568+description:

569+ GHC's functionality can be useful for more things than just

570+ compiling Haskell programs. Important use cases are programs

571+ that analyse (and perhaps transform) Haskell code. Others

572+ include loading Haskell code dynamically in a GHCi-like manner.

573+ For this reason, a lot of GHC's functionality is made available

574+ through this package.

575+category: Development

576+exposed-modules:

577+ Annotations ApiAnnotation Ar AsmCodeGen AsmUtils Avail Bag

578+ BasicTypes BinFingerprint BinIface Binary Bitmap BkpSyn BlockId

579+ BlockLayout BooleanFormula BufWrite BuildTyCl ByteCodeAsm

580+ ByteCodeGen ByteCodeInstr ByteCodeItbls ByteCodeLink ByteCodeTypes

581+ CFG CLabel CPrim CSE CallArity CgUtils Check Class ClsInst

582+ CmdLineParser Cmm CmmBuildInfoTables CmmCallConv CmmCommonBlockElim

583+ CmmContFlowOpt CmmExpr CmmImplementSwitchPlans CmmInfo

584+ CmmLayoutStack CmmLex CmmLint CmmLive CmmMachOp CmmMonad CmmNode

585+ CmmOpt CmmParse CmmPipeline CmmProcPoint CmmSink CmmSwitch CmmType

586+ CmmUtils CoAxiom CodeGen.Platform CodeGen.Platform.ARM

587+ CodeGen.Platform.ARM64 CodeGen.Platform.NoRegs CodeGen.Platform.PPC

588+ CodeGen.Platform.SPARC CodeGen.Platform.X86 CodeGen.Platform.X86_64

589+ CodeOutput Coercion ConLike Config Constants Convert CoreArity

590+ CoreFVs CoreLint CoreMap CoreMonad CoreOpt CorePrep CoreSeq

591+ CoreStats CoreSubst CoreSyn CoreTidy CoreToStg CoreUnfold CoreUtils

592+ CostCentre CostCentreState Coverage Ctype DataCon Debug Debugger

593+ Demand Desugar Digraph DmdAnal DriverBkp DriverMkDepend

594+ DriverPhases DriverPipeline DsArrows DsBinds DsCCall DsExpr

595+ DsForeign DsGRHSs DsListComp DsMeta DsMonad DsUsage DsUtils Dwarf

596+ Dwarf.Constants Dwarf.Types DynFlags DynamicLoading Elf Encoding

597+ EnumSet ErrUtils Exception Exitify ExtractDocs FV FamInst

598+ FamInstEnv FastFunctions FastMutInt FastString FastStringEnv

599+ FieldLabel FileCleanup Finder Fingerprint FiniteMap FlagChecker

600+ FloatIn FloatOut ForeignCall Format FunDeps GHC GHCi GhcMake

601+ GhcMonad GhcPlugins GraphBase GraphColor GraphOps GraphPpr

602+ HaddockUtils HeaderInfo HieAst HieBin HieDebug HieTypes HieUtils

603+ Hooks Hoopl.Block Hoopl.Collections Hoopl.Dataflow Hoopl.Graph

604+ Hoopl.Label HsBinds HsDecls HsDoc HsDumpAst HsExpr HsExtension

605+ HsImpExp HsInstances HsLit HsPat HsSyn HsTypes HsUtils HscMain

606+ HscStats HscTypes IOEnv Id IdInfo IfaceEnv IfaceSyn IfaceType Inst

607+ InstEnv Instruction InteractiveEval InteractiveEvalTypes Json Kind

608+ KnownUniques Lexeme Lexer LiberateCase Linker ListSetOps ListT

609+ Literal Llvm Llvm.AbsSyn Llvm.MetaData Llvm.PpLlvm Llvm.Types

610+ LlvmCodeGen LlvmCodeGen.Base LlvmCodeGen.CodeGen LlvmCodeGen.Data

611+ LlvmCodeGen.Ppr LlvmCodeGen.Regs LlvmMangler LoadIface Match

612+ MatchCon MatchLit Maybes MkCore MkGraph MkId MkIface Module

613+ MonadUtils NCGMonad Name NameCache NameEnv NameSet NameShape

614+ OccName OccurAnal OptCoercion OrdList Outputable PIC PPC.CodeGen

615+ PPC.Cond PPC.Instr PPC.Ppr PPC.RegInfo PPC.Regs PackageConfig

616+ Packages Pair Panic Parser PatSyn PipelineMonad PlaceHolder

617+ PlainPanic Platform PlatformConstants Plugins PmExpr PprBase PprC

618+ PprCmm PprCmmDecl PprCmmExpr PprColour PprCore PprTyThing PrelInfo

619+ PrelNames PrelRules Pretty PrimOp ProfInit RdrHsSyn RdrName Reg

620+ RegAlloc.Graph.ArchBase RegAlloc.Graph.ArchX86

621+ RegAlloc.Graph.Coalesce RegAlloc.Graph.Main RegAlloc.Graph.Spill

622+ RegAlloc.Graph.SpillClean RegAlloc.Graph.SpillCost

623+ RegAlloc.Graph.Stats RegAlloc.Graph.TrivColorable

624+ RegAlloc.Linear.Base RegAlloc.Linear.FreeRegs

625+ RegAlloc.Linear.JoinToTargets RegAlloc.Linear.Main

626+ RegAlloc.Linear.PPC.FreeRegs RegAlloc.Linear.SPARC.FreeRegs

627+ RegAlloc.Linear.StackMap RegAlloc.Linear.State

628+ RegAlloc.Linear.Stats RegAlloc.Linear.X86.FreeRegs

629+ RegAlloc.Linear.X86_64.FreeRegs RegAlloc.Liveness RegClass RepType

630+ RnBinds RnEnv RnExpr RnFixity RnHsDoc RnModIface RnNames RnPat

631+ RnSource RnSplice RnTypes RnUnbound RnUtils RtClosureInspect Rules

632+ SAT SMRep SPARC.AddrMode SPARC.Base SPARC.CodeGen

633+ SPARC.CodeGen.Amode SPARC.CodeGen.Base SPARC.CodeGen.CondCode

634+ SPARC.CodeGen.Expand SPARC.CodeGen.Gen32 SPARC.CodeGen.Gen64

635+ SPARC.CodeGen.Sanity SPARC.Cond SPARC.Imm SPARC.Instr SPARC.Ppr

636+ SPARC.Regs SPARC.ShortcutJump SPARC.Stack SetLevels SimplCore

637+ SimplEnv SimplMonad SimplStg SimplUtils Simplify SpecConstr

638+ Specialise SrcLoc State StaticPtrTable StgCmm StgCmmArgRep

639+ StgCmmBind StgCmmClosure StgCmmCon StgCmmEnv StgCmmExpr

640+ StgCmmExtCode StgCmmForeign StgCmmHeap StgCmmHpc StgCmmLayout

641+ StgCmmMonad StgCmmPrim StgCmmProf StgCmmTicky StgCmmUtils StgCse

642+ StgFVs StgLiftLams StgLiftLams.Analysis StgLiftLams.LiftM

643+ StgLiftLams.Transformation StgLint StgStats StgSubst StgSyn Stream

644+ StringBuffer SysTools SysTools.BaseDir SysTools.ExtraObj

645+ SysTools.Info SysTools.Process SysTools.Tasks SysTools.Terminal

646+ THNames TargetReg TcAnnotations TcArrows TcBackpack TcBinds

647+ TcCanonical TcClassDcl TcDefaults TcDeriv TcDerivInfer TcDerivUtils

648+ TcEnv TcErrors TcEvTerm TcEvidence TcExpr TcFlatten TcForeign

649+ TcGenDeriv TcGenFunctor TcGenGenerics TcHoleErrors TcHsSyn TcHsType

650+ TcIface TcInstDcls TcInteract TcMType TcMatches TcPat TcPatSyn

651+ TcPluginM TcRnDriver TcRnExports TcRnMonad TcRnTypes TcRules

652+ TcSMonad TcSigs TcSimplify TcSplice TcTyClsDecls TcTyDecls TcType

653+ TcTypeNats TcTypeable TcTypeableValidity TcUnify TcValidity TidyPgm

654+ TmOracle ToIface TrieMap TyCoRep TyCon Type TysPrim TysWiredIn

655+ UnVarGraph UnariseStg Unify UniqDFM UniqDSet UniqFM UniqMap UniqSet

656+ UniqSupply Unique Util Var VarEnv VarSet WorkWrap WwLib X86.CodeGen

657+ X86.Cond X86.Instr X86.Ppr X86.RegInfo X86.Regs

658+hidden-modules: GhcPrelude

659+import-dirs:

660+library-dirs:

661+dynamic-library-dirs:

662+data-dir:

663+hs-libraries: HSghc-8.8.4

664+include-dirs:

665+depends:

666+ array-0.5.4.0 base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.1

667+ containers-0.6.2.1 deepseq-1.4.4.0 directory-1.3.6.0

668+ filepath-1.4.2.1 ghc-boot-8.8.4 ghc-boot-th-8.8.4 ghc-heap-8.8.4

669+ ghci-8.8.4 hpc-0.6.0.3 integer-gmp-1.0.2.0 process-1.6.9.0

670+ template-haskell-2.15.0.0 terminfo-0.4.1.4 time-1.9.3

671+ transformers-0.5.6.2 unix-2.7.2.2

672+haddock-interfaces:

673+haddock-html:

674+---

675+name: ghc-boot

676+version: 8.8.4

677+visibility: public

678+id: ghc-boot-8.8.4

679+key: ghc-boot-8.8.4

680+license: BSD-3-Clause

681+maintainer: ghc-devs@haskell.org

682+synopsis: Shared functionality between GHC and its boot libraries

683+description:

684+ This library is shared between GHC, ghc-pkg, and other boot

685+ libraries.

686+ A note about "GHC.PackageDb": it only deals with the subset of

687+ the package database that the compiler cares about: modules

688+ paths etc and not package metadata like description, authors

689+ etc. It is thus not a library interface to ghc-pkg and is *not*

690+ suitable for modifying GHC package databases.

691+ The package database format and this library are constructed in

692+ such a way that while ghc-pkg depends on Cabal, the GHC library

693+ and program do not have to depend on Cabal.

694+category: GHC

695+exposed: True

696+exposed-modules:

697+ GHC.ForeignSrcLang GHC.HandleEncoding GHC.LanguageExtensions

698+ GHC.PackageDb GHC.Serialized

699+import-dirs:

700+library-dirs:

701+dynamic-library-dirs:

702+data-dir:

703+hs-libraries: HSghc-boot-8.8.4

704+depends:

705+ base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.1 directory-1.3.6.0

706+ filepath-1.4.2.1 ghc-boot-th-8.8.4

707+haddock-interfaces:

708+haddock-html:

709+---

710+name: ghc-boot-th

711+version: 8.8.4

712+visibility: public

713+id: ghc-boot-th-8.8.4

714+key: ghc-boot-th-8.8.4

715+license: BSD-3-Clause

716+maintainer: ghc-devs@haskell.org

717+synopsis:

718+ Shared functionality between GHC and the @template-haskell@

719+ library

720+description:

721+ This library contains various bits shared between the @ghc@ and

722+ @template-haskell@ libraries.

723+ This package exists to ensure that @template-haskell@ has a

724+ minimal set of transitive dependencies, since it is intended to

725+ be depended upon by user code.

726+category: GHC

727+exposed: True

728+exposed-modules:

729+ GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme

730+import-dirs:

731+library-dirs:

732+dynamic-library-dirs:

733+data-dir:

734+hs-libraries: HSghc-boot-th-8.8.4

735+depends: base-4.13.0.0

736+haddock-interfaces:

737+haddock-html:

738+---

739+name: ghc-compact

740+version: 0.1.0.0

741+visibility: public

742+id: ghc-compact-0.1.0.0

743+key: ghc-compact-0.1.0.0

744+license: BSD-3-Clause

745+maintainer: libraries@haskell.org

746+synopsis: In memory storage of deeply evaluated data structure

747+description:

748+ This package provides minimal functionality for working with

749+ "compact regions", which hold a fully evaluated Haskell object graph.

750+ These regions maintain the invariant that no pointers live inside the struct

751+ that point outside it, which ensures efficient garbage collection without

752+ ever reading the structure contents (effectively, it works as a manually

753+ managed "oldest generation" which is never freed until the whole is

754+ released).

755+ Internally, the struct is stored a single contiguous block of memory,

756+ which allows efficient serialization and deserialization of structs

757+ for distributed computing.

758+category: Data

759+exposed: True

760+exposed-modules: GHC.Compact GHC.Compact.Serialized

761+import-dirs:

762+library-dirs:

763+dynamic-library-dirs:

764+data-dir:

765+hs-libraries: HSghc-compact-0.1.0.0

766+depends: base-4.13.0.0 bytestring-0.10.10.1 ghc-prim-0.5.3

767+haddock-interfaces:

768+haddock-html:

769+---

770+name: ghc-heap

771+version: 8.8.4

772+visibility: public

773+id: ghc-heap-8.8.4

774+key: ghc-heap-8.8.4

775+license: BSD-3-Clause

776+maintainer: libraries@haskell.org

777+synopsis: Functions for walking GHC's heap

778+description:

779+ This package provides functions for walking the GHC heap data structures

780+ and retrieving information about those data structures.

781+category: GHC

782+exposed: True

783+exposed-modules:

784+ GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures

785+ GHC.Exts.Heap.Constants GHC.Exts.Heap.InfoTable

786+ GHC.Exts.Heap.InfoTable.Types GHC.Exts.Heap.InfoTableProf

787+ GHC.Exts.Heap.Utils

788+import-dirs:

789+library-dirs:

790+dynamic-library-dirs:

791+data-dir:

792+hs-libraries: HSghc-heap-8.8.4

793+depends: base-4.13.0.0 ghc-prim-0.5.3 rts

794+haddock-interfaces:

795+haddock-html:

796+---

797+name: ghc-prim

798+version: 0.5.3

799+visibility: public

800+id: ghc-prim-0.5.3

801+key: ghc-prim-0.5.3

802+license: BSD-3-Clause

803+maintainer: libraries@haskell.org

804+synopsis: GHC primitives

805+description:

806+ This package contains the primitive types and operations supplied by GHC.

807+category: GHC

808+exposed: True

809+exposed-modules:

810+ GHC.CString GHC.Classes GHC.Debug GHC.IntWord64 GHC.Magic

811+ GHC.PrimopWrappers GHC.Tuple GHC.Types GHC.Prim

812+import-dirs:

813+library-dirs:

814+dynamic-library-dirs:

815+data-dir:

816+hs-libraries: HSghc-prim-0.5.3

817+extra-libraries: c m

818+include-dirs:

819+depends: rts

820+haddock-interfaces:

821+haddock-html:

822+---

823+name: ghci

824+version: 8.8.4

825+visibility: public

826+id: ghci-8.8.4

827+key: ghci-8.8.4

828+license: BSD-3-Clause

829+maintainer: ghc-devs@haskell.org

830+synopsis: The library supporting GHC's interactive interpreter

831+description:

832+ This library offers interfaces which mediate interactions between the

833+ @ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter

834+ backend.

835+category: GHC

836+exposed: True

837+exposed-modules:

838+ GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI

839+ GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes

840+ GHCi.ResolvedBCO GHCi.Run GHCi.Signals GHCi.StaticPtrTable GHCi.TH

841+ GHCi.TH.Binary SizedSeq

842+import-dirs:

843+library-dirs:

844+dynamic-library-dirs:

845+data-dir:

846+hs-libraries: HSghci-8.8.4

847+include-dirs:

848+depends:

849+ array-0.5.4.0 base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.1

850+ containers-0.6.2.1 deepseq-1.4.4.0 filepath-1.4.2.1 ghc-boot-8.8.4

851+ ghc-boot-th-8.8.4 ghc-heap-8.8.4 template-haskell-2.15.0.0

852+ transformers-0.5.6.2 unix-2.7.2.2

853+haddock-interfaces:

854+haddock-html:

855+---

856+name: haskeline

857+version: 0.7.5.0

858+visibility: public

859+id: haskeline-0.7.5.0

860+key: haskeline-0.7.5.0

861+license: BSD-3-Clause

862+copyright: (c) Judah Jacobson

863+maintainer: Judah Jacobson <judah.jacobson@gmail.com>

864+author: Judah Jacobson

865+stability: Stable

866+homepage: https://github.com/judah/haskeline

867+synopsis:

868+ A command-line interface for user input, written in Haskell.

869+description:

870+ Haskeline provides a user interface for line input in command-line

871+ programs. This library is similar in purpose to readline, but since

872+ it is written in Haskell it is (hopefully) more easily used in other

873+ Haskell programs.

874+ Haskeline runs both on POSIX-compatible systems and on Windows.

875+category: User Interfaces

876+exposed: True

877+exposed-modules:

878+ System.Console.Haskeline System.Console.Haskeline.Completion

879+ System.Console.Haskeline.History System.Console.Haskeline.IO

880+ System.Console.Haskeline.MonadException

881+hidden-modules:

882+ System.Console.Haskeline.Backend

883+ System.Console.Haskeline.Backend.WCWidth

884+ System.Console.Haskeline.Command

885+ System.Console.Haskeline.Command.Completion

886+ System.Console.Haskeline.Command.History

887+ System.Console.Haskeline.Command.KillRing

888+ System.Console.Haskeline.Directory System.Console.Haskeline.Emacs

889+ System.Console.Haskeline.InputT System.Console.Haskeline.Key

890+ System.Console.Haskeline.LineState System.Console.Haskeline.Monads

891+ System.Console.Haskeline.Prefs System.Console.Haskeline.Recover

892+ System.Console.Haskeline.RunCommand System.Console.Haskeline.Term

893+ System.Console.Haskeline.Command.Undo System.Console.Haskeline.Vi

894+ System.Console.Haskeline.Backend.Posix

895+ System.Console.Haskeline.Backend.Posix.Encoder

896+ System.Console.Haskeline.Backend.DumbTerm

897+ System.Console.Haskeline.Backend.Terminfo

898+import-dirs:

899+library-dirs:

900+dynamic-library-dirs:

901+data-dir:

902+hs-libraries: HShaskeline-0.7.5.0

903+depends:

904+ base-4.13.0.0 bytestring-0.10.10.1 containers-0.6.2.1

905+ directory-1.3.6.0 filepath-1.4.2.1 process-1.6.9.0 stm-2.5.0.0

906+ terminfo-0.4.1.4 transformers-0.5.6.2 unix-2.7.2.2

907+haddock-interfaces:

908+haddock-html:

909+---

910+name: hpc

911+version: 0.6.0.3

912+visibility: public

913+id: hpc-0.6.0.3

914+key: hpc-0.6.0.3

915+license: BSD-3-Clause

916+maintainer: ghc-devs@haskell.org

917+author: Andy Gill

918+synopsis: Code Coverage Library for Haskell

919+description:

920+ This package provides the code coverage library for Haskell.

921+ See <http://www.haskell.org/haskellwiki/Haskell_program_coverage> for more

922+ information.

923+category: Control

924+exposed: True

925+exposed-modules:

926+ Trace.Hpc.Mix Trace.Hpc.Reflect Trace.Hpc.Tix Trace.Hpc.Util

927+import-dirs:

928+library-dirs:

929+dynamic-library-dirs:

930+data-dir:

931+hs-libraries: HShpc-0.6.0.3

932+depends:

933+ base-4.13.0.0 containers-0.6.2.1 directory-1.3.6.0 filepath-1.4.2.1

934+ time-1.9.3

935+haddock-interfaces:

936+haddock-html:

937+---

938+name: integer-gmp

939+version: 1.0.2.0

940+visibility: public

941+id: integer-gmp-1.0.2.0

942+key: integer-gmp-1.0.2.0

943+license: BSD-3-Clause

944+maintainer: hvr@gnu.org

945+author: Herbert Valerio Riedel

946+synopsis: Integer library based on GMP

947+description:

948+ This package provides the low-level implementation of the standard

949+ 'Integer' type based on the

950+ <http://gmplib.org/ GNU Multiple Precision Arithmetic Library (GMP)>.

951+ This package provides access to the internal representation of

952+ 'Integer' as well as primitive operations with no proper error

953+ handling, and should only be used directly with the utmost care.

954+category: Numeric, Algebra

955+exposed: True

956+exposed-modules:

957+ GHC.Integer GHC.Integer.GMP.Internals GHC.Integer.Logarithms

958+ GHC.Integer.Logarithms.Internals

959+hidden-modules: GHC.Integer.Type

960+import-dirs:

961+library-dirs:

962+dynamic-library-dirs:

963+data-dir:

964+hs-libraries: HSinteger-gmp-1.0.2.0

965+extra-libraries: gmp

966+include-dirs:

967+depends: ghc-prim-0.5.3

968+haddock-interfaces:

969+haddock-html:

970+---

971+name: libiserv

972+version: 8.8.4

973+visibility: public

974+id: libiserv-8.8.4

975+key: libiserv-8.8.4

976+license: BSD-3-Clause

977+copyright: XXX

978+maintainer: XXX

979+author: XXX

980+synopsis: Provides shared functionality between iserv and iserv-proxy

981+category: Development

982+exposed: True

983+exposed-modules: GHCi.Utils Lib

984+import-dirs:

985+library-dirs:

986+dynamic-library-dirs:

987+data-dir:

988+hs-libraries: HSlibiserv-8.8.4

989+depends:

990+ base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.1

991+ containers-0.6.2.1 deepseq-1.4.4.0 ghci-8.8.4 unix-2.7.2.2

992+haddock-interfaces:

993+haddock-html:

994+---

995+name: mtl

996+version: 2.2.2

997+visibility: public

998+id: mtl-2.2.2

999+key: mtl-2.2.2

1000+license: BSD-3-Clause

1001+maintainer: Edward Kmett <ekmett@gmail.com>

1002+author: Andy Gill

1003+homepage: http://github.com/haskell/mtl

1004+synopsis: Monad classes, using functional dependencies

1005+description:

1006+ Monad classes using functional dependencies, with instances

1007+ for various monad transformers, inspired by the paper

1008+ /Functional Programming with Overloading and Higher-Order Polymorphism/,

1009+ by Mark P Jones, in /Advanced School of Functional Programming/, 1995

1010+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1011+category: Control

1012+exposed: True

1013+exposed-modules:

1014+ Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error

1015+ Control.Monad.Error.Class Control.Monad.Except

1016+ Control.Monad.Identity Control.Monad.List Control.Monad.RWS

1017+ Control.Monad.RWS.Class Control.Monad.RWS.Lazy

1018+ Control.Monad.RWS.Strict Control.Monad.Reader

1019+ Control.Monad.Reader.Class Control.Monad.State

1020+ Control.Monad.State.Class Control.Monad.State.Lazy

1021+ Control.Monad.State.Strict Control.Monad.Trans Control.Monad.Writer

1022+ Control.Monad.Writer.Class Control.Monad.Writer.Lazy

1023+ Control.Monad.Writer.Strict

1024+import-dirs:

1025+library-dirs:

1026+dynamic-library-dirs:

1027+data-dir:

1028+hs-libraries: HSmtl-2.2.2

1029+depends: base-4.13.0.0 transformers-0.5.6.2

1030+haddock-interfaces:

1031+haddock-html:

1032+---

1033+name: parsec

1034+version: 3.1.14.0

1035+visibility: public

1036+id: parsec-3.1.14.0

1037+key: parsec-3.1.14.0

1038+license: BSD-3-Clause

1039+maintainer: Herbert Valerio Riedel <hvr@gnu.org>

1040+author:

1041+ Daan Leijen <daan@microsoft.com>, Paolo Martini <paolo@nemail.it>, Antoine Latter <aslatter@gmail.com>

1042+homepage: https://github.com/haskell/parsec

1043+synopsis: Monadic parser combinators

1044+description:

1045+ Parsec is designed from scratch as an industrial-strength parser

1046+ library. It is simple, safe, well documented (on the package

1047+ homepage), has extensive libraries, good error messages,

1048+ and is fast. It is defined as a monad transformer that can be

1049+ stacked on arbitrary monads, and it is also parametric in the

1050+ input stream type.

1051+ The main entry point is the "Text.Parsec" module which provides

1052+ defaults for parsing 'Char'acter data.

1053+ The "Text.ParserCombinators.Parsec" module hierarchy contains

1054+ the legacy @parsec-2@ API and may be removed at some point in

1055+ the future.

1056+category: Parsing

1057+exposed: True

1058+exposed-modules:

1059+ Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy

1060+ Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error

1061+ Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm

1062+ Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String

1063+ Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token

1064+ Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char

1065+ Text.ParserCombinators.Parsec.Combinator

1066+ Text.ParserCombinators.Parsec.Error

1067+ Text.ParserCombinators.Parsec.Expr

1068+ Text.ParserCombinators.Parsec.Language

1069+ Text.ParserCombinators.Parsec.Perm

1070+ Text.ParserCombinators.Parsec.Pos

1071+ Text.ParserCombinators.Parsec.Prim

1072+ Text.ParserCombinators.Parsec.Token

1073+import-dirs:

1074+library-dirs:

1075+dynamic-library-dirs:

1076+data-dir:

1077+hs-libraries: HSparsec-3.1.14.0

1078+depends:

1079+ base-4.13.0.0 bytestring-0.10.10.1 mtl-2.2.2 text-1.2.4.0

1080+haddock-interfaces:

1081+haddock-html:

1082+---

1083+name: pretty

1084+version: 1.1.3.6

1085+visibility: public

1086+id: pretty-1.1.3.6

1087+key: pretty-1.1.3.6

1088+license: BSD-3-Clause

1089+maintainer: David Terei <code@davidterei.com>

1090+stability: Stable

1091+homepage: http://github.com/haskell/pretty

1092+synopsis: Pretty-printing library

1093+description:

1094+ This package contains a pretty-printing library, a set of API's

1095+ that provides a way to easily print out text in a consistent

1096+ format of your choosing. This is useful for compilers and related

1097+ tools.

1098+ This library was originally designed by John Hughes's and has since

1099+ been heavily modified by Simon Peyton Jones.

1100+category: Text

1101+exposed: True

1102+exposed-modules:

1103+ Text.PrettyPrint Text.PrettyPrint.Annotated

1104+ Text.PrettyPrint.Annotated.HughesPJ

1105+ Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ

1106+ Text.PrettyPrint.HughesPJClass

1107+import-dirs:

1108+library-dirs:

1109+dynamic-library-dirs:

1110+data-dir:

1111+hs-libraries: HSpretty-1.1.3.6

1112+depends: base-4.13.0.0 deepseq-1.4.4.0 ghc-prim-0.5.3

1113+haddock-interfaces:

1114+haddock-html:

1115+---

1116+name: process

1117+version: 1.6.9.0

1118+visibility: public

1119+id: process-1.6.9.0

1120+key: process-1.6.9.0

1121+license: BSD-3-Clause

1122+maintainer: libraries@haskell.org

1123+synopsis: Process libraries

1124+description:

1125+ This package contains libraries for dealing with system processes.

1126+ The typed-process package is a more recent take on a process API,

1127+ which uses this package internally. It features better binary

1128+ support, easier concurrency, and a more composable API. You can

1129+ read more about it at

1130+ <https://github.com/fpco/typed-process/#readme>.

1131+category: System

1132+exposed: True

1133+exposed-modules: System.Cmd System.Process System.Process.Internals

1134+hidden-modules: System.Process.Common System.Process.Posix

1135+import-dirs:

1136+library-dirs:

1137+dynamic-library-dirs:

1138+data-dir:

1139+hs-libraries: HSprocess-1.6.9.0

1140+include-dirs:

1141+includes: runProcess.h

1142+depends:

1143+ base-4.13.0.0 deepseq-1.4.4.0 directory-1.3.6.0 filepath-1.4.2.1

1144+ unix-2.7.2.2

1145+haddock-interfaces:

1146+haddock-html:

1147+---

1148+name: stm

1149+version: 2.5.0.0

1150+visibility: public

1151+id: stm-2.5.0.0

1152+key: stm-2.5.0.0

1153+license: BSD-3-Clause

1154+maintainer: libraries@haskell.org

1155+homepage: https://wiki.haskell.org/Software_transactional_memory

1156+synopsis: Software Transactional Memory

1157+description:

1158+ Software Transactional Memory, or STM, is an abstraction for

1159+ concurrent communication. The main benefits of STM are

1160+ /composability/ and /modularity/. That is, using STM you can write

1161+ concurrent abstractions that can be easily composed with any other

1162+ abstraction built using STM, without exposing the details of how

1163+ your abstraction ensures safety. This is typically not the case

1164+ with other forms of concurrent communication, such as locks or

1165+ 'MVar's.

1166+category: Concurrency

1167+exposed: True

1168+exposed-modules:

1169+ Control.Concurrent.STM Control.Concurrent.STM.TArray

1170+ Control.Concurrent.STM.TBQueue Control.Concurrent.STM.TChan

1171+ Control.Concurrent.STM.TMVar Control.Concurrent.STM.TQueue

1172+ Control.Concurrent.STM.TSem Control.Concurrent.STM.TVar

1173+ Control.Monad.STM

1174+hidden-modules: Control.Sequential.STM

1175+import-dirs:

1176+library-dirs:

1177+dynamic-library-dirs:

1178+data-dir:

1179+hs-libraries: HSstm-2.5.0.0

1180+depends: array-0.5.4.0 base-4.13.0.0

1181+haddock-interfaces:

1182+haddock-html:

1183+---

1184+name: template-haskell

1185+version: 2.15.0.0

1186+visibility: public

1187+id: template-haskell-2.15.0.0

1188+key: template-haskell-2.15.0.0

1189+license: BSD-3-Clause

1190+maintainer: libraries@haskell.org

1191+synopsis: Support library for Template Haskell

1192+description:

1193+ This package provides modules containing facilities for manipulating

1194+ Haskell source code using Template Haskell.

1195+ See <http://www.haskell.org/haskellwiki/Template_Haskell> for more

1196+ information.

1197+category: Template Haskell

1198+exposed: True

1199+exposed-modules:

1200+ Language.Haskell.TH Language.Haskell.TH.LanguageExtensions

1201+ Language.Haskell.TH.Lib Language.Haskell.TH.Lib.Internal

1202+ Language.Haskell.TH.Ppr Language.Haskell.TH.PprLib

1203+ Language.Haskell.TH.Quote Language.Haskell.TH.Syntax

1204+hidden-modules: Language.Haskell.TH.Lib.Map

1205+import-dirs:

1206+library-dirs:

1207+dynamic-library-dirs:

1208+data-dir:

1209+hs-libraries: HStemplate-haskell-2.15.0.0

1210+depends: base-4.13.0.0 ghc-boot-th-8.8.4 pretty-1.1.3.6

1211+haddock-interfaces:

1212+haddock-html:

1213+---

1214+name: terminfo

1215+version: 0.4.1.4

1216+visibility: public

1217+id: terminfo-0.4.1.4

1218+key: terminfo-0.4.1.4

1219+license: BSD-3-Clause

1220+copyright: (c) Judah Jacobson

1221+maintainer: Judah Jacobson <judah.jacobson@gmail.com>

1222+author: Judah Jacobson

1223+stability: Stable

1224+homepage: https://github.com/judah/terminfo

1225+synopsis: Haskell bindings to the terminfo library.

1226+description:

1227+ This library provides an interface to the terminfo database (via bindings to the

1228+ curses library). <http://en.wikipedia.org/wiki/Terminfo Terminfo> allows POSIX

1229+ systems to interact with a variety of terminals using a standard set of capabilities.

1230+category: User Interfaces

1231+exposed: True

1232+exposed-modules:

1233+ System.Console.Terminfo System.Console.Terminfo.Base

1234+ System.Console.Terminfo.Color System.Console.Terminfo.Cursor

1235+ System.Console.Terminfo.Edit System.Console.Terminfo.Effects

1236+ System.Console.Terminfo.Keys

1237+import-dirs:

1238+library-dirs:

1239+dynamic-library-dirs:

1240+data-dir:

1241+hs-libraries: HSterminfo-0.4.1.4

1242+extra-libraries: tinfo

1243+depends: base-4.13.0.0

1244+haddock-interfaces:

1245+haddock-html:

1246+---

1247+name: text

1248+version: 1.2.4.0

1249+visibility: public

1250+id: text-1.2.4.0

1251+key: text-1.2.4.0

1252+license: BSD-2-Clause

1253+copyright: 2009-2011 Bryan O'Sullivan, 2008-2009 Tom Harper

1254+maintainer:

1255+ Bryan O'Sullivan <bos@serpentine.com>, Herbert Valerio Riedel <hvr@gnu.org>

1256+author: Bryan O'Sullivan <bos@serpentine.com>

1257+homepage: https://github.com/haskell/text

1258+synopsis: An efficient packed Unicode text type.

1259+description:

1260+ An efficient packed, immutable Unicode text type (both strict and

1261+ lazy), with a powerful loop fusion optimization framework.

1262+ The 'Text' type represents Unicode character strings, in a time and

1263+ space-efficient manner. This package provides text processing

1264+ capabilities that are optimized for performance critical use, both

1265+ in terms of large data quantities and high speed.

1266+ The 'Text' type provides character-encoding, type-safe case

1267+ conversion via whole-string case conversion functions (see "Data.Text").

1268+ It also provides a range of functions for converting 'Text' values to

1269+ and from 'ByteStrings', using several standard encodings

1270+ (see "Data.Text.Encoding").

1271+ Efficient locale-sensitive support for text IO is also supported

1272+ (see "Data.Text.IO").

1273+ These modules are intended to be imported qualified, to avoid name

1274+ clashes with Prelude functions, e.g.

1275+ > import qualified Data.Text as T

1276+ == ICU Support

1277+ To use an extended and very rich family of functions for working

1278+ with Unicode text (including normalization, regular expressions,

1279+ non-standard encodings, text breaking, and locales), see

1280+ the [text-icu package](https://hackage.haskell.org/package/text-icu)

1281+ based on the well-respected and liberally

1282+ licensed [ICU library](http://site.icu-project.org/).

1283+ == Internal Representation: UTF-16 vs. UTF-8

1284+ Currently the @text@ library uses UTF-16 as its internal representation

1285+ which is [neither a fixed-width nor always the most dense representation](http://utf8everywhere.org/)

1286+ for Unicode text. We're currently investigating the feasibility

1287+ of [changing Text's internal representation to UTF-8](https://github.com/text-utf8)

1288+ and if you need such a 'Text' type right now you might be interested in using the spin-off

1289+ packages <https://hackage.haskell.org/package/text-utf8 text-utf8> and

1290+ <https://hackage.haskell.org/package/text-short text-short>.

1291+category: Data, Text

1292+exposed: True

1293+exposed-modules:

1294+ Data.Text Data.Text.Array Data.Text.Encoding

1295+ Data.Text.Encoding.Error Data.Text.Foreign Data.Text.IO

1296+ Data.Text.Internal Data.Text.Internal.Builder

1297+ Data.Text.Internal.Builder.Functions

1298+ Data.Text.Internal.Builder.Int.Digits

1299+ Data.Text.Internal.Builder.RealFloat.Functions

1300+ Data.Text.Internal.Encoding.Fusion

1301+ Data.Text.Internal.Encoding.Fusion.Common

1302+ Data.Text.Internal.Encoding.Utf16 Data.Text.Internal.Encoding.Utf32

1303+ Data.Text.Internal.Encoding.Utf8 Data.Text.Internal.Functions

1304+ Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping

1305+ Data.Text.Internal.Fusion.Common Data.Text.Internal.Fusion.Size

1306+ Data.Text.Internal.Fusion.Types Data.Text.Internal.IO

1307+ Data.Text.Internal.Lazy Data.Text.Internal.Lazy.Encoding.Fusion

1308+ Data.Text.Internal.Lazy.Fusion Data.Text.Internal.Lazy.Search

1309+ Data.Text.Internal.Private Data.Text.Internal.Read

1310+ Data.Text.Internal.Search Data.Text.Internal.Unsafe

1311+ Data.Text.Internal.Unsafe.Char Data.Text.Internal.Unsafe.Shift

1312+ Data.Text.Lazy Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int

1313+ Data.Text.Lazy.Builder.RealFloat Data.Text.Lazy.Encoding

1314+ Data.Text.Lazy.IO Data.Text.Lazy.Internal Data.Text.Lazy.Read

1315+ Data.Text.Read Data.Text.Unsafe

1316+hidden-modules: Data.Text.Show

1317+import-dirs:

1318+library-dirs:

1319+dynamic-library-dirs:

1320+data-dir:

1321+hs-libraries: HStext-1.2.4.0

1322+depends:

1323+ array-0.5.4.0 base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.1

1324+ deepseq-1.4.4.0 ghc-prim-0.5.3 integer-gmp-1.0.2.0

1325+ template-haskell-2.15.0.0

1326+haddock-interfaces:

1327+haddock-html:

1328+---

1329+name: time

1330+version: 1.9.3

1331+visibility: public

1332+id: time-1.9.3

1333+key: time-1.9.3

1334+license: BSD-3-Clause

1335+maintainer: <ashley@semantic.org>

1336+author: Ashley Yakeley

1337+stability: stable

1338+homepage: https://github.com/haskell/time

1339+synopsis: A time library

1340+description: Time, clocks and calendars

1341+category: Time

1342+exposed: True

1343+exposed-modules:

1344+ Data.Time Data.Time.Calendar Data.Time.Calendar.Easter

1345+ Data.Time.Calendar.Julian Data.Time.Calendar.MonthDay

1346+ Data.Time.Calendar.OrdinalDate Data.Time.Calendar.WeekDate

1347+ Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System

1348+ Data.Time.Clock.TAI Data.Time.Format Data.Time.Format.ISO8601

1349+ Data.Time.Format.Internal Data.Time.LocalTime

1350+hidden-modules:

1351+ Data.Format Data.Time.Calendar.Private Data.Time.Calendar.Days

1352+ Data.Time.Calendar.Gregorian Data.Time.Calendar.CalendarDiffDays

1353+ Data.Time.Calendar.Week Data.Time.Calendar.JulianYearDay

1354+ Data.Time.Clock.Internal.DiffTime

1355+ Data.Time.Clock.Internal.AbsoluteTime

1356+ Data.Time.Clock.Internal.NominalDiffTime

1357+ Data.Time.Clock.Internal.POSIXTime

1358+ Data.Time.Clock.Internal.UniversalTime

1359+ Data.Time.Clock.Internal.SystemTime

1360+ Data.Time.Clock.Internal.UTCTime Data.Time.Clock.Internal.CTimeval

1361+ Data.Time.Clock.Internal.CTimespec Data.Time.Clock.Internal.UTCDiff

1362+ Data.Time.LocalTime.Internal.TimeZone

1363+ Data.Time.LocalTime.Internal.TimeOfDay

1364+ Data.Time.LocalTime.Internal.CalendarDiffTime

1365+ Data.Time.LocalTime.Internal.LocalTime

1366+ Data.Time.LocalTime.Internal.ZonedTime Data.Time.Format.Parse

1367+ Data.Time.Format.Locale Data.Time.Format.Format.Class

1368+ Data.Time.Format.Format.Instances Data.Time.Format.Parse.Class

1369+ Data.Time.Format.Parse.Instances

1370+import-dirs:

1371+library-dirs:

1372+dynamic-library-dirs:

1373+data-dir:

1374+hs-libraries: HStime-1.9.3

1375+include-dirs:

1376+depends: base-4.13.0.0 deepseq-1.4.4.0

1377+haddock-interfaces:

1378+haddock-html:

1379+---

1380+name: transformers

1381+version: 0.5.6.2

1382+visibility: public

1383+id: transformers-0.5.6.2

1384+key: transformers-0.5.6.2

1385+license: BSD-3-Clause

1386+maintainer: Ross Paterson <R.Paterson@city.ac.uk>

1387+author: Andy Gill, Ross Paterson

1388+synopsis: Concrete functor and monad transformers

1389+description:

1390+ A portable library of functor and monad transformers, inspired by

1391+ the paper

1392+ * \"Functional Programming with Overloading and Higher-Order

1393+ Polymorphism\", by Mark P Jones,

1394+ in /Advanced School of Functional Programming/, 1995

1395+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1396+ This package contains:

1397+ * the monad transformer class (in "Control.Monad.Trans.Class")

1398+ * concrete functor and monad transformers, each with associated

1399+ operations and functions to lift operations associated with other

1400+ transformers.

1401+ The package can be used on its own in portable Haskell code, in

1402+ which case operations need to be manually lifted through transformer

1403+ stacks (see "Control.Monad.Trans.Class" for some examples).

1404+ Alternatively, it can be used with the non-portable monad classes in

1405+ the @mtl@ or @monads-tf@ packages, which automatically lift operations

1406+ introduced by monad transformers through other transformers.

1407+category: Control

1408+exposed: True

1409+exposed-modules:

1410+ Control.Applicative.Backwards Control.Applicative.Lift

1411+ Control.Monad.Signatures Control.Monad.Trans.Accum

1412+ Control.Monad.Trans.Class Control.Monad.Trans.Cont

1413+ Control.Monad.Trans.Error Control.Monad.Trans.Except

1414+ Control.Monad.Trans.Identity Control.Monad.Trans.List

1415+ Control.Monad.Trans.Maybe Control.Monad.Trans.RWS

1416+ Control.Monad.Trans.RWS.CPS Control.Monad.Trans.RWS.Lazy

1417+ Control.Monad.Trans.RWS.Strict Control.Monad.Trans.Reader

1418+ Control.Monad.Trans.Select Control.Monad.Trans.State

1419+ Control.Monad.Trans.State.Lazy Control.Monad.Trans.State.Strict

1420+ Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS

1421+ Control.Monad.Trans.Writer.Lazy Control.Monad.Trans.Writer.Strict

1422+ Data.Functor.Constant Data.Functor.Reverse

1423+import-dirs:

1424+library-dirs:

1425+dynamic-library-dirs:

1426+data-dir:

1427+hs-libraries: HStransformers-0.5.6.2

1428+depends: base-4.13.0.0

1429+haddock-interfaces:

1430+haddock-html:

1431+---

1432+name: unix

1433+version: 2.7.2.2

1434+visibility: public

1435+id: unix-2.7.2.2

1436+key: unix-2.7.2.2

1437+license: BSD-3-Clause

1438+maintainer: libraries@haskell.org

1439+homepage: https://github.com/haskell/unix

1440+synopsis: POSIX functionality

1441+description:

1442+ This package gives you access to the set of operating system

1443+ services standardised by

1444+ <http://pubs.opengroup.org/onlinepubs/9699919799/ POSIX.1-2008>

1445+ (or the IEEE Portable Operating System Interface for Computing

1446+ Environments - IEEE Std. 1003.1).

1447+ The package is not supported under Windows.

1448+category: System

1449+exposed: True

1450+exposed-modules:

1451+ System.Posix System.Posix.ByteString

1452+ System.Posix.ByteString.FilePath System.Posix.Directory

1453+ System.Posix.Directory.ByteString System.Posix.DynamicLinker

1454+ System.Posix.DynamicLinker.ByteString

1455+ System.Posix.DynamicLinker.Module

1456+ System.Posix.DynamicLinker.Module.ByteString

1457+ System.Posix.DynamicLinker.Prim System.Posix.Env

1458+ System.Posix.Env.ByteString System.Posix.Error System.Posix.Fcntl

1459+ System.Posix.Files System.Posix.Files.ByteString System.Posix.IO

1460+ System.Posix.IO.ByteString System.Posix.Process

1461+ System.Posix.Process.ByteString System.Posix.Process.Internals

1462+ System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem

1463+ System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp

1464+ System.Posix.Temp.ByteString System.Posix.Terminal

1465+ System.Posix.Terminal.ByteString System.Posix.Time

1466+ System.Posix.Unistd System.Posix.User

1467+hidden-modules:

1468+ System.Posix.Directory.Common System.Posix.DynamicLinker.Common

1469+ System.Posix.Files.Common System.Posix.IO.Common

1470+ System.Posix.Process.Common System.Posix.Terminal.Common

1471+import-dirs:

1472+library-dirs:

1473+dynamic-library-dirs:

1474+data-dir:

1475+hs-libraries: HSunix-2.7.2.2

1476+extra-libraries: rt util dl pthread

1477+include-dirs:

1478+includes: HsUnix.h execvpe.h

1479+depends: base-4.13.0.0 bytestring-0.10.10.1 time-1.9.3

1480+haddock-interfaces:

1481+haddock-html:

1482+---

1483+name: xhtml

1484+version: 3000.2.2.1

1485+visibility: public

1486+id: xhtml-3000.2.2.1

1487+key: xhtml-3000.2.2.1

1488+license: BSD-3-Clause

1489+copyright:

1490+ Bjorn Bringert 2004-2006, Andy Gill and the Oregon

1491+ Graduate Institute of Science and Technology, 1999-2001

1492+maintainer: Chris Dornan <chris@chrisdornan.com>

1493+author: Bjorn Bringert

1494+stability: Stable

1495+homepage: https://github.com/haskell/xhtml

1496+synopsis: An XHTML combinator library

1497+description:

1498+ This package provides combinators for producing

1499+ XHTML 1.0, including the Strict, Transitional and

1500+ Frameset variants.

1501+category: Web, XML, Pretty Printer

1502+exposed: True

1503+exposed-modules:

1504+ Text.XHtml Text.XHtml.Debug Text.XHtml.Frameset Text.XHtml.Strict

1505+ Text.XHtml.Table Text.XHtml.Transitional

1506+hidden-modules:

1507+ Text.XHtml.Strict.Attributes Text.XHtml.Strict.Elements

1508+ Text.XHtml.Frameset.Attributes Text.XHtml.Frameset.Elements

1509+ Text.XHtml.Transitional.Attributes Text.XHtml.Transitional.Elements

1510+ Text.XHtml.BlockTable Text.XHtml.Extras Text.XHtml.Internals

1511+import-dirs:

1512+library-dirs:

1513+dynamic-library-dirs:

1514+data-dir:

1515+hs-libraries: HSxhtml-3000.2.2.1

1516+depends: base-4.13.0.0

1517+haddock-interfaces:

1518+haddock-html:

1519+---

1520+name: rts

1521+version: 1.0

1522+visibility: public

1523+id: rts

1524+key: rts

1525+license: BSD-3-Clause

1526+maintainer: glasgow-haskell-users@haskell.org

1527+exposed: True

1528+library-dirs:

1529+hs-libraries: HSrts

1530+extra-libraries: m rt dl ffi numa pthread

1531+include-dirs:

1532+includes: Stg.h

1533+ld-options:

1534+ "-Wl,-u,base_GHCziTopHandler_runIO_closure"

1535+ "-Wl,-u,base_GHCziTopHandler_runNonIO_closure"

1536+ "-Wl,-u,ghczmprim_GHCziTuple_Z0T_closure"

1537+ "-Wl,-u,ghczmprim_GHCziTypes_True_closure"

1538+ "-Wl,-u,ghczmprim_GHCziTypes_False_closure"

1539+ "-Wl,-u,base_GHCziPack_unpackCString_closure"

1540+ "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure"

1541+ "-Wl,-u,base_GHCziIOziException_stackOverflow_closure"

1542+ "-Wl,-u,base_GHCziIOziException_heapOverflow_closure"

1543+ "-Wl,-u,base_GHCziIOziException_allocationLimitExceeded_closure"

1544+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"

1545+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"

1546+ "-Wl,-u,base_GHCziIOziException_cannotCompactFunction_closure"

1547+ "-Wl,-u,base_GHCziIOziException_cannotCompactPinned_closure"

1548+ "-Wl,-u,base_GHCziIOziException_cannotCompactMutable_closure"

1549+ "-Wl,-u,base_ControlziExceptionziBase_absentSumFieldError_closure"

1550+ "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure"

1551+ "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure"

1552+ "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure"

1553+ "-Wl,-u,base_GHCziConcziSync_runSparks_closure"

1554+ "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure"

1555+ "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"

1556+ "-Wl,-u,base_GHCziConcziSignal_runHandlersPtr_closure"

1557+ "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure"

1558+ "-Wl,-u,base_GHCziTopHandler_runMainIO_closure"

1559+ "-Wl,-u,ghczmprim_GHCziTypes_Czh_con_info"

1560+ "-Wl,-u,ghczmprim_GHCziTypes_Izh_con_info"

1561+ "-Wl,-u,ghczmprim_GHCziTypes_Fzh_con_info"

1562+ "-Wl,-u,ghczmprim_GHCziTypes_Dzh_con_info"

1563+ "-Wl,-u,ghczmprim_GHCziTypes_Wzh_con_info"

1564+ "-Wl,-u,base_GHCziPtr_Ptr_con_info"

1565+ "-Wl,-u,base_GHCziPtr_FunPtr_con_info"

1566+ "-Wl,-u,base_GHCziInt_I8zh_con_info"

1567+ "-Wl,-u,base_GHCziInt_I16zh_con_info"

1568+ "-Wl,-u,base_GHCziInt_I32zh_con_info"

1569+ "-Wl,-u,base_GHCziInt_I64zh_con_info"

1570+ "-Wl,-u,base_GHCziWord_W8zh_con_info"

1571+ "-Wl,-u,base_GHCziWord_W16zh_con_info"

1572+ "-Wl,-u,base_GHCziWord_W32zh_con_info"

1573+ "-Wl,-u,base_GHCziWord_W64zh_con_info"

1574+ "-Wl,-u,base_GHCziStable_StablePtr_con_info"

1575+ "-Wl,-u,hs_atomic_add8" "-Wl,-u,hs_atomic_add16"

1576+ "-Wl,-u,hs_atomic_add32" "-Wl,-u,hs_atomic_add64"

1577+ "-Wl,-u,hs_atomic_sub8" "-Wl,-u,hs_atomic_sub16"

1578+ "-Wl,-u,hs_atomic_sub32" "-Wl,-u,hs_atomic_sub64"

1579+ "-Wl,-u,hs_atomic_and8" "-Wl,-u,hs_atomic_and16"

1580+ "-Wl,-u,hs_atomic_and32" "-Wl,-u,hs_atomic_and64"

1581+ "-Wl,-u,hs_atomic_nand8" "-Wl,-u,hs_atomic_nand16"

1582+ "-Wl,-u,hs_atomic_nand32" "-Wl,-u,hs_atomic_nand64"

1583+ "-Wl,-u,hs_atomic_or8" "-Wl,-u,hs_atomic_or16"

1584+ "-Wl,-u,hs_atomic_or32" "-Wl,-u,hs_atomic_or64"

1585+ "-Wl,-u,hs_atomic_xor8" "-Wl,-u,hs_atomic_xor16"

1586+ "-Wl,-u,hs_atomic_xor32" "-Wl,-u,hs_atomic_xor64"

1587+ "-Wl,-u,hs_cmpxchg8" "-Wl,-u,hs_cmpxchg16" "-Wl,-u,hs_cmpxchg32"

1588+ "-Wl,-u,hs_cmpxchg64" "-Wl,-u,hs_atomicread8"

1589+ "-Wl,-u,hs_atomicread16" "-Wl,-u,hs_atomicread32"

1590+ "-Wl,-u,hs_atomicread64" "-Wl,-u,hs_atomicwrite8"

1591+ "-Wl,-u,hs_atomicwrite16" "-Wl,-u,hs_atomicwrite32"

1592+ "-Wl,-u,hs_atomicwrite64"

materialized/dummy-ghc/ghc-8.8.4-aarch64-linux/ghc-pkg/versionnew file+1

@@ -0,0 +1 @@

1+GHC package manager version 8.8.4

materialized/dummy-ghc/ghc-8.8.4-aarch64-linux/ghc/infonew file+60

@@ -0,0 +1,60 @@

1+ [("Project name","The Glorious Glasgow Haskell Compilation System")

2+ ,("GCC extra via C opts"," -fwrapv -fno-builtin")

3+ ,("C compiler command","gcc")

4+ ,("C compiler flags","")

5+ ,("C compiler link flags"," -Wl,-z,noexecstack")

6+ ,("C compiler supports -no-pie","YES")

7+ ,("Haskell CPP command","gcc")

8+ ,("Haskell CPP flags","-E -undef -traditional")

9+ ,("ld command","ld")

10+ ,("ld flags"," -z noexecstack")

11+ ,("ld supports compact unwind","YES")

12+ ,("ld supports build-id","YES")

13+ ,("ld supports filelist","NO")

14+ ,("ld is GNU ld","YES")

15+ ,("ar command","ar")

16+ ,("ar flags","q")

17+ ,("ar supports at file","YES")

18+ ,("ranlib command","ranlib")

19+ ,("touch command","touch")

20+ ,("dllwrap command","/bin/false")

21+ ,("windres command","/bin/false")

22+ ,("libtool command","libtool")

23+ ,("cross compiling","NO")

24+ ,("target os","OSLinux")

25+ ,("target arch","ArchARM64")

26+ ,("target word size","8")

27+ ,("target has GNU nonexec stack","True")

28+ ,("target has .ident directive","True")

29+ ,("target has subsections via symbols","False")

30+ ,("target has RTS linker","YES")

31+ ,("Unregisterised","NO")

32+ ,("LLVM clang command","clang")

33+ ,("Project version","8.8.4")

34+ ,("Project Git commit id","6cf8f835267581d551ca6695b3b02c34797e2cf4")

35+ ,("Booter version","8.8.3")

36+ ,("Stage","2")

37+ ,("Build platform","aarch64-unknown-linux")

38+ ,("Host platform","aarch64-unknown-linux")

39+ ,("Target platform","aarch64-unknown-linux")

40+ ,("Have interpreter","YES")

41+ ,("Object splitting supported","NO")

42+ ,("Have native code generator","NO")

43+ ,("Support SMP","YES")

44+ ,("Tables next to code","YES")

45+ ,("RTS ways","l debug thr thr_debug thr_l thr_p dyn debug_dyn thr_dyn thr_debug_dyn l_dyn thr_l_dyn thr_debug_p debug_p")

46+ ,("RTS expects libdw","NO")

47+ ,("Support dynamic-too","YES")

48+ ,("Support parallel --make","YES")

49+ ,("Support reexported-modules","YES")

50+ ,("Support thinning and renaming package flags","YES")

51+ ,("Support Backpack","YES")

52+ ,("Requires unified installed package IDs","YES")

53+ ,("Uses package keys","YES")

54+ ,("Uses unit IDs","YES")

55+ ,("Dynamic by default","NO")

56+ ,("GHC Dynamic","YES")

57+ ,("GHC Profiled","NO")

58+ ,("Leading underscore","NO")

59+ ,("Debug on","False")

60+ ]

materialized/dummy-ghc/ghc-8.8.4-aarch64-linux/ghc/numeric-versionnew file+1

@@ -0,0 +1 @@

1+8.8.4

materialized/dummy-ghc/ghc-8.8.4-aarch64-linux/ghc/supported-languagesnew file+247

@@ -0,0 +1,247 @@

1+Haskell98

2+Haskell2010

3+Unsafe

4+Trustworthy

5+Safe

6+AllowAmbiguousTypes

7+NoAllowAmbiguousTypes

8+AlternativeLayoutRule

9+NoAlternativeLayoutRule

10+AlternativeLayoutRuleTransitional

11+NoAlternativeLayoutRuleTransitional

12+Arrows

13+NoArrows

14+AutoDeriveTypeable

15+NoAutoDeriveTypeable

16+BangPatterns

17+NoBangPatterns

18+BinaryLiterals

19+NoBinaryLiterals

20+CApiFFI

21+NoCApiFFI

22+CPP

23+NoCPP

24+ConstrainedClassMethods

25+NoConstrainedClassMethods

26+ConstraintKinds

27+NoConstraintKinds

28+DataKinds

29+NoDataKinds

30+DatatypeContexts

31+NoDatatypeContexts

32+DefaultSignatures

33+NoDefaultSignatures

34+DeriveAnyClass

35+NoDeriveAnyClass

36+DeriveDataTypeable

37+NoDeriveDataTypeable

38+DeriveFoldable

39+NoDeriveFoldable

40+DeriveFunctor

41+NoDeriveFunctor

42+DeriveGeneric

43+NoDeriveGeneric

44+DeriveLift

45+NoDeriveLift

46+DeriveTraversable

47+NoDeriveTraversable

48+DerivingStrategies

49+NoDerivingStrategies

50+DerivingVia

51+NoDerivingVia

52+DisambiguateRecordFields

53+NoDisambiguateRecordFields

54+DoAndIfThenElse

55+NoDoAndIfThenElse

56+BlockArguments

57+NoBlockArguments

58+DoRec

59+NoDoRec

60+DuplicateRecordFields

61+NoDuplicateRecordFields

62+EmptyCase

63+NoEmptyCase

64+EmptyDataDecls

65+NoEmptyDataDecls

66+EmptyDataDeriving

67+NoEmptyDataDeriving

68+ExistentialQuantification

69+NoExistentialQuantification

70+ExplicitForAll

71+NoExplicitForAll

72+ExplicitNamespaces

73+NoExplicitNamespaces

74+ExtendedDefaultRules

75+NoExtendedDefaultRules

76+FlexibleContexts

77+NoFlexibleContexts

78+FlexibleInstances

79+NoFlexibleInstances

80+ForeignFunctionInterface

81+NoForeignFunctionInterface

82+FunctionalDependencies

83+NoFunctionalDependencies

84+GADTSyntax

85+NoGADTSyntax

86+GADTs

87+NoGADTs

88+GHCForeignImportPrim

89+NoGHCForeignImportPrim

90+GeneralizedNewtypeDeriving

91+NoGeneralizedNewtypeDeriving

92+GeneralisedNewtypeDeriving

93+NoGeneralisedNewtypeDeriving

94+ImplicitParams

95+NoImplicitParams

96+ImplicitPrelude

97+NoImplicitPrelude

98+ImpredicativeTypes

99+NoImpredicativeTypes

100+IncoherentInstances

101+NoIncoherentInstances

102+TypeFamilyDependencies

103+NoTypeFamilyDependencies

104+InstanceSigs

105+NoInstanceSigs

106+ApplicativeDo

107+NoApplicativeDo

108+InterruptibleFFI

109+NoInterruptibleFFI

110+JavaScriptFFI

111+NoJavaScriptFFI

112+KindSignatures

113+NoKindSignatures

114+LambdaCase

115+NoLambdaCase

116+LiberalTypeSynonyms

117+NoLiberalTypeSynonyms

118+MagicHash

119+NoMagicHash

120+MonadComprehensions

121+NoMonadComprehensions

122+MonadFailDesugaring

123+NoMonadFailDesugaring

124+MonoLocalBinds

125+NoMonoLocalBinds

126+MonoPatBinds

127+NoMonoPatBinds

128+MonomorphismRestriction

129+NoMonomorphismRestriction

130+MultiParamTypeClasses

131+NoMultiParamTypeClasses

132+MultiWayIf

133+NoMultiWayIf

134+NumericUnderscores

135+NoNumericUnderscores

136+NPlusKPatterns

137+NoNPlusKPatterns

138+NamedFieldPuns

139+NoNamedFieldPuns

140+NamedWildCards

141+NoNamedWildCards

142+NegativeLiterals

143+NoNegativeLiterals

144+HexFloatLiterals

145+NoHexFloatLiterals

146+NondecreasingIndentation

147+NoNondecreasingIndentation

148+NullaryTypeClasses

149+NoNullaryTypeClasses

150+NumDecimals

151+NoNumDecimals

152+OverlappingInstances

153+NoOverlappingInstances

154+OverloadedLabels

155+NoOverloadedLabels

156+OverloadedLists

157+NoOverloadedLists

158+OverloadedStrings

159+NoOverloadedStrings

160+PackageImports

161+NoPackageImports

162+ParallelArrays

163+NoParallelArrays

164+ParallelListComp

165+NoParallelListComp

166+PartialTypeSignatures

167+NoPartialTypeSignatures

168+PatternGuards

169+NoPatternGuards

170+PatternSignatures

171+NoPatternSignatures

172+PatternSynonyms

173+NoPatternSynonyms

174+PolyKinds

175+NoPolyKinds

176+PolymorphicComponents

177+NoPolymorphicComponents

178+QuantifiedConstraints

179+NoQuantifiedConstraints

180+PostfixOperators

181+NoPostfixOperators

182+QuasiQuotes

183+NoQuasiQuotes

184+Rank2Types

185+NoRank2Types

186+RankNTypes

187+NoRankNTypes

188+RebindableSyntax

189+NoRebindableSyntax

190+RecordPuns

191+NoRecordPuns

192+RecordWildCards

193+NoRecordWildCards

194+RecursiveDo

195+NoRecursiveDo

196+RelaxedLayout

197+NoRelaxedLayout

198+RelaxedPolyRec

199+NoRelaxedPolyRec

200+RoleAnnotations

201+NoRoleAnnotations

202+ScopedTypeVariables

203+NoScopedTypeVariables

204+StandaloneDeriving

205+NoStandaloneDeriving

206+StarIsType

207+NoStarIsType

208+StaticPointers

209+NoStaticPointers

210+Strict

211+NoStrict

212+StrictData

213+NoStrictData

214+TemplateHaskell

215+NoTemplateHaskell

216+TemplateHaskellQuotes

217+NoTemplateHaskellQuotes

218+TraditionalRecordSyntax

219+NoTraditionalRecordSyntax

220+TransformListComp

221+NoTransformListComp

222+TupleSections

223+NoTupleSections

224+TypeApplications

225+NoTypeApplications

226+TypeInType

227+NoTypeInType

228+TypeFamilies

229+NoTypeFamilies

230+TypeOperators

231+NoTypeOperators

232+TypeSynonymInstances

233+NoTypeSynonymInstances

234+UnboxedTuples

235+NoUnboxedTuples

236+UnboxedSums

237+NoUnboxedSums

238+UndecidableInstances

239+NoUndecidableInstances

240+UndecidableSuperClasses

241+NoUndecidableSuperClasses

242+UnicodeSyntax

243+NoUnicodeSyntax

244+UnliftedFFITypes

245+NoUnliftedFFITypes

246+ViewPatterns

247+NoViewPatterns

materialized/dummy-ghc/ghc-8.8.4-aarch64-linux/ghc/versionnew file+1

@@ -0,0 +1 @@

1+The Glorious Glasgow Haskell Compilation System, version 8.8.4

materialized/dummy-ghc/ghc-8.8.4-x86_64-darwin/ghc/info+5

@@ -1,16 +1,21 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts"," -fwrapv -fno-builtin")

3+ ,("C compiler command","clang")

34 ,("C compiler flags","")

45 ,("C compiler link flags"," ")

56 ,("C compiler supports -no-pie","NO")

7+ ,("Haskell CPP command","clang")

68 ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

9+ ,("ld command","ld")

710 ,("ld flags","")

811 ,("ld supports compact unwind","YES")

912 ,("ld supports build-id","NO")

1013 ,("ld supports filelist","YES")

1114 ,("ld is GNU ld","NO")

15+ ,("ar command","ar")

1216 ,("ar flags","qcls")

1317 ,("ar supports at file","NO")

18+ ,("ranlib command","ranlib")

1419 ,("touch command","touch")

1520 ,("dllwrap command","/bin/false")

1621 ,("windres command","/bin/false")

materialized/dummy-ghc/ghc-8.8.4-x86_64-linux/ghc/info+5

@@ -1,16 +1,21 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts"," -fwrapv -fno-builtin")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags","")

45 ,("C compiler link flags"," ")

56 ,("C compiler supports -no-pie","YES")

7+ ,("Haskell CPP command","gcc")

68 ,("Haskell CPP flags","-E -undef -traditional")

9+ ,("ld command","ld")

710 ,("ld flags","")

811 ,("ld supports compact unwind","YES")

912 ,("ld supports build-id","YES")

1013 ,("ld supports filelist","NO")

1114 ,("ld is GNU ld","YES")

15+ ,("ar command","ar")

1216 ,("ar flags","q")

1317 ,("ar supports at file","YES")

18+ ,("ranlib command","ranlib")

1419 ,("touch command","touch")

1520 ,("dllwrap command","/bin/false")

1621 ,("windres command","/bin/false")

materialized/dummy-ghc/ghc-9.0.1-aarch64-darwin/ghc-pkg/dump-globalnew file+1759

@@ -0,0 +1,1759 @@

1+name: Cabal

2+version: 3.4.0.0

3+visibility: public

4+id: Cabal-3.4.0.0

5+key: Cabal-3.4.0.0

6+license: BSD-3-Clause

7+copyright: 2003-2020, 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.Doctest

71+ Distribution.Simple.Flag Distribution.Simple.GHC

72+ Distribution.Simple.GHCJS Distribution.Simple.Glob

73+ Distribution.Simple.Haddock Distribution.Simple.HaskellSuite

74+ Distribution.Simple.Hpc Distribution.Simple.Install

75+ Distribution.Simple.InstallDirs

76+ Distribution.Simple.InstallDirs.Internal

77+ Distribution.Simple.LocalBuildInfo Distribution.Simple.PackageIndex

78+ Distribution.Simple.PreProcess Distribution.Simple.PreProcess.Unlit

79+ Distribution.Simple.Program Distribution.Simple.Program.Ar

80+ Distribution.Simple.Program.Builtin Distribution.Simple.Program.Db

81+ Distribution.Simple.Program.Find Distribution.Simple.Program.GHC

82+ Distribution.Simple.Program.HcPkg Distribution.Simple.Program.Hpc

83+ Distribution.Simple.Program.Internal Distribution.Simple.Program.Ld

84+ Distribution.Simple.Program.ResponseFile

85+ Distribution.Simple.Program.Run Distribution.Simple.Program.Script

86+ Distribution.Simple.Program.Strip Distribution.Simple.Program.Types

87+ Distribution.Simple.Register Distribution.Simple.Setup

88+ Distribution.Simple.ShowBuildInfo Distribution.Simple.SrcDist

89+ Distribution.Simple.Test Distribution.Simple.Test.ExeV10

90+ Distribution.Simple.Test.LibV09 Distribution.Simple.Test.Log

91+ Distribution.Simple.UHC Distribution.Simple.UserHooks

92+ Distribution.Simple.Utils Distribution.System

93+ Distribution.TestSuite Distribution.Text

94+ Distribution.Types.AbiDependency Distribution.Types.AbiHash

95+ Distribution.Types.AnnotatedId Distribution.Types.Benchmark

96+ Distribution.Types.Benchmark.Lens

97+ Distribution.Types.BenchmarkInterface

98+ Distribution.Types.BenchmarkType Distribution.Types.BuildInfo

99+ Distribution.Types.BuildInfo.Lens Distribution.Types.BuildType

100+ Distribution.Types.Component Distribution.Types.ComponentId

101+ Distribution.Types.ComponentInclude

102+ Distribution.Types.ComponentLocalBuildInfo

103+ Distribution.Types.ComponentName

104+ Distribution.Types.ComponentRequestedSpec

105+ Distribution.Types.CondTree Distribution.Types.Condition

106+ Distribution.Types.ConfVar Distribution.Types.Dependency

107+ Distribution.Types.DependencyMap Distribution.Types.ExeDependency

108+ Distribution.Types.Executable Distribution.Types.Executable.Lens

109+ Distribution.Types.ExecutableScope Distribution.Types.ExposedModule

110+ Distribution.Types.Flag Distribution.Types.ForeignLib

111+ Distribution.Types.ForeignLib.Lens

112+ Distribution.Types.ForeignLibOption

113+ Distribution.Types.ForeignLibType

114+ Distribution.Types.GenericPackageDescription

115+ Distribution.Types.GenericPackageDescription.Lens

116+ Distribution.Types.GivenComponent

117+ Distribution.Types.HookedBuildInfo

118+ Distribution.Types.IncludeRenaming

119+ Distribution.Types.InstalledPackageInfo

120+ Distribution.Types.InstalledPackageInfo.FieldGrammar

121+ Distribution.Types.InstalledPackageInfo.Lens

122+ Distribution.Types.LegacyExeDependency Distribution.Types.Lens

123+ Distribution.Types.Library Distribution.Types.Library.Lens

124+ Distribution.Types.LibraryName Distribution.Types.LibraryVisibility

125+ Distribution.Types.LocalBuildInfo Distribution.Types.Mixin

126+ Distribution.Types.Module Distribution.Types.ModuleReexport

127+ Distribution.Types.ModuleRenaming

128+ Distribution.Types.MungedPackageId

129+ Distribution.Types.MungedPackageName

130+ Distribution.Types.PackageDescription

131+ Distribution.Types.PackageDescription.Lens

132+ Distribution.Types.PackageId Distribution.Types.PackageId.Lens

133+ Distribution.Types.PackageName Distribution.Types.PackageName.Magic

134+ Distribution.Types.PackageVersionConstraint

135+ Distribution.Types.PkgconfigDependency

136+ Distribution.Types.PkgconfigName

137+ Distribution.Types.PkgconfigVersion

138+ Distribution.Types.PkgconfigVersionRange

139+ Distribution.Types.SetupBuildInfo

140+ Distribution.Types.SetupBuildInfo.Lens

141+ Distribution.Types.SourceRepo Distribution.Types.SourceRepo.Lens

142+ Distribution.Types.TargetInfo Distribution.Types.TestSuite

143+ Distribution.Types.TestSuite.Lens

144+ Distribution.Types.TestSuiteInterface Distribution.Types.TestType

145+ Distribution.Types.UnitId Distribution.Types.UnqualComponentName

146+ Distribution.Types.Version Distribution.Types.VersionInterval

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.Progress

152+ Distribution.Utils.ShortText Distribution.Utils.Structured

153+ Distribution.Verbosity Distribution.Verbosity.Internal

154+ Distribution.Version Language.Haskell.Extension

155+hidden-modules:

156+ Distribution.Backpack.PreExistingComponent

157+ Distribution.Backpack.ReadyComponent Distribution.Backpack.MixLink

158+ Distribution.Backpack.ModuleScope Distribution.Backpack.UnifyM

159+ Distribution.Backpack.Id Distribution.Utils.UnionFind

160+ Distribution.Utils.Base62 Distribution.Compat.Async

161+ Distribution.Compat.CopyFile Distribution.Compat.GetShortPathName

162+ Distribution.Compat.MonadFail Distribution.Compat.Prelude

163+ Distribution.Compat.SnocList Distribution.GetOpt Distribution.Lex

164+ Distribution.Utils.String Distribution.Simple.Build.Macros.Z

165+ Distribution.Simple.GHC.EnvironmentParser

166+ Distribution.Simple.GHC.Internal Distribution.Simple.GHC.ImplInfo

167+ Distribution.Simple.Utils.Json Distribution.ZinzaPrelude

168+ Paths_Cabal

169+import-dirs:

170+library-dirs:

171+dynamic-library-dirs:

172+data-dir:

173+hs-libraries: HSCabal-3.4.0.0

174+depends:

175+ array-0.5.4.0 base-4.15.0.0 binary-0.8.8.0 bytestring-0.10.12.1

176+ containers-0.6.4.1 deepseq-1.4.5.0 directory-1.3.6.1

177+ filepath-1.4.2.1 mtl-2.2.2 parsec-3.1.14.0 pretty-1.1.3.6

178+ process-1.6.11.0 text-1.2.4.1 time-1.9.3 transformers-0.5.6.2

179+ unix-2.7.2.2

180+haddock-interfaces:

181+haddock-html:

182+---

183+name: array

184+version: 0.5.4.0

185+visibility: public

186+id: array-0.5.4.0

187+key: array-0.5.4.0

188+license: BSD-3-Clause

189+maintainer: libraries@haskell.org

190+synopsis: Mutable and immutable arrays

191+description:

192+ In addition to providing the "Data.Array" module

193+ <http://www.haskell.org/onlinereport/haskell2010/haskellch14.html as specified in the Haskell 2010 Language Report>,

194+ this package also defines the classes 'IArray' of

195+ immutable arrays and 'MArray' of arrays mutable within appropriate

196+ monads, as well as some instances of these classes.

197+category: Data Structures

198+exposed: True

199+exposed-modules:

200+ Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO

201+ Data.Array.IO.Internals Data.Array.IO.Safe Data.Array.MArray

202+ Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe

203+ Data.Array.Storable Data.Array.Storable.Internals

204+ Data.Array.Storable.Safe Data.Array.Unboxed Data.Array.Unsafe

205+import-dirs:

206+library-dirs:

207+dynamic-library-dirs:

208+data-dir:

209+hs-libraries: HSarray-0.5.4.0

210+depends: base-4.15.0.0

211+haddock-interfaces:

212+haddock-html:

213+---

214+name: base

215+version: 4.15.0.0

216+visibility: public

217+id: base-4.15.0.0

218+key: base-4.15.0.0

219+license: BSD-3-Clause

220+maintainer: libraries@haskell.org

221+synopsis: Basic libraries

222+description:

223+ This package contains the Standard Haskell "Prelude" and its support libraries,

224+ and a large collection of useful libraries ranging from data

225+ structures to parsing combinators and debugging utilities.

226+category: Prelude

227+exposed: True

228+exposed-modules:

229+ Control.Applicative, Control.Arrow, Control.Category,

230+ Control.Concurrent, Control.Concurrent.Chan,

231+ Control.Concurrent.MVar, Control.Concurrent.QSem,

232+ Control.Concurrent.QSemN, Control.Exception,

233+ Control.Exception.Base, Control.Monad, Control.Monad.Fail,

234+ Control.Monad.Fix, Control.Monad.IO.Class, Control.Monad.Instances,

235+ Control.Monad.ST, Control.Monad.ST.Lazy,

236+ Control.Monad.ST.Lazy.Safe, Control.Monad.ST.Lazy.Unsafe,

237+ Control.Monad.ST.Safe, Control.Monad.ST.Strict,

238+ Control.Monad.ST.Unsafe, Control.Monad.Zip, Data.Bifoldable,

239+ Data.Bifunctor, Data.Bitraversable, Data.Bits, Data.Bool,

240+ Data.Char, Data.Coerce, Data.Complex, Data.Data, Data.Dynamic,

241+ Data.Either, Data.Eq, Data.Fixed, Data.Foldable, Data.Function,

242+ Data.Functor, Data.Functor.Classes, Data.Functor.Compose,

243+ Data.Functor.Const, Data.Functor.Contravariant,

244+ Data.Functor.Identity, Data.Functor.Product, Data.Functor.Sum,

245+ Data.IORef, Data.Int, Data.Ix, Data.Kind, Data.List,

246+ Data.List.NonEmpty, Data.Maybe, Data.Monoid, Data.Ord, Data.Proxy,

247+ Data.Ratio, Data.STRef, Data.STRef.Lazy, Data.STRef.Strict,

248+ Data.Semigroup, Data.String, Data.Traversable, Data.Tuple,

249+ Data.Type.Bool, Data.Type.Coercion, Data.Type.Equality,

250+ Data.Typeable, Data.Unique, Data.Version, Data.Void, Data.Word,

251+ Debug.Trace, Foreign, Foreign.C, Foreign.C.Error, Foreign.C.String,

252+ Foreign.C.Types, Foreign.Concurrent, Foreign.ForeignPtr,

253+ Foreign.ForeignPtr.Safe, Foreign.ForeignPtr.Unsafe,

254+ Foreign.Marshal, Foreign.Marshal.Alloc, Foreign.Marshal.Array,

255+ Foreign.Marshal.Error, Foreign.Marshal.Pool, Foreign.Marshal.Safe,

256+ Foreign.Marshal.Unsafe, Foreign.Marshal.Utils, Foreign.Ptr,

257+ Foreign.Safe, Foreign.StablePtr, Foreign.Storable, GHC.Arr,

258+ GHC.Base, GHC.ByteOrder, GHC.Char, GHC.Clock, GHC.Conc,

259+ GHC.Conc.IO, GHC.Conc.Signal, GHC.Conc.Sync, GHC.ConsoleHandler,

260+ GHC.Constants, GHC.Desugar, GHC.Enum, GHC.Environment, GHC.Err,

261+ GHC.Event, GHC.Event.TimeOut, GHC.Exception, GHC.Exception.Type,

262+ GHC.ExecutionStack, GHC.ExecutionStack.Internal, GHC.Exts,

263+ GHC.Fingerprint, GHC.Fingerprint.Type, GHC.Float,

264+ GHC.Float.ConversionUtils, GHC.Float.RealFracMethods, GHC.Foreign,

265+ GHC.ForeignPtr, GHC.GHCi, GHC.GHCi.Helpers, GHC.Generics, GHC.IO,

266+ GHC.IO.Buffer, GHC.IO.BufferedIO, GHC.IO.Device, GHC.IO.Encoding,

267+ GHC.IO.Encoding.CodePage, GHC.IO.Encoding.Failure,

268+ GHC.IO.Encoding.Iconv, GHC.IO.Encoding.Latin1,

269+ GHC.IO.Encoding.Types, GHC.IO.Encoding.UTF16,

270+ GHC.IO.Encoding.UTF32, GHC.IO.Encoding.UTF8, GHC.IO.Exception,

271+ GHC.IO.FD, GHC.IO.Handle, GHC.IO.Handle.FD,

272+ GHC.IO.Handle.Internals, GHC.IO.Handle.Lock, GHC.IO.Handle.Text,

273+ GHC.IO.Handle.Types, GHC.IO.IOMode, GHC.IO.StdHandles,

274+ GHC.IO.SubSystem, GHC.IO.Unsafe, GHC.IOArray, GHC.IOPort,

275+ GHC.IORef, GHC.Int, GHC.Integer, GHC.Integer.Logarithms, GHC.Ix,

276+ GHC.List, GHC.MVar, GHC.Maybe, GHC.Natural, GHC.Num,

277+ GHC.Num.BigNat from ghc-bignum-1.0:GHC.Num.BigNat,

278+ GHC.Num.Integer from ghc-bignum-1.0:GHC.Num.Integer,

279+ GHC.Num.Natural from ghc-bignum-1.0:GHC.Num.Natural, GHC.OldList,

280+ GHC.OverloadedLabels, GHC.Pack, GHC.Profiling, GHC.Ptr,

281+ GHC.RTS.Flags, GHC.Read, GHC.Real, GHC.Records, GHC.ResponseFile,

282+ GHC.ST, GHC.STRef, GHC.Show, GHC.Stable, GHC.StableName, GHC.Stack,

283+ GHC.Stack.CCS, GHC.Stack.Types, GHC.StaticPtr, GHC.Stats,

284+ GHC.Storable, GHC.TopHandler, GHC.TypeLits, GHC.TypeNats,

285+ GHC.Unicode, GHC.Weak, GHC.Word, Numeric, Numeric.Natural, Prelude,

286+ System.CPUTime, System.Console.GetOpt, System.Environment,

287+ System.Environment.Blank, System.Exit, System.IO, System.IO.Error,

288+ System.IO.Unsafe, System.Info, System.Mem, System.Mem.StableName,

289+ System.Mem.Weak, System.Posix.Internals, System.Posix.Types,

290+ System.Timeout, Text.ParserCombinators.ReadP,

291+ Text.ParserCombinators.ReadPrec, Text.Printf, Text.Read,

292+ Text.Read.Lex, Text.Show, Text.Show.Functions, Type.Reflection,

293+ Type.Reflection.Unsafe, Unsafe.Coerce

294+hidden-modules:

295+ Control.Monad.ST.Imp Control.Monad.ST.Lazy.Imp Data.Functor.Utils

296+ Data.OldList Data.Semigroup.Internal Data.Typeable.Internal

297+ Foreign.ForeignPtr.Imp GHC.IO.Handle.Lock.Common

298+ GHC.IO.Handle.Lock.Flock GHC.IO.Handle.Lock.LinuxOFD

299+ GHC.IO.Handle.Lock.NoOp GHC.IO.Handle.Lock.Windows

300+ GHC.StaticPtr.Internal GHC.Event.Internal.Types

301+ System.Environment.ExecutablePath System.CPUTime.Utils

302+ GHC.Event.Arr GHC.Event.Array GHC.Event.Control GHC.Event.EPoll

303+ GHC.Event.IntTable GHC.Event.Internal GHC.Event.KQueue

304+ GHC.Event.Manager GHC.Event.PSQ GHC.Event.Poll GHC.Event.Thread

305+ GHC.Event.TimerManager GHC.Event.Unique

306+ System.CPUTime.Posix.ClockGetTime System.CPUTime.Posix.Times

307+ System.CPUTime.Posix.RUsage System.CPUTime.Unsupported

308+import-dirs:

309+library-dirs:

310+dynamic-library-dirs:

311+data-dir:

312+hs-libraries: HSbase-4.15.0.0

313+extra-libraries: iconv

314+include-dirs:

315+includes: HsBase.h

316+depends: ghc-bignum-1.0 ghc-prim-0.7.0 rts

317+haddock-interfaces:

318+haddock-html:

319+---

320+name: binary

321+version: 0.8.8.0

322+visibility: public

323+id: binary-0.8.8.0

324+key: binary-0.8.8.0

325+license: BSD-3-Clause

326+maintainer: Lennart Kolmodin, Don Stewart <dons00@gmail.com>

327+author: Lennart Kolmodin <kolmodin@gmail.com>

328+stability: provisional

329+homepage: https://github.com/kolmodin/binary

330+synopsis:

331+ Binary serialisation for Haskell values using lazy ByteStrings

332+description:

333+ Efficient, pure binary serialisation using lazy ByteStrings.

334+ Haskell values may be encoded to and from binary formats,

335+ written to disk as binary, or sent over the network.

336+ The format used can be automatically generated, or

337+ you can choose to implement a custom format if needed.

338+ Serialisation speeds of over 1 G\/sec have been observed,

339+ so this library should be suitable for high performance

340+ scenarios.

341+category: Data, Parsing

342+exposed: True

343+exposed-modules:

344+ Data.Binary Data.Binary.Builder Data.Binary.Get

345+ Data.Binary.Get.Internal Data.Binary.Put

346+hidden-modules:

347+ Data.Binary.Class Data.Binary.Internal Data.Binary.Generic

348+ Data.Binary.FloatCast

349+import-dirs:

350+library-dirs:

351+dynamic-library-dirs:

352+data-dir:

353+hs-libraries: HSbinary-0.8.8.0

354+depends:

355+ array-0.5.4.0 base-4.15.0.0 bytestring-0.10.12.1 containers-0.6.4.1

356+haddock-interfaces:

357+haddock-html:

358+---

359+name: bytestring

360+version: 0.10.12.1

361+visibility: public

362+id: bytestring-0.10.12.1

363+key: bytestring-0.10.12.1

364+license: BSD-3-Clause

365+copyright:

366+ Copyright (c) Don Stewart 2005-2009,

367+ (c) Duncan Coutts 2006-2015,

368+ (c) David Roundy 2003-2005,

369+ (c) Jasper Van der Jeugt 2010,

370+ (c) Simon Meier 2010-2013.

371+maintainer:

372+ Haskell Bytestring Team <andrew.lelechenko@gmail.com>, Core Libraries Committee

373+author:

374+ Don Stewart,

375+ Duncan Coutts

376+homepage: https://github.com/haskell/bytestring

377+synopsis:

378+ Fast, compact, strict and lazy byte strings with a list interface

379+description:

380+ An efficient compact, immutable byte string type (both strict and lazy)

381+ suitable for binary or 8-bit character data.

382+ The 'ByteString' type represents sequences of bytes or 8-bit characters.

383+ It is suitable for high performance use, both in terms of large data

384+ quantities, or high speed requirements. The 'ByteString' functions follow

385+ the same style as Haskell\'s ordinary lists, so it is easy to convert code

386+ from using 'String' to 'ByteString'.

387+ Two 'ByteString' variants are provided:

388+ * Strict 'ByteString's keep the string as a single large array. This

389+ makes them convenient for passing data between C and Haskell.

390+ * Lazy 'ByteString's use a lazy list of strict chunks which makes it

391+ suitable for I\/O streaming tasks.

392+ The @Char8@ modules provide a character-based view of the same

393+ underlying 'ByteString' types. This makes it convenient to handle mixed

394+ binary and 8-bit character content (which is common in many file formats

395+ and network protocols).

396+ The 'Builder' module provides an efficient way to build up 'ByteString's

397+ in an ad-hoc way by repeated concatenation. This is ideal for fast

398+ serialisation or pretty printing.

399+ There is also a 'ShortByteString' type which has a lower memory overhead

400+ and can can be converted to or from a 'ByteString', but supports very few

401+ other operations. It is suitable for keeping many short strings in memory.

402+ 'ByteString's are not designed for Unicode. For Unicode strings you should

403+ use the 'Text' type from the @text@ package.

404+ These modules are intended to be imported qualified, to avoid name clashes

405+ with "Prelude" functions, e.g.

406+ > import qualified Data.ByteString as BS

407+category: Data

408+exposed: True

409+exposed-modules:

410+ Data.ByteString Data.ByteString.Builder

411+ Data.ByteString.Builder.Extra Data.ByteString.Builder.Internal

412+ Data.ByteString.Builder.Prim Data.ByteString.Builder.Prim.Internal

413+ Data.ByteString.Char8 Data.ByteString.Internal Data.ByteString.Lazy

414+ Data.ByteString.Lazy.Builder Data.ByteString.Lazy.Builder.ASCII

415+ Data.ByteString.Lazy.Builder.Extras Data.ByteString.Lazy.Char8

416+ Data.ByteString.Lazy.Internal Data.ByteString.Short

417+ Data.ByteString.Short.Internal Data.ByteString.Unsafe

418+hidden-modules:

419+ Data.ByteString.Builder.ASCII Data.ByteString.Builder.Prim.Binary

420+ Data.ByteString.Builder.Prim.ASCII

421+ Data.ByteString.Builder.Prim.Internal.Floating

422+ Data.ByteString.Builder.Prim.Internal.UncheckedShifts

423+ Data.ByteString.Builder.Prim.Internal.Base16

424+import-dirs:

425+library-dirs:

426+dynamic-library-dirs:

427+data-dir:

428+hs-libraries: HSbytestring-0.10.12.1

429+include-dirs:

430+includes: fpstring.h

431+depends:

432+ base-4.15.0.0 deepseq-1.4.5.0 ghc-bignum-1.0 ghc-prim-0.7.0

433+haddock-interfaces:

434+haddock-html:

435+---

436+name: containers

437+version: 0.6.4.1

438+visibility: public

439+id: containers-0.6.4.1

440+key: containers-0.6.4.1

441+license: BSD-3-Clause

442+maintainer: libraries@haskell.org

443+synopsis: Assorted concrete container types

444+description:

445+ This package contains efficient general-purpose implementations

446+ of various immutable container types including sets, maps, sequences,

447+ trees, and graphs.

448+ For a walkthrough of what this package provides with examples of common

449+ operations see the [containers

450+ introduction](https://haskell-containers.readthedocs.io).

451+ The declared cost of each operation is either worst-case or amortized, but

452+ remains valid even if structures are shared.

453+category: Data Structures

454+exposed: True

455+exposed-modules:

456+ Data.Containers.ListUtils Data.Graph Data.IntMap

457+ Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy

458+ Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict

459+ Data.IntMap.Strict.Internal Data.IntSet Data.IntSet.Internal

460+ Data.Map Data.Map.Internal Data.Map.Internal.Debug Data.Map.Lazy

461+ Data.Map.Merge.Lazy Data.Map.Merge.Strict Data.Map.Strict

462+ Data.Map.Strict.Internal Data.Sequence Data.Sequence.Internal

463+ Data.Sequence.Internal.Sorting Data.Set Data.Set.Internal Data.Tree

464+ Utils.Containers.Internal.BitQueue

465+ Utils.Containers.Internal.BitUtil

466+ Utils.Containers.Internal.StrictPair

467+hidden-modules:

468+ Utils.Containers.Internal.State

469+ Utils.Containers.Internal.StrictMaybe

470+ Utils.Containers.Internal.PtrEquality

471+ Utils.Containers.Internal.Coercions

472+ Utils.Containers.Internal.TypeError

473+ Data.Map.Internal.DeprecatedShowTree

474+ Data.IntMap.Internal.DeprecatedDebug

475+import-dirs:

476+library-dirs:

477+dynamic-library-dirs:

478+data-dir:

479+hs-libraries: HScontainers-0.6.4.1

480+depends: array-0.5.4.0 base-4.15.0.0 deepseq-1.4.5.0

481+haddock-interfaces:

482+haddock-html:

483+---

484+name: deepseq

485+version: 1.4.5.0

486+visibility: public

487+id: deepseq-1.4.5.0

488+key: deepseq-1.4.5.0

489+license: BSD-3-Clause

490+maintainer: libraries@haskell.org

491+synopsis: Deep evaluation of data structures

492+description:

493+ This package provides methods for fully evaluating data structures

494+ (\"deep evaluation\"). Deep evaluation is often used for adding

495+ strictness to a program, e.g. in order to force pending exceptions,

496+ remove space leaks, or force lazy I/O to happen. It is also useful

497+ in parallel programs, to ensure pending work does not migrate to the

498+ wrong thread.

499+ The primary use of this package is via the 'deepseq' function, a

500+ \"deep\" version of 'seq'. It is implemented on top of an 'NFData'

501+ typeclass (\"Normal Form Data\", data structures with no unevaluated

502+ components) which defines strategies for fully evaluating different

503+ data types. See module documentation in "Control.DeepSeq" for more

504+ details.

505+category: Control

506+exposed: True

507+exposed-modules: Control.DeepSeq

508+hidden-modules: Control.DeepSeq.BackDoor

509+import-dirs:

510+library-dirs:

511+dynamic-library-dirs:

512+data-dir:

513+hs-libraries: HSdeepseq-1.4.5.0

514+depends: array-0.5.4.0 base-4.15.0.0

515+haddock-interfaces:

516+haddock-html:

517+---

518+name: directory

519+version: 1.3.6.1

520+visibility: public

521+id: directory-1.3.6.1

522+key: directory-1.3.6.1

523+license: BSD-3-Clause

524+maintainer: libraries@haskell.org

525+synopsis: Platform-agnostic library for filesystem operations

526+description:

527+ This library provides a basic set of operations for manipulating files and

528+ directories in a portable way.

529+category: System

530+exposed: True

531+exposed-modules:

532+ System.Directory System.Directory.Internal

533+ System.Directory.Internal.Prelude

534+hidden-modules:

535+ System.Directory.Internal.C_utimensat

536+ System.Directory.Internal.Common System.Directory.Internal.Config

537+ System.Directory.Internal.Posix System.Directory.Internal.Windows

538+import-dirs:

539+library-dirs:

540+dynamic-library-dirs:

541+data-dir:

542+hs-libraries: HSdirectory-1.3.6.1

543+depends:

544+ base-4.15.0.0 filepath-1.4.2.1 time-1.9.3 unix-2.7.2.2

545+haddock-interfaces:

546+haddock-html:

547+---

548+name: exceptions

549+version: 0.10.4

550+visibility: public

551+id: exceptions-0.10.4

552+key: exceptions-0.10.4

553+license: BSD-3-Clause

554+copyright:

555+ Copyright (C) 2013-2015 Edward A. Kmett

556+ Copyright (C) 2012 Google Inc.

557+maintainer: Edward A. Kmett <ekmett@gmail.com>

558+author: Edward A. Kmett

559+stability: provisional

560+homepage: http://github.com/ekmett/exceptions/

561+synopsis: Extensible optionally-pure exceptions

562+description: Extensible optionally-pure exceptions.

563+category: Control, Exceptions, Monad

564+exposed: True

565+exposed-modules: Control.Monad.Catch Control.Monad.Catch.Pure

566+import-dirs:

567+library-dirs:

568+dynamic-library-dirs:

569+data-dir:

570+hs-libraries: HSexceptions-0.10.4

571+depends:

572+ base-4.15.0.0 mtl-2.2.2 stm-2.5.0.0 template-haskell-2.17.0.0

573+ transformers-0.5.6.2

574+haddock-interfaces:

575+haddock-html:

576+---

577+name: filepath

578+version: 1.4.2.1

579+visibility: public

580+id: filepath-1.4.2.1

581+key: filepath-1.4.2.1

582+license: BSD-3-Clause

583+copyright: Neil Mitchell 2005-2020

584+maintainer: Neil Mitchell <ndmitchell@gmail.com>

585+author: Neil Mitchell <ndmitchell@gmail.com>

586+homepage: https://github.com/haskell/filepath#readme

587+synopsis: Library for manipulating FilePaths in a cross platform way.

588+description:

589+ 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:

590+ * "System.FilePath.Posix" manipulates POSIX\/Linux style @FilePath@ values (with @\/@ as the path separator).

591+ * "System.FilePath.Windows" manipulates Windows style @FilePath@ values (with either @\\@ or @\/@ as the path separator, and deals with drives).

592+ * "System.FilePath" is an alias for the module appropriate to your platform.

593+ All three modules provide the same API, and the same documentation (calling out differences in the different variants).

594+category: System

595+exposed: True

596+exposed-modules:

597+ System.FilePath System.FilePath.Posix System.FilePath.Windows

598+import-dirs:

599+library-dirs:

600+dynamic-library-dirs:

601+data-dir:

602+hs-libraries: HSfilepath-1.4.2.1

603+depends: base-4.15.0.0

604+haddock-interfaces:

605+haddock-html:

606+---

607+name: ghc

608+version: 9.0.1

609+visibility: public

610+id: ghc-9.0.1

611+key: ghc-9.0.1

612+license: BSD-3-Clause

613+maintainer: glasgow-haskell-users@haskell.org

614+author: The GHC Team

615+homepage: http://www.haskell.org/ghc/

616+synopsis: The GHC API

617+description:

618+ GHC's functionality can be useful for more things than just

619+ compiling Haskell programs. Important use cases are programs

620+ that analyse (and perhaps transform) Haskell code. Others

621+ include loading Haskell code dynamically in a GHCi-like manner.

622+ For this reason, a lot of GHC's functionality is made available

623+ through this package.

624+ See <https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler>

625+ for more information.

626+category: Development

627+exposed-modules:

628+ GHC GHC.Builtin.Names GHC.Builtin.Names.TH GHC.Builtin.PrimOps

629+ GHC.Builtin.RebindableNames GHC.Builtin.Types

630+ GHC.Builtin.Types.Literals GHC.Builtin.Types.Prim

631+ GHC.Builtin.Uniques GHC.Builtin.Utils GHC.ByteCode.Asm

632+ GHC.ByteCode.InfoTable GHC.ByteCode.Instr GHC.ByteCode.Linker

633+ GHC.ByteCode.Types GHC.Cmm GHC.Cmm.BlockId GHC.Cmm.CLabel

634+ GHC.Cmm.CallConv GHC.Cmm.CommonBlockElim GHC.Cmm.ContFlowOpt

635+ GHC.Cmm.Dataflow GHC.Cmm.Dataflow.Block

636+ GHC.Cmm.Dataflow.Collections GHC.Cmm.Dataflow.Graph

637+ GHC.Cmm.Dataflow.Label GHC.Cmm.DebugBlock GHC.Cmm.Expr

638+ GHC.Cmm.Graph GHC.Cmm.Info GHC.Cmm.Info.Build GHC.Cmm.LayoutStack

639+ GHC.Cmm.Lexer GHC.Cmm.Lint GHC.Cmm.Liveness GHC.Cmm.MachOp

640+ GHC.Cmm.Monad GHC.Cmm.Node GHC.Cmm.Opt GHC.Cmm.Parser

641+ GHC.Cmm.Pipeline GHC.Cmm.Ppr GHC.Cmm.Ppr.Decl GHC.Cmm.Ppr.Expr

642+ GHC.Cmm.ProcPoint GHC.Cmm.Sink GHC.Cmm.Switch

643+ GHC.Cmm.Switch.Implement GHC.Cmm.Type GHC.Cmm.Utils GHC.CmmToAsm

644+ GHC.CmmToAsm.BlockLayout GHC.CmmToAsm.CFG

645+ GHC.CmmToAsm.CFG.Dominators GHC.CmmToAsm.CPrim GHC.CmmToAsm.Config

646+ GHC.CmmToAsm.Dwarf GHC.CmmToAsm.Dwarf.Constants

647+ GHC.CmmToAsm.Dwarf.Types GHC.CmmToAsm.Format GHC.CmmToAsm.Instr

648+ GHC.CmmToAsm.Monad GHC.CmmToAsm.PIC GHC.CmmToAsm.PPC.CodeGen

649+ GHC.CmmToAsm.PPC.Cond GHC.CmmToAsm.PPC.Instr GHC.CmmToAsm.PPC.Ppr

650+ GHC.CmmToAsm.PPC.RegInfo GHC.CmmToAsm.PPC.Regs GHC.CmmToAsm.Ppr

651+ GHC.CmmToAsm.Reg.Graph GHC.CmmToAsm.Reg.Graph.Base

652+ GHC.CmmToAsm.Reg.Graph.Coalesce GHC.CmmToAsm.Reg.Graph.Spill

653+ GHC.CmmToAsm.Reg.Graph.SpillClean GHC.CmmToAsm.Reg.Graph.SpillCost

654+ GHC.CmmToAsm.Reg.Graph.Stats GHC.CmmToAsm.Reg.Graph.TrivColorable

655+ GHC.CmmToAsm.Reg.Graph.X86 GHC.CmmToAsm.Reg.Linear

656+ GHC.CmmToAsm.Reg.Linear.Base GHC.CmmToAsm.Reg.Linear.FreeRegs

657+ GHC.CmmToAsm.Reg.Linear.JoinToTargets GHC.CmmToAsm.Reg.Linear.PPC

658+ GHC.CmmToAsm.Reg.Linear.SPARC GHC.CmmToAsm.Reg.Linear.StackMap

659+ GHC.CmmToAsm.Reg.Linear.State GHC.CmmToAsm.Reg.Linear.Stats

660+ GHC.CmmToAsm.Reg.Linear.X86 GHC.CmmToAsm.Reg.Linear.X86_64

661+ GHC.CmmToAsm.Reg.Liveness GHC.CmmToAsm.Reg.Target

662+ GHC.CmmToAsm.Reg.Utils GHC.CmmToAsm.SPARC.AddrMode

663+ GHC.CmmToAsm.SPARC.Base GHC.CmmToAsm.SPARC.CodeGen

664+ GHC.CmmToAsm.SPARC.CodeGen.Amode GHC.CmmToAsm.SPARC.CodeGen.Base

665+ GHC.CmmToAsm.SPARC.CodeGen.CondCode

666+ GHC.CmmToAsm.SPARC.CodeGen.Expand GHC.CmmToAsm.SPARC.CodeGen.Gen32

667+ GHC.CmmToAsm.SPARC.CodeGen.Gen64 GHC.CmmToAsm.SPARC.CodeGen.Sanity

668+ GHC.CmmToAsm.SPARC.Cond GHC.CmmToAsm.SPARC.Imm

669+ GHC.CmmToAsm.SPARC.Instr GHC.CmmToAsm.SPARC.Ppr

670+ GHC.CmmToAsm.SPARC.Regs GHC.CmmToAsm.SPARC.ShortcutJump

671+ GHC.CmmToAsm.SPARC.Stack GHC.CmmToAsm.X86.CodeGen

672+ GHC.CmmToAsm.X86.Cond GHC.CmmToAsm.X86.Instr GHC.CmmToAsm.X86.Ppr

673+ GHC.CmmToAsm.X86.RegInfo GHC.CmmToAsm.X86.Regs GHC.CmmToC

674+ GHC.CmmToLlvm GHC.CmmToLlvm.Base GHC.CmmToLlvm.CodeGen

675+ GHC.CmmToLlvm.Data GHC.CmmToLlvm.Mangler GHC.CmmToLlvm.Ppr

676+ GHC.CmmToLlvm.Regs GHC.Core GHC.Core.Class GHC.Core.Coercion

677+ GHC.Core.Coercion.Axiom GHC.Core.Coercion.Opt GHC.Core.ConLike

678+ GHC.Core.DataCon GHC.Core.FVs GHC.Core.FamInstEnv GHC.Core.InstEnv

679+ GHC.Core.Lint GHC.Core.Make GHC.Core.Map GHC.Core.Multiplicity

680+ GHC.Core.Opt.Arity GHC.Core.Opt.CSE GHC.Core.Opt.CallArity

681+ GHC.Core.Opt.ConstantFold GHC.Core.Opt.CprAnal GHC.Core.Opt.DmdAnal

682+ GHC.Core.Opt.Exitify GHC.Core.Opt.FloatIn GHC.Core.Opt.FloatOut

683+ GHC.Core.Opt.LiberateCase GHC.Core.Opt.Monad GHC.Core.Opt.OccurAnal

684+ GHC.Core.Opt.Pipeline GHC.Core.Opt.SetLevels GHC.Core.Opt.Simplify

685+ GHC.Core.Opt.Simplify.Env GHC.Core.Opt.Simplify.Monad

686+ GHC.Core.Opt.Simplify.Utils GHC.Core.Opt.SpecConstr

687+ GHC.Core.Opt.Specialise GHC.Core.Opt.StaticArgs

688+ GHC.Core.Opt.WorkWrap GHC.Core.Opt.WorkWrap.Utils GHC.Core.PatSyn

689+ GHC.Core.Ppr GHC.Core.Ppr.TyThing GHC.Core.Predicate GHC.Core.Rules

690+ GHC.Core.Seq GHC.Core.SimpleOpt GHC.Core.Stats GHC.Core.Subst

691+ GHC.Core.Tidy GHC.Core.TyCo.FVs GHC.Core.TyCo.Ppr GHC.Core.TyCo.Rep

692+ GHC.Core.TyCo.Subst GHC.Core.TyCo.Tidy GHC.Core.TyCon GHC.Core.Type

693+ GHC.Core.Unfold GHC.Core.Unify GHC.Core.UsageEnv GHC.Core.Utils

694+ GHC.CoreToByteCode GHC.CoreToIface GHC.CoreToStg GHC.CoreToStg.Prep

695+ GHC.Data.Bag GHC.Data.Bitmap GHC.Data.BooleanFormula

696+ GHC.Data.EnumSet GHC.Data.FastMutInt GHC.Data.FastString

697+ GHC.Data.FastString.Env GHC.Data.FiniteMap GHC.Data.Graph.Base

698+ GHC.Data.Graph.Color GHC.Data.Graph.Directed GHC.Data.Graph.Ops

699+ GHC.Data.Graph.Ppr GHC.Data.Graph.UnVar GHC.Data.IOEnv

700+ GHC.Data.List.SetOps GHC.Data.Maybe GHC.Data.OrdList GHC.Data.Pair

701+ GHC.Data.Stream GHC.Data.StringBuffer GHC.Data.TrieMap

702+ GHC.Driver.Backend GHC.Driver.Backpack GHC.Driver.Backpack.Syntax

703+ GHC.Driver.CmdLine GHC.Driver.CodeOutput GHC.Driver.Finder

704+ GHC.Driver.Flags GHC.Driver.Hooks GHC.Driver.Main GHC.Driver.Make

705+ GHC.Driver.MakeFile GHC.Driver.Monad GHC.Driver.Phases

706+ GHC.Driver.Pipeline GHC.Driver.Pipeline.Monad GHC.Driver.Plugins

707+ GHC.Driver.Session GHC.Driver.Types GHC.Driver.Ways GHC.Hs

708+ GHC.Hs.Binds GHC.Hs.Decls GHC.Hs.Doc GHC.Hs.Dump GHC.Hs.Expr

709+ GHC.Hs.Extension GHC.Hs.ImpExp GHC.Hs.Instances GHC.Hs.Lit

710+ GHC.Hs.Pat GHC.Hs.Stats GHC.Hs.Type GHC.Hs.Utils GHC.HsToCore

711+ GHC.HsToCore.Arrows GHC.HsToCore.Binds GHC.HsToCore.Coverage

712+ GHC.HsToCore.Docs GHC.HsToCore.Expr GHC.HsToCore.Foreign.Call

713+ GHC.HsToCore.Foreign.Decl GHC.HsToCore.GuardedRHSs

714+ GHC.HsToCore.ListComp GHC.HsToCore.Match

715+ GHC.HsToCore.Match.Constructor GHC.HsToCore.Match.Literal

716+ GHC.HsToCore.Monad GHC.HsToCore.PmCheck GHC.HsToCore.PmCheck.Oracle

717+ GHC.HsToCore.PmCheck.Ppr GHC.HsToCore.PmCheck.Types

718+ GHC.HsToCore.Quote GHC.HsToCore.Usage GHC.HsToCore.Utils

719+ GHC.Iface.Binary GHC.Iface.Env GHC.Iface.Ext.Ast

720+ GHC.Iface.Ext.Binary GHC.Iface.Ext.Debug GHC.Iface.Ext.Types

721+ GHC.Iface.Ext.Utils GHC.Iface.Load GHC.Iface.Make GHC.Iface.Recomp

722+ GHC.Iface.Recomp.Binary GHC.Iface.Recomp.Flags GHC.Iface.Rename

723+ GHC.Iface.Syntax GHC.Iface.Tidy GHC.Iface.Tidy.StaticPtrTable

724+ GHC.Iface.Type GHC.Iface.UpdateIdInfos GHC.IfaceToCore GHC.Llvm

725+ GHC.Llvm.MetaData GHC.Llvm.Ppr GHC.Llvm.Syntax GHC.Llvm.Types

726+ GHC.Parser GHC.Parser.Annotation GHC.Parser.CharClass

727+ GHC.Parser.Header GHC.Parser.Lexer GHC.Parser.PostProcess

728+ GHC.Parser.PostProcess.Haddock GHC.Platform.AArch64

729+ GHC.Platform.ARM GHC.Platform.NoRegs GHC.Platform.PPC

730+ GHC.Platform.Reg GHC.Platform.Reg.Class GHC.Platform.Regs

731+ GHC.Platform.S390X GHC.Platform.SPARC GHC.Platform.X86

732+ GHC.Platform.X86_64 GHC.Plugins GHC.Prelude GHC.Rename.Bind

733+ GHC.Rename.Doc GHC.Rename.Env GHC.Rename.Expr GHC.Rename.Fixity

734+ GHC.Rename.HsType GHC.Rename.Module GHC.Rename.Names GHC.Rename.Pat

735+ GHC.Rename.Splice GHC.Rename.Unbound GHC.Rename.Utils

736+ GHC.Runtime.Debugger GHC.Runtime.Eval GHC.Runtime.Eval.Types

737+ GHC.Runtime.Heap.Inspect GHC.Runtime.Heap.Layout

738+ GHC.Runtime.Interpreter GHC.Runtime.Interpreter.Types

739+ GHC.Runtime.Linker GHC.Runtime.Linker.Types GHC.Runtime.Loader

740+ GHC.Settings GHC.Settings.Config GHC.Settings.Constants

741+ GHC.Settings.IO GHC.Stg.CSE GHC.Stg.DepAnal GHC.Stg.FVs

742+ GHC.Stg.Lift GHC.Stg.Lift.Analysis GHC.Stg.Lift.Monad GHC.Stg.Lint

743+ GHC.Stg.Pipeline GHC.Stg.Stats GHC.Stg.Subst GHC.Stg.Syntax

744+ GHC.Stg.Unarise GHC.StgToCmm GHC.StgToCmm.ArgRep GHC.StgToCmm.Bind

745+ GHC.StgToCmm.CgUtils GHC.StgToCmm.Closure GHC.StgToCmm.DataCon

746+ GHC.StgToCmm.Env GHC.StgToCmm.Expr GHC.StgToCmm.ExtCode

747+ GHC.StgToCmm.Foreign GHC.StgToCmm.Heap GHC.StgToCmm.Hpc

748+ GHC.StgToCmm.Layout GHC.StgToCmm.Monad GHC.StgToCmm.Prim

749+ GHC.StgToCmm.Prof GHC.StgToCmm.Ticky GHC.StgToCmm.Types

750+ GHC.StgToCmm.Utils GHC.SysTools GHC.SysTools.Ar

751+ GHC.SysTools.BaseDir GHC.SysTools.Elf GHC.SysTools.ExtraObj

752+ GHC.SysTools.FileCleanup GHC.SysTools.Info GHC.SysTools.Process

753+ GHC.SysTools.Tasks GHC.SysTools.Terminal GHC.Tc.Deriv

754+ GHC.Tc.Deriv.Functor GHC.Tc.Deriv.Generate GHC.Tc.Deriv.Generics

755+ GHC.Tc.Deriv.Infer GHC.Tc.Deriv.Utils GHC.Tc.Errors

756+ GHC.Tc.Errors.Hole GHC.Tc.Errors.Hole.FitTypes

757+ GHC.Tc.Gen.Annotation GHC.Tc.Gen.Arrow GHC.Tc.Gen.Bind

758+ GHC.Tc.Gen.Default GHC.Tc.Gen.Export GHC.Tc.Gen.Expr

759+ GHC.Tc.Gen.Foreign GHC.Tc.Gen.HsType GHC.Tc.Gen.Match

760+ GHC.Tc.Gen.Pat GHC.Tc.Gen.Rule GHC.Tc.Gen.Sig GHC.Tc.Gen.Splice

761+ GHC.Tc.Instance.Class GHC.Tc.Instance.Family

762+ GHC.Tc.Instance.FunDeps GHC.Tc.Instance.Typeable GHC.Tc.Module

763+ GHC.Tc.Plugin GHC.Tc.Solver GHC.Tc.Solver.Canonical

764+ GHC.Tc.Solver.Flatten GHC.Tc.Solver.Interact GHC.Tc.Solver.Monad

765+ GHC.Tc.TyCl GHC.Tc.TyCl.Build GHC.Tc.TyCl.Class

766+ GHC.Tc.TyCl.Instance GHC.Tc.TyCl.PatSyn GHC.Tc.TyCl.Utils

767+ GHC.Tc.Types GHC.Tc.Types.Constraint GHC.Tc.Types.EvTerm

768+ GHC.Tc.Types.Evidence GHC.Tc.Types.Origin GHC.Tc.Utils.Backpack

769+ GHC.Tc.Utils.Env GHC.Tc.Utils.Instantiate GHC.Tc.Utils.Monad

770+ GHC.Tc.Utils.TcMType GHC.Tc.Utils.TcType GHC.Tc.Utils.Unify

771+ GHC.Tc.Utils.Zonk GHC.Tc.Validity GHC.ThToHs GHC.Types.Annotations

772+ GHC.Types.Avail GHC.Types.Basic GHC.Types.CostCentre

773+ GHC.Types.CostCentre.State GHC.Types.Cpr GHC.Types.Demand

774+ GHC.Types.FieldLabel GHC.Types.ForeignCall GHC.Types.Id

775+ GHC.Types.Id.Info GHC.Types.Id.Make GHC.Types.Literal

776+ GHC.Types.Name GHC.Types.Name.Cache GHC.Types.Name.Env

777+ GHC.Types.Name.Occurrence GHC.Types.Name.Reader GHC.Types.Name.Set

778+ GHC.Types.Name.Shape GHC.Types.RepType GHC.Types.SrcLoc

779+ GHC.Types.Unique GHC.Types.Unique.DFM GHC.Types.Unique.DSet

780+ GHC.Types.Unique.FM GHC.Types.Unique.Set GHC.Types.Unique.Supply

781+ GHC.Types.Var GHC.Types.Var.Env GHC.Types.Var.Set GHC.Unit

782+ GHC.Unit.Info GHC.Unit.Module GHC.Unit.Module.Env

783+ GHC.Unit.Module.Location GHC.Unit.Module.Name GHC.Unit.Parser

784+ GHC.Unit.Ppr GHC.Unit.State GHC.Unit.Types GHC.Utils.Asm

785+ GHC.Utils.Binary GHC.Utils.BufHandle GHC.Utils.CliOption

786+ GHC.Utils.Encoding GHC.Utils.Error GHC.Utils.Exception GHC.Utils.FV

787+ GHC.Utils.Fingerprint GHC.Utils.IO.Unsafe GHC.Utils.Json

788+ GHC.Utils.Lexeme GHC.Utils.Misc GHC.Utils.Monad

789+ GHC.Utils.Monad.State GHC.Utils.Outputable GHC.Utils.Panic

790+ GHC.Utils.Panic.Plain GHC.Utils.Ppr GHC.Utils.Ppr.Colour

791+import-dirs:

792+library-dirs:

793+dynamic-library-dirs:

794+data-dir:

795+hs-libraries: HSghc-9.0.1

796+include-dirs:

797+depends:

798+ array-0.5.4.0 base-4.15.0.0 binary-0.8.8.0 bytestring-0.10.12.1

799+ containers-0.6.4.1 deepseq-1.4.5.0 directory-1.3.6.1

800+ exceptions-0.10.4 filepath-1.4.2.1 ghc-boot-9.0.1 ghc-boot-th-9.0.1

801+ ghc-heap-9.0.1 ghci-9.0.1 hpc-0.6.1.0 process-1.6.11.0

802+ template-haskell-2.17.0.0 terminfo-0.4.1.4 time-1.9.3

803+ transformers-0.5.6.2 unix-2.7.2.2

804+haddock-interfaces:

805+haddock-html:

806+---

807+name: ghc-bignum

808+version: 1.0

809+visibility: public

810+id: ghc-bignum-1.0

811+key: ghc-bignum-1.0

812+license: BSD-3-Clause

813+maintainer: libraries@haskell.org

814+author: Sylvain Henry

815+synopsis: GHC BigNum library

816+description:

817+ This package provides the low-level implementation of the standard

818+ 'BigNat', 'Natural' and 'Integer' types.

819+category: Numeric, Algebra, GHC

820+exposed: True

821+exposed-modules:

822+ GHC.Num.Backend GHC.Num.Backend.Native GHC.Num.Backend.Selected

823+ GHC.Num.BigNat GHC.Num.Integer GHC.Num.Natural GHC.Num.Primitives

824+ GHC.Num.WordArray

825+hidden-modules: GHC.Num.Backend.GMP

826+import-dirs:

827+library-dirs:

828+dynamic-library-dirs:

829+data-dir:

830+hs-libraries: HSghc-bignum-1.0

831+extra-libraries: gmp

832+include-dirs:

833+depends: ghc-prim-0.7.0

834+haddock-interfaces:

835+haddock-html:

836+---

837+name: ghc-boot

838+version: 9.0.1

839+visibility: public

840+id: ghc-boot-9.0.1

841+key: ghc-boot-9.0.1

842+license: BSD-3-Clause

843+maintainer: ghc-devs@haskell.org

844+synopsis: Shared functionality between GHC and its boot libraries

845+description:

846+ This library is shared between GHC, ghc-pkg, and other boot

847+ libraries.

848+ A note about "GHC.Unit.Database": it only deals with the subset of

849+ the package database that the compiler cares about: modules

850+ paths etc and not package metadata like description, authors

851+ etc. It is thus not a library interface to ghc-pkg and is *not*

852+ suitable for modifying GHC package databases.

853+ The package database format and this library are constructed in

854+ such a way that while ghc-pkg depends on Cabal, the GHC library

855+ and program do not have to depend on Cabal.

856+category: GHC

857+exposed: True

858+exposed-modules:

859+ GHC.BaseDir GHC.ForeignSrcLang GHC.HandleEncoding

860+ GHC.LanguageExtensions GHC.Platform GHC.Platform.Host

861+ GHC.Serialized GHC.Settings.Platform GHC.Settings.Utils

862+ GHC.UniqueSubdir GHC.Unit.Database GHC.Version

863+import-dirs:

864+library-dirs:

865+dynamic-library-dirs:

866+data-dir:

867+hs-libraries: HSghc-boot-9.0.1

868+depends:

869+ base-4.15.0.0 binary-0.8.8.0 bytestring-0.10.12.1

870+ containers-0.6.4.1 directory-1.3.6.1 filepath-1.4.2.1

871+ ghc-boot-th-9.0.1

872+haddock-interfaces:

873+haddock-html:

874+---

875+name: ghc-boot-th

876+version: 9.0.1

877+visibility: public

878+id: ghc-boot-th-9.0.1

879+key: ghc-boot-th-9.0.1

880+license: BSD-3-Clause

881+maintainer: ghc-devs@haskell.org

882+synopsis:

883+ Shared functionality between GHC and the @template-haskell@

884+ library

885+description:

886+ This library contains various bits shared between the @ghc@ and

887+ @template-haskell@ libraries.

888+ This package exists to ensure that @template-haskell@ has a

889+ minimal set of transitive dependencies, since it is intended to

890+ be depended upon by user code.

891+category: GHC

892+exposed: True

893+exposed-modules:

894+ GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme

895+import-dirs:

896+library-dirs:

897+dynamic-library-dirs:

898+data-dir:

899+hs-libraries: HSghc-boot-th-9.0.1

900+depends: base-4.15.0.0

901+haddock-interfaces:

902+haddock-html:

903+---

904+name: ghc-compact

905+version: 0.1.0.0

906+visibility: public

907+id: ghc-compact-0.1.0.0

908+key: ghc-compact-0.1.0.0

909+license: BSD-3-Clause

910+maintainer: libraries@haskell.org

911+synopsis: In memory storage of deeply evaluated data structure

912+description:

913+ This package provides minimal functionality for working with

914+ "compact regions", which hold a fully evaluated Haskell object graph.

915+ These regions maintain the invariant that no pointers live inside the struct

916+ that point outside it, which ensures efficient garbage collection without

917+ ever reading the structure contents (effectively, it works as a manually

918+ managed "oldest generation" which is never freed until the whole is

919+ released).

920+ Internally, the struct is stored a single contiguous block of memory,

921+ which allows efficient serialization and deserialization of structs

922+ for distributed computing.

923+category: Data

924+exposed: True

925+exposed-modules: GHC.Compact GHC.Compact.Serialized

926+import-dirs:

927+library-dirs:

928+dynamic-library-dirs:

929+data-dir:

930+hs-libraries: HSghc-compact-0.1.0.0

931+depends: base-4.15.0.0 bytestring-0.10.12.1 ghc-prim-0.7.0

932+haddock-interfaces:

933+haddock-html:

934+---

935+name: ghc-heap

936+version: 9.0.1

937+visibility: public

938+id: ghc-heap-9.0.1

939+key: ghc-heap-9.0.1

940+license: BSD-3-Clause

941+maintainer: libraries@haskell.org

942+synopsis: Functions for walking GHC's heap

943+description:

944+ This package provides functions for walking the GHC heap data structures

945+ and retrieving information about those data structures.

946+category: GHC

947+exposed: True

948+exposed-modules:

949+ GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures

950+ GHC.Exts.Heap.Constants GHC.Exts.Heap.InfoTable

951+ GHC.Exts.Heap.InfoTable.Types GHC.Exts.Heap.InfoTableProf

952+ GHC.Exts.Heap.Utils

953+import-dirs:

954+library-dirs:

955+dynamic-library-dirs:

956+data-dir:

957+hs-libraries: HSghc-heap-9.0.1

958+depends: base-4.15.0.0 ghc-prim-0.7.0 rts

959+haddock-interfaces:

960+haddock-html:

961+---

962+name: ghc-prim

963+version: 0.7.0

964+visibility: public

965+id: ghc-prim-0.7.0

966+key: ghc-prim-0.7.0

967+license: BSD-3-Clause

968+maintainer: libraries@haskell.org

969+synopsis: GHC primitives

970+description:

971+ This package contains the primitive types and operations supplied by GHC.

972+category: GHC

973+exposed: True

974+exposed-modules:

975+ GHC.CString GHC.Classes GHC.Debug GHC.IntWord64 GHC.Magic

976+ GHC.Prim.Exception GHC.Prim.Ext GHC.Prim.Panic GHC.PrimopWrappers

977+ GHC.Tuple GHC.Types GHC.Prim

978+import-dirs:

979+library-dirs:

980+dynamic-library-dirs:

981+data-dir:

982+hs-libraries: HSghc-prim-0.7.0

983+depends: rts

984+haddock-interfaces:

985+haddock-html:

986+---

987+name: ghci

988+version: 9.0.1

989+visibility: public

990+id: ghci-9.0.1

991+key: ghci-9.0.1

992+license: BSD-3-Clause

993+maintainer: ghc-devs@haskell.org

994+synopsis: The library supporting GHC's interactive interpreter

995+description:

996+ This library offers interfaces which mediate interactions between the

997+ @ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter

998+ backend.

999+category: GHC

1000+exposed: True

1001+exposed-modules:

1002+ GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI

1003+ GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes

1004+ GHCi.ResolvedBCO GHCi.Run GHCi.Signals GHCi.StaticPtrTable GHCi.TH

1005+ GHCi.TH.Binary SizedSeq

1006+import-dirs:

1007+library-dirs:

1008+dynamic-library-dirs:

1009+data-dir:

1010+hs-libraries: HSghci-9.0.1

1011+include-dirs:

1012+depends:

1013+ array-0.5.4.0 base-4.15.0.0 binary-0.8.8.0 bytestring-0.10.12.1

1014+ containers-0.6.4.1 deepseq-1.4.5.0 filepath-1.4.2.1 ghc-boot-9.0.1

1015+ ghc-boot-th-9.0.1 ghc-heap-9.0.1 template-haskell-2.17.0.0

1016+ transformers-0.5.6.2 unix-2.7.2.2

1017+haddock-interfaces:

1018+haddock-html:

1019+---

1020+name: haskeline

1021+version: 0.8.1.0

1022+visibility: public

1023+id: haskeline-0.8.1.0

1024+key: haskeline-0.8.1.0

1025+license: BSD-3-Clause

1026+copyright: (c) Judah Jacobson

1027+maintainer: Judah Jacobson <judah.jacobson@gmail.com>

1028+author: Judah Jacobson

1029+stability: Stable

1030+homepage: https://github.com/judah/haskeline

1031+synopsis:

1032+ A command-line interface for user input, written in Haskell.

1033+description:

1034+ Haskeline provides a user interface for line input in command-line

1035+ programs. This library is similar in purpose to readline, but since

1036+ it is written in Haskell it is (hopefully) more easily used in other

1037+ Haskell programs.

1038+ Haskeline runs both on POSIX-compatible systems and on Windows.

1039+category: User Interfaces

1040+exposed: True

1041+exposed-modules:

1042+ System.Console.Haskeline System.Console.Haskeline.Completion

1043+ System.Console.Haskeline.History System.Console.Haskeline.IO

1044+ System.Console.Haskeline.Internal

1045+hidden-modules:

1046+ System.Console.Haskeline.Backend

1047+ System.Console.Haskeline.Backend.WCWidth

1048+ System.Console.Haskeline.Command

1049+ System.Console.Haskeline.Command.Completion

1050+ System.Console.Haskeline.Command.History

1051+ System.Console.Haskeline.Command.KillRing

1052+ System.Console.Haskeline.Directory System.Console.Haskeline.Emacs

1053+ System.Console.Haskeline.InputT System.Console.Haskeline.Key

1054+ System.Console.Haskeline.LineState System.Console.Haskeline.Monads

1055+ System.Console.Haskeline.Prefs System.Console.Haskeline.Recover

1056+ System.Console.Haskeline.RunCommand System.Console.Haskeline.Term

1057+ System.Console.Haskeline.Command.Undo System.Console.Haskeline.Vi

1058+ System.Console.Haskeline.Backend.Posix

1059+ System.Console.Haskeline.Backend.Posix.Encoder

1060+ System.Console.Haskeline.Backend.DumbTerm

1061+ System.Console.Haskeline.Backend.Terminfo

1062+import-dirs:

1063+library-dirs:

1064+dynamic-library-dirs:

1065+data-dir:

1066+hs-libraries: HShaskeline-0.8.1.0

1067+depends:

1068+ base-4.15.0.0 bytestring-0.10.12.1 containers-0.6.4.1

1069+ directory-1.3.6.1 exceptions-0.10.4 filepath-1.4.2.1

1070+ process-1.6.11.0 stm-2.5.0.0 terminfo-0.4.1.4 transformers-0.5.6.2

1071+ unix-2.7.2.2

1072+haddock-interfaces:

1073+haddock-html:

1074+---

1075+name: hpc

1076+version: 0.6.1.0

1077+visibility: public

1078+id: hpc-0.6.1.0

1079+key: hpc-0.6.1.0

1080+license: BSD-3-Clause

1081+maintainer: ghc-devs@haskell.org

1082+author: Andy Gill

1083+synopsis: Code Coverage Library for Haskell

1084+description:

1085+ This package provides the code coverage library for Haskell.

1086+ See <http://www.haskell.org/haskellwiki/Haskell_program_coverage> for more

1087+ information.

1088+category: Control

1089+exposed: True

1090+exposed-modules:

1091+ Trace.Hpc.Mix Trace.Hpc.Reflect Trace.Hpc.Tix Trace.Hpc.Util

1092+import-dirs:

1093+library-dirs:

1094+dynamic-library-dirs:

1095+data-dir:

1096+hs-libraries: HShpc-0.6.1.0

1097+depends:

1098+ base-4.15.0.0 containers-0.6.4.1 deepseq-1.4.5.0 directory-1.3.6.1

1099+ filepath-1.4.2.1 time-1.9.3

1100+haddock-interfaces:

1101+haddock-html:

1102+---

1103+name: integer-gmp

1104+version: 1.1

1105+visibility: public

1106+id: integer-gmp-1.1

1107+key: integer-gmp-1.1

1108+license: BSD-3-Clause

1109+maintainer: hvr@gnu.org

1110+author: Herbert Valerio Riedel

1111+synopsis: Integer library based on GMP

1112+description:

1113+ This package used to provide an implementation of the standard 'Integer'

1114+ type based on the

1115+ <http://gmplib.org/ GNU Multiple Precision Arithmetic Library (GMP)>.

1116+ It is now deprecated in favor of the 'ghc-bignum' package.

1117+ Its purpose is to provide backward compatibility for codes directly

1118+ depending on the `integer-gmp` package.

1119+category: Numeric, Algebra

1120+exposed: True

1121+exposed-modules: GHC.Integer.GMP.Internals

1122+import-dirs:

1123+library-dirs:

1124+dynamic-library-dirs:

1125+data-dir:

1126+hs-libraries: HSinteger-gmp-1.1

1127+depends: base-4.15.0.0 ghc-bignum-1.0 ghc-prim-0.7.0

1128+haddock-interfaces:

1129+haddock-html:

1130+---

1131+name: libiserv

1132+version: 9.0.1

1133+visibility: public

1134+id: libiserv-9.0.1

1135+key: libiserv-9.0.1

1136+license: BSD-3-Clause

1137+copyright: XXX

1138+maintainer: XXX

1139+author: XXX

1140+synopsis: Provides shared functionality between iserv and iserv-proxy

1141+category: Development

1142+exposed: True

1143+exposed-modules: GHCi.Utils Lib

1144+import-dirs:

1145+library-dirs:

1146+dynamic-library-dirs:

1147+data-dir:

1148+hs-libraries: HSlibiserv-9.0.1

1149+depends:

1150+ base-4.15.0.0 binary-0.8.8.0 bytestring-0.10.12.1

1151+ containers-0.6.4.1 deepseq-1.4.5.0 ghci-9.0.1 unix-2.7.2.2

1152+haddock-interfaces:

1153+haddock-html:

1154+---

1155+name: mtl

1156+version: 2.2.2

1157+visibility: public

1158+id: mtl-2.2.2

1159+key: mtl-2.2.2

1160+license: BSD-3-Clause

1161+maintainer: Edward Kmett <ekmett@gmail.com>

1162+author: Andy Gill

1163+homepage: http://github.com/haskell/mtl

1164+synopsis: Monad classes, using functional dependencies

1165+description:

1166+ Monad classes using functional dependencies, with instances

1167+ for various monad transformers, inspired by the paper

1168+ /Functional Programming with Overloading and Higher-Order Polymorphism/,

1169+ by Mark P Jones, in /Advanced School of Functional Programming/, 1995

1170+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1171+category: Control

1172+exposed: True

1173+exposed-modules:

1174+ Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error

1175+ Control.Monad.Error.Class Control.Monad.Except

1176+ Control.Monad.Identity Control.Monad.List Control.Monad.RWS

1177+ Control.Monad.RWS.Class Control.Monad.RWS.Lazy

1178+ Control.Monad.RWS.Strict Control.Monad.Reader

1179+ Control.Monad.Reader.Class Control.Monad.State

1180+ Control.Monad.State.Class Control.Monad.State.Lazy

1181+ Control.Monad.State.Strict Control.Monad.Trans Control.Monad.Writer

1182+ Control.Monad.Writer.Class Control.Monad.Writer.Lazy

1183+ Control.Monad.Writer.Strict

1184+import-dirs:

1185+library-dirs:

1186+dynamic-library-dirs:

1187+data-dir:

1188+hs-libraries: HSmtl-2.2.2

1189+depends: base-4.15.0.0 transformers-0.5.6.2

1190+haddock-interfaces:

1191+haddock-html:

1192+---

1193+name: parsec

1194+version: 3.1.14.0

1195+visibility: public

1196+id: parsec-3.1.14.0

1197+key: parsec-3.1.14.0

1198+license: BSD-3-Clause

1199+maintainer: Herbert Valerio Riedel <hvr@gnu.org>

1200+author:

1201+ Daan Leijen <daan@microsoft.com>, Paolo Martini <paolo@nemail.it>, Antoine Latter <aslatter@gmail.com>

1202+homepage: https://github.com/haskell/parsec

1203+synopsis: Monadic parser combinators

1204+description:

1205+ Parsec is designed from scratch as an industrial-strength parser

1206+ library. It is simple, safe, well documented (on the package

1207+ homepage), has extensive libraries, good error messages,

1208+ and is fast. It is defined as a monad transformer that can be

1209+ stacked on arbitrary monads, and it is also parametric in the

1210+ input stream type.

1211+ The main entry point is the "Text.Parsec" module which provides

1212+ defaults for parsing 'Char'acter data.

1213+ The "Text.ParserCombinators.Parsec" module hierarchy contains

1214+ the legacy @parsec-2@ API and may be removed at some point in

1215+ the future.

1216+category: Parsing

1217+exposed: True

1218+exposed-modules:

1219+ Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy

1220+ Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error

1221+ Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm

1222+ Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String

1223+ Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token

1224+ Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char

1225+ Text.ParserCombinators.Parsec.Combinator

1226+ Text.ParserCombinators.Parsec.Error

1227+ Text.ParserCombinators.Parsec.Expr

1228+ Text.ParserCombinators.Parsec.Language

1229+ Text.ParserCombinators.Parsec.Perm

1230+ Text.ParserCombinators.Parsec.Pos

1231+ Text.ParserCombinators.Parsec.Prim

1232+ Text.ParserCombinators.Parsec.Token

1233+import-dirs:

1234+library-dirs:

1235+dynamic-library-dirs:

1236+data-dir:

1237+hs-libraries: HSparsec-3.1.14.0

1238+depends:

1239+ base-4.15.0.0 bytestring-0.10.12.1 mtl-2.2.2 text-1.2.4.1

1240+haddock-interfaces:

1241+haddock-html:

1242+---

1243+name: pretty

1244+version: 1.1.3.6

1245+visibility: public

1246+id: pretty-1.1.3.6

1247+key: pretty-1.1.3.6

1248+license: BSD-3-Clause

1249+maintainer: David Terei <code@davidterei.com>

1250+stability: Stable

1251+homepage: http://github.com/haskell/pretty

1252+synopsis: Pretty-printing library

1253+description:

1254+ This package contains a pretty-printing library, a set of API's

1255+ that provides a way to easily print out text in a consistent

1256+ format of your choosing. This is useful for compilers and related

1257+ tools.

1258+ This library was originally designed by John Hughes's and has since

1259+ been heavily modified by Simon Peyton Jones.

1260+category: Text

1261+exposed: True

1262+exposed-modules:

1263+ Text.PrettyPrint Text.PrettyPrint.Annotated

1264+ Text.PrettyPrint.Annotated.HughesPJ

1265+ Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ

1266+ Text.PrettyPrint.HughesPJClass

1267+import-dirs:

1268+library-dirs:

1269+dynamic-library-dirs:

1270+data-dir:

1271+hs-libraries: HSpretty-1.1.3.6

1272+depends: base-4.15.0.0 deepseq-1.4.5.0 ghc-prim-0.7.0

1273+haddock-interfaces:

1274+haddock-html:

1275+---

1276+name: process

1277+version: 1.6.11.0

1278+visibility: public

1279+id: process-1.6.11.0

1280+key: process-1.6.11.0

1281+license: BSD-3-Clause

1282+maintainer: libraries@haskell.org

1283+synopsis: Process libraries

1284+description:

1285+ This package contains libraries for dealing with system processes.

1286+ The typed-process package is a more recent take on a process API,

1287+ which uses this package internally. It features better binary

1288+ support, easier concurrency, and a more composable API. You can

1289+ read more about it at

1290+ <https://github.com/fpco/typed-process/#readme>.

1291+category: System

1292+exposed: True

1293+exposed-modules: System.Cmd System.Process System.Process.Internals

1294+hidden-modules: System.Process.Common System.Process.Posix

1295+import-dirs:

1296+library-dirs:

1297+dynamic-library-dirs:

1298+data-dir:

1299+hs-libraries: HSprocess-1.6.11.0

1300+include-dirs:

1301+includes: runProcess.h

1302+depends:

1303+ base-4.15.0.0 deepseq-1.4.5.0 directory-1.3.6.1 filepath-1.4.2.1

1304+ unix-2.7.2.2

1305+haddock-interfaces:

1306+haddock-html:

1307+---

1308+name: stm

1309+version: 2.5.0.0

1310+visibility: public

1311+id: stm-2.5.0.0

1312+key: stm-2.5.0.0

1313+license: BSD-3-Clause

1314+maintainer: libraries@haskell.org

1315+homepage: https://wiki.haskell.org/Software_transactional_memory

1316+synopsis: Software Transactional Memory

1317+description:

1318+ Software Transactional Memory, or STM, is an abstraction for

1319+ concurrent communication. The main benefits of STM are

1320+ /composability/ and /modularity/. That is, using STM you can write

1321+ concurrent abstractions that can be easily composed with any other

1322+ abstraction built using STM, without exposing the details of how

1323+ your abstraction ensures safety. This is typically not the case

1324+ with other forms of concurrent communication, such as locks or

1325+ 'MVar's.

1326+category: Concurrency

1327+exposed: True

1328+exposed-modules:

1329+ Control.Concurrent.STM Control.Concurrent.STM.TArray

1330+ Control.Concurrent.STM.TBQueue Control.Concurrent.STM.TChan

1331+ Control.Concurrent.STM.TMVar Control.Concurrent.STM.TQueue

1332+ Control.Concurrent.STM.TSem Control.Concurrent.STM.TVar

1333+ Control.Monad.STM

1334+hidden-modules: Control.Sequential.STM

1335+import-dirs:

1336+library-dirs:

1337+dynamic-library-dirs:

1338+data-dir:

1339+hs-libraries: HSstm-2.5.0.0

1340+depends: array-0.5.4.0 base-4.15.0.0

1341+haddock-interfaces:

1342+haddock-html:

1343+---

1344+name: template-haskell

1345+version: 2.17.0.0

1346+visibility: public

1347+id: template-haskell-2.17.0.0

1348+key: template-haskell-2.17.0.0

1349+license: BSD-3-Clause

1350+maintainer: libraries@haskell.org

1351+synopsis: Support library for Template Haskell

1352+description:

1353+ This package provides modules containing facilities for manipulating

1354+ Haskell source code using Template Haskell.

1355+ See <http://www.haskell.org/haskellwiki/Template_Haskell> for more

1356+ information.

1357+category: Template Haskell

1358+exposed: True

1359+exposed-modules:

1360+ Language.Haskell.TH Language.Haskell.TH.CodeDo

1361+ Language.Haskell.TH.LanguageExtensions Language.Haskell.TH.Lib

1362+ Language.Haskell.TH.Lib.Internal Language.Haskell.TH.Ppr

1363+ Language.Haskell.TH.PprLib Language.Haskell.TH.Quote

1364+ Language.Haskell.TH.Syntax

1365+hidden-modules: Language.Haskell.TH.Lib.Map

1366+import-dirs:

1367+library-dirs:

1368+dynamic-library-dirs:

1369+data-dir:

1370+hs-libraries: HStemplate-haskell-2.17.0.0

1371+depends:

1372+ base-4.15.0.0 ghc-boot-th-9.0.1 ghc-prim-0.7.0 pretty-1.1.3.6

1373+haddock-interfaces:

1374+haddock-html:

1375+---

1376+name: terminfo

1377+version: 0.4.1.4

1378+visibility: public

1379+id: terminfo-0.4.1.4

1380+key: terminfo-0.4.1.4

1381+license: BSD-3-Clause

1382+copyright: (c) Judah Jacobson

1383+maintainer: Judah Jacobson <judah.jacobson@gmail.com>

1384+author: Judah Jacobson

1385+stability: Stable

1386+homepage: https://github.com/judah/terminfo

1387+synopsis: Haskell bindings to the terminfo library.

1388+description:

1389+ This library provides an interface to the terminfo database (via bindings to the

1390+ curses library). <http://en.wikipedia.org/wiki/Terminfo Terminfo> allows POSIX

1391+ systems to interact with a variety of terminals using a standard set of capabilities.

1392+category: User Interfaces

1393+exposed: True

1394+exposed-modules:

1395+ System.Console.Terminfo System.Console.Terminfo.Base

1396+ System.Console.Terminfo.Color System.Console.Terminfo.Cursor

1397+ System.Console.Terminfo.Edit System.Console.Terminfo.Effects

1398+ System.Console.Terminfo.Keys

1399+import-dirs:

1400+library-dirs:

1401+dynamic-library-dirs:

1402+data-dir:

1403+hs-libraries: HSterminfo-0.4.1.4

1404+extra-libraries: tinfo

1405+depends: base-4.15.0.0

1406+haddock-interfaces:

1407+haddock-html:

1408+---

1409+name: text

1410+version: 1.2.4.1

1411+visibility: public

1412+id: text-1.2.4.1

1413+key: text-1.2.4.1

1414+license: BSD-2-Clause

1415+copyright: 2009-2011 Bryan O'Sullivan, 2008-2009 Tom Harper

1416+maintainer:

1417+ Bryan O'Sullivan <bos@serpentine.com>, Herbert Valerio Riedel <hvr@gnu.org>

1418+author: Bryan O'Sullivan <bos@serpentine.com>

1419+homepage: https://github.com/haskell/text

1420+synopsis: An efficient packed Unicode text type.

1421+description:

1422+ An efficient packed, immutable Unicode text type (both strict and

1423+ lazy), with a powerful loop fusion optimization framework.

1424+ The 'Text' type represents Unicode character strings, in a time and

1425+ space-efficient manner. This package provides text processing

1426+ capabilities that are optimized for performance critical use, both

1427+ in terms of large data quantities and high speed.

1428+ The 'Text' type provides character-encoding, type-safe case

1429+ conversion via whole-string case conversion functions (see "Data.Text").

1430+ It also provides a range of functions for converting 'Text' values to

1431+ and from 'ByteStrings', using several standard encodings

1432+ (see "Data.Text.Encoding").

1433+ Efficient locale-sensitive support for text IO is also supported

1434+ (see "Data.Text.IO").

1435+ These modules are intended to be imported qualified, to avoid name

1436+ clashes with Prelude functions, e.g.

1437+ > import qualified Data.Text as T

1438+ == ICU Support

1439+ To use an extended and very rich family of functions for working

1440+ with Unicode text (including normalization, regular expressions,

1441+ non-standard encodings, text breaking, and locales), see

1442+ the [text-icu package](https://hackage.haskell.org/package/text-icu)

1443+ based on the well-respected and liberally

1444+ licensed [ICU library](http://site.icu-project.org/).

1445+ == Internal Representation: UTF-16 vs. UTF-8

1446+ Currently the @text@ library uses UTF-16 as its internal representation

1447+ which is [neither a fixed-width nor always the most dense representation](http://utf8everywhere.org/)

1448+ for Unicode text. We're currently investigating the feasibility

1449+ of [changing Text's internal representation to UTF-8](https://github.com/text-utf8)

1450+ and if you need such a 'Text' type right now you might be interested in using the spin-off

1451+ packages <https://hackage.haskell.org/package/text-utf8 text-utf8> and

1452+ <https://hackage.haskell.org/package/text-short text-short>.

1453+category: Data, Text

1454+exposed: True

1455+exposed-modules:

1456+ Data.Text Data.Text.Array Data.Text.Encoding

1457+ Data.Text.Encoding.Error Data.Text.Foreign Data.Text.IO

1458+ Data.Text.Internal Data.Text.Internal.Builder

1459+ Data.Text.Internal.Builder.Functions

1460+ Data.Text.Internal.Builder.Int.Digits

1461+ Data.Text.Internal.Builder.RealFloat.Functions

1462+ Data.Text.Internal.ByteStringCompat

1463+ Data.Text.Internal.Encoding.Fusion

1464+ Data.Text.Internal.Encoding.Fusion.Common

1465+ Data.Text.Internal.Encoding.Utf16 Data.Text.Internal.Encoding.Utf32

1466+ Data.Text.Internal.Encoding.Utf8 Data.Text.Internal.Functions

1467+ Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping

1468+ Data.Text.Internal.Fusion.Common Data.Text.Internal.Fusion.Size

1469+ Data.Text.Internal.Fusion.Types Data.Text.Internal.IO

1470+ Data.Text.Internal.Lazy Data.Text.Internal.Lazy.Encoding.Fusion

1471+ Data.Text.Internal.Lazy.Fusion Data.Text.Internal.Lazy.Search

1472+ Data.Text.Internal.Private Data.Text.Internal.Read

1473+ Data.Text.Internal.Search Data.Text.Internal.Unsafe

1474+ Data.Text.Internal.Unsafe.Char Data.Text.Internal.Unsafe.Shift

1475+ Data.Text.Lazy Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int

1476+ Data.Text.Lazy.Builder.RealFloat Data.Text.Lazy.Encoding

1477+ Data.Text.Lazy.IO Data.Text.Lazy.Internal Data.Text.Lazy.Read

1478+ Data.Text.Read Data.Text.Unsafe

1479+hidden-modules: Data.Text.Show

1480+import-dirs:

1481+library-dirs:

1482+dynamic-library-dirs:

1483+data-dir:

1484+hs-libraries: HStext-1.2.4.1

1485+depends:

1486+ array-0.5.4.0 base-4.15.0.0 binary-0.8.8.0 bytestring-0.10.12.1

1487+ deepseq-1.4.5.0 ghc-bignum-1.0 ghc-prim-0.7.0

1488+ template-haskell-2.17.0.0

1489+haddock-interfaces:

1490+haddock-html:

1491+---

1492+name: time

1493+version: 1.9.3

1494+visibility: public

1495+id: time-1.9.3

1496+key: time-1.9.3

1497+license: BSD-3-Clause

1498+maintainer: <ashley@semantic.org>

1499+author: Ashley Yakeley

1500+stability: stable

1501+homepage: https://github.com/haskell/time

1502+synopsis: A time library

1503+description: Time, clocks and calendars

1504+category: Time

1505+exposed: True

1506+exposed-modules:

1507+ Data.Time Data.Time.Calendar Data.Time.Calendar.Easter

1508+ Data.Time.Calendar.Julian Data.Time.Calendar.MonthDay

1509+ Data.Time.Calendar.OrdinalDate Data.Time.Calendar.WeekDate

1510+ Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System

1511+ Data.Time.Clock.TAI Data.Time.Format Data.Time.Format.ISO8601

1512+ Data.Time.Format.Internal Data.Time.LocalTime

1513+hidden-modules:

1514+ Data.Format Data.Time.Calendar.Private Data.Time.Calendar.Days

1515+ Data.Time.Calendar.Gregorian Data.Time.Calendar.CalendarDiffDays

1516+ Data.Time.Calendar.Week Data.Time.Calendar.JulianYearDay

1517+ Data.Time.Clock.Internal.DiffTime

1518+ Data.Time.Clock.Internal.AbsoluteTime

1519+ Data.Time.Clock.Internal.NominalDiffTime

1520+ Data.Time.Clock.Internal.POSIXTime

1521+ Data.Time.Clock.Internal.UniversalTime

1522+ Data.Time.Clock.Internal.SystemTime

1523+ Data.Time.Clock.Internal.UTCTime Data.Time.Clock.Internal.CTimeval

1524+ Data.Time.Clock.Internal.CTimespec Data.Time.Clock.Internal.UTCDiff

1525+ Data.Time.LocalTime.Internal.TimeZone

1526+ Data.Time.LocalTime.Internal.TimeOfDay

1527+ Data.Time.LocalTime.Internal.CalendarDiffTime

1528+ Data.Time.LocalTime.Internal.LocalTime

1529+ Data.Time.LocalTime.Internal.ZonedTime Data.Time.Format.Parse

1530+ Data.Time.Format.Locale Data.Time.Format.Format.Class

1531+ Data.Time.Format.Format.Instances Data.Time.Format.Parse.Class

1532+ Data.Time.Format.Parse.Instances

1533+import-dirs:

1534+library-dirs:

1535+dynamic-library-dirs:

1536+data-dir:

1537+hs-libraries: HStime-1.9.3

1538+include-dirs:

1539+depends: base-4.15.0.0 deepseq-1.4.5.0

1540+haddock-interfaces:

1541+haddock-html:

1542+---

1543+name: transformers

1544+version: 0.5.6.2

1545+visibility: public

1546+id: transformers-0.5.6.2

1547+key: transformers-0.5.6.2

1548+license: BSD-3-Clause

1549+maintainer: Ross Paterson <R.Paterson@city.ac.uk>

1550+author: Andy Gill, Ross Paterson

1551+synopsis: Concrete functor and monad transformers

1552+description:

1553+ A portable library of functor and monad transformers, inspired by

1554+ the paper

1555+ * \"Functional Programming with Overloading and Higher-Order

1556+ Polymorphism\", by Mark P Jones,

1557+ in /Advanced School of Functional Programming/, 1995

1558+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1559+ This package contains:

1560+ * the monad transformer class (in "Control.Monad.Trans.Class")

1561+ * concrete functor and monad transformers, each with associated

1562+ operations and functions to lift operations associated with other

1563+ transformers.

1564+ The package can be used on its own in portable Haskell code, in

1565+ which case operations need to be manually lifted through transformer

1566+ stacks (see "Control.Monad.Trans.Class" for some examples).

1567+ Alternatively, it can be used with the non-portable monad classes in

1568+ the @mtl@ or @monads-tf@ packages, which automatically lift operations

1569+ introduced by monad transformers through other transformers.

1570+category: Control

1571+exposed: True

1572+exposed-modules:

1573+ Control.Applicative.Backwards Control.Applicative.Lift

1574+ Control.Monad.Signatures Control.Monad.Trans.Accum

1575+ Control.Monad.Trans.Class Control.Monad.Trans.Cont

1576+ Control.Monad.Trans.Error Control.Monad.Trans.Except

1577+ Control.Monad.Trans.Identity Control.Monad.Trans.List

1578+ Control.Monad.Trans.Maybe Control.Monad.Trans.RWS

1579+ Control.Monad.Trans.RWS.CPS Control.Monad.Trans.RWS.Lazy

1580+ Control.Monad.Trans.RWS.Strict Control.Monad.Trans.Reader

1581+ Control.Monad.Trans.Select Control.Monad.Trans.State

1582+ Control.Monad.Trans.State.Lazy Control.Monad.Trans.State.Strict

1583+ Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS

1584+ Control.Monad.Trans.Writer.Lazy Control.Monad.Trans.Writer.Strict

1585+ Data.Functor.Constant Data.Functor.Reverse

1586+import-dirs:

1587+library-dirs:

1588+dynamic-library-dirs:

1589+data-dir:

1590+hs-libraries: HStransformers-0.5.6.2

1591+depends: base-4.15.0.0

1592+haddock-interfaces:

1593+haddock-html:

1594+---

1595+name: unix

1596+version: 2.7.2.2

1597+visibility: public

1598+id: unix-2.7.2.2

1599+key: unix-2.7.2.2

1600+license: BSD-3-Clause

1601+maintainer: libraries@haskell.org

1602+homepage: https://github.com/haskell/unix

1603+synopsis: POSIX functionality

1604+description:

1605+ This package gives you access to the set of operating system

1606+ services standardised by

1607+ <http://pubs.opengroup.org/onlinepubs/9699919799/ POSIX.1-2008>

1608+ (or the IEEE Portable Operating System Interface for Computing

1609+ Environments - IEEE Std. 1003.1).

1610+ The package is not supported under Windows.

1611+category: System

1612+exposed: True

1613+exposed-modules:

1614+ System.Posix System.Posix.ByteString

1615+ System.Posix.ByteString.FilePath System.Posix.Directory

1616+ System.Posix.Directory.ByteString System.Posix.DynamicLinker

1617+ System.Posix.DynamicLinker.ByteString

1618+ System.Posix.DynamicLinker.Module

1619+ System.Posix.DynamicLinker.Module.ByteString

1620+ System.Posix.DynamicLinker.Prim System.Posix.Env

1621+ System.Posix.Env.ByteString System.Posix.Error System.Posix.Fcntl

1622+ System.Posix.Files System.Posix.Files.ByteString System.Posix.IO

1623+ System.Posix.IO.ByteString System.Posix.Process

1624+ System.Posix.Process.ByteString System.Posix.Process.Internals

1625+ System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem

1626+ System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp

1627+ System.Posix.Temp.ByteString System.Posix.Terminal

1628+ System.Posix.Terminal.ByteString System.Posix.Time

1629+ System.Posix.Unistd System.Posix.User

1630+hidden-modules:

1631+ System.Posix.Directory.Common System.Posix.DynamicLinker.Common

1632+ System.Posix.Files.Common System.Posix.IO.Common

1633+ System.Posix.Process.Common System.Posix.Terminal.Common

1634+import-dirs:

1635+library-dirs:

1636+dynamic-library-dirs:

1637+data-dir:

1638+hs-libraries: HSunix-2.7.2.2

1639+include-dirs:

1640+includes: HsUnix.h execvpe.h

1641+depends: base-4.15.0.0 bytestring-0.10.12.1 time-1.9.3

1642+haddock-interfaces:

1643+haddock-html:

1644+---

1645+name: xhtml

1646+version: 3000.2.2.1

1647+visibility: public

1648+id: xhtml-3000.2.2.1

1649+key: xhtml-3000.2.2.1

1650+license: BSD-3-Clause

1651+copyright:

1652+ Bjorn Bringert 2004-2006, Andy Gill and the Oregon

1653+ Graduate Institute of Science and Technology, 1999-2001

1654+maintainer: Chris Dornan <chris@chrisdornan.com>

1655+author: Bjorn Bringert

1656+stability: Stable

1657+homepage: https://github.com/haskell/xhtml

1658+synopsis: An XHTML combinator library

1659+description:

1660+ This package provides combinators for producing

1661+ XHTML 1.0, including the Strict, Transitional and

1662+ Frameset variants.

1663+category: Web, XML, Pretty Printer

1664+exposed: True

1665+exposed-modules:

1666+ Text.XHtml Text.XHtml.Debug Text.XHtml.Frameset Text.XHtml.Strict

1667+ Text.XHtml.Table Text.XHtml.Transitional

1668+hidden-modules:

1669+ Text.XHtml.Strict.Attributes Text.XHtml.Strict.Elements

1670+ Text.XHtml.Frameset.Attributes Text.XHtml.Frameset.Elements

1671+ Text.XHtml.Transitional.Attributes Text.XHtml.Transitional.Elements

1672+ Text.XHtml.BlockTable Text.XHtml.Extras Text.XHtml.Internals

1673+import-dirs:

1674+library-dirs:

1675+dynamic-library-dirs:

1676+data-dir:

1677+hs-libraries: HSxhtml-3000.2.2.1

1678+depends: base-4.15.0.0

1679+haddock-interfaces:

1680+haddock-html:

1681+---

1682+name: rts

1683+version: 1.0

1684+visibility: public

1685+id: rts

1686+key: rts

1687+license: BSD-3-Clause

1688+maintainer: glasgow-haskell-users@haskell.org

1689+exposed: True

1690+library-dirs:

1691+hs-libraries: HSrts

1692+extra-libraries: m dl ffi

1693+include-dirs:

1694+includes: Stg.h

1695+ld-options:

1696+ "-Wl,-u,_base_GHCziTopHandler_runIO_closure"

1697+ "-Wl,-u,_base_GHCziTopHandler_runNonIO_closure"

1698+ "-Wl,-u,_ghczmprim_GHCziTuple_Z0T_closure"

1699+ "-Wl,-u,_ghczmprim_GHCziTypes_True_closure"

1700+ "-Wl,-u,_ghczmprim_GHCziTypes_False_closure"

1701+ "-Wl,-u,_base_GHCziPack_unpackCString_closure"

1702+ "-Wl,-u,_base_GHCziWeak_runFinalizzerBatch_closure"

1703+ "-Wl,-u,_base_GHCziIOziException_stackOverflow_closure"

1704+ "-Wl,-u,_base_GHCziIOziException_heapOverflow_closure"

1705+ "-Wl,-u,_base_GHCziIOziException_allocationLimitExceeded_closure"

1706+ "-Wl,-u,_base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"

1707+ "-Wl,-u,_base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"

1708+ "-Wl,-u,_base_GHCziIOziException_cannotCompactFunction_closure"

1709+ "-Wl,-u,_base_GHCziIOziException_cannotCompactPinned_closure"

1710+ "-Wl,-u,_base_GHCziIOziException_cannotCompactMutable_closure"

1711+ "-Wl,-u,_base_GHCziIOPort_doubleReadException_closure"

1712+ "-Wl,-u,_base_ControlziExceptionziBase_nonTermination_closure"

1713+ "-Wl,-u,_base_ControlziExceptionziBase_nestedAtomically_closure"

1714+ "-Wl,-u,_base_GHCziEventziThread_blockedOnBadFD_closure"

1715+ "-Wl,-u,_base_GHCziExceptionziType_divZZeroException_closure"

1716+ "-Wl,-u,_base_GHCziExceptionziType_underflowException_closure"

1717+ "-Wl,-u,_base_GHCziExceptionziType_overflowException_closure"

1718+ "-Wl,-u,_base_GHCziConcziSync_runSparks_closure"

1719+ "-Wl,-u,_base_GHCziConcziIO_ensureIOManagerIsRunning_closure"

1720+ "-Wl,-u,_base_GHCziConcziIO_interruptIOManager_closure"

1721+ "-Wl,-u,_base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"

1722+ "-Wl,-u,_base_GHCziConcziSignal_runHandlersPtr_closure"

1723+ "-Wl,-u,_base_GHCziTopHandler_flushStdHandles_closure"

1724+ "-Wl,-u,_base_GHCziTopHandler_runMainIO_closure"

1725+ "-Wl,-u,_ghczmprim_GHCziTypes_Czh_con_info"

1726+ "-Wl,-u,_ghczmprim_GHCziTypes_Izh_con_info"

1727+ "-Wl,-u,_ghczmprim_GHCziTypes_Fzh_con_info"

1728+ "-Wl,-u,_ghczmprim_GHCziTypes_Dzh_con_info"

1729+ "-Wl,-u,_ghczmprim_GHCziTypes_Wzh_con_info"

1730+ "-Wl,-u,_base_GHCziPtr_Ptr_con_info"

1731+ "-Wl,-u,_base_GHCziPtr_FunPtr_con_info"

1732+ "-Wl,-u,_base_GHCziInt_I8zh_con_info"

1733+ "-Wl,-u,_base_GHCziInt_I16zh_con_info"

1734+ "-Wl,-u,_base_GHCziInt_I32zh_con_info"

1735+ "-Wl,-u,_base_GHCziInt_I64zh_con_info"

1736+ "-Wl,-u,_base_GHCziWord_W8zh_con_info"

1737+ "-Wl,-u,_base_GHCziWord_W16zh_con_info"

1738+ "-Wl,-u,_base_GHCziWord_W32zh_con_info"

1739+ "-Wl,-u,_base_GHCziWord_W64zh_con_info"

1740+ "-Wl,-u,_base_GHCziStable_StablePtr_con_info"

1741+ "-Wl,-u,_hs_atomic_add8" "-Wl,-u,_hs_atomic_add16"

1742+ "-Wl,-u,_hs_atomic_add32" "-Wl,-u,_hs_atomic_add64"

1743+ "-Wl,-u,_hs_atomic_sub8" "-Wl,-u,_hs_atomic_sub16"

1744+ "-Wl,-u,_hs_atomic_sub32" "-Wl,-u,_hs_atomic_sub64"

1745+ "-Wl,-u,_hs_atomic_and8" "-Wl,-u,_hs_atomic_and16"

1746+ "-Wl,-u,_hs_atomic_and32" "-Wl,-u,_hs_atomic_and64"

1747+ "-Wl,-u,_hs_atomic_nand8" "-Wl,-u,_hs_atomic_nand16"

1748+ "-Wl,-u,_hs_atomic_nand32" "-Wl,-u,_hs_atomic_nand64"

1749+ "-Wl,-u,_hs_atomic_or8" "-Wl,-u,_hs_atomic_or16"

1750+ "-Wl,-u,_hs_atomic_or32" "-Wl,-u,_hs_atomic_or64"

1751+ "-Wl,-u,_hs_atomic_xor8" "-Wl,-u,_hs_atomic_xor16"

1752+ "-Wl,-u,_hs_atomic_xor32" "-Wl,-u,_hs_atomic_xor64"

1753+ "-Wl,-u,_hs_cmpxchg8" "-Wl,-u,_hs_cmpxchg16" "-Wl,-u,_hs_cmpxchg32"

1754+ "-Wl,-u,_hs_cmpxchg64" "-Wl,-u,_hs_xchg8" "-Wl,-u,_hs_xchg16"

1755+ "-Wl,-u,_hs_xchg32" "-Wl,-u,_hs_xchg64" "-Wl,-u,_hs_atomicread8"

1756+ "-Wl,-u,_hs_atomicread16" "-Wl,-u,_hs_atomicread32"

1757+ "-Wl,-u,_hs_atomicread64" "-Wl,-u,_hs_atomicwrite8"

1758+ "-Wl,-u,_hs_atomicwrite16" "-Wl,-u,_hs_atomicwrite32"

1759+ "-Wl,-u,_hs_atomicwrite64" "-Wl,-search_paths_first"

materialized/dummy-ghc/ghc-9.0.1-aarch64-darwin/ghc-pkg/versionnew file+1

@@ -0,0 +1 @@

1+GHC package manager version 9.0.1

materialized/dummy-ghc/ghc-9.0.1-aarch64-darwin/ghc/infonew file+74

@@ -0,0 +1,74 @@

1+ [("Project name","The Glorious Glasgow Haskell Compilation System")

2+ ,("GCC extra via C opts","")

3+ ,("C compiler command","clang")

4+ ,("C compiler flags","")

5+ ,("C++ compiler flags","")

6+ ,("C compiler link flags","")

7+ ,("C compiler supports -no-pie","NO")

8+ ,("Haskell CPP command","clang")

9+ ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

10+ ,("ld command","ld")

11+ ,("ld flags","")

12+ ,("ld supports compact unwind","YES")

13+ ,("ld supports build-id","NO")

14+ ,("ld supports filelist","YES")

15+ ,("ld is GNU ld","NO")

16+ ,("Merge objects command","ld")

17+ ,("Merge objects flags","-r")

18+ ,("ar command","ar")

19+ ,("ar flags","qcls")

20+ ,("ar supports at file","NO")

21+ ,("ranlib command","ranlib")

22+ ,("otool command","otool")

23+ ,("install_name_tool command","install_name_tool")

24+ ,("touch command","touch")

25+ ,("dllwrap command","/bin/false")

26+ ,("windres command","/bin/false")

27+ ,("libtool command","libtool")

28+ ,("cross compiling","NO")

29+ ,("target platform string","aarch64-apple-darwin")

30+ ,("target os","OSDarwin")

31+ ,("target arch","ArchAArch64")

32+ ,("target word size","8")

33+ ,("target word big endian","NO")

34+ ,("target has GNU nonexec stack","NO")

35+ ,("target has .ident directive","YES")

36+ ,("target has subsections via symbols","NO")

37+ ,("target has RTS linker","YES")

38+ ,("Unregisterised","NO")

39+ ,("LLVM target","arm64-apple-darwin")

40+ ,("LLVM clang command","clang")

41+ ,("bignum backend","gmp")

42+ ,("Use interpreter","YES")

43+ ,("Support SMP","YES")

44+ ,("RTS ways","l debug thr thr_debug thr_l thr_p dyn debug_dyn thr_dyn thr_debug_dyn l_dyn thr_l_dyn thr_debug_p debug_p")

45+ ,("Tables next to code","YES")

46+ ,("Leading underscore","YES")

47+ ,("Use LibFFI","YES")

48+ ,("Use Threads","YES")

49+ ,("Use Debugging","NO")

50+ ,("RTS expects libdw","NO")

51+ ,("Project version","9.0.1")

52+ ,("Project Git commit id","da53a348150d30193a6f28e1b7ddcabdf45ab726")

53+ ,("Booter version","8.10.7")

54+ ,("Stage","2")

55+ ,("Build platform","aarch64-apple-darwin")

56+ ,("Host platform","aarch64-apple-darwin")

57+ ,("Target platform","aarch64-apple-darwin")

58+ ,("Have interpreter","YES")

59+ ,("Object splitting supported","NO")

60+ ,("Have native code generator","NO")

61+ ,("Target default backend","LLVM")

62+ ,("Support dynamic-too","YES")

63+ ,("Support parallel --make","YES")

64+ ,("Support reexported-modules","YES")

65+ ,("Support thinning and renaming package flags","YES")

66+ ,("Support Backpack","YES")

67+ ,("Requires unified installed package IDs","YES")

68+ ,("Uses package keys","YES")

69+ ,("Uses unit IDs","YES")

70+ ,("Dynamic by default","NO")

71+ ,("GHC Dynamic","YES")

72+ ,("GHC Profiled","NO")

73+ ,("Debug on","NO")

74+ ]

materialized/dummy-ghc/ghc-9.0.1-aarch64-darwin/ghc/numeric-versionnew file+1

@@ -0,0 +1 @@

1+9.0.1

materialized/dummy-ghc/ghc-9.0.1-aarch64-darwin/ghc/supported-languagesnew file+261

@@ -0,0 +1,261 @@

1+Haskell98

2+Haskell2010

3+Unsafe

4+Trustworthy

5+Safe

6+AllowAmbiguousTypes

7+NoAllowAmbiguousTypes

8+AlternativeLayoutRule

9+NoAlternativeLayoutRule

10+AlternativeLayoutRuleTransitional

11+NoAlternativeLayoutRuleTransitional

12+Arrows

13+NoArrows

14+AutoDeriveTypeable

15+NoAutoDeriveTypeable

16+BangPatterns

17+NoBangPatterns

18+BinaryLiterals

19+NoBinaryLiterals

20+CApiFFI

21+NoCApiFFI

22+CPP

23+NoCPP

24+CUSKs

25+NoCUSKs

26+ConstrainedClassMethods

27+NoConstrainedClassMethods

28+ConstraintKinds

29+NoConstraintKinds

30+DataKinds

31+NoDataKinds

32+DatatypeContexts

33+NoDatatypeContexts

34+DefaultSignatures

35+NoDefaultSignatures

36+DeriveAnyClass

37+NoDeriveAnyClass

38+DeriveDataTypeable

39+NoDeriveDataTypeable

40+DeriveFoldable

41+NoDeriveFoldable

42+DeriveFunctor

43+NoDeriveFunctor

44+DeriveGeneric

45+NoDeriveGeneric

46+DeriveLift

47+NoDeriveLift

48+DeriveTraversable

49+NoDeriveTraversable

50+DerivingStrategies

51+NoDerivingStrategies

52+DerivingVia

53+NoDerivingVia

54+DisambiguateRecordFields

55+NoDisambiguateRecordFields

56+DoAndIfThenElse

57+NoDoAndIfThenElse

58+BlockArguments

59+NoBlockArguments

60+DoRec

61+NoDoRec

62+DuplicateRecordFields

63+NoDuplicateRecordFields

64+EmptyCase

65+NoEmptyCase

66+EmptyDataDecls

67+NoEmptyDataDecls

68+EmptyDataDeriving

69+NoEmptyDataDeriving

70+ExistentialQuantification

71+NoExistentialQuantification

72+ExplicitForAll

73+NoExplicitForAll

74+ExplicitNamespaces

75+NoExplicitNamespaces

76+ExtendedDefaultRules

77+NoExtendedDefaultRules

78+FlexibleContexts

79+NoFlexibleContexts

80+FlexibleInstances

81+NoFlexibleInstances

82+ForeignFunctionInterface

83+NoForeignFunctionInterface

84+FunctionalDependencies

85+NoFunctionalDependencies

86+GADTSyntax

87+NoGADTSyntax

88+GADTs

89+NoGADTs

90+GHCForeignImportPrim

91+NoGHCForeignImportPrim

92+GeneralizedNewtypeDeriving

93+NoGeneralizedNewtypeDeriving

94+GeneralisedNewtypeDeriving

95+NoGeneralisedNewtypeDeriving

96+ImplicitParams

97+NoImplicitParams

98+ImplicitPrelude

99+NoImplicitPrelude

100+ImportQualifiedPost

101+NoImportQualifiedPost

102+ImpredicativeTypes

103+NoImpredicativeTypes

104+IncoherentInstances

105+NoIncoherentInstances

106+TypeFamilyDependencies

107+NoTypeFamilyDependencies

108+InstanceSigs

109+NoInstanceSigs

110+ApplicativeDo

111+NoApplicativeDo

112+InterruptibleFFI

113+NoInterruptibleFFI

114+JavaScriptFFI

115+NoJavaScriptFFI

116+KindSignatures

117+NoKindSignatures

118+LambdaCase

119+NoLambdaCase

120+LexicalNegation

121+NoLexicalNegation

122+LiberalTypeSynonyms

123+NoLiberalTypeSynonyms

124+LinearTypes

125+NoLinearTypes

126+MagicHash

127+NoMagicHash

128+MonadComprehensions

129+NoMonadComprehensions

130+MonadFailDesugaring

131+NoMonadFailDesugaring

132+MonoLocalBinds

133+NoMonoLocalBinds

134+MonoPatBinds

135+NoMonoPatBinds

136+MonomorphismRestriction

137+NoMonomorphismRestriction

138+MultiParamTypeClasses

139+NoMultiParamTypeClasses

140+MultiWayIf

141+NoMultiWayIf

142+NumericUnderscores

143+NoNumericUnderscores

144+NPlusKPatterns

145+NoNPlusKPatterns

146+NamedFieldPuns

147+NoNamedFieldPuns

148+NamedWildCards

149+NoNamedWildCards

150+NegativeLiterals

151+NoNegativeLiterals

152+HexFloatLiterals

153+NoHexFloatLiterals

154+NondecreasingIndentation

155+NoNondecreasingIndentation

156+NullaryTypeClasses

157+NoNullaryTypeClasses

158+NumDecimals

159+NoNumDecimals

160+OverlappingInstances

161+NoOverlappingInstances

162+OverloadedLabels

163+NoOverloadedLabels

164+OverloadedLists

165+NoOverloadedLists

166+OverloadedStrings

167+NoOverloadedStrings

168+PackageImports

169+NoPackageImports

170+ParallelArrays

171+NoParallelArrays

172+ParallelListComp

173+NoParallelListComp

174+PartialTypeSignatures

175+NoPartialTypeSignatures

176+PatternGuards

177+NoPatternGuards

178+PatternSignatures

179+NoPatternSignatures

180+PatternSynonyms

181+NoPatternSynonyms

182+PolyKinds

183+NoPolyKinds

184+PolymorphicComponents

185+NoPolymorphicComponents

186+QuantifiedConstraints

187+NoQuantifiedConstraints

188+PostfixOperators

189+NoPostfixOperators

190+QuasiQuotes

191+NoQuasiQuotes

192+QualifiedDo

193+NoQualifiedDo

194+Rank2Types

195+NoRank2Types

196+RankNTypes

197+NoRankNTypes

198+RebindableSyntax

199+NoRebindableSyntax

200+RecordPuns

201+NoRecordPuns

202+RecordWildCards

203+NoRecordWildCards

204+RecursiveDo

205+NoRecursiveDo

206+RelaxedLayout

207+NoRelaxedLayout

208+RelaxedPolyRec

209+NoRelaxedPolyRec

210+RoleAnnotations

211+NoRoleAnnotations

212+ScopedTypeVariables

213+NoScopedTypeVariables

214+StandaloneDeriving

215+NoStandaloneDeriving

216+StarIsType

217+NoStarIsType

218+StaticPointers

219+NoStaticPointers

220+Strict

221+NoStrict

222+StrictData

223+NoStrictData

224+TemplateHaskell

225+NoTemplateHaskell

226+TemplateHaskellQuotes

227+NoTemplateHaskellQuotes

228+StandaloneKindSignatures

229+NoStandaloneKindSignatures

230+TraditionalRecordSyntax

231+NoTraditionalRecordSyntax

232+TransformListComp

233+NoTransformListComp

234+TupleSections

235+NoTupleSections

236+TypeApplications

237+NoTypeApplications

238+TypeInType

239+NoTypeInType

240+TypeFamilies

241+NoTypeFamilies

242+TypeOperators

243+NoTypeOperators

244+TypeSynonymInstances

245+NoTypeSynonymInstances

246+UnboxedTuples

247+NoUnboxedTuples

248+UnboxedSums

249+NoUnboxedSums

250+UndecidableInstances

251+NoUndecidableInstances

252+UndecidableSuperClasses

253+NoUndecidableSuperClasses

254+UnicodeSyntax

255+NoUnicodeSyntax

256+UnliftedFFITypes

257+NoUnliftedFFITypes

258+UnliftedNewtypes

259+NoUnliftedNewtypes

260+ViewPatterns

261+NoViewPatterns

materialized/dummy-ghc/ghc-9.0.1-aarch64-darwin/ghc/versionnew file+1

@@ -0,0 +1 @@

1+The Glorious Glasgow Haskell Compilation System, version 9.0.1

materialized/dummy-ghc/ghc-9.0.1-aarch64-linux/ghc-pkg/dump-globalnew file+1760

@@ -0,0 +1,1760 @@

1+name: Cabal

2+version: 3.4.0.0

3+visibility: public

4+id: Cabal-3.4.0.0

5+key: Cabal-3.4.0.0

6+license: BSD-3-Clause

7+copyright: 2003-2020, 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.Doctest

71+ Distribution.Simple.Flag Distribution.Simple.GHC

72+ Distribution.Simple.GHCJS Distribution.Simple.Glob

73+ Distribution.Simple.Haddock Distribution.Simple.HaskellSuite

74+ Distribution.Simple.Hpc Distribution.Simple.Install

75+ Distribution.Simple.InstallDirs

76+ Distribution.Simple.InstallDirs.Internal

77+ Distribution.Simple.LocalBuildInfo Distribution.Simple.PackageIndex

78+ Distribution.Simple.PreProcess Distribution.Simple.PreProcess.Unlit

79+ Distribution.Simple.Program Distribution.Simple.Program.Ar

80+ Distribution.Simple.Program.Builtin Distribution.Simple.Program.Db

81+ Distribution.Simple.Program.Find Distribution.Simple.Program.GHC

82+ Distribution.Simple.Program.HcPkg Distribution.Simple.Program.Hpc

83+ Distribution.Simple.Program.Internal Distribution.Simple.Program.Ld

84+ Distribution.Simple.Program.ResponseFile

85+ Distribution.Simple.Program.Run Distribution.Simple.Program.Script

86+ Distribution.Simple.Program.Strip Distribution.Simple.Program.Types

87+ Distribution.Simple.Register Distribution.Simple.Setup

88+ Distribution.Simple.ShowBuildInfo Distribution.Simple.SrcDist

89+ Distribution.Simple.Test Distribution.Simple.Test.ExeV10

90+ Distribution.Simple.Test.LibV09 Distribution.Simple.Test.Log

91+ Distribution.Simple.UHC Distribution.Simple.UserHooks

92+ Distribution.Simple.Utils Distribution.System

93+ Distribution.TestSuite Distribution.Text

94+ Distribution.Types.AbiDependency Distribution.Types.AbiHash

95+ Distribution.Types.AnnotatedId Distribution.Types.Benchmark

96+ Distribution.Types.Benchmark.Lens

97+ Distribution.Types.BenchmarkInterface

98+ Distribution.Types.BenchmarkType Distribution.Types.BuildInfo

99+ Distribution.Types.BuildInfo.Lens Distribution.Types.BuildType

100+ Distribution.Types.Component Distribution.Types.ComponentId

101+ Distribution.Types.ComponentInclude

102+ Distribution.Types.ComponentLocalBuildInfo

103+ Distribution.Types.ComponentName

104+ Distribution.Types.ComponentRequestedSpec

105+ Distribution.Types.CondTree Distribution.Types.Condition

106+ Distribution.Types.ConfVar Distribution.Types.Dependency

107+ Distribution.Types.DependencyMap Distribution.Types.ExeDependency

108+ Distribution.Types.Executable Distribution.Types.Executable.Lens

109+ Distribution.Types.ExecutableScope Distribution.Types.ExposedModule

110+ Distribution.Types.Flag Distribution.Types.ForeignLib

111+ Distribution.Types.ForeignLib.Lens

112+ Distribution.Types.ForeignLibOption

113+ Distribution.Types.ForeignLibType

114+ Distribution.Types.GenericPackageDescription

115+ Distribution.Types.GenericPackageDescription.Lens

116+ Distribution.Types.GivenComponent

117+ Distribution.Types.HookedBuildInfo

118+ Distribution.Types.IncludeRenaming

119+ Distribution.Types.InstalledPackageInfo

120+ Distribution.Types.InstalledPackageInfo.FieldGrammar

121+ Distribution.Types.InstalledPackageInfo.Lens

122+ Distribution.Types.LegacyExeDependency Distribution.Types.Lens

123+ Distribution.Types.Library Distribution.Types.Library.Lens

124+ Distribution.Types.LibraryName Distribution.Types.LibraryVisibility

125+ Distribution.Types.LocalBuildInfo Distribution.Types.Mixin

126+ Distribution.Types.Module Distribution.Types.ModuleReexport

127+ Distribution.Types.ModuleRenaming

128+ Distribution.Types.MungedPackageId

129+ Distribution.Types.MungedPackageName

130+ Distribution.Types.PackageDescription

131+ Distribution.Types.PackageDescription.Lens

132+ Distribution.Types.PackageId Distribution.Types.PackageId.Lens

133+ Distribution.Types.PackageName Distribution.Types.PackageName.Magic

134+ Distribution.Types.PackageVersionConstraint

135+ Distribution.Types.PkgconfigDependency

136+ Distribution.Types.PkgconfigName

137+ Distribution.Types.PkgconfigVersion

138+ Distribution.Types.PkgconfigVersionRange

139+ Distribution.Types.SetupBuildInfo

140+ Distribution.Types.SetupBuildInfo.Lens

141+ Distribution.Types.SourceRepo Distribution.Types.SourceRepo.Lens

142+ Distribution.Types.TargetInfo Distribution.Types.TestSuite

143+ Distribution.Types.TestSuite.Lens

144+ Distribution.Types.TestSuiteInterface Distribution.Types.TestType

145+ Distribution.Types.UnitId Distribution.Types.UnqualComponentName

146+ Distribution.Types.Version Distribution.Types.VersionInterval

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.Progress

152+ Distribution.Utils.ShortText Distribution.Utils.Structured

153+ Distribution.Verbosity Distribution.Verbosity.Internal

154+ Distribution.Version Language.Haskell.Extension

155+hidden-modules:

156+ Distribution.Backpack.PreExistingComponent

157+ Distribution.Backpack.ReadyComponent Distribution.Backpack.MixLink

158+ Distribution.Backpack.ModuleScope Distribution.Backpack.UnifyM

159+ Distribution.Backpack.Id Distribution.Utils.UnionFind

160+ Distribution.Utils.Base62 Distribution.Compat.Async

161+ Distribution.Compat.CopyFile Distribution.Compat.GetShortPathName

162+ Distribution.Compat.MonadFail Distribution.Compat.Prelude

163+ Distribution.Compat.SnocList Distribution.GetOpt Distribution.Lex

164+ Distribution.Utils.String Distribution.Simple.Build.Macros.Z

165+ Distribution.Simple.GHC.EnvironmentParser

166+ Distribution.Simple.GHC.Internal Distribution.Simple.GHC.ImplInfo

167+ Distribution.Simple.Utils.Json Distribution.ZinzaPrelude

168+ Paths_Cabal

169+import-dirs:

170+library-dirs:

171+dynamic-library-dirs:

172+data-dir:

173+hs-libraries: HSCabal-3.4.0.0

174+depends:

175+ array-0.5.4.0 base-4.15.0.0 binary-0.8.8.0 bytestring-0.10.12.1

176+ containers-0.6.4.1 deepseq-1.4.5.0 directory-1.3.6.1

177+ filepath-1.4.2.1 mtl-2.2.2 parsec-3.1.14.0 pretty-1.1.3.6

178+ process-1.6.11.0 text-1.2.4.1 time-1.9.3 transformers-0.5.6.2

179+ unix-2.7.2.2

180+haddock-interfaces:

181+haddock-html:

182+---

183+name: array

184+version: 0.5.4.0

185+visibility: public

186+id: array-0.5.4.0

187+key: array-0.5.4.0

188+license: BSD-3-Clause

189+maintainer: libraries@haskell.org

190+synopsis: Mutable and immutable arrays

191+description:

192+ In addition to providing the "Data.Array" module

193+ <http://www.haskell.org/onlinereport/haskell2010/haskellch14.html as specified in the Haskell 2010 Language Report>,

194+ this package also defines the classes 'IArray' of

195+ immutable arrays and 'MArray' of arrays mutable within appropriate

196+ monads, as well as some instances of these classes.

197+category: Data Structures

198+exposed: True

199+exposed-modules:

200+ Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO

201+ Data.Array.IO.Internals Data.Array.IO.Safe Data.Array.MArray

202+ Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe

203+ Data.Array.Storable Data.Array.Storable.Internals

204+ Data.Array.Storable.Safe Data.Array.Unboxed Data.Array.Unsafe

205+import-dirs:

206+library-dirs:

207+dynamic-library-dirs:

208+data-dir:

209+hs-libraries: HSarray-0.5.4.0

210+depends: base-4.15.0.0

211+haddock-interfaces:

212+haddock-html:

213+---

214+name: base

215+version: 4.15.0.0

216+visibility: public

217+id: base-4.15.0.0

218+key: base-4.15.0.0

219+license: BSD-3-Clause

220+maintainer: libraries@haskell.org

221+synopsis: Basic libraries

222+description:

223+ This package contains the Standard Haskell "Prelude" and its support libraries,

224+ and a large collection of useful libraries ranging from data

225+ structures to parsing combinators and debugging utilities.

226+category: Prelude

227+exposed: True

228+exposed-modules:

229+ Control.Applicative, Control.Arrow, Control.Category,

230+ Control.Concurrent, Control.Concurrent.Chan,

231+ Control.Concurrent.MVar, Control.Concurrent.QSem,

232+ Control.Concurrent.QSemN, Control.Exception,

233+ Control.Exception.Base, Control.Monad, Control.Monad.Fail,

234+ Control.Monad.Fix, Control.Monad.IO.Class, Control.Monad.Instances,

235+ Control.Monad.ST, Control.Monad.ST.Lazy,

236+ Control.Monad.ST.Lazy.Safe, Control.Monad.ST.Lazy.Unsafe,

237+ Control.Monad.ST.Safe, Control.Monad.ST.Strict,

238+ Control.Monad.ST.Unsafe, Control.Monad.Zip, Data.Bifoldable,

239+ Data.Bifunctor, Data.Bitraversable, Data.Bits, Data.Bool,

240+ Data.Char, Data.Coerce, Data.Complex, Data.Data, Data.Dynamic,

241+ Data.Either, Data.Eq, Data.Fixed, Data.Foldable, Data.Function,

242+ Data.Functor, Data.Functor.Classes, Data.Functor.Compose,

243+ Data.Functor.Const, Data.Functor.Contravariant,

244+ Data.Functor.Identity, Data.Functor.Product, Data.Functor.Sum,

245+ Data.IORef, Data.Int, Data.Ix, Data.Kind, Data.List,

246+ Data.List.NonEmpty, Data.Maybe, Data.Monoid, Data.Ord, Data.Proxy,

247+ Data.Ratio, Data.STRef, Data.STRef.Lazy, Data.STRef.Strict,

248+ Data.Semigroup, Data.String, Data.Traversable, Data.Tuple,

249+ Data.Type.Bool, Data.Type.Coercion, Data.Type.Equality,

250+ Data.Typeable, Data.Unique, Data.Version, Data.Void, Data.Word,

251+ Debug.Trace, Foreign, Foreign.C, Foreign.C.Error, Foreign.C.String,

252+ Foreign.C.Types, Foreign.Concurrent, Foreign.ForeignPtr,

253+ Foreign.ForeignPtr.Safe, Foreign.ForeignPtr.Unsafe,

254+ Foreign.Marshal, Foreign.Marshal.Alloc, Foreign.Marshal.Array,

255+ Foreign.Marshal.Error, Foreign.Marshal.Pool, Foreign.Marshal.Safe,

256+ Foreign.Marshal.Unsafe, Foreign.Marshal.Utils, Foreign.Ptr,

257+ Foreign.Safe, Foreign.StablePtr, Foreign.Storable, GHC.Arr,

258+ GHC.Base, GHC.ByteOrder, GHC.Char, GHC.Clock, GHC.Conc,

259+ GHC.Conc.IO, GHC.Conc.Signal, GHC.Conc.Sync, GHC.ConsoleHandler,

260+ GHC.Constants, GHC.Desugar, GHC.Enum, GHC.Environment, GHC.Err,

261+ GHC.Event, GHC.Event.TimeOut, GHC.Exception, GHC.Exception.Type,

262+ GHC.ExecutionStack, GHC.ExecutionStack.Internal, GHC.Exts,

263+ GHC.Fingerprint, GHC.Fingerprint.Type, GHC.Float,

264+ GHC.Float.ConversionUtils, GHC.Float.RealFracMethods, GHC.Foreign,

265+ GHC.ForeignPtr, GHC.GHCi, GHC.GHCi.Helpers, GHC.Generics, GHC.IO,

266+ GHC.IO.Buffer, GHC.IO.BufferedIO, GHC.IO.Device, GHC.IO.Encoding,

267+ GHC.IO.Encoding.CodePage, GHC.IO.Encoding.Failure,

268+ GHC.IO.Encoding.Iconv, GHC.IO.Encoding.Latin1,

269+ GHC.IO.Encoding.Types, GHC.IO.Encoding.UTF16,

270+ GHC.IO.Encoding.UTF32, GHC.IO.Encoding.UTF8, GHC.IO.Exception,

271+ GHC.IO.FD, GHC.IO.Handle, GHC.IO.Handle.FD,

272+ GHC.IO.Handle.Internals, GHC.IO.Handle.Lock, GHC.IO.Handle.Text,

273+ GHC.IO.Handle.Types, GHC.IO.IOMode, GHC.IO.StdHandles,

274+ GHC.IO.SubSystem, GHC.IO.Unsafe, GHC.IOArray, GHC.IOPort,

275+ GHC.IORef, GHC.Int, GHC.Integer, GHC.Integer.Logarithms, GHC.Ix,

276+ GHC.List, GHC.MVar, GHC.Maybe, GHC.Natural, GHC.Num,

277+ GHC.Num.BigNat from ghc-bignum-1.0:GHC.Num.BigNat,

278+ GHC.Num.Integer from ghc-bignum-1.0:GHC.Num.Integer,

279+ GHC.Num.Natural from ghc-bignum-1.0:GHC.Num.Natural, GHC.OldList,

280+ GHC.OverloadedLabels, GHC.Pack, GHC.Profiling, GHC.Ptr,

281+ GHC.RTS.Flags, GHC.Read, GHC.Real, GHC.Records, GHC.ResponseFile,

282+ GHC.ST, GHC.STRef, GHC.Show, GHC.Stable, GHC.StableName, GHC.Stack,

283+ GHC.Stack.CCS, GHC.Stack.Types, GHC.StaticPtr, GHC.Stats,

284+ GHC.Storable, GHC.TopHandler, GHC.TypeLits, GHC.TypeNats,

285+ GHC.Unicode, GHC.Weak, GHC.Word, Numeric, Numeric.Natural, Prelude,

286+ System.CPUTime, System.Console.GetOpt, System.Environment,

287+ System.Environment.Blank, System.Exit, System.IO, System.IO.Error,

288+ System.IO.Unsafe, System.Info, System.Mem, System.Mem.StableName,

289+ System.Mem.Weak, System.Posix.Internals, System.Posix.Types,

290+ System.Timeout, Text.ParserCombinators.ReadP,

291+ Text.ParserCombinators.ReadPrec, Text.Printf, Text.Read,

292+ Text.Read.Lex, Text.Show, Text.Show.Functions, Type.Reflection,

293+ Type.Reflection.Unsafe, Unsafe.Coerce

294+hidden-modules:

295+ Control.Monad.ST.Imp Control.Monad.ST.Lazy.Imp Data.Functor.Utils

296+ Data.OldList Data.Semigroup.Internal Data.Typeable.Internal

297+ Foreign.ForeignPtr.Imp GHC.IO.Handle.Lock.Common

298+ GHC.IO.Handle.Lock.Flock GHC.IO.Handle.Lock.LinuxOFD

299+ GHC.IO.Handle.Lock.NoOp GHC.IO.Handle.Lock.Windows

300+ GHC.StaticPtr.Internal GHC.Event.Internal.Types

301+ System.Environment.ExecutablePath System.CPUTime.Utils

302+ GHC.Event.Arr GHC.Event.Array GHC.Event.Control GHC.Event.EPoll

303+ GHC.Event.IntTable GHC.Event.Internal GHC.Event.KQueue

304+ GHC.Event.Manager GHC.Event.PSQ GHC.Event.Poll GHC.Event.Thread

305+ GHC.Event.TimerManager GHC.Event.Unique

306+ System.CPUTime.Posix.ClockGetTime System.CPUTime.Posix.Times

307+ System.CPUTime.Posix.RUsage System.CPUTime.Unsupported

308+import-dirs:

309+library-dirs:

310+dynamic-library-dirs:

311+data-dir:

312+hs-libraries: HSbase-4.15.0.0

313+include-dirs:

314+includes: HsBase.h

315+depends: ghc-bignum-1.0 ghc-prim-0.7.0 rts

316+haddock-interfaces:

317+haddock-html:

318+---

319+name: binary

320+version: 0.8.8.0

321+visibility: public

322+id: binary-0.8.8.0

323+key: binary-0.8.8.0

324+license: BSD-3-Clause

325+maintainer: Lennart Kolmodin, Don Stewart <dons00@gmail.com>

326+author: Lennart Kolmodin <kolmodin@gmail.com>

327+stability: provisional

328+homepage: https://github.com/kolmodin/binary

329+synopsis:

330+ Binary serialisation for Haskell values using lazy ByteStrings

331+description:

332+ Efficient, pure binary serialisation using lazy ByteStrings.

333+ Haskell values may be encoded to and from binary formats,

334+ written to disk as binary, or sent over the network.

335+ The format used can be automatically generated, or

336+ you can choose to implement a custom format if needed.

337+ Serialisation speeds of over 1 G\/sec have been observed,

338+ so this library should be suitable for high performance

339+ scenarios.

340+category: Data, Parsing

341+exposed: True

342+exposed-modules:

343+ Data.Binary Data.Binary.Builder Data.Binary.Get

344+ Data.Binary.Get.Internal Data.Binary.Put

345+hidden-modules:

346+ Data.Binary.Class Data.Binary.Internal Data.Binary.Generic

347+ Data.Binary.FloatCast

348+import-dirs:

349+library-dirs:

350+dynamic-library-dirs:

351+data-dir:

352+hs-libraries: HSbinary-0.8.8.0

353+depends:

354+ array-0.5.4.0 base-4.15.0.0 bytestring-0.10.12.1 containers-0.6.4.1

355+haddock-interfaces:

356+haddock-html:

357+---

358+name: bytestring

359+version: 0.10.12.1

360+visibility: public

361+id: bytestring-0.10.12.1

362+key: bytestring-0.10.12.1

363+license: BSD-3-Clause

364+copyright:

365+ Copyright (c) Don Stewart 2005-2009,

366+ (c) Duncan Coutts 2006-2015,

367+ (c) David Roundy 2003-2005,

368+ (c) Jasper Van der Jeugt 2010,

369+ (c) Simon Meier 2010-2013.

370+maintainer:

371+ Haskell Bytestring Team <andrew.lelechenko@gmail.com>, Core Libraries Committee

372+author:

373+ Don Stewart,

374+ Duncan Coutts

375+homepage: https://github.com/haskell/bytestring

376+synopsis:

377+ Fast, compact, strict and lazy byte strings with a list interface

378+description:

379+ An efficient compact, immutable byte string type (both strict and lazy)

380+ suitable for binary or 8-bit character data.

381+ The 'ByteString' type represents sequences of bytes or 8-bit characters.

382+ It is suitable for high performance use, both in terms of large data

383+ quantities, or high speed requirements. The 'ByteString' functions follow

384+ the same style as Haskell\'s ordinary lists, so it is easy to convert code

385+ from using 'String' to 'ByteString'.

386+ Two 'ByteString' variants are provided:

387+ * Strict 'ByteString's keep the string as a single large array. This

388+ makes them convenient for passing data between C and Haskell.

389+ * Lazy 'ByteString's use a lazy list of strict chunks which makes it

390+ suitable for I\/O streaming tasks.

391+ The @Char8@ modules provide a character-based view of the same

392+ underlying 'ByteString' types. This makes it convenient to handle mixed

393+ binary and 8-bit character content (which is common in many file formats

394+ and network protocols).

395+ The 'Builder' module provides an efficient way to build up 'ByteString's

396+ in an ad-hoc way by repeated concatenation. This is ideal for fast

397+ serialisation or pretty printing.

398+ There is also a 'ShortByteString' type which has a lower memory overhead

399+ and can can be converted to or from a 'ByteString', but supports very few

400+ other operations. It is suitable for keeping many short strings in memory.

401+ 'ByteString's are not designed for Unicode. For Unicode strings you should

402+ use the 'Text' type from the @text@ package.

403+ These modules are intended to be imported qualified, to avoid name clashes

404+ with "Prelude" functions, e.g.

405+ > import qualified Data.ByteString as BS

406+category: Data

407+exposed: True

408+exposed-modules:

409+ Data.ByteString Data.ByteString.Builder

410+ Data.ByteString.Builder.Extra Data.ByteString.Builder.Internal

411+ Data.ByteString.Builder.Prim Data.ByteString.Builder.Prim.Internal

412+ Data.ByteString.Char8 Data.ByteString.Internal Data.ByteString.Lazy

413+ Data.ByteString.Lazy.Builder Data.ByteString.Lazy.Builder.ASCII

414+ Data.ByteString.Lazy.Builder.Extras Data.ByteString.Lazy.Char8

415+ Data.ByteString.Lazy.Internal Data.ByteString.Short

416+ Data.ByteString.Short.Internal Data.ByteString.Unsafe

417+hidden-modules:

418+ Data.ByteString.Builder.ASCII Data.ByteString.Builder.Prim.Binary

419+ Data.ByteString.Builder.Prim.ASCII

420+ Data.ByteString.Builder.Prim.Internal.Floating

421+ Data.ByteString.Builder.Prim.Internal.UncheckedShifts

422+ Data.ByteString.Builder.Prim.Internal.Base16

423+import-dirs:

424+library-dirs:

425+dynamic-library-dirs:

426+data-dir:

427+hs-libraries: HSbytestring-0.10.12.1

428+include-dirs:

429+includes: fpstring.h

430+depends:

431+ base-4.15.0.0 deepseq-1.4.5.0 ghc-bignum-1.0 ghc-prim-0.7.0

432+haddock-interfaces:

433+haddock-html:

434+---

435+name: containers

436+version: 0.6.4.1

437+visibility: public

438+id: containers-0.6.4.1

439+key: containers-0.6.4.1

440+license: BSD-3-Clause

441+maintainer: libraries@haskell.org

442+synopsis: Assorted concrete container types

443+description:

444+ This package contains efficient general-purpose implementations

445+ of various immutable container types including sets, maps, sequences,

446+ trees, and graphs.

447+ For a walkthrough of what this package provides with examples of common

448+ operations see the [containers

449+ introduction](https://haskell-containers.readthedocs.io).

450+ The declared cost of each operation is either worst-case or amortized, but

451+ remains valid even if structures are shared.

452+category: Data Structures

453+exposed: True

454+exposed-modules:

455+ Data.Containers.ListUtils Data.Graph Data.IntMap

456+ Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy

457+ Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict

458+ Data.IntMap.Strict.Internal Data.IntSet Data.IntSet.Internal

459+ Data.Map Data.Map.Internal Data.Map.Internal.Debug Data.Map.Lazy

460+ Data.Map.Merge.Lazy Data.Map.Merge.Strict Data.Map.Strict

461+ Data.Map.Strict.Internal Data.Sequence Data.Sequence.Internal

462+ Data.Sequence.Internal.Sorting Data.Set Data.Set.Internal Data.Tree

463+ Utils.Containers.Internal.BitQueue

464+ Utils.Containers.Internal.BitUtil

465+ Utils.Containers.Internal.StrictPair

466+hidden-modules:

467+ Utils.Containers.Internal.State

468+ Utils.Containers.Internal.StrictMaybe

469+ Utils.Containers.Internal.PtrEquality

470+ Utils.Containers.Internal.Coercions

471+ Utils.Containers.Internal.TypeError

472+ Data.Map.Internal.DeprecatedShowTree

473+ Data.IntMap.Internal.DeprecatedDebug

474+import-dirs:

475+library-dirs:

476+dynamic-library-dirs:

477+data-dir:

478+hs-libraries: HScontainers-0.6.4.1

479+depends: array-0.5.4.0 base-4.15.0.0 deepseq-1.4.5.0

480+haddock-interfaces:

481+haddock-html:

482+---

483+name: deepseq

484+version: 1.4.5.0

485+visibility: public

486+id: deepseq-1.4.5.0

487+key: deepseq-1.4.5.0

488+license: BSD-3-Clause

489+maintainer: libraries@haskell.org

490+synopsis: Deep evaluation of data structures

491+description:

492+ This package provides methods for fully evaluating data structures

493+ (\"deep evaluation\"). Deep evaluation is often used for adding

494+ strictness to a program, e.g. in order to force pending exceptions,

495+ remove space leaks, or force lazy I/O to happen. It is also useful

496+ in parallel programs, to ensure pending work does not migrate to the

497+ wrong thread.

498+ The primary use of this package is via the 'deepseq' function, a

499+ \"deep\" version of 'seq'. It is implemented on top of an 'NFData'

500+ typeclass (\"Normal Form Data\", data structures with no unevaluated

501+ components) which defines strategies for fully evaluating different

502+ data types. See module documentation in "Control.DeepSeq" for more

503+ details.

504+category: Control

505+exposed: True

506+exposed-modules: Control.DeepSeq

507+hidden-modules: Control.DeepSeq.BackDoor

508+import-dirs:

509+library-dirs:

510+dynamic-library-dirs:

511+data-dir:

512+hs-libraries: HSdeepseq-1.4.5.0

513+depends: array-0.5.4.0 base-4.15.0.0

514+haddock-interfaces:

515+haddock-html:

516+---

517+name: directory

518+version: 1.3.6.1

519+visibility: public

520+id: directory-1.3.6.1

521+key: directory-1.3.6.1

522+license: BSD-3-Clause

523+maintainer: libraries@haskell.org

524+synopsis: Platform-agnostic library for filesystem operations

525+description:

526+ This library provides a basic set of operations for manipulating files and

527+ directories in a portable way.

528+category: System

529+exposed: True

530+exposed-modules:

531+ System.Directory System.Directory.Internal

532+ System.Directory.Internal.Prelude

533+hidden-modules:

534+ System.Directory.Internal.C_utimensat

535+ System.Directory.Internal.Common System.Directory.Internal.Config

536+ System.Directory.Internal.Posix System.Directory.Internal.Windows

537+import-dirs:

538+library-dirs:

539+dynamic-library-dirs:

540+data-dir:

541+hs-libraries: HSdirectory-1.3.6.1

542+depends:

543+ base-4.15.0.0 filepath-1.4.2.1 time-1.9.3 unix-2.7.2.2

544+haddock-interfaces:

545+haddock-html:

546+---

547+name: exceptions

548+version: 0.10.4

549+visibility: public

550+id: exceptions-0.10.4

551+key: exceptions-0.10.4

552+license: BSD-3-Clause

553+copyright:

554+ Copyright (C) 2013-2015 Edward A. Kmett

555+ Copyright (C) 2012 Google Inc.

556+maintainer: Edward A. Kmett <ekmett@gmail.com>

557+author: Edward A. Kmett

558+stability: provisional

559+homepage: http://github.com/ekmett/exceptions/

560+synopsis: Extensible optionally-pure exceptions

561+description: Extensible optionally-pure exceptions.

562+category: Control, Exceptions, Monad

563+exposed: True

564+exposed-modules: Control.Monad.Catch Control.Monad.Catch.Pure

565+import-dirs:

566+library-dirs:

567+dynamic-library-dirs:

568+data-dir:

569+hs-libraries: HSexceptions-0.10.4

570+depends:

571+ base-4.15.0.0 mtl-2.2.2 stm-2.5.0.0 template-haskell-2.17.0.0

572+ transformers-0.5.6.2

573+haddock-interfaces:

574+haddock-html:

575+---

576+name: filepath

577+version: 1.4.2.1

578+visibility: public

579+id: filepath-1.4.2.1

580+key: filepath-1.4.2.1

581+license: BSD-3-Clause

582+copyright: Neil Mitchell 2005-2020

583+maintainer: Neil Mitchell <ndmitchell@gmail.com>

584+author: Neil Mitchell <ndmitchell@gmail.com>

585+homepage: https://github.com/haskell/filepath#readme

586+synopsis: Library for manipulating FilePaths in a cross platform way.

587+description:

588+ 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:

589+ * "System.FilePath.Posix" manipulates POSIX\/Linux style @FilePath@ values (with @\/@ as the path separator).

590+ * "System.FilePath.Windows" manipulates Windows style @FilePath@ values (with either @\\@ or @\/@ as the path separator, and deals with drives).

591+ * "System.FilePath" is an alias for the module appropriate to your platform.

592+ All three modules provide the same API, and the same documentation (calling out differences in the different variants).

593+category: System

594+exposed: True

595+exposed-modules:

596+ System.FilePath System.FilePath.Posix System.FilePath.Windows

597+import-dirs:

598+library-dirs:

599+dynamic-library-dirs:

600+data-dir:

601+hs-libraries: HSfilepath-1.4.2.1

602+depends: base-4.15.0.0

603+haddock-interfaces:

604+haddock-html:

605+---

606+name: ghc

607+version: 9.0.1

608+visibility: public

609+id: ghc-9.0.1

610+key: ghc-9.0.1

611+license: BSD-3-Clause

612+maintainer: glasgow-haskell-users@haskell.org

613+author: The GHC Team

614+homepage: http://www.haskell.org/ghc/

615+synopsis: The GHC API

616+description:

617+ GHC's functionality can be useful for more things than just

618+ compiling Haskell programs. Important use cases are programs

619+ that analyse (and perhaps transform) Haskell code. Others

620+ include loading Haskell code dynamically in a GHCi-like manner.

621+ For this reason, a lot of GHC's functionality is made available

622+ through this package.

623+ See <https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler>

624+ for more information.

625+category: Development

626+exposed-modules:

627+ GHC GHC.Builtin.Names GHC.Builtin.Names.TH GHC.Builtin.PrimOps

628+ GHC.Builtin.RebindableNames GHC.Builtin.Types

629+ GHC.Builtin.Types.Literals GHC.Builtin.Types.Prim

630+ GHC.Builtin.Uniques GHC.Builtin.Utils GHC.ByteCode.Asm

631+ GHC.ByteCode.InfoTable GHC.ByteCode.Instr GHC.ByteCode.Linker

632+ GHC.ByteCode.Types GHC.Cmm GHC.Cmm.BlockId GHC.Cmm.CLabel

633+ GHC.Cmm.CallConv GHC.Cmm.CommonBlockElim GHC.Cmm.ContFlowOpt

634+ GHC.Cmm.Dataflow GHC.Cmm.Dataflow.Block

635+ GHC.Cmm.Dataflow.Collections GHC.Cmm.Dataflow.Graph

636+ GHC.Cmm.Dataflow.Label GHC.Cmm.DebugBlock GHC.Cmm.Expr

637+ GHC.Cmm.Graph GHC.Cmm.Info GHC.Cmm.Info.Build GHC.Cmm.LayoutStack

638+ GHC.Cmm.Lexer GHC.Cmm.Lint GHC.Cmm.Liveness GHC.Cmm.MachOp

639+ GHC.Cmm.Monad GHC.Cmm.Node GHC.Cmm.Opt GHC.Cmm.Parser

640+ GHC.Cmm.Pipeline GHC.Cmm.Ppr GHC.Cmm.Ppr.Decl GHC.Cmm.Ppr.Expr

641+ GHC.Cmm.ProcPoint GHC.Cmm.Sink GHC.Cmm.Switch

642+ GHC.Cmm.Switch.Implement GHC.Cmm.Type GHC.Cmm.Utils GHC.CmmToAsm

643+ GHC.CmmToAsm.BlockLayout GHC.CmmToAsm.CFG

644+ GHC.CmmToAsm.CFG.Dominators GHC.CmmToAsm.CPrim GHC.CmmToAsm.Config

645+ GHC.CmmToAsm.Dwarf GHC.CmmToAsm.Dwarf.Constants

646+ GHC.CmmToAsm.Dwarf.Types GHC.CmmToAsm.Format GHC.CmmToAsm.Instr

647+ GHC.CmmToAsm.Monad GHC.CmmToAsm.PIC GHC.CmmToAsm.PPC.CodeGen

648+ GHC.CmmToAsm.PPC.Cond GHC.CmmToAsm.PPC.Instr GHC.CmmToAsm.PPC.Ppr

649+ GHC.CmmToAsm.PPC.RegInfo GHC.CmmToAsm.PPC.Regs GHC.CmmToAsm.Ppr

650+ GHC.CmmToAsm.Reg.Graph GHC.CmmToAsm.Reg.Graph.Base

651+ GHC.CmmToAsm.Reg.Graph.Coalesce GHC.CmmToAsm.Reg.Graph.Spill

652+ GHC.CmmToAsm.Reg.Graph.SpillClean GHC.CmmToAsm.Reg.Graph.SpillCost

653+ GHC.CmmToAsm.Reg.Graph.Stats GHC.CmmToAsm.Reg.Graph.TrivColorable

654+ GHC.CmmToAsm.Reg.Graph.X86 GHC.CmmToAsm.Reg.Linear

655+ GHC.CmmToAsm.Reg.Linear.Base GHC.CmmToAsm.Reg.Linear.FreeRegs

656+ GHC.CmmToAsm.Reg.Linear.JoinToTargets GHC.CmmToAsm.Reg.Linear.PPC

657+ GHC.CmmToAsm.Reg.Linear.SPARC GHC.CmmToAsm.Reg.Linear.StackMap

658+ GHC.CmmToAsm.Reg.Linear.State GHC.CmmToAsm.Reg.Linear.Stats

659+ GHC.CmmToAsm.Reg.Linear.X86 GHC.CmmToAsm.Reg.Linear.X86_64

660+ GHC.CmmToAsm.Reg.Liveness GHC.CmmToAsm.Reg.Target

661+ GHC.CmmToAsm.Reg.Utils GHC.CmmToAsm.SPARC.AddrMode

662+ GHC.CmmToAsm.SPARC.Base GHC.CmmToAsm.SPARC.CodeGen

663+ GHC.CmmToAsm.SPARC.CodeGen.Amode GHC.CmmToAsm.SPARC.CodeGen.Base

664+ GHC.CmmToAsm.SPARC.CodeGen.CondCode

665+ GHC.CmmToAsm.SPARC.CodeGen.Expand GHC.CmmToAsm.SPARC.CodeGen.Gen32

666+ GHC.CmmToAsm.SPARC.CodeGen.Gen64 GHC.CmmToAsm.SPARC.CodeGen.Sanity

667+ GHC.CmmToAsm.SPARC.Cond GHC.CmmToAsm.SPARC.Imm

668+ GHC.CmmToAsm.SPARC.Instr GHC.CmmToAsm.SPARC.Ppr

669+ GHC.CmmToAsm.SPARC.Regs GHC.CmmToAsm.SPARC.ShortcutJump

670+ GHC.CmmToAsm.SPARC.Stack GHC.CmmToAsm.X86.CodeGen

671+ GHC.CmmToAsm.X86.Cond GHC.CmmToAsm.X86.Instr GHC.CmmToAsm.X86.Ppr

672+ GHC.CmmToAsm.X86.RegInfo GHC.CmmToAsm.X86.Regs GHC.CmmToC

673+ GHC.CmmToLlvm GHC.CmmToLlvm.Base GHC.CmmToLlvm.CodeGen

674+ GHC.CmmToLlvm.Data GHC.CmmToLlvm.Mangler GHC.CmmToLlvm.Ppr

675+ GHC.CmmToLlvm.Regs GHC.Core GHC.Core.Class GHC.Core.Coercion

676+ GHC.Core.Coercion.Axiom GHC.Core.Coercion.Opt GHC.Core.ConLike

677+ GHC.Core.DataCon GHC.Core.FVs GHC.Core.FamInstEnv GHC.Core.InstEnv

678+ GHC.Core.Lint GHC.Core.Make GHC.Core.Map GHC.Core.Multiplicity

679+ GHC.Core.Opt.Arity GHC.Core.Opt.CSE GHC.Core.Opt.CallArity

680+ GHC.Core.Opt.ConstantFold GHC.Core.Opt.CprAnal GHC.Core.Opt.DmdAnal

681+ GHC.Core.Opt.Exitify GHC.Core.Opt.FloatIn GHC.Core.Opt.FloatOut

682+ GHC.Core.Opt.LiberateCase GHC.Core.Opt.Monad GHC.Core.Opt.OccurAnal

683+ GHC.Core.Opt.Pipeline GHC.Core.Opt.SetLevels GHC.Core.Opt.Simplify

684+ GHC.Core.Opt.Simplify.Env GHC.Core.Opt.Simplify.Monad

685+ GHC.Core.Opt.Simplify.Utils GHC.Core.Opt.SpecConstr

686+ GHC.Core.Opt.Specialise GHC.Core.Opt.StaticArgs

687+ GHC.Core.Opt.WorkWrap GHC.Core.Opt.WorkWrap.Utils GHC.Core.PatSyn

688+ GHC.Core.Ppr GHC.Core.Ppr.TyThing GHC.Core.Predicate GHC.Core.Rules

689+ GHC.Core.Seq GHC.Core.SimpleOpt GHC.Core.Stats GHC.Core.Subst

690+ GHC.Core.Tidy GHC.Core.TyCo.FVs GHC.Core.TyCo.Ppr GHC.Core.TyCo.Rep

691+ GHC.Core.TyCo.Subst GHC.Core.TyCo.Tidy GHC.Core.TyCon GHC.Core.Type

692+ GHC.Core.Unfold GHC.Core.Unify GHC.Core.UsageEnv GHC.Core.Utils

693+ GHC.CoreToByteCode GHC.CoreToIface GHC.CoreToStg GHC.CoreToStg.Prep

694+ GHC.Data.Bag GHC.Data.Bitmap GHC.Data.BooleanFormula

695+ GHC.Data.EnumSet GHC.Data.FastMutInt GHC.Data.FastString

696+ GHC.Data.FastString.Env GHC.Data.FiniteMap GHC.Data.Graph.Base

697+ GHC.Data.Graph.Color GHC.Data.Graph.Directed GHC.Data.Graph.Ops

698+ GHC.Data.Graph.Ppr GHC.Data.Graph.UnVar GHC.Data.IOEnv

699+ GHC.Data.List.SetOps GHC.Data.Maybe GHC.Data.OrdList GHC.Data.Pair

700+ GHC.Data.Stream GHC.Data.StringBuffer GHC.Data.TrieMap

701+ GHC.Driver.Backend GHC.Driver.Backpack GHC.Driver.Backpack.Syntax

702+ GHC.Driver.CmdLine GHC.Driver.CodeOutput GHC.Driver.Finder

703+ GHC.Driver.Flags GHC.Driver.Hooks GHC.Driver.Main GHC.Driver.Make

704+ GHC.Driver.MakeFile GHC.Driver.Monad GHC.Driver.Phases

705+ GHC.Driver.Pipeline GHC.Driver.Pipeline.Monad GHC.Driver.Plugins

706+ GHC.Driver.Session GHC.Driver.Types GHC.Driver.Ways GHC.Hs

707+ GHC.Hs.Binds GHC.Hs.Decls GHC.Hs.Doc GHC.Hs.Dump GHC.Hs.Expr

708+ GHC.Hs.Extension GHC.Hs.ImpExp GHC.Hs.Instances GHC.Hs.Lit

709+ GHC.Hs.Pat GHC.Hs.Stats GHC.Hs.Type GHC.Hs.Utils GHC.HsToCore

710+ GHC.HsToCore.Arrows GHC.HsToCore.Binds GHC.HsToCore.Coverage

711+ GHC.HsToCore.Docs GHC.HsToCore.Expr GHC.HsToCore.Foreign.Call

712+ GHC.HsToCore.Foreign.Decl GHC.HsToCore.GuardedRHSs

713+ GHC.HsToCore.ListComp GHC.HsToCore.Match

714+ GHC.HsToCore.Match.Constructor GHC.HsToCore.Match.Literal

715+ GHC.HsToCore.Monad GHC.HsToCore.PmCheck GHC.HsToCore.PmCheck.Oracle

716+ GHC.HsToCore.PmCheck.Ppr GHC.HsToCore.PmCheck.Types

717+ GHC.HsToCore.Quote GHC.HsToCore.Usage GHC.HsToCore.Utils

718+ GHC.Iface.Binary GHC.Iface.Env GHC.Iface.Ext.Ast

719+ GHC.Iface.Ext.Binary GHC.Iface.Ext.Debug GHC.Iface.Ext.Types

720+ GHC.Iface.Ext.Utils GHC.Iface.Load GHC.Iface.Make GHC.Iface.Recomp

721+ GHC.Iface.Recomp.Binary GHC.Iface.Recomp.Flags GHC.Iface.Rename

722+ GHC.Iface.Syntax GHC.Iface.Tidy GHC.Iface.Tidy.StaticPtrTable

723+ GHC.Iface.Type GHC.Iface.UpdateIdInfos GHC.IfaceToCore GHC.Llvm

724+ GHC.Llvm.MetaData GHC.Llvm.Ppr GHC.Llvm.Syntax GHC.Llvm.Types

725+ GHC.Parser GHC.Parser.Annotation GHC.Parser.CharClass

726+ GHC.Parser.Header GHC.Parser.Lexer GHC.Parser.PostProcess

727+ GHC.Parser.PostProcess.Haddock GHC.Platform.AArch64

728+ GHC.Platform.ARM GHC.Platform.NoRegs GHC.Platform.PPC

729+ GHC.Platform.Reg GHC.Platform.Reg.Class GHC.Platform.Regs

730+ GHC.Platform.S390X GHC.Platform.SPARC GHC.Platform.X86

731+ GHC.Platform.X86_64 GHC.Plugins GHC.Prelude GHC.Rename.Bind

732+ GHC.Rename.Doc GHC.Rename.Env GHC.Rename.Expr GHC.Rename.Fixity

733+ GHC.Rename.HsType GHC.Rename.Module GHC.Rename.Names GHC.Rename.Pat

734+ GHC.Rename.Splice GHC.Rename.Unbound GHC.Rename.Utils

735+ GHC.Runtime.Debugger GHC.Runtime.Eval GHC.Runtime.Eval.Types

736+ GHC.Runtime.Heap.Inspect GHC.Runtime.Heap.Layout

737+ GHC.Runtime.Interpreter GHC.Runtime.Interpreter.Types

738+ GHC.Runtime.Linker GHC.Runtime.Linker.Types GHC.Runtime.Loader

739+ GHC.Settings GHC.Settings.Config GHC.Settings.Constants

740+ GHC.Settings.IO GHC.Stg.CSE GHC.Stg.DepAnal GHC.Stg.FVs

741+ GHC.Stg.Lift GHC.Stg.Lift.Analysis GHC.Stg.Lift.Monad GHC.Stg.Lint

742+ GHC.Stg.Pipeline GHC.Stg.Stats GHC.Stg.Subst GHC.Stg.Syntax

743+ GHC.Stg.Unarise GHC.StgToCmm GHC.StgToCmm.ArgRep GHC.StgToCmm.Bind

744+ GHC.StgToCmm.CgUtils GHC.StgToCmm.Closure GHC.StgToCmm.DataCon

745+ GHC.StgToCmm.Env GHC.StgToCmm.Expr GHC.StgToCmm.ExtCode

746+ GHC.StgToCmm.Foreign GHC.StgToCmm.Heap GHC.StgToCmm.Hpc

747+ GHC.StgToCmm.Layout GHC.StgToCmm.Monad GHC.StgToCmm.Prim

748+ GHC.StgToCmm.Prof GHC.StgToCmm.Ticky GHC.StgToCmm.Types

749+ GHC.StgToCmm.Utils GHC.SysTools GHC.SysTools.Ar

750+ GHC.SysTools.BaseDir GHC.SysTools.Elf GHC.SysTools.ExtraObj

751+ GHC.SysTools.FileCleanup GHC.SysTools.Info GHC.SysTools.Process

752+ GHC.SysTools.Tasks GHC.SysTools.Terminal GHC.Tc.Deriv

753+ GHC.Tc.Deriv.Functor GHC.Tc.Deriv.Generate GHC.Tc.Deriv.Generics

754+ GHC.Tc.Deriv.Infer GHC.Tc.Deriv.Utils GHC.Tc.Errors

755+ GHC.Tc.Errors.Hole GHC.Tc.Errors.Hole.FitTypes

756+ GHC.Tc.Gen.Annotation GHC.Tc.Gen.Arrow GHC.Tc.Gen.Bind

757+ GHC.Tc.Gen.Default GHC.Tc.Gen.Export GHC.Tc.Gen.Expr

758+ GHC.Tc.Gen.Foreign GHC.Tc.Gen.HsType GHC.Tc.Gen.Match

759+ GHC.Tc.Gen.Pat GHC.Tc.Gen.Rule GHC.Tc.Gen.Sig GHC.Tc.Gen.Splice

760+ GHC.Tc.Instance.Class GHC.Tc.Instance.Family

761+ GHC.Tc.Instance.FunDeps GHC.Tc.Instance.Typeable GHC.Tc.Module

762+ GHC.Tc.Plugin GHC.Tc.Solver GHC.Tc.Solver.Canonical

763+ GHC.Tc.Solver.Flatten GHC.Tc.Solver.Interact GHC.Tc.Solver.Monad

764+ GHC.Tc.TyCl GHC.Tc.TyCl.Build GHC.Tc.TyCl.Class

765+ GHC.Tc.TyCl.Instance GHC.Tc.TyCl.PatSyn GHC.Tc.TyCl.Utils

766+ GHC.Tc.Types GHC.Tc.Types.Constraint GHC.Tc.Types.EvTerm

767+ GHC.Tc.Types.Evidence GHC.Tc.Types.Origin GHC.Tc.Utils.Backpack

768+ GHC.Tc.Utils.Env GHC.Tc.Utils.Instantiate GHC.Tc.Utils.Monad

769+ GHC.Tc.Utils.TcMType GHC.Tc.Utils.TcType GHC.Tc.Utils.Unify

770+ GHC.Tc.Utils.Zonk GHC.Tc.Validity GHC.ThToHs GHC.Types.Annotations

771+ GHC.Types.Avail GHC.Types.Basic GHC.Types.CostCentre

772+ GHC.Types.CostCentre.State GHC.Types.Cpr GHC.Types.Demand

773+ GHC.Types.FieldLabel GHC.Types.ForeignCall GHC.Types.Id

774+ GHC.Types.Id.Info GHC.Types.Id.Make GHC.Types.Literal

775+ GHC.Types.Name GHC.Types.Name.Cache GHC.Types.Name.Env

776+ GHC.Types.Name.Occurrence GHC.Types.Name.Reader GHC.Types.Name.Set

777+ GHC.Types.Name.Shape GHC.Types.RepType GHC.Types.SrcLoc

778+ GHC.Types.Unique GHC.Types.Unique.DFM GHC.Types.Unique.DSet

779+ GHC.Types.Unique.FM GHC.Types.Unique.Set GHC.Types.Unique.Supply

780+ GHC.Types.Var GHC.Types.Var.Env GHC.Types.Var.Set GHC.Unit

781+ GHC.Unit.Info GHC.Unit.Module GHC.Unit.Module.Env

782+ GHC.Unit.Module.Location GHC.Unit.Module.Name GHC.Unit.Parser

783+ GHC.Unit.Ppr GHC.Unit.State GHC.Unit.Types GHC.Utils.Asm

784+ GHC.Utils.Binary GHC.Utils.BufHandle GHC.Utils.CliOption

785+ GHC.Utils.Encoding GHC.Utils.Error GHC.Utils.Exception GHC.Utils.FV

786+ GHC.Utils.Fingerprint GHC.Utils.IO.Unsafe GHC.Utils.Json

787+ GHC.Utils.Lexeme GHC.Utils.Misc GHC.Utils.Monad

788+ GHC.Utils.Monad.State GHC.Utils.Outputable GHC.Utils.Panic

789+ GHC.Utils.Panic.Plain GHC.Utils.Ppr GHC.Utils.Ppr.Colour

790+import-dirs:

791+library-dirs:

792+dynamic-library-dirs:

793+data-dir:

794+hs-libraries: HSghc-9.0.1

795+include-dirs:

796+depends:

797+ array-0.5.4.0 base-4.15.0.0 binary-0.8.8.0 bytestring-0.10.12.1

798+ containers-0.6.4.1 deepseq-1.4.5.0 directory-1.3.6.1

799+ exceptions-0.10.4 filepath-1.4.2.1 ghc-boot-9.0.1 ghc-boot-th-9.0.1

800+ ghc-heap-9.0.1 ghci-9.0.1 hpc-0.6.1.0 process-1.6.11.0

801+ template-haskell-2.17.0.0 terminfo-0.4.1.4 time-1.9.3

802+ transformers-0.5.6.2 unix-2.7.2.2

803+haddock-interfaces:

804+haddock-html:

805+---

806+name: ghc-bignum

807+version: 1.0

808+visibility: public

809+id: ghc-bignum-1.0

810+key: ghc-bignum-1.0

811+license: BSD-3-Clause

812+maintainer: libraries@haskell.org

813+author: Sylvain Henry

814+synopsis: GHC BigNum library

815+description:

816+ This package provides the low-level implementation of the standard

817+ 'BigNat', 'Natural' and 'Integer' types.

818+category: Numeric, Algebra, GHC

819+exposed: True

820+exposed-modules:

821+ GHC.Num.Backend GHC.Num.Backend.Native GHC.Num.Backend.Selected

822+ GHC.Num.BigNat GHC.Num.Integer GHC.Num.Natural GHC.Num.Primitives

823+ GHC.Num.WordArray

824+hidden-modules: GHC.Num.Backend.GMP

825+import-dirs:

826+library-dirs:

827+dynamic-library-dirs:

828+data-dir:

829+hs-libraries: HSghc-bignum-1.0

830+extra-libraries: gmp

831+include-dirs:

832+depends: ghc-prim-0.7.0

833+haddock-interfaces:

834+haddock-html:

835+---

836+name: ghc-boot

837+version: 9.0.1

838+visibility: public

839+id: ghc-boot-9.0.1

840+key: ghc-boot-9.0.1

841+license: BSD-3-Clause

842+maintainer: ghc-devs@haskell.org

843+synopsis: Shared functionality between GHC and its boot libraries

844+description:

845+ This library is shared between GHC, ghc-pkg, and other boot

846+ libraries.

847+ A note about "GHC.Unit.Database": it only deals with the subset of

848+ the package database that the compiler cares about: modules

849+ paths etc and not package metadata like description, authors

850+ etc. It is thus not a library interface to ghc-pkg and is *not*

851+ suitable for modifying GHC package databases.

852+ The package database format and this library are constructed in

853+ such a way that while ghc-pkg depends on Cabal, the GHC library

854+ and program do not have to depend on Cabal.

855+category: GHC

856+exposed: True

857+exposed-modules:

858+ GHC.BaseDir GHC.ForeignSrcLang GHC.HandleEncoding

859+ GHC.LanguageExtensions GHC.Platform GHC.Platform.Host

860+ GHC.Serialized GHC.Settings.Platform GHC.Settings.Utils

861+ GHC.UniqueSubdir GHC.Unit.Database GHC.Version

862+import-dirs:

863+library-dirs:

864+dynamic-library-dirs:

865+data-dir:

866+hs-libraries: HSghc-boot-9.0.1

867+depends:

868+ base-4.15.0.0 binary-0.8.8.0 bytestring-0.10.12.1

869+ containers-0.6.4.1 directory-1.3.6.1 filepath-1.4.2.1

870+ ghc-boot-th-9.0.1

871+haddock-interfaces:

872+haddock-html:

873+---

874+name: ghc-boot-th

875+version: 9.0.1

876+visibility: public

877+id: ghc-boot-th-9.0.1

878+key: ghc-boot-th-9.0.1

879+license: BSD-3-Clause

880+maintainer: ghc-devs@haskell.org

881+synopsis:

882+ Shared functionality between GHC and the @template-haskell@

883+ library

884+description:

885+ This library contains various bits shared between the @ghc@ and

886+ @template-haskell@ libraries.

887+ This package exists to ensure that @template-haskell@ has a

888+ minimal set of transitive dependencies, since it is intended to

889+ be depended upon by user code.

890+category: GHC

891+exposed: True

892+exposed-modules:

893+ GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme

894+import-dirs:

895+library-dirs:

896+dynamic-library-dirs:

897+data-dir:

898+hs-libraries: HSghc-boot-th-9.0.1

899+depends: base-4.15.0.0

900+haddock-interfaces:

901+haddock-html:

902+---

903+name: ghc-compact

904+version: 0.1.0.0

905+visibility: public

906+id: ghc-compact-0.1.0.0

907+key: ghc-compact-0.1.0.0

908+license: BSD-3-Clause

909+maintainer: libraries@haskell.org

910+synopsis: In memory storage of deeply evaluated data structure

911+description:

912+ This package provides minimal functionality for working with

913+ "compact regions", which hold a fully evaluated Haskell object graph.

914+ These regions maintain the invariant that no pointers live inside the struct

915+ that point outside it, which ensures efficient garbage collection without

916+ ever reading the structure contents (effectively, it works as a manually

917+ managed "oldest generation" which is never freed until the whole is

918+ released).

919+ Internally, the struct is stored a single contiguous block of memory,

920+ which allows efficient serialization and deserialization of structs

921+ for distributed computing.

922+category: Data

923+exposed: True

924+exposed-modules: GHC.Compact GHC.Compact.Serialized

925+import-dirs:

926+library-dirs:

927+dynamic-library-dirs:

928+data-dir:

929+hs-libraries: HSghc-compact-0.1.0.0

930+depends: base-4.15.0.0 bytestring-0.10.12.1 ghc-prim-0.7.0

931+haddock-interfaces:

932+haddock-html:

933+---

934+name: ghc-heap

935+version: 9.0.1

936+visibility: public

937+id: ghc-heap-9.0.1

938+key: ghc-heap-9.0.1

939+license: BSD-3-Clause

940+maintainer: libraries@haskell.org

941+synopsis: Functions for walking GHC's heap

942+description:

943+ This package provides functions for walking the GHC heap data structures

944+ and retrieving information about those data structures.

945+category: GHC

946+exposed: True

947+exposed-modules:

948+ GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures

949+ GHC.Exts.Heap.Constants GHC.Exts.Heap.InfoTable

950+ GHC.Exts.Heap.InfoTable.Types GHC.Exts.Heap.InfoTableProf

951+ GHC.Exts.Heap.Utils

952+import-dirs:

953+library-dirs:

954+dynamic-library-dirs:

955+data-dir:

956+hs-libraries: HSghc-heap-9.0.1

957+depends: base-4.15.0.0 ghc-prim-0.7.0 rts

958+haddock-interfaces:

959+haddock-html:

960+---

961+name: ghc-prim

962+version: 0.7.0

963+visibility: public

964+id: ghc-prim-0.7.0

965+key: ghc-prim-0.7.0

966+license: BSD-3-Clause

967+maintainer: libraries@haskell.org

968+synopsis: GHC primitives

969+description:

970+ This package contains the primitive types and operations supplied by GHC.

971+category: GHC

972+exposed: True

973+exposed-modules:

974+ GHC.CString GHC.Classes GHC.Debug GHC.IntWord64 GHC.Magic

975+ GHC.Prim.Exception GHC.Prim.Ext GHC.Prim.Panic GHC.PrimopWrappers

976+ GHC.Tuple GHC.Types GHC.Prim

977+import-dirs:

978+library-dirs:

979+dynamic-library-dirs:

980+data-dir:

981+hs-libraries: HSghc-prim-0.7.0

982+extra-libraries: gcc c m

983+depends: rts

984+haddock-interfaces:

985+haddock-html:

986+---

987+name: ghci

988+version: 9.0.1

989+visibility: public

990+id: ghci-9.0.1

991+key: ghci-9.0.1

992+license: BSD-3-Clause

993+maintainer: ghc-devs@haskell.org

994+synopsis: The library supporting GHC's interactive interpreter

995+description:

996+ This library offers interfaces which mediate interactions between the

997+ @ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter

998+ backend.

999+category: GHC

1000+exposed: True

1001+exposed-modules:

1002+ GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI

1003+ GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes

1004+ GHCi.ResolvedBCO GHCi.Run GHCi.Signals GHCi.StaticPtrTable GHCi.TH

1005+ GHCi.TH.Binary SizedSeq

1006+import-dirs:

1007+library-dirs:

1008+dynamic-library-dirs:

1009+data-dir:

1010+hs-libraries: HSghci-9.0.1

1011+include-dirs:

1012+depends:

1013+ array-0.5.4.0 base-4.15.0.0 binary-0.8.8.0 bytestring-0.10.12.1

1014+ containers-0.6.4.1 deepseq-1.4.5.0 filepath-1.4.2.1 ghc-boot-9.0.1

1015+ ghc-boot-th-9.0.1 ghc-heap-9.0.1 template-haskell-2.17.0.0

1016+ transformers-0.5.6.2 unix-2.7.2.2

1017+haddock-interfaces:

1018+haddock-html:

1019+---

1020+name: haskeline

1021+version: 0.8.1.0

1022+visibility: public

1023+id: haskeline-0.8.1.0

1024+key: haskeline-0.8.1.0

1025+license: BSD-3-Clause

1026+copyright: (c) Judah Jacobson

1027+maintainer: Judah Jacobson <judah.jacobson@gmail.com>

1028+author: Judah Jacobson

1029+stability: Stable

1030+homepage: https://github.com/judah/haskeline

1031+synopsis:

1032+ A command-line interface for user input, written in Haskell.

1033+description:

1034+ Haskeline provides a user interface for line input in command-line

1035+ programs. This library is similar in purpose to readline, but since

1036+ it is written in Haskell it is (hopefully) more easily used in other

1037+ Haskell programs.

1038+ Haskeline runs both on POSIX-compatible systems and on Windows.

1039+category: User Interfaces

1040+exposed: True

1041+exposed-modules:

1042+ System.Console.Haskeline System.Console.Haskeline.Completion

1043+ System.Console.Haskeline.History System.Console.Haskeline.IO

1044+ System.Console.Haskeline.Internal

1045+hidden-modules:

1046+ System.Console.Haskeline.Backend

1047+ System.Console.Haskeline.Backend.WCWidth

1048+ System.Console.Haskeline.Command

1049+ System.Console.Haskeline.Command.Completion

1050+ System.Console.Haskeline.Command.History

1051+ System.Console.Haskeline.Command.KillRing

1052+ System.Console.Haskeline.Directory System.Console.Haskeline.Emacs

1053+ System.Console.Haskeline.InputT System.Console.Haskeline.Key

1054+ System.Console.Haskeline.LineState System.Console.Haskeline.Monads

1055+ System.Console.Haskeline.Prefs System.Console.Haskeline.Recover

1056+ System.Console.Haskeline.RunCommand System.Console.Haskeline.Term

1057+ System.Console.Haskeline.Command.Undo System.Console.Haskeline.Vi

1058+ System.Console.Haskeline.Backend.Posix

1059+ System.Console.Haskeline.Backend.Posix.Encoder

1060+ System.Console.Haskeline.Backend.DumbTerm

1061+ System.Console.Haskeline.Backend.Terminfo

1062+import-dirs:

1063+library-dirs:

1064+dynamic-library-dirs:

1065+data-dir:

1066+hs-libraries: HShaskeline-0.8.1.0

1067+depends:

1068+ base-4.15.0.0 bytestring-0.10.12.1 containers-0.6.4.1

1069+ directory-1.3.6.1 exceptions-0.10.4 filepath-1.4.2.1

1070+ process-1.6.11.0 stm-2.5.0.0 terminfo-0.4.1.4 transformers-0.5.6.2

1071+ unix-2.7.2.2

1072+haddock-interfaces:

1073+haddock-html:

1074+---

1075+name: hpc

1076+version: 0.6.1.0

1077+visibility: public

1078+id: hpc-0.6.1.0

1079+key: hpc-0.6.1.0

1080+license: BSD-3-Clause

1081+maintainer: ghc-devs@haskell.org

1082+author: Andy Gill

1083+synopsis: Code Coverage Library for Haskell

1084+description:

1085+ This package provides the code coverage library for Haskell.

1086+ See <http://www.haskell.org/haskellwiki/Haskell_program_coverage> for more

1087+ information.

1088+category: Control

1089+exposed: True

1090+exposed-modules:

1091+ Trace.Hpc.Mix Trace.Hpc.Reflect Trace.Hpc.Tix Trace.Hpc.Util

1092+import-dirs:

1093+library-dirs:

1094+dynamic-library-dirs:

1095+data-dir:

1096+hs-libraries: HShpc-0.6.1.0

1097+depends:

1098+ base-4.15.0.0 containers-0.6.4.1 deepseq-1.4.5.0 directory-1.3.6.1

1099+ filepath-1.4.2.1 time-1.9.3

1100+haddock-interfaces:

1101+haddock-html:

1102+---

1103+name: integer-gmp

1104+version: 1.1

1105+visibility: public

1106+id: integer-gmp-1.1

1107+key: integer-gmp-1.1

1108+license: BSD-3-Clause

1109+maintainer: hvr@gnu.org

1110+author: Herbert Valerio Riedel

1111+synopsis: Integer library based on GMP

1112+description:

1113+ This package used to provide an implementation of the standard 'Integer'

1114+ type based on the

1115+ <http://gmplib.org/ GNU Multiple Precision Arithmetic Library (GMP)>.

1116+ It is now deprecated in favor of the 'ghc-bignum' package.

1117+ Its purpose is to provide backward compatibility for codes directly

1118+ depending on the `integer-gmp` package.

1119+category: Numeric, Algebra

1120+exposed: True

1121+exposed-modules: GHC.Integer.GMP.Internals

1122+import-dirs:

1123+library-dirs:

1124+dynamic-library-dirs:

1125+data-dir:

1126+hs-libraries: HSinteger-gmp-1.1

1127+depends: base-4.15.0.0 ghc-bignum-1.0 ghc-prim-0.7.0

1128+haddock-interfaces:

1129+haddock-html:

1130+---

1131+name: libiserv

1132+version: 9.0.1

1133+visibility: public

1134+id: libiserv-9.0.1

1135+key: libiserv-9.0.1

1136+license: BSD-3-Clause

1137+copyright: XXX

1138+maintainer: XXX

1139+author: XXX

1140+synopsis: Provides shared functionality between iserv and iserv-proxy

1141+category: Development

1142+exposed: True

1143+exposed-modules: GHCi.Utils Lib

1144+import-dirs:

1145+library-dirs:

1146+dynamic-library-dirs:

1147+data-dir:

1148+hs-libraries: HSlibiserv-9.0.1

1149+depends:

1150+ base-4.15.0.0 binary-0.8.8.0 bytestring-0.10.12.1

1151+ containers-0.6.4.1 deepseq-1.4.5.0 ghci-9.0.1 unix-2.7.2.2

1152+haddock-interfaces:

1153+haddock-html:

1154+---

1155+name: mtl

1156+version: 2.2.2

1157+visibility: public

1158+id: mtl-2.2.2

1159+key: mtl-2.2.2

1160+license: BSD-3-Clause

1161+maintainer: Edward Kmett <ekmett@gmail.com>

1162+author: Andy Gill

1163+homepage: http://github.com/haskell/mtl

1164+synopsis: Monad classes, using functional dependencies

1165+description:

1166+ Monad classes using functional dependencies, with instances

1167+ for various monad transformers, inspired by the paper

1168+ /Functional Programming with Overloading and Higher-Order Polymorphism/,

1169+ by Mark P Jones, in /Advanced School of Functional Programming/, 1995

1170+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1171+category: Control

1172+exposed: True

1173+exposed-modules:

1174+ Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error

1175+ Control.Monad.Error.Class Control.Monad.Except

1176+ Control.Monad.Identity Control.Monad.List Control.Monad.RWS

1177+ Control.Monad.RWS.Class Control.Monad.RWS.Lazy

1178+ Control.Monad.RWS.Strict Control.Monad.Reader

1179+ Control.Monad.Reader.Class Control.Monad.State

1180+ Control.Monad.State.Class Control.Monad.State.Lazy

1181+ Control.Monad.State.Strict Control.Monad.Trans Control.Monad.Writer

1182+ Control.Monad.Writer.Class Control.Monad.Writer.Lazy

1183+ Control.Monad.Writer.Strict

1184+import-dirs:

1185+library-dirs:

1186+dynamic-library-dirs:

1187+data-dir:

1188+hs-libraries: HSmtl-2.2.2

1189+depends: base-4.15.0.0 transformers-0.5.6.2

1190+haddock-interfaces:

1191+haddock-html:

1192+---

1193+name: parsec

1194+version: 3.1.14.0

1195+visibility: public

1196+id: parsec-3.1.14.0

1197+key: parsec-3.1.14.0

1198+license: BSD-3-Clause

1199+maintainer: Herbert Valerio Riedel <hvr@gnu.org>

1200+author:

1201+ Daan Leijen <daan@microsoft.com>, Paolo Martini <paolo@nemail.it>, Antoine Latter <aslatter@gmail.com>

1202+homepage: https://github.com/haskell/parsec

1203+synopsis: Monadic parser combinators

1204+description:

1205+ Parsec is designed from scratch as an industrial-strength parser

1206+ library. It is simple, safe, well documented (on the package

1207+ homepage), has extensive libraries, good error messages,

1208+ and is fast. It is defined as a monad transformer that can be

1209+ stacked on arbitrary monads, and it is also parametric in the

1210+ input stream type.

1211+ The main entry point is the "Text.Parsec" module which provides

1212+ defaults for parsing 'Char'acter data.

1213+ The "Text.ParserCombinators.Parsec" module hierarchy contains

1214+ the legacy @parsec-2@ API and may be removed at some point in

1215+ the future.

1216+category: Parsing

1217+exposed: True

1218+exposed-modules:

1219+ Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy

1220+ Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error

1221+ Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm

1222+ Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String

1223+ Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token

1224+ Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char

1225+ Text.ParserCombinators.Parsec.Combinator

1226+ Text.ParserCombinators.Parsec.Error

1227+ Text.ParserCombinators.Parsec.Expr

1228+ Text.ParserCombinators.Parsec.Language

1229+ Text.ParserCombinators.Parsec.Perm

1230+ Text.ParserCombinators.Parsec.Pos

1231+ Text.ParserCombinators.Parsec.Prim

1232+ Text.ParserCombinators.Parsec.Token

1233+import-dirs:

1234+library-dirs:

1235+dynamic-library-dirs:

1236+data-dir:

1237+hs-libraries: HSparsec-3.1.14.0

1238+depends:

1239+ base-4.15.0.0 bytestring-0.10.12.1 mtl-2.2.2 text-1.2.4.1

1240+haddock-interfaces:

1241+haddock-html:

1242+---

1243+name: pretty

1244+version: 1.1.3.6

1245+visibility: public

1246+id: pretty-1.1.3.6

1247+key: pretty-1.1.3.6

1248+license: BSD-3-Clause

1249+maintainer: David Terei <code@davidterei.com>

1250+stability: Stable

1251+homepage: http://github.com/haskell/pretty

1252+synopsis: Pretty-printing library

1253+description:

1254+ This package contains a pretty-printing library, a set of API's

1255+ that provides a way to easily print out text in a consistent

1256+ format of your choosing. This is useful for compilers and related

1257+ tools.

1258+ This library was originally designed by John Hughes's and has since

1259+ been heavily modified by Simon Peyton Jones.

1260+category: Text

1261+exposed: True

1262+exposed-modules:

1263+ Text.PrettyPrint Text.PrettyPrint.Annotated

1264+ Text.PrettyPrint.Annotated.HughesPJ

1265+ Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ

1266+ Text.PrettyPrint.HughesPJClass

1267+import-dirs:

1268+library-dirs:

1269+dynamic-library-dirs:

1270+data-dir:

1271+hs-libraries: HSpretty-1.1.3.6

1272+depends: base-4.15.0.0 deepseq-1.4.5.0 ghc-prim-0.7.0

1273+haddock-interfaces:

1274+haddock-html:

1275+---

1276+name: process

1277+version: 1.6.11.0

1278+visibility: public

1279+id: process-1.6.11.0

1280+key: process-1.6.11.0

1281+license: BSD-3-Clause

1282+maintainer: libraries@haskell.org

1283+synopsis: Process libraries

1284+description:

1285+ This package contains libraries for dealing with system processes.

1286+ The typed-process package is a more recent take on a process API,

1287+ which uses this package internally. It features better binary

1288+ support, easier concurrency, and a more composable API. You can

1289+ read more about it at

1290+ <https://github.com/fpco/typed-process/#readme>.

1291+category: System

1292+exposed: True

1293+exposed-modules: System.Cmd System.Process System.Process.Internals

1294+hidden-modules: System.Process.Common System.Process.Posix

1295+import-dirs:

1296+library-dirs:

1297+dynamic-library-dirs:

1298+data-dir:

1299+hs-libraries: HSprocess-1.6.11.0

1300+include-dirs:

1301+includes: runProcess.h

1302+depends:

1303+ base-4.15.0.0 deepseq-1.4.5.0 directory-1.3.6.1 filepath-1.4.2.1

1304+ unix-2.7.2.2

1305+haddock-interfaces:

1306+haddock-html:

1307+---

1308+name: stm

1309+version: 2.5.0.0

1310+visibility: public

1311+id: stm-2.5.0.0

1312+key: stm-2.5.0.0

1313+license: BSD-3-Clause

1314+maintainer: libraries@haskell.org

1315+homepage: https://wiki.haskell.org/Software_transactional_memory

1316+synopsis: Software Transactional Memory

1317+description:

1318+ Software Transactional Memory, or STM, is an abstraction for

1319+ concurrent communication. The main benefits of STM are

1320+ /composability/ and /modularity/. That is, using STM you can write

1321+ concurrent abstractions that can be easily composed with any other

1322+ abstraction built using STM, without exposing the details of how

1323+ your abstraction ensures safety. This is typically not the case

1324+ with other forms of concurrent communication, such as locks or

1325+ 'MVar's.

1326+category: Concurrency

1327+exposed: True

1328+exposed-modules:

1329+ Control.Concurrent.STM Control.Concurrent.STM.TArray

1330+ Control.Concurrent.STM.TBQueue Control.Concurrent.STM.TChan

1331+ Control.Concurrent.STM.TMVar Control.Concurrent.STM.TQueue

1332+ Control.Concurrent.STM.TSem Control.Concurrent.STM.TVar

1333+ Control.Monad.STM

1334+hidden-modules: Control.Sequential.STM

1335+import-dirs:

1336+library-dirs:

1337+dynamic-library-dirs:

1338+data-dir:

1339+hs-libraries: HSstm-2.5.0.0

1340+depends: array-0.5.4.0 base-4.15.0.0

1341+haddock-interfaces:

1342+haddock-html:

1343+---

1344+name: template-haskell

1345+version: 2.17.0.0

1346+visibility: public

1347+id: template-haskell-2.17.0.0

1348+key: template-haskell-2.17.0.0

1349+license: BSD-3-Clause

1350+maintainer: libraries@haskell.org

1351+synopsis: Support library for Template Haskell

1352+description:

1353+ This package provides modules containing facilities for manipulating

1354+ Haskell source code using Template Haskell.

1355+ See <http://www.haskell.org/haskellwiki/Template_Haskell> for more

1356+ information.

1357+category: Template Haskell

1358+exposed: True

1359+exposed-modules:

1360+ Language.Haskell.TH Language.Haskell.TH.CodeDo

1361+ Language.Haskell.TH.LanguageExtensions Language.Haskell.TH.Lib

1362+ Language.Haskell.TH.Lib.Internal Language.Haskell.TH.Ppr

1363+ Language.Haskell.TH.PprLib Language.Haskell.TH.Quote

1364+ Language.Haskell.TH.Syntax

1365+hidden-modules: Language.Haskell.TH.Lib.Map

1366+import-dirs:

1367+library-dirs:

1368+dynamic-library-dirs:

1369+data-dir:

1370+hs-libraries: HStemplate-haskell-2.17.0.0

1371+depends:

1372+ base-4.15.0.0 ghc-boot-th-9.0.1 ghc-prim-0.7.0 pretty-1.1.3.6

1373+haddock-interfaces:

1374+haddock-html:

1375+---

1376+name: terminfo

1377+version: 0.4.1.4

1378+visibility: public

1379+id: terminfo-0.4.1.4

1380+key: terminfo-0.4.1.4

1381+license: BSD-3-Clause

1382+copyright: (c) Judah Jacobson

1383+maintainer: Judah Jacobson <judah.jacobson@gmail.com>

1384+author: Judah Jacobson

1385+stability: Stable

1386+homepage: https://github.com/judah/terminfo

1387+synopsis: Haskell bindings to the terminfo library.

1388+description:

1389+ This library provides an interface to the terminfo database (via bindings to the

1390+ curses library). <http://en.wikipedia.org/wiki/Terminfo Terminfo> allows POSIX

1391+ systems to interact with a variety of terminals using a standard set of capabilities.

1392+category: User Interfaces

1393+exposed: True

1394+exposed-modules:

1395+ System.Console.Terminfo System.Console.Terminfo.Base

1396+ System.Console.Terminfo.Color System.Console.Terminfo.Cursor

1397+ System.Console.Terminfo.Edit System.Console.Terminfo.Effects

1398+ System.Console.Terminfo.Keys

1399+import-dirs:

1400+library-dirs:

1401+dynamic-library-dirs:

1402+data-dir:

1403+hs-libraries: HSterminfo-0.4.1.4

1404+extra-libraries: tinfo

1405+depends: base-4.15.0.0

1406+haddock-interfaces:

1407+haddock-html:

1408+---

1409+name: text

1410+version: 1.2.4.1

1411+visibility: public

1412+id: text-1.2.4.1

1413+key: text-1.2.4.1

1414+license: BSD-2-Clause

1415+copyright: 2009-2011 Bryan O'Sullivan, 2008-2009 Tom Harper

1416+maintainer:

1417+ Bryan O'Sullivan <bos@serpentine.com>, Herbert Valerio Riedel <hvr@gnu.org>

1418+author: Bryan O'Sullivan <bos@serpentine.com>

1419+homepage: https://github.com/haskell/text

1420+synopsis: An efficient packed Unicode text type.

1421+description:

1422+ An efficient packed, immutable Unicode text type (both strict and

1423+ lazy), with a powerful loop fusion optimization framework.

1424+ The 'Text' type represents Unicode character strings, in a time and

1425+ space-efficient manner. This package provides text processing

1426+ capabilities that are optimized for performance critical use, both

1427+ in terms of large data quantities and high speed.

1428+ The 'Text' type provides character-encoding, type-safe case

1429+ conversion via whole-string case conversion functions (see "Data.Text").

1430+ It also provides a range of functions for converting 'Text' values to

1431+ and from 'ByteStrings', using several standard encodings

1432+ (see "Data.Text.Encoding").

1433+ Efficient locale-sensitive support for text IO is also supported

1434+ (see "Data.Text.IO").

1435+ These modules are intended to be imported qualified, to avoid name

1436+ clashes with Prelude functions, e.g.

1437+ > import qualified Data.Text as T

1438+ == ICU Support

1439+ To use an extended and very rich family of functions for working

1440+ with Unicode text (including normalization, regular expressions,

1441+ non-standard encodings, text breaking, and locales), see

1442+ the [text-icu package](https://hackage.haskell.org/package/text-icu)

1443+ based on the well-respected and liberally

1444+ licensed [ICU library](http://site.icu-project.org/).

1445+ == Internal Representation: UTF-16 vs. UTF-8

1446+ Currently the @text@ library uses UTF-16 as its internal representation

1447+ which is [neither a fixed-width nor always the most dense representation](http://utf8everywhere.org/)

1448+ for Unicode text. We're currently investigating the feasibility

1449+ of [changing Text's internal representation to UTF-8](https://github.com/text-utf8)

1450+ and if you need such a 'Text' type right now you might be interested in using the spin-off

1451+ packages <https://hackage.haskell.org/package/text-utf8 text-utf8> and

1452+ <https://hackage.haskell.org/package/text-short text-short>.

1453+category: Data, Text

1454+exposed: True

1455+exposed-modules:

1456+ Data.Text Data.Text.Array Data.Text.Encoding

1457+ Data.Text.Encoding.Error Data.Text.Foreign Data.Text.IO

1458+ Data.Text.Internal Data.Text.Internal.Builder

1459+ Data.Text.Internal.Builder.Functions

1460+ Data.Text.Internal.Builder.Int.Digits

1461+ Data.Text.Internal.Builder.RealFloat.Functions

1462+ Data.Text.Internal.ByteStringCompat

1463+ Data.Text.Internal.Encoding.Fusion

1464+ Data.Text.Internal.Encoding.Fusion.Common

1465+ Data.Text.Internal.Encoding.Utf16 Data.Text.Internal.Encoding.Utf32

1466+ Data.Text.Internal.Encoding.Utf8 Data.Text.Internal.Functions

1467+ Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping

1468+ Data.Text.Internal.Fusion.Common Data.Text.Internal.Fusion.Size

1469+ Data.Text.Internal.Fusion.Types Data.Text.Internal.IO

1470+ Data.Text.Internal.Lazy Data.Text.Internal.Lazy.Encoding.Fusion

1471+ Data.Text.Internal.Lazy.Fusion Data.Text.Internal.Lazy.Search

1472+ Data.Text.Internal.Private Data.Text.Internal.Read

1473+ Data.Text.Internal.Search Data.Text.Internal.Unsafe

1474+ Data.Text.Internal.Unsafe.Char Data.Text.Internal.Unsafe.Shift

1475+ Data.Text.Lazy Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int

1476+ Data.Text.Lazy.Builder.RealFloat Data.Text.Lazy.Encoding

1477+ Data.Text.Lazy.IO Data.Text.Lazy.Internal Data.Text.Lazy.Read

1478+ Data.Text.Read Data.Text.Unsafe

1479+hidden-modules: Data.Text.Show

1480+import-dirs:

1481+library-dirs:

1482+dynamic-library-dirs:

1483+data-dir:

1484+hs-libraries: HStext-1.2.4.1

1485+depends:

1486+ array-0.5.4.0 base-4.15.0.0 binary-0.8.8.0 bytestring-0.10.12.1

1487+ deepseq-1.4.5.0 ghc-bignum-1.0 ghc-prim-0.7.0

1488+ template-haskell-2.17.0.0

1489+haddock-interfaces:

1490+haddock-html:

1491+---

1492+name: time

1493+version: 1.9.3

1494+visibility: public

1495+id: time-1.9.3

1496+key: time-1.9.3

1497+license: BSD-3-Clause

1498+maintainer: <ashley@semantic.org>

1499+author: Ashley Yakeley

1500+stability: stable

1501+homepage: https://github.com/haskell/time

1502+synopsis: A time library

1503+description: Time, clocks and calendars

1504+category: Time

1505+exposed: True

1506+exposed-modules:

1507+ Data.Time Data.Time.Calendar Data.Time.Calendar.Easter

1508+ Data.Time.Calendar.Julian Data.Time.Calendar.MonthDay

1509+ Data.Time.Calendar.OrdinalDate Data.Time.Calendar.WeekDate

1510+ Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System

1511+ Data.Time.Clock.TAI Data.Time.Format Data.Time.Format.ISO8601

1512+ Data.Time.Format.Internal Data.Time.LocalTime

1513+hidden-modules:

1514+ Data.Format Data.Time.Calendar.Private Data.Time.Calendar.Days

1515+ Data.Time.Calendar.Gregorian Data.Time.Calendar.CalendarDiffDays

1516+ Data.Time.Calendar.Week Data.Time.Calendar.JulianYearDay

1517+ Data.Time.Clock.Internal.DiffTime

1518+ Data.Time.Clock.Internal.AbsoluteTime

1519+ Data.Time.Clock.Internal.NominalDiffTime

1520+ Data.Time.Clock.Internal.POSIXTime

1521+ Data.Time.Clock.Internal.UniversalTime

1522+ Data.Time.Clock.Internal.SystemTime

1523+ Data.Time.Clock.Internal.UTCTime Data.Time.Clock.Internal.CTimeval

1524+ Data.Time.Clock.Internal.CTimespec Data.Time.Clock.Internal.UTCDiff

1525+ Data.Time.LocalTime.Internal.TimeZone

1526+ Data.Time.LocalTime.Internal.TimeOfDay

1527+ Data.Time.LocalTime.Internal.CalendarDiffTime

1528+ Data.Time.LocalTime.Internal.LocalTime

1529+ Data.Time.LocalTime.Internal.ZonedTime Data.Time.Format.Parse

1530+ Data.Time.Format.Locale Data.Time.Format.Format.Class

1531+ Data.Time.Format.Format.Instances Data.Time.Format.Parse.Class

1532+ Data.Time.Format.Parse.Instances

1533+import-dirs:

1534+library-dirs:

1535+dynamic-library-dirs:

1536+data-dir:

1537+hs-libraries: HStime-1.9.3

1538+include-dirs:

1539+depends: base-4.15.0.0 deepseq-1.4.5.0

1540+haddock-interfaces:

1541+haddock-html:

1542+---

1543+name: transformers

1544+version: 0.5.6.2

1545+visibility: public

1546+id: transformers-0.5.6.2

1547+key: transformers-0.5.6.2

1548+license: BSD-3-Clause

1549+maintainer: Ross Paterson <R.Paterson@city.ac.uk>

1550+author: Andy Gill, Ross Paterson

1551+synopsis: Concrete functor and monad transformers

1552+description:

1553+ A portable library of functor and monad transformers, inspired by

1554+ the paper

1555+ * \"Functional Programming with Overloading and Higher-Order

1556+ Polymorphism\", by Mark P Jones,

1557+ in /Advanced School of Functional Programming/, 1995

1558+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1559+ This package contains:

1560+ * the monad transformer class (in "Control.Monad.Trans.Class")

1561+ * concrete functor and monad transformers, each with associated

1562+ operations and functions to lift operations associated with other

1563+ transformers.

1564+ The package can be used on its own in portable Haskell code, in

1565+ which case operations need to be manually lifted through transformer

1566+ stacks (see "Control.Monad.Trans.Class" for some examples).

1567+ Alternatively, it can be used with the non-portable monad classes in

1568+ the @mtl@ or @monads-tf@ packages, which automatically lift operations

1569+ introduced by monad transformers through other transformers.

1570+category: Control

1571+exposed: True

1572+exposed-modules:

1573+ Control.Applicative.Backwards Control.Applicative.Lift

1574+ Control.Monad.Signatures Control.Monad.Trans.Accum

1575+ Control.Monad.Trans.Class Control.Monad.Trans.Cont

1576+ Control.Monad.Trans.Error Control.Monad.Trans.Except

1577+ Control.Monad.Trans.Identity Control.Monad.Trans.List

1578+ Control.Monad.Trans.Maybe Control.Monad.Trans.RWS

1579+ Control.Monad.Trans.RWS.CPS Control.Monad.Trans.RWS.Lazy

1580+ Control.Monad.Trans.RWS.Strict Control.Monad.Trans.Reader

1581+ Control.Monad.Trans.Select Control.Monad.Trans.State

1582+ Control.Monad.Trans.State.Lazy Control.Monad.Trans.State.Strict

1583+ Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS

1584+ Control.Monad.Trans.Writer.Lazy Control.Monad.Trans.Writer.Strict

1585+ Data.Functor.Constant Data.Functor.Reverse

1586+import-dirs:

1587+library-dirs:

1588+dynamic-library-dirs:

1589+data-dir:

1590+hs-libraries: HStransformers-0.5.6.2

1591+depends: base-4.15.0.0

1592+haddock-interfaces:

1593+haddock-html:

1594+---

1595+name: unix

1596+version: 2.7.2.2

1597+visibility: public

1598+id: unix-2.7.2.2

1599+key: unix-2.7.2.2

1600+license: BSD-3-Clause

1601+maintainer: libraries@haskell.org

1602+homepage: https://github.com/haskell/unix

1603+synopsis: POSIX functionality

1604+description:

1605+ This package gives you access to the set of operating system

1606+ services standardised by

1607+ <http://pubs.opengroup.org/onlinepubs/9699919799/ POSIX.1-2008>

1608+ (or the IEEE Portable Operating System Interface for Computing

1609+ Environments - IEEE Std. 1003.1).

1610+ The package is not supported under Windows.

1611+category: System

1612+exposed: True

1613+exposed-modules:

1614+ System.Posix System.Posix.ByteString

1615+ System.Posix.ByteString.FilePath System.Posix.Directory

1616+ System.Posix.Directory.ByteString System.Posix.DynamicLinker

1617+ System.Posix.DynamicLinker.ByteString

1618+ System.Posix.DynamicLinker.Module

1619+ System.Posix.DynamicLinker.Module.ByteString

1620+ System.Posix.DynamicLinker.Prim System.Posix.Env

1621+ System.Posix.Env.ByteString System.Posix.Error System.Posix.Fcntl

1622+ System.Posix.Files System.Posix.Files.ByteString System.Posix.IO

1623+ System.Posix.IO.ByteString System.Posix.Process

1624+ System.Posix.Process.ByteString System.Posix.Process.Internals

1625+ System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem

1626+ System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp

1627+ System.Posix.Temp.ByteString System.Posix.Terminal

1628+ System.Posix.Terminal.ByteString System.Posix.Time

1629+ System.Posix.Unistd System.Posix.User

1630+hidden-modules:

1631+ System.Posix.Directory.Common System.Posix.DynamicLinker.Common

1632+ System.Posix.Files.Common System.Posix.IO.Common

1633+ System.Posix.Process.Common System.Posix.Terminal.Common

1634+import-dirs:

1635+library-dirs:

1636+dynamic-library-dirs:

1637+data-dir:

1638+hs-libraries: HSunix-2.7.2.2

1639+extra-libraries: rt util dl pthread

1640+include-dirs:

1641+includes: HsUnix.h execvpe.h

1642+depends: base-4.15.0.0 bytestring-0.10.12.1 time-1.9.3

1643+haddock-interfaces:

1644+haddock-html:

1645+---

1646+name: xhtml

1647+version: 3000.2.2.1

1648+visibility: public

1649+id: xhtml-3000.2.2.1

1650+key: xhtml-3000.2.2.1

1651+license: BSD-3-Clause

1652+copyright:

1653+ Bjorn Bringert 2004-2006, Andy Gill and the Oregon

1654+ Graduate Institute of Science and Technology, 1999-2001

1655+maintainer: Chris Dornan <chris@chrisdornan.com>

1656+author: Bjorn Bringert

1657+stability: Stable

1658+homepage: https://github.com/haskell/xhtml

1659+synopsis: An XHTML combinator library

1660+description:

1661+ This package provides combinators for producing

1662+ XHTML 1.0, including the Strict, Transitional and

1663+ Frameset variants.

1664+category: Web, XML, Pretty Printer

1665+exposed: True

1666+exposed-modules:

1667+ Text.XHtml Text.XHtml.Debug Text.XHtml.Frameset Text.XHtml.Strict

1668+ Text.XHtml.Table Text.XHtml.Transitional

1669+hidden-modules:

1670+ Text.XHtml.Strict.Attributes Text.XHtml.Strict.Elements

1671+ Text.XHtml.Frameset.Attributes Text.XHtml.Frameset.Elements

1672+ Text.XHtml.Transitional.Attributes Text.XHtml.Transitional.Elements

1673+ Text.XHtml.BlockTable Text.XHtml.Extras Text.XHtml.Internals

1674+import-dirs:

1675+library-dirs:

1676+dynamic-library-dirs:

1677+data-dir:

1678+hs-libraries: HSxhtml-3000.2.2.1

1679+depends: base-4.15.0.0

1680+haddock-interfaces:

1681+haddock-html:

1682+---

1683+name: rts

1684+version: 1.0

1685+visibility: public

1686+id: rts

1687+key: rts

1688+license: BSD-3-Clause

1689+maintainer: glasgow-haskell-users@haskell.org

1690+exposed: True

1691+library-dirs:

1692+hs-libraries: HSrts

1693+extra-libraries: m rt dl ffi numa pthread

1694+include-dirs:

1695+includes: Stg.h

1696+ld-options:

1697+ "-Wl,-u,base_GHCziTopHandler_runIO_closure"

1698+ "-Wl,-u,base_GHCziTopHandler_runNonIO_closure"

1699+ "-Wl,-u,ghczmprim_GHCziTuple_Z0T_closure"

1700+ "-Wl,-u,ghczmprim_GHCziTypes_True_closure"

1701+ "-Wl,-u,ghczmprim_GHCziTypes_False_closure"

1702+ "-Wl,-u,base_GHCziPack_unpackCString_closure"

1703+ "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure"

1704+ "-Wl,-u,base_GHCziIOziException_stackOverflow_closure"

1705+ "-Wl,-u,base_GHCziIOziException_heapOverflow_closure"

1706+ "-Wl,-u,base_GHCziIOziException_allocationLimitExceeded_closure"

1707+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"

1708+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"

1709+ "-Wl,-u,base_GHCziIOziException_cannotCompactFunction_closure"

1710+ "-Wl,-u,base_GHCziIOziException_cannotCompactPinned_closure"

1711+ "-Wl,-u,base_GHCziIOziException_cannotCompactMutable_closure"

1712+ "-Wl,-u,base_GHCziIOPort_doubleReadException_closure"

1713+ "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure"

1714+ "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure"

1715+ "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure"

1716+ "-Wl,-u,base_GHCziExceptionziType_divZZeroException_closure"

1717+ "-Wl,-u,base_GHCziExceptionziType_underflowException_closure"

1718+ "-Wl,-u,base_GHCziExceptionziType_overflowException_closure"

1719+ "-Wl,-u,base_GHCziConcziSync_runSparks_closure"

1720+ "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure"

1721+ "-Wl,-u,base_GHCziConcziIO_interruptIOManager_closure"

1722+ "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"

1723+ "-Wl,-u,base_GHCziConcziSignal_runHandlersPtr_closure"

1724+ "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure"

1725+ "-Wl,-u,base_GHCziTopHandler_runMainIO_closure"

1726+ "-Wl,-u,ghczmprim_GHCziTypes_Czh_con_info"

1727+ "-Wl,-u,ghczmprim_GHCziTypes_Izh_con_info"

1728+ "-Wl,-u,ghczmprim_GHCziTypes_Fzh_con_info"

1729+ "-Wl,-u,ghczmprim_GHCziTypes_Dzh_con_info"

1730+ "-Wl,-u,ghczmprim_GHCziTypes_Wzh_con_info"

1731+ "-Wl,-u,base_GHCziPtr_Ptr_con_info"

1732+ "-Wl,-u,base_GHCziPtr_FunPtr_con_info"

1733+ "-Wl,-u,base_GHCziInt_I8zh_con_info"

1734+ "-Wl,-u,base_GHCziInt_I16zh_con_info"

1735+ "-Wl,-u,base_GHCziInt_I32zh_con_info"

1736+ "-Wl,-u,base_GHCziInt_I64zh_con_info"

1737+ "-Wl,-u,base_GHCziWord_W8zh_con_info"

1738+ "-Wl,-u,base_GHCziWord_W16zh_con_info"

1739+ "-Wl,-u,base_GHCziWord_W32zh_con_info"

1740+ "-Wl,-u,base_GHCziWord_W64zh_con_info"

1741+ "-Wl,-u,base_GHCziStable_StablePtr_con_info"

1742+ "-Wl,-u,hs_atomic_add8" "-Wl,-u,hs_atomic_add16"

1743+ "-Wl,-u,hs_atomic_add32" "-Wl,-u,hs_atomic_add64"

1744+ "-Wl,-u,hs_atomic_sub8" "-Wl,-u,hs_atomic_sub16"

1745+ "-Wl,-u,hs_atomic_sub32" "-Wl,-u,hs_atomic_sub64"

1746+ "-Wl,-u,hs_atomic_and8" "-Wl,-u,hs_atomic_and16"

1747+ "-Wl,-u,hs_atomic_and32" "-Wl,-u,hs_atomic_and64"

1748+ "-Wl,-u,hs_atomic_nand8" "-Wl,-u,hs_atomic_nand16"

1749+ "-Wl,-u,hs_atomic_nand32" "-Wl,-u,hs_atomic_nand64"

1750+ "-Wl,-u,hs_atomic_or8" "-Wl,-u,hs_atomic_or16"

1751+ "-Wl,-u,hs_atomic_or32" "-Wl,-u,hs_atomic_or64"

1752+ "-Wl,-u,hs_atomic_xor8" "-Wl,-u,hs_atomic_xor16"

1753+ "-Wl,-u,hs_atomic_xor32" "-Wl,-u,hs_atomic_xor64"

1754+ "-Wl,-u,hs_cmpxchg8" "-Wl,-u,hs_cmpxchg16" "-Wl,-u,hs_cmpxchg32"

1755+ "-Wl,-u,hs_cmpxchg64" "-Wl,-u,hs_xchg8" "-Wl,-u,hs_xchg16"

1756+ "-Wl,-u,hs_xchg32" "-Wl,-u,hs_xchg64" "-Wl,-u,hs_atomicread8"

1757+ "-Wl,-u,hs_atomicread16" "-Wl,-u,hs_atomicread32"

1758+ "-Wl,-u,hs_atomicread64" "-Wl,-u,hs_atomicwrite8"

1759+ "-Wl,-u,hs_atomicwrite16" "-Wl,-u,hs_atomicwrite32"

1760+ "-Wl,-u,hs_atomicwrite64"

materialized/dummy-ghc/ghc-9.0.1-aarch64-linux/ghc-pkg/versionnew file+1

@@ -0,0 +1 @@

1+GHC package manager version 9.0.1

materialized/dummy-ghc/ghc-9.0.1-aarch64-linux/ghc/infonew file+74

@@ -0,0 +1,74 @@

1+ [("Project name","The Glorious Glasgow Haskell Compilation System")

2+ ,("GCC extra via C opts","")

3+ ,("C compiler command","gcc")

4+ ,("C compiler flags","")

5+ ,("C++ compiler flags","")

6+ ,("C compiler link flags","-Wl,-z,noexecstack")

7+ ,("C compiler supports -no-pie","YES")

8+ ,("Haskell CPP command","gcc")

9+ ,("Haskell CPP flags","-E -undef -traditional")

10+ ,("ld command","ld")

11+ ,("ld flags","-z noexecstack")

12+ ,("ld supports compact unwind","YES")

13+ ,("ld supports build-id","YES")

14+ ,("ld supports filelist","NO")

15+ ,("ld is GNU ld","YES")

16+ ,("Merge objects command","ld")

17+ ,("Merge objects flags","-r")

18+ ,("ar command","ar")

19+ ,("ar flags","q")

20+ ,("ar supports at file","YES")

21+ ,("ranlib command","ranlib")

22+ ,("otool command","otool")

23+ ,("install_name_tool command","install_name_tool")

24+ ,("touch command","touch")

25+ ,("dllwrap command","/bin/false")

26+ ,("windres command","/bin/false")

27+ ,("libtool command","libtool")

28+ ,("cross compiling","NO")

29+ ,("target platform string","aarch64-unknown-linux")

30+ ,("target os","OSLinux")

31+ ,("target arch","ArchAArch64")

32+ ,("target word size","8")

33+ ,("target word big endian","NO")

34+ ,("target has GNU nonexec stack","YES")

35+ ,("target has .ident directive","YES")

36+ ,("target has subsections via symbols","NO")

37+ ,("target has RTS linker","YES")

38+ ,("Unregisterised","NO")

39+ ,("LLVM target","aarch64-unknown-linux")

40+ ,("LLVM clang command","clang")

41+ ,("bignum backend","gmp")

42+ ,("Use interpreter","YES")

43+ ,("Support SMP","YES")

44+ ,("RTS ways","l debug thr thr_debug thr_l thr_p dyn debug_dyn thr_dyn thr_debug_dyn l_dyn thr_l_dyn thr_debug_p debug_p")

45+ ,("Tables next to code","YES")

46+ ,("Leading underscore","NO")

47+ ,("Use LibFFI","YES")

48+ ,("Use Threads","YES")

49+ ,("Use Debugging","NO")

50+ ,("RTS expects libdw","NO")

51+ ,("Project version","9.0.1")

52+ ,("Project Git commit id","da53a348150d30193a6f28e1b7ddcabdf45ab726")

53+ ,("Booter version","8.8.4")

54+ ,("Stage","2")

55+ ,("Build platform","aarch64-unknown-linux")

56+ ,("Host platform","aarch64-unknown-linux")

57+ ,("Target platform","aarch64-unknown-linux")

58+ ,("Have interpreter","YES")

59+ ,("Object splitting supported","NO")

60+ ,("Have native code generator","NO")

61+ ,("Target default backend","LLVM")

62+ ,("Support dynamic-too","YES")

63+ ,("Support parallel --make","YES")

64+ ,("Support reexported-modules","YES")

65+ ,("Support thinning and renaming package flags","YES")

66+ ,("Support Backpack","YES")

67+ ,("Requires unified installed package IDs","YES")

68+ ,("Uses package keys","YES")

69+ ,("Uses unit IDs","YES")

70+ ,("Dynamic by default","NO")

71+ ,("GHC Dynamic","YES")

72+ ,("GHC Profiled","NO")

73+ ,("Debug on","NO")

74+ ]

materialized/dummy-ghc/ghc-9.0.1-aarch64-linux/ghc/numeric-versionnew file+1

@@ -0,0 +1 @@

1+9.0.1

materialized/dummy-ghc/ghc-9.0.1-aarch64-linux/ghc/supported-languagesnew file+261

@@ -0,0 +1,261 @@

1+Haskell98

2+Haskell2010

3+Unsafe

4+Trustworthy

5+Safe

6+AllowAmbiguousTypes

7+NoAllowAmbiguousTypes

8+AlternativeLayoutRule

9+NoAlternativeLayoutRule

10+AlternativeLayoutRuleTransitional

11+NoAlternativeLayoutRuleTransitional

12+Arrows

13+NoArrows

14+AutoDeriveTypeable

15+NoAutoDeriveTypeable

16+BangPatterns

17+NoBangPatterns

18+BinaryLiterals

19+NoBinaryLiterals

20+CApiFFI

21+NoCApiFFI

22+CPP

23+NoCPP

24+CUSKs

25+NoCUSKs

26+ConstrainedClassMethods

27+NoConstrainedClassMethods

28+ConstraintKinds

29+NoConstraintKinds

30+DataKinds

31+NoDataKinds

32+DatatypeContexts

33+NoDatatypeContexts

34+DefaultSignatures

35+NoDefaultSignatures

36+DeriveAnyClass

37+NoDeriveAnyClass

38+DeriveDataTypeable

39+NoDeriveDataTypeable

40+DeriveFoldable

41+NoDeriveFoldable

42+DeriveFunctor

43+NoDeriveFunctor

44+DeriveGeneric

45+NoDeriveGeneric

46+DeriveLift

47+NoDeriveLift

48+DeriveTraversable

49+NoDeriveTraversable

50+DerivingStrategies

51+NoDerivingStrategies

52+DerivingVia

53+NoDerivingVia

54+DisambiguateRecordFields

55+NoDisambiguateRecordFields

56+DoAndIfThenElse

57+NoDoAndIfThenElse

58+BlockArguments

59+NoBlockArguments

60+DoRec

61+NoDoRec

62+DuplicateRecordFields

63+NoDuplicateRecordFields

64+EmptyCase

65+NoEmptyCase

66+EmptyDataDecls

67+NoEmptyDataDecls

68+EmptyDataDeriving

69+NoEmptyDataDeriving

70+ExistentialQuantification

71+NoExistentialQuantification

72+ExplicitForAll

73+NoExplicitForAll

74+ExplicitNamespaces

75+NoExplicitNamespaces

76+ExtendedDefaultRules

77+NoExtendedDefaultRules

78+FlexibleContexts

79+NoFlexibleContexts

80+FlexibleInstances

81+NoFlexibleInstances

82+ForeignFunctionInterface

83+NoForeignFunctionInterface

84+FunctionalDependencies

85+NoFunctionalDependencies

86+GADTSyntax

87+NoGADTSyntax

88+GADTs

89+NoGADTs

90+GHCForeignImportPrim

91+NoGHCForeignImportPrim

92+GeneralizedNewtypeDeriving

93+NoGeneralizedNewtypeDeriving

94+GeneralisedNewtypeDeriving

95+NoGeneralisedNewtypeDeriving

96+ImplicitParams

97+NoImplicitParams

98+ImplicitPrelude

99+NoImplicitPrelude

100+ImportQualifiedPost

101+NoImportQualifiedPost

102+ImpredicativeTypes

103+NoImpredicativeTypes

104+IncoherentInstances

105+NoIncoherentInstances

106+TypeFamilyDependencies

107+NoTypeFamilyDependencies

108+InstanceSigs

109+NoInstanceSigs

110+ApplicativeDo

111+NoApplicativeDo

112+InterruptibleFFI

113+NoInterruptibleFFI

114+JavaScriptFFI

115+NoJavaScriptFFI

116+KindSignatures

117+NoKindSignatures

118+LambdaCase

119+NoLambdaCase

120+LexicalNegation

121+NoLexicalNegation

122+LiberalTypeSynonyms

123+NoLiberalTypeSynonyms

124+LinearTypes

125+NoLinearTypes

126+MagicHash

127+NoMagicHash

128+MonadComprehensions

129+NoMonadComprehensions

130+MonadFailDesugaring

131+NoMonadFailDesugaring

132+MonoLocalBinds

133+NoMonoLocalBinds

134+MonoPatBinds

135+NoMonoPatBinds

136+MonomorphismRestriction

137+NoMonomorphismRestriction

138+MultiParamTypeClasses

139+NoMultiParamTypeClasses

140+MultiWayIf

141+NoMultiWayIf

142+NumericUnderscores

143+NoNumericUnderscores

144+NPlusKPatterns

145+NoNPlusKPatterns

146+NamedFieldPuns

147+NoNamedFieldPuns

148+NamedWildCards

149+NoNamedWildCards

150+NegativeLiterals

151+NoNegativeLiterals

152+HexFloatLiterals

153+NoHexFloatLiterals

154+NondecreasingIndentation

155+NoNondecreasingIndentation

156+NullaryTypeClasses

157+NoNullaryTypeClasses

158+NumDecimals

159+NoNumDecimals

160+OverlappingInstances

161+NoOverlappingInstances

162+OverloadedLabels

163+NoOverloadedLabels

164+OverloadedLists

165+NoOverloadedLists

166+OverloadedStrings

167+NoOverloadedStrings

168+PackageImports

169+NoPackageImports

170+ParallelArrays

171+NoParallelArrays

172+ParallelListComp

173+NoParallelListComp

174+PartialTypeSignatures

175+NoPartialTypeSignatures

176+PatternGuards

177+NoPatternGuards

178+PatternSignatures

179+NoPatternSignatures

180+PatternSynonyms

181+NoPatternSynonyms

182+PolyKinds

183+NoPolyKinds

184+PolymorphicComponents

185+NoPolymorphicComponents

186+QuantifiedConstraints

187+NoQuantifiedConstraints

188+PostfixOperators

189+NoPostfixOperators

190+QuasiQuotes

191+NoQuasiQuotes

192+QualifiedDo

193+NoQualifiedDo

194+Rank2Types

195+NoRank2Types

196+RankNTypes

197+NoRankNTypes

198+RebindableSyntax

199+NoRebindableSyntax

200+RecordPuns

201+NoRecordPuns

202+RecordWildCards

203+NoRecordWildCards

204+RecursiveDo

205+NoRecursiveDo

206+RelaxedLayout

207+NoRelaxedLayout

208+RelaxedPolyRec

209+NoRelaxedPolyRec

210+RoleAnnotations

211+NoRoleAnnotations

212+ScopedTypeVariables

213+NoScopedTypeVariables

214+StandaloneDeriving

215+NoStandaloneDeriving

216+StarIsType

217+NoStarIsType

218+StaticPointers

219+NoStaticPointers

220+Strict

221+NoStrict

222+StrictData

223+NoStrictData

224+TemplateHaskell

225+NoTemplateHaskell

226+TemplateHaskellQuotes

227+NoTemplateHaskellQuotes

228+StandaloneKindSignatures

229+NoStandaloneKindSignatures

230+TraditionalRecordSyntax

231+NoTraditionalRecordSyntax

232+TransformListComp

233+NoTransformListComp

234+TupleSections

235+NoTupleSections

236+TypeApplications

237+NoTypeApplications

238+TypeInType

239+NoTypeInType

240+TypeFamilies

241+NoTypeFamilies

242+TypeOperators

243+NoTypeOperators

244+TypeSynonymInstances

245+NoTypeSynonymInstances

246+UnboxedTuples

247+NoUnboxedTuples

248+UnboxedSums

249+NoUnboxedSums

250+UndecidableInstances

251+NoUndecidableInstances

252+UndecidableSuperClasses

253+NoUndecidableSuperClasses

254+UnicodeSyntax

255+NoUnicodeSyntax

256+UnliftedFFITypes

257+NoUnliftedFFITypes

258+UnliftedNewtypes

259+NoUnliftedNewtypes

260+ViewPatterns

261+NoViewPatterns

materialized/dummy-ghc/ghc-9.0.1-aarch64-linux/ghc/versionnew file+1

@@ -0,0 +1 @@

1+The Glorious Glasgow Haskell Compilation System, version 9.0.1

materialized/dummy-ghc/ghc-9.0.1-x86_64-darwin/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","clang")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","NO")

8+ ,("Haskell CPP command","clang")

79 ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","NO")

1114 ,("ld supports filelist","YES")

1215 ,("ld is GNU ld","NO")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","qcls")

1520 ,("ar supports at file","NO")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-9.0.1-x86_64-linux/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","YES")

8+ ,("Haskell CPP command","gcc")

79 ,("Haskell CPP flags","-E -undef -traditional")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","YES")

1114 ,("ld supports filelist","NO")

1215 ,("ld is GNU ld","YES")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","q")

1520 ,("ar supports at file","YES")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-9.0.2-aarch64-darwin/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","clang")

34 ,("C compiler flags","--target=arm64-apple-darwin ")

45 ,("C++ compiler flags","--target=arm64-apple-darwin ")

56 ,("C compiler link flags","--target=arm64-apple-darwin ")

67 ,("C compiler supports -no-pie","NO")

8+ ,("Haskell CPP command","clang")

79 ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","NO")

1114 ,("ld supports filelist","YES")

1215 ,("ld is GNU ld","NO")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","qcls")

1520 ,("ar supports at file","NO")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-9.0.2-aarch64-linux/ghc-pkg/dump-globalnew file+1767

@@ -0,0 +1,1767 @@

1+name: Cabal

2+version: 3.4.1.0

3+visibility: public

4+id: Cabal-3.4.1.0

5+key: Cabal-3.4.1.0

6+license: BSD-3-Clause

7+copyright: 2003-2020, 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.Doctest

71+ Distribution.Simple.Flag Distribution.Simple.GHC

72+ Distribution.Simple.GHCJS Distribution.Simple.Glob

73+ Distribution.Simple.Haddock Distribution.Simple.HaskellSuite

74+ Distribution.Simple.Hpc Distribution.Simple.Install

75+ Distribution.Simple.InstallDirs

76+ Distribution.Simple.InstallDirs.Internal

77+ Distribution.Simple.LocalBuildInfo Distribution.Simple.PackageIndex

78+ Distribution.Simple.PreProcess Distribution.Simple.PreProcess.Unlit

79+ Distribution.Simple.Program Distribution.Simple.Program.Ar

80+ Distribution.Simple.Program.Builtin Distribution.Simple.Program.Db

81+ Distribution.Simple.Program.Find Distribution.Simple.Program.GHC

82+ Distribution.Simple.Program.HcPkg Distribution.Simple.Program.Hpc

83+ Distribution.Simple.Program.Internal Distribution.Simple.Program.Ld

84+ Distribution.Simple.Program.ResponseFile

85+ Distribution.Simple.Program.Run Distribution.Simple.Program.Script

86+ Distribution.Simple.Program.Strip Distribution.Simple.Program.Types

87+ Distribution.Simple.Register Distribution.Simple.Setup

88+ Distribution.Simple.ShowBuildInfo Distribution.Simple.SrcDist

89+ Distribution.Simple.Test Distribution.Simple.Test.ExeV10

90+ Distribution.Simple.Test.LibV09 Distribution.Simple.Test.Log

91+ Distribution.Simple.UHC Distribution.Simple.UserHooks

92+ Distribution.Simple.Utils Distribution.System

93+ Distribution.TestSuite Distribution.Text

94+ Distribution.Types.AbiDependency Distribution.Types.AbiHash

95+ Distribution.Types.AnnotatedId Distribution.Types.Benchmark

96+ Distribution.Types.Benchmark.Lens

97+ Distribution.Types.BenchmarkInterface

98+ Distribution.Types.BenchmarkType Distribution.Types.BuildInfo

99+ Distribution.Types.BuildInfo.Lens Distribution.Types.BuildType

100+ Distribution.Types.Component Distribution.Types.ComponentId

101+ Distribution.Types.ComponentInclude

102+ Distribution.Types.ComponentLocalBuildInfo

103+ Distribution.Types.ComponentName

104+ Distribution.Types.ComponentRequestedSpec

105+ Distribution.Types.CondTree Distribution.Types.Condition

106+ Distribution.Types.ConfVar Distribution.Types.Dependency

107+ Distribution.Types.DependencyMap Distribution.Types.ExeDependency

108+ Distribution.Types.Executable Distribution.Types.Executable.Lens

109+ Distribution.Types.ExecutableScope Distribution.Types.ExposedModule

110+ Distribution.Types.Flag Distribution.Types.ForeignLib

111+ Distribution.Types.ForeignLib.Lens

112+ Distribution.Types.ForeignLibOption

113+ Distribution.Types.ForeignLibType

114+ Distribution.Types.GenericPackageDescription

115+ Distribution.Types.GenericPackageDescription.Lens

116+ Distribution.Types.GivenComponent

117+ Distribution.Types.HookedBuildInfo

118+ Distribution.Types.IncludeRenaming

119+ Distribution.Types.InstalledPackageInfo

120+ Distribution.Types.InstalledPackageInfo.FieldGrammar

121+ Distribution.Types.InstalledPackageInfo.Lens

122+ Distribution.Types.LegacyExeDependency Distribution.Types.Lens

123+ Distribution.Types.Library Distribution.Types.Library.Lens

124+ Distribution.Types.LibraryName Distribution.Types.LibraryVisibility

125+ Distribution.Types.LocalBuildInfo Distribution.Types.Mixin

126+ Distribution.Types.Module Distribution.Types.ModuleReexport

127+ Distribution.Types.ModuleRenaming

128+ Distribution.Types.MungedPackageId

129+ Distribution.Types.MungedPackageName

130+ Distribution.Types.PackageDescription

131+ Distribution.Types.PackageDescription.Lens

132+ Distribution.Types.PackageId Distribution.Types.PackageId.Lens

133+ Distribution.Types.PackageName Distribution.Types.PackageName.Magic

134+ Distribution.Types.PackageVersionConstraint

135+ Distribution.Types.PkgconfigDependency

136+ Distribution.Types.PkgconfigName

137+ Distribution.Types.PkgconfigVersion

138+ Distribution.Types.PkgconfigVersionRange

139+ Distribution.Types.SetupBuildInfo

140+ Distribution.Types.SetupBuildInfo.Lens

141+ Distribution.Types.SourceRepo Distribution.Types.SourceRepo.Lens

142+ Distribution.Types.TargetInfo Distribution.Types.TestSuite

143+ Distribution.Types.TestSuite.Lens

144+ Distribution.Types.TestSuiteInterface Distribution.Types.TestType

145+ Distribution.Types.UnitId Distribution.Types.UnqualComponentName

146+ Distribution.Types.Version Distribution.Types.VersionInterval

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.Progress

152+ Distribution.Utils.ShortText Distribution.Utils.Structured

153+ Distribution.Verbosity Distribution.Verbosity.Internal

154+ Distribution.Version Language.Haskell.Extension

155+hidden-modules:

156+ Distribution.Backpack.PreExistingComponent

157+ Distribution.Backpack.ReadyComponent Distribution.Backpack.MixLink

158+ Distribution.Backpack.ModuleScope Distribution.Backpack.UnifyM

159+ Distribution.Backpack.Id Distribution.Utils.UnionFind

160+ Distribution.Utils.Base62 Distribution.Compat.Async

161+ Distribution.Compat.CopyFile Distribution.Compat.GetShortPathName

162+ Distribution.Compat.MonadFail Distribution.Compat.Prelude

163+ Distribution.Compat.SnocList Distribution.GetOpt Distribution.Lex

164+ Distribution.Utils.String Distribution.Simple.Build.Macros.Z

165+ Distribution.Simple.GHC.EnvironmentParser

166+ Distribution.Simple.GHC.Internal Distribution.Simple.GHC.ImplInfo

167+ Distribution.Simple.Utils.Json Distribution.ZinzaPrelude

168+ Paths_Cabal

169+import-dirs:

170+library-dirs:

171+dynamic-library-dirs:

172+data-dir:

173+hs-libraries: HSCabal-3.4.1.0

174+depends:

175+ array-0.5.4.0 base-4.15.1.0 binary-0.8.8.0 bytestring-0.10.12.1

176+ containers-0.6.4.1 deepseq-1.4.5.0 directory-1.3.6.2

177+ filepath-1.4.2.1 mtl-2.2.2 parsec-3.1.14.0 pretty-1.1.3.6

178+ process-1.6.13.2 text-1.2.5.0 time-1.9.3 transformers-0.5.6.2

179+ unix-2.7.2.2

180+haddock-interfaces:

181+haddock-html:

182+---

183+name: array

184+version: 0.5.4.0

185+visibility: public

186+id: array-0.5.4.0

187+key: array-0.5.4.0

188+license: BSD-3-Clause

189+maintainer: libraries@haskell.org

190+synopsis: Mutable and immutable arrays

191+description:

192+ In addition to providing the "Data.Array" module

193+ <http://www.haskell.org/onlinereport/haskell2010/haskellch14.html as specified in the Haskell 2010 Language Report>,

194+ this package also defines the classes 'IArray' of

195+ immutable arrays and 'MArray' of arrays mutable within appropriate

196+ monads, as well as some instances of these classes.

197+category: Data Structures

198+exposed: True

199+exposed-modules:

200+ Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO

201+ Data.Array.IO.Internals Data.Array.IO.Safe Data.Array.MArray

202+ Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe

203+ Data.Array.Storable Data.Array.Storable.Internals

204+ Data.Array.Storable.Safe Data.Array.Unboxed Data.Array.Unsafe

205+import-dirs:

206+library-dirs:

207+dynamic-library-dirs:

208+data-dir:

209+hs-libraries: HSarray-0.5.4.0

210+depends: base-4.15.1.0

211+haddock-interfaces:

212+haddock-html:

213+---

214+name: base

215+version: 4.15.1.0

216+visibility: public

217+id: base-4.15.1.0

218+key: base-4.15.1.0

219+license: BSD-3-Clause

220+maintainer: libraries@haskell.org

221+synopsis: Basic libraries

222+description:

223+ This package contains the Standard Haskell "Prelude" and its support libraries,

224+ and a large collection of useful libraries ranging from data

225+ structures to parsing combinators and debugging utilities.

226+category: Prelude

227+exposed: True

228+exposed-modules:

229+ Control.Applicative, Control.Arrow, Control.Category,

230+ Control.Concurrent, Control.Concurrent.Chan,

231+ Control.Concurrent.MVar, Control.Concurrent.QSem,

232+ Control.Concurrent.QSemN, Control.Exception,

233+ Control.Exception.Base, Control.Monad, Control.Monad.Fail,

234+ Control.Monad.Fix, Control.Monad.IO.Class, Control.Monad.Instances,

235+ Control.Monad.ST, Control.Monad.ST.Lazy,

236+ Control.Monad.ST.Lazy.Safe, Control.Monad.ST.Lazy.Unsafe,

237+ Control.Monad.ST.Safe, Control.Monad.ST.Strict,

238+ Control.Monad.ST.Unsafe, Control.Monad.Zip, Data.Bifoldable,

239+ Data.Bifunctor, Data.Bitraversable, Data.Bits, Data.Bool,

240+ Data.Char, Data.Coerce, Data.Complex, Data.Data, Data.Dynamic,

241+ Data.Either, Data.Eq, Data.Fixed, Data.Foldable, Data.Function,

242+ Data.Functor, Data.Functor.Classes, Data.Functor.Compose,

243+ Data.Functor.Const, Data.Functor.Contravariant,

244+ Data.Functor.Identity, Data.Functor.Product, Data.Functor.Sum,

245+ Data.IORef, Data.Int, Data.Ix, Data.Kind, Data.List,

246+ Data.List.NonEmpty, Data.Maybe, Data.Monoid, Data.Ord, Data.Proxy,

247+ Data.Ratio, Data.STRef, Data.STRef.Lazy, Data.STRef.Strict,

248+ Data.Semigroup, Data.String, Data.Traversable, Data.Tuple,

249+ Data.Type.Bool, Data.Type.Coercion, Data.Type.Equality,

250+ Data.Typeable, Data.Unique, Data.Version, Data.Void, Data.Word,

251+ Debug.Trace, Foreign, Foreign.C, Foreign.C.Error, Foreign.C.String,

252+ Foreign.C.Types, Foreign.Concurrent, Foreign.ForeignPtr,

253+ Foreign.ForeignPtr.Safe, Foreign.ForeignPtr.Unsafe,

254+ Foreign.Marshal, Foreign.Marshal.Alloc, Foreign.Marshal.Array,

255+ Foreign.Marshal.Error, Foreign.Marshal.Pool, Foreign.Marshal.Safe,

256+ Foreign.Marshal.Unsafe, Foreign.Marshal.Utils, Foreign.Ptr,

257+ Foreign.Safe, Foreign.StablePtr, Foreign.Storable, GHC.Arr,

258+ GHC.Base, GHC.ByteOrder, GHC.Char, GHC.Clock, GHC.Conc,

259+ GHC.Conc.IO, GHC.Conc.Signal, GHC.Conc.Sync, GHC.ConsoleHandler,

260+ GHC.Constants, GHC.Desugar, GHC.Enum, GHC.Environment, GHC.Err,

261+ GHC.Event, GHC.Event.TimeOut, GHC.Exception, GHC.Exception.Type,

262+ GHC.ExecutionStack, GHC.ExecutionStack.Internal, GHC.Exts,

263+ GHC.Fingerprint, GHC.Fingerprint.Type, GHC.Float,

264+ GHC.Float.ConversionUtils, GHC.Float.RealFracMethods, GHC.Foreign,

265+ GHC.ForeignPtr, GHC.GHCi, GHC.GHCi.Helpers, GHC.Generics, GHC.IO,

266+ GHC.IO.Buffer, GHC.IO.BufferedIO, GHC.IO.Device, GHC.IO.Encoding,

267+ GHC.IO.Encoding.CodePage, GHC.IO.Encoding.Failure,

268+ GHC.IO.Encoding.Iconv, GHC.IO.Encoding.Latin1,

269+ GHC.IO.Encoding.Types, GHC.IO.Encoding.UTF16,

270+ GHC.IO.Encoding.UTF32, GHC.IO.Encoding.UTF8, GHC.IO.Exception,

271+ GHC.IO.FD, GHC.IO.Handle, GHC.IO.Handle.FD,

272+ GHC.IO.Handle.Internals, GHC.IO.Handle.Lock, GHC.IO.Handle.Text,

273+ GHC.IO.Handle.Types, GHC.IO.IOMode, GHC.IO.StdHandles,

274+ GHC.IO.SubSystem, GHC.IO.Unsafe, GHC.IOArray, GHC.IOPort,

275+ GHC.IORef, GHC.Int, GHC.Integer, GHC.Integer.Logarithms, GHC.Ix,

276+ GHC.List, GHC.MVar, GHC.Maybe, GHC.Natural, GHC.Num,

277+ GHC.Num.BigNat from ghc-bignum-1.1:GHC.Num.BigNat,

278+ GHC.Num.Integer from ghc-bignum-1.1:GHC.Num.Integer,

279+ GHC.Num.Natural from ghc-bignum-1.1:GHC.Num.Natural, GHC.OldList,

280+ GHC.OverloadedLabels, GHC.Pack, GHC.Profiling, GHC.Ptr,

281+ GHC.RTS.Flags, GHC.Read, GHC.Real, GHC.Records, GHC.ResponseFile,

282+ GHC.ST, GHC.STRef, GHC.Show, GHC.Stable, GHC.StableName, GHC.Stack,

283+ GHC.Stack.CCS, GHC.Stack.Types, GHC.StaticPtr, GHC.Stats,

284+ GHC.Storable, GHC.TopHandler, GHC.TypeLits, GHC.TypeNats,

285+ GHC.Unicode, GHC.Weak, GHC.Word, Numeric, Numeric.Natural, Prelude,

286+ System.CPUTime, System.Console.GetOpt, System.Environment,

287+ System.Environment.Blank, System.Exit, System.IO, System.IO.Error,

288+ System.IO.Unsafe, System.Info, System.Mem, System.Mem.StableName,

289+ System.Mem.Weak, System.Posix.Internals, System.Posix.Types,

290+ System.Timeout, Text.ParserCombinators.ReadP,

291+ Text.ParserCombinators.ReadPrec, Text.Printf, Text.Read,

292+ Text.Read.Lex, Text.Show, Text.Show.Functions, Type.Reflection,

293+ Type.Reflection.Unsafe, Unsafe.Coerce

294+hidden-modules:

295+ Control.Monad.ST.Imp Control.Monad.ST.Lazy.Imp Data.Functor.Utils

296+ Data.OldList Data.Semigroup.Internal Data.Typeable.Internal

297+ Foreign.ForeignPtr.Imp GHC.IO.Handle.Lock.Common

298+ GHC.IO.Handle.Lock.Flock GHC.IO.Handle.Lock.LinuxOFD

299+ GHC.IO.Handle.Lock.NoOp GHC.IO.Handle.Lock.Windows

300+ GHC.StaticPtr.Internal GHC.Event.Internal.Types

301+ System.Environment.ExecutablePath System.CPUTime.Utils

302+ GHC.Event.Arr GHC.Event.Array GHC.Event.Control GHC.Event.EPoll

303+ GHC.Event.IntTable GHC.Event.Internal GHC.Event.KQueue

304+ GHC.Event.Manager GHC.Event.PSQ GHC.Event.Poll GHC.Event.Thread

305+ GHC.Event.TimerManager GHC.Event.Unique

306+ System.CPUTime.Posix.ClockGetTime System.CPUTime.Posix.Times

307+ System.CPUTime.Posix.RUsage System.CPUTime.Unsupported

308+import-dirs:

309+library-dirs:

310+dynamic-library-dirs:

311+data-dir:

312+hs-libraries: HSbase-4.15.1.0

313+include-dirs:

314+includes: HsBase.h

315+depends: ghc-bignum-1.1 ghc-prim-0.7.0 rts

316+haddock-interfaces:

317+haddock-html:

318+---

319+name: binary

320+version: 0.8.8.0

321+visibility: public

322+id: binary-0.8.8.0

323+key: binary-0.8.8.0

324+license: BSD-3-Clause

325+maintainer: Lennart Kolmodin, Don Stewart <dons00@gmail.com>

326+author: Lennart Kolmodin <kolmodin@gmail.com>

327+stability: provisional

328+homepage: https://github.com/kolmodin/binary

329+synopsis:

330+ Binary serialisation for Haskell values using lazy ByteStrings

331+description:

332+ Efficient, pure binary serialisation using lazy ByteStrings.

333+ Haskell values may be encoded to and from binary formats,

334+ written to disk as binary, or sent over the network.

335+ The format used can be automatically generated, or

336+ you can choose to implement a custom format if needed.

337+ Serialisation speeds of over 1 G\/sec have been observed,

338+ so this library should be suitable for high performance

339+ scenarios.

340+category: Data, Parsing

341+exposed: True

342+exposed-modules:

343+ Data.Binary Data.Binary.Builder Data.Binary.Get

344+ Data.Binary.Get.Internal Data.Binary.Put

345+hidden-modules:

346+ Data.Binary.Class Data.Binary.Internal Data.Binary.Generic

347+ Data.Binary.FloatCast

348+import-dirs:

349+library-dirs:

350+dynamic-library-dirs:

351+data-dir:

352+hs-libraries: HSbinary-0.8.8.0

353+depends:

354+ array-0.5.4.0 base-4.15.1.0 bytestring-0.10.12.1 containers-0.6.4.1

355+haddock-interfaces:

356+haddock-html:

357+---

358+name: bytestring

359+version: 0.10.12.1

360+visibility: public

361+id: bytestring-0.10.12.1

362+key: bytestring-0.10.12.1

363+license: BSD-3-Clause

364+copyright:

365+ Copyright (c) Don Stewart 2005-2009,

366+ (c) Duncan Coutts 2006-2015,

367+ (c) David Roundy 2003-2005,

368+ (c) Jasper Van der Jeugt 2010,

369+ (c) Simon Meier 2010-2013.

370+maintainer:

371+ Haskell Bytestring Team <andrew.lelechenko@gmail.com>, Core Libraries Committee

372+author:

373+ Don Stewart,

374+ Duncan Coutts

375+homepage: https://github.com/haskell/bytestring

376+synopsis:

377+ Fast, compact, strict and lazy byte strings with a list interface

378+description:

379+ An efficient compact, immutable byte string type (both strict and lazy)

380+ suitable for binary or 8-bit character data.

381+ The 'ByteString' type represents sequences of bytes or 8-bit characters.

382+ It is suitable for high performance use, both in terms of large data

383+ quantities, or high speed requirements. The 'ByteString' functions follow

384+ the same style as Haskell\'s ordinary lists, so it is easy to convert code

385+ from using 'String' to 'ByteString'.

386+ Two 'ByteString' variants are provided:

387+ * Strict 'ByteString's keep the string as a single large array. This

388+ makes them convenient for passing data between C and Haskell.

389+ * Lazy 'ByteString's use a lazy list of strict chunks which makes it

390+ suitable for I\/O streaming tasks.

391+ The @Char8@ modules provide a character-based view of the same

392+ underlying 'ByteString' types. This makes it convenient to handle mixed

393+ binary and 8-bit character content (which is common in many file formats

394+ and network protocols).

395+ The 'Builder' module provides an efficient way to build up 'ByteString's

396+ in an ad-hoc way by repeated concatenation. This is ideal for fast

397+ serialisation or pretty printing.

398+ There is also a 'ShortByteString' type which has a lower memory overhead

399+ and can can be converted to or from a 'ByteString', but supports very few

400+ other operations. It is suitable for keeping many short strings in memory.

401+ 'ByteString's are not designed for Unicode. For Unicode strings you should

402+ use the 'Text' type from the @text@ package.

403+ These modules are intended to be imported qualified, to avoid name clashes

404+ with "Prelude" functions, e.g.

405+ > import qualified Data.ByteString as BS

406+category: Data

407+exposed: True

408+exposed-modules:

409+ Data.ByteString Data.ByteString.Builder

410+ Data.ByteString.Builder.Extra Data.ByteString.Builder.Internal

411+ Data.ByteString.Builder.Prim Data.ByteString.Builder.Prim.Internal

412+ Data.ByteString.Char8 Data.ByteString.Internal Data.ByteString.Lazy

413+ Data.ByteString.Lazy.Builder Data.ByteString.Lazy.Builder.ASCII

414+ Data.ByteString.Lazy.Builder.Extras Data.ByteString.Lazy.Char8

415+ Data.ByteString.Lazy.Internal Data.ByteString.Short

416+ Data.ByteString.Short.Internal Data.ByteString.Unsafe

417+hidden-modules:

418+ Data.ByteString.Builder.ASCII Data.ByteString.Builder.Prim.Binary

419+ Data.ByteString.Builder.Prim.ASCII

420+ Data.ByteString.Builder.Prim.Internal.Floating

421+ Data.ByteString.Builder.Prim.Internal.UncheckedShifts

422+ Data.ByteString.Builder.Prim.Internal.Base16

423+import-dirs:

424+library-dirs:

425+dynamic-library-dirs:

426+data-dir:

427+hs-libraries: HSbytestring-0.10.12.1

428+include-dirs:

429+includes: fpstring.h

430+depends:

431+ base-4.15.1.0 deepseq-1.4.5.0 ghc-bignum-1.1 ghc-prim-0.7.0

432+haddock-interfaces:

433+haddock-html:

434+---

435+name: containers

436+version: 0.6.4.1

437+visibility: public

438+id: containers-0.6.4.1

439+key: containers-0.6.4.1

440+license: BSD-3-Clause

441+maintainer: libraries@haskell.org

442+synopsis: Assorted concrete container types

443+description:

444+ This package contains efficient general-purpose implementations

445+ of various immutable container types including sets, maps, sequences,

446+ trees, and graphs.

447+ For a walkthrough of what this package provides with examples of common

448+ operations see the [containers

449+ introduction](https://haskell-containers.readthedocs.io).

450+ The declared cost of each operation is either worst-case or amortized, but

451+ remains valid even if structures are shared.

452+category: Data Structures

453+exposed: True

454+exposed-modules:

455+ Data.Containers.ListUtils Data.Graph Data.IntMap

456+ Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy

457+ Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict

458+ Data.IntMap.Strict.Internal Data.IntSet Data.IntSet.Internal

459+ Data.Map Data.Map.Internal Data.Map.Internal.Debug Data.Map.Lazy

460+ Data.Map.Merge.Lazy Data.Map.Merge.Strict Data.Map.Strict

461+ Data.Map.Strict.Internal Data.Sequence Data.Sequence.Internal

462+ Data.Sequence.Internal.Sorting Data.Set Data.Set.Internal Data.Tree

463+ Utils.Containers.Internal.BitQueue

464+ Utils.Containers.Internal.BitUtil

465+ Utils.Containers.Internal.StrictPair

466+hidden-modules:

467+ Utils.Containers.Internal.State

468+ Utils.Containers.Internal.StrictMaybe

469+ Utils.Containers.Internal.PtrEquality

470+ Utils.Containers.Internal.Coercions

471+ Utils.Containers.Internal.TypeError

472+ Data.Map.Internal.DeprecatedShowTree

473+ Data.IntMap.Internal.DeprecatedDebug

474+import-dirs:

475+library-dirs:

476+dynamic-library-dirs:

477+data-dir:

478+hs-libraries: HScontainers-0.6.4.1

479+depends: array-0.5.4.0 base-4.15.1.0 deepseq-1.4.5.0

480+haddock-interfaces:

481+haddock-html:

482+---

483+name: deepseq

484+version: 1.4.5.0

485+visibility: public

486+id: deepseq-1.4.5.0

487+key: deepseq-1.4.5.0

488+license: BSD-3-Clause

489+maintainer: libraries@haskell.org

490+synopsis: Deep evaluation of data structures

491+description:

492+ This package provides methods for fully evaluating data structures

493+ (\"deep evaluation\"). Deep evaluation is often used for adding

494+ strictness to a program, e.g. in order to force pending exceptions,

495+ remove space leaks, or force lazy I/O to happen. It is also useful

496+ in parallel programs, to ensure pending work does not migrate to the

497+ wrong thread.

498+ The primary use of this package is via the 'deepseq' function, a

499+ \"deep\" version of 'seq'. It is implemented on top of an 'NFData'

500+ typeclass (\"Normal Form Data\", data structures with no unevaluated

501+ components) which defines strategies for fully evaluating different

502+ data types. See module documentation in "Control.DeepSeq" for more

503+ details.

504+category: Control

505+exposed: True

506+exposed-modules: Control.DeepSeq

507+hidden-modules: Control.DeepSeq.BackDoor

508+import-dirs:

509+library-dirs:

510+dynamic-library-dirs:

511+data-dir:

512+hs-libraries: HSdeepseq-1.4.5.0

513+depends: array-0.5.4.0 base-4.15.1.0

514+haddock-interfaces:

515+haddock-html:

516+---

517+name: directory

518+version: 1.3.6.2

519+visibility: public

520+id: directory-1.3.6.2

521+key: directory-1.3.6.2

522+license: BSD-3-Clause

523+maintainer: libraries@haskell.org

524+synopsis: Platform-agnostic library for filesystem operations

525+description:

526+ This library provides a basic set of operations for manipulating files and

527+ directories in a portable way.

528+category: System

529+exposed: True

530+exposed-modules:

531+ System.Directory System.Directory.Internal

532+ System.Directory.Internal.Prelude

533+hidden-modules:

534+ System.Directory.Internal.C_utimensat

535+ System.Directory.Internal.Common System.Directory.Internal.Config

536+ System.Directory.Internal.Posix System.Directory.Internal.Windows

537+import-dirs:

538+library-dirs:

539+dynamic-library-dirs:

540+data-dir:

541+hs-libraries: HSdirectory-1.3.6.2

542+depends:

543+ base-4.15.1.0 filepath-1.4.2.1 time-1.9.3 unix-2.7.2.2

544+haddock-interfaces:

545+haddock-html:

546+---

547+name: exceptions

548+version: 0.10.4

549+visibility: public

550+id: exceptions-0.10.4

551+key: exceptions-0.10.4

552+license: BSD-3-Clause

553+copyright:

554+ Copyright (C) 2013-2015 Edward A. Kmett

555+ Copyright (C) 2012 Google Inc.

556+maintainer: Edward A. Kmett <ekmett@gmail.com>

557+author: Edward A. Kmett

558+stability: provisional

559+homepage: http://github.com/ekmett/exceptions/

560+synopsis: Extensible optionally-pure exceptions

561+description: Extensible optionally-pure exceptions.

562+category: Control, Exceptions, Monad

563+exposed: True

564+exposed-modules: Control.Monad.Catch Control.Monad.Catch.Pure

565+import-dirs:

566+library-dirs:

567+dynamic-library-dirs:

568+data-dir:

569+hs-libraries: HSexceptions-0.10.4

570+depends:

571+ base-4.15.1.0 mtl-2.2.2 stm-2.5.0.0 template-haskell-2.17.0.0

572+ transformers-0.5.6.2

573+haddock-interfaces:

574+haddock-html:

575+---

576+name: filepath

577+version: 1.4.2.1

578+visibility: public

579+id: filepath-1.4.2.1

580+key: filepath-1.4.2.1

581+license: BSD-3-Clause

582+copyright: Neil Mitchell 2005-2020

583+maintainer: Neil Mitchell <ndmitchell@gmail.com>

584+author: Neil Mitchell <ndmitchell@gmail.com>

585+homepage: https://github.com/haskell/filepath#readme

586+synopsis: Library for manipulating FilePaths in a cross platform way.

587+description:

588+ 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:

589+ * "System.FilePath.Posix" manipulates POSIX\/Linux style @FilePath@ values (with @\/@ as the path separator).

590+ * "System.FilePath.Windows" manipulates Windows style @FilePath@ values (with either @\\@ or @\/@ as the path separator, and deals with drives).

591+ * "System.FilePath" is an alias for the module appropriate to your platform.

592+ All three modules provide the same API, and the same documentation (calling out differences in the different variants).

593+category: System

594+exposed: True

595+exposed-modules:

596+ System.FilePath System.FilePath.Posix System.FilePath.Windows

597+import-dirs:

598+library-dirs:

599+dynamic-library-dirs:

600+data-dir:

601+hs-libraries: HSfilepath-1.4.2.1

602+depends: base-4.15.1.0

603+haddock-interfaces:

604+haddock-html:

605+---

606+name: ghc

607+version: 9.0.2

608+visibility: public

609+id: ghc-9.0.2

610+key: ghc-9.0.2

611+license: BSD-3-Clause

612+maintainer: glasgow-haskell-users@haskell.org

613+author: The GHC Team

614+homepage: http://www.haskell.org/ghc/

615+synopsis: The GHC API

616+description:

617+ GHC's functionality can be useful for more things than just

618+ compiling Haskell programs. Important use cases are programs

619+ that analyse (and perhaps transform) Haskell code. Others

620+ include loading Haskell code dynamically in a GHCi-like manner.

621+ For this reason, a lot of GHC's functionality is made available

622+ through this package.

623+ See <https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler>

624+ for more information.

625+category: Development

626+exposed-modules:

627+ GHC GHC.Builtin.Names GHC.Builtin.Names.TH GHC.Builtin.PrimOps

628+ GHC.Builtin.RebindableNames GHC.Builtin.Types

629+ GHC.Builtin.Types.Literals GHC.Builtin.Types.Prim

630+ GHC.Builtin.Uniques GHC.Builtin.Utils GHC.ByteCode.Asm

631+ GHC.ByteCode.InfoTable GHC.ByteCode.Instr GHC.ByteCode.Linker

632+ GHC.ByteCode.Types GHC.Cmm GHC.Cmm.BlockId GHC.Cmm.CLabel

633+ GHC.Cmm.CallConv GHC.Cmm.CommonBlockElim GHC.Cmm.ContFlowOpt

634+ GHC.Cmm.Dataflow GHC.Cmm.Dataflow.Block

635+ GHC.Cmm.Dataflow.Collections GHC.Cmm.Dataflow.Graph

636+ GHC.Cmm.Dataflow.Label GHC.Cmm.DebugBlock GHC.Cmm.Expr

637+ GHC.Cmm.Graph GHC.Cmm.Info GHC.Cmm.Info.Build GHC.Cmm.LayoutStack

638+ GHC.Cmm.Lexer GHC.Cmm.Lint GHC.Cmm.Liveness GHC.Cmm.MachOp

639+ GHC.Cmm.Monad GHC.Cmm.Node GHC.Cmm.Opt GHC.Cmm.Parser

640+ GHC.Cmm.Pipeline GHC.Cmm.Ppr GHC.Cmm.Ppr.Decl GHC.Cmm.Ppr.Expr

641+ GHC.Cmm.ProcPoint GHC.Cmm.Sink GHC.Cmm.Switch

642+ GHC.Cmm.Switch.Implement GHC.Cmm.Type GHC.Cmm.Utils GHC.CmmToAsm

643+ GHC.CmmToAsm.BlockLayout GHC.CmmToAsm.CFG

644+ GHC.CmmToAsm.CFG.Dominators GHC.CmmToAsm.CPrim GHC.CmmToAsm.Config

645+ GHC.CmmToAsm.Dwarf GHC.CmmToAsm.Dwarf.Constants

646+ GHC.CmmToAsm.Dwarf.Types GHC.CmmToAsm.Format GHC.CmmToAsm.Instr

647+ GHC.CmmToAsm.Monad GHC.CmmToAsm.PIC GHC.CmmToAsm.PPC.CodeGen

648+ GHC.CmmToAsm.PPC.Cond GHC.CmmToAsm.PPC.Instr GHC.CmmToAsm.PPC.Ppr

649+ GHC.CmmToAsm.PPC.RegInfo GHC.CmmToAsm.PPC.Regs GHC.CmmToAsm.Ppr

650+ GHC.CmmToAsm.Reg.Graph GHC.CmmToAsm.Reg.Graph.Base

651+ GHC.CmmToAsm.Reg.Graph.Coalesce GHC.CmmToAsm.Reg.Graph.Spill

652+ GHC.CmmToAsm.Reg.Graph.SpillClean GHC.CmmToAsm.Reg.Graph.SpillCost

653+ GHC.CmmToAsm.Reg.Graph.Stats GHC.CmmToAsm.Reg.Graph.TrivColorable

654+ GHC.CmmToAsm.Reg.Graph.X86 GHC.CmmToAsm.Reg.Linear

655+ GHC.CmmToAsm.Reg.Linear.Base GHC.CmmToAsm.Reg.Linear.FreeRegs

656+ GHC.CmmToAsm.Reg.Linear.JoinToTargets GHC.CmmToAsm.Reg.Linear.PPC

657+ GHC.CmmToAsm.Reg.Linear.SPARC GHC.CmmToAsm.Reg.Linear.StackMap

658+ GHC.CmmToAsm.Reg.Linear.State GHC.CmmToAsm.Reg.Linear.Stats

659+ GHC.CmmToAsm.Reg.Linear.X86 GHC.CmmToAsm.Reg.Linear.X86_64

660+ GHC.CmmToAsm.Reg.Liveness GHC.CmmToAsm.Reg.Target

661+ GHC.CmmToAsm.Reg.Utils GHC.CmmToAsm.SPARC.AddrMode

662+ GHC.CmmToAsm.SPARC.Base GHC.CmmToAsm.SPARC.CodeGen

663+ GHC.CmmToAsm.SPARC.CodeGen.Amode GHC.CmmToAsm.SPARC.CodeGen.Base

664+ GHC.CmmToAsm.SPARC.CodeGen.CondCode

665+ GHC.CmmToAsm.SPARC.CodeGen.Expand GHC.CmmToAsm.SPARC.CodeGen.Gen32

666+ GHC.CmmToAsm.SPARC.CodeGen.Gen64 GHC.CmmToAsm.SPARC.CodeGen.Sanity

667+ GHC.CmmToAsm.SPARC.Cond GHC.CmmToAsm.SPARC.Imm

668+ GHC.CmmToAsm.SPARC.Instr GHC.CmmToAsm.SPARC.Ppr

669+ GHC.CmmToAsm.SPARC.Regs GHC.CmmToAsm.SPARC.ShortcutJump

670+ GHC.CmmToAsm.SPARC.Stack GHC.CmmToAsm.X86.CodeGen

671+ GHC.CmmToAsm.X86.Cond GHC.CmmToAsm.X86.Instr GHC.CmmToAsm.X86.Ppr

672+ GHC.CmmToAsm.X86.RegInfo GHC.CmmToAsm.X86.Regs GHC.CmmToC

673+ GHC.CmmToLlvm GHC.CmmToLlvm.Base GHC.CmmToLlvm.CodeGen

674+ GHC.CmmToLlvm.Data GHC.CmmToLlvm.Mangler GHC.CmmToLlvm.Ppr

675+ GHC.CmmToLlvm.Regs GHC.Core GHC.Core.Class GHC.Core.Coercion

676+ GHC.Core.Coercion.Axiom GHC.Core.Coercion.Opt GHC.Core.ConLike

677+ GHC.Core.DataCon GHC.Core.FVs GHC.Core.FamInstEnv GHC.Core.InstEnv

678+ GHC.Core.Lint GHC.Core.Make GHC.Core.Map GHC.Core.Multiplicity

679+ GHC.Core.Opt.Arity GHC.Core.Opt.CSE GHC.Core.Opt.CallArity

680+ GHC.Core.Opt.ConstantFold GHC.Core.Opt.CprAnal GHC.Core.Opt.DmdAnal

681+ GHC.Core.Opt.Exitify GHC.Core.Opt.FloatIn GHC.Core.Opt.FloatOut

682+ GHC.Core.Opt.LiberateCase GHC.Core.Opt.Monad GHC.Core.Opt.OccurAnal

683+ GHC.Core.Opt.Pipeline GHC.Core.Opt.SetLevels GHC.Core.Opt.Simplify

684+ GHC.Core.Opt.Simplify.Env GHC.Core.Opt.Simplify.Monad

685+ GHC.Core.Opt.Simplify.Utils GHC.Core.Opt.SpecConstr

686+ GHC.Core.Opt.Specialise GHC.Core.Opt.StaticArgs

687+ GHC.Core.Opt.WorkWrap GHC.Core.Opt.WorkWrap.Utils GHC.Core.PatSyn

688+ GHC.Core.Ppr GHC.Core.Ppr.TyThing GHC.Core.Predicate GHC.Core.Rules

689+ GHC.Core.Seq GHC.Core.SimpleOpt GHC.Core.Stats GHC.Core.Subst

690+ GHC.Core.Tidy GHC.Core.TyCo.FVs GHC.Core.TyCo.Ppr GHC.Core.TyCo.Rep

691+ GHC.Core.TyCo.Subst GHC.Core.TyCo.Tidy GHC.Core.TyCon GHC.Core.Type

692+ GHC.Core.Unfold GHC.Core.Unify GHC.Core.UsageEnv GHC.Core.Utils

693+ GHC.CoreToByteCode GHC.CoreToIface GHC.CoreToStg GHC.CoreToStg.Prep

694+ GHC.Data.Bag GHC.Data.Bitmap GHC.Data.BooleanFormula

695+ GHC.Data.EnumSet GHC.Data.FastMutInt GHC.Data.FastString

696+ GHC.Data.FastString.Env GHC.Data.FiniteMap GHC.Data.Graph.Base

697+ GHC.Data.Graph.Color GHC.Data.Graph.Directed GHC.Data.Graph.Ops

698+ GHC.Data.Graph.Ppr GHC.Data.Graph.UnVar GHC.Data.IOEnv

699+ GHC.Data.List.SetOps GHC.Data.Maybe GHC.Data.OrdList GHC.Data.Pair

700+ GHC.Data.Stream GHC.Data.StringBuffer GHC.Data.TrieMap

701+ GHC.Data.UnionFind GHC.Driver.Backend GHC.Driver.Backpack

702+ GHC.Driver.Backpack.Syntax GHC.Driver.CmdLine GHC.Driver.CodeOutput

703+ GHC.Driver.Finder GHC.Driver.Flags GHC.Driver.Hooks GHC.Driver.Main

704+ GHC.Driver.Make GHC.Driver.MakeFile GHC.Driver.Monad

705+ GHC.Driver.Phases GHC.Driver.Pipeline GHC.Driver.Pipeline.Monad

706+ GHC.Driver.Plugins GHC.Driver.Session GHC.Driver.Types

707+ GHC.Driver.Ways GHC.Hs GHC.Hs.Binds GHC.Hs.Decls GHC.Hs.Doc

708+ GHC.Hs.Dump GHC.Hs.Expr GHC.Hs.Extension GHC.Hs.ImpExp

709+ GHC.Hs.Instances GHC.Hs.Lit GHC.Hs.Pat GHC.Hs.Stats GHC.Hs.Type

710+ GHC.Hs.Utils GHC.HsToCore GHC.HsToCore.Arrows GHC.HsToCore.Binds

711+ GHC.HsToCore.Coverage GHC.HsToCore.Docs GHC.HsToCore.Expr

712+ GHC.HsToCore.Foreign.Call GHC.HsToCore.Foreign.Decl

713+ GHC.HsToCore.GuardedRHSs GHC.HsToCore.ListComp GHC.HsToCore.Match

714+ GHC.HsToCore.Match.Constructor GHC.HsToCore.Match.Literal

715+ GHC.HsToCore.Monad GHC.HsToCore.PmCheck GHC.HsToCore.PmCheck.Oracle

716+ GHC.HsToCore.PmCheck.Ppr GHC.HsToCore.PmCheck.Types

717+ GHC.HsToCore.Quote GHC.HsToCore.Usage GHC.HsToCore.Utils

718+ GHC.Iface.Binary GHC.Iface.Env GHC.Iface.Ext.Ast

719+ GHC.Iface.Ext.Binary GHC.Iface.Ext.Debug GHC.Iface.Ext.Types

720+ GHC.Iface.Ext.Utils GHC.Iface.Load GHC.Iface.Make GHC.Iface.Recomp

721+ GHC.Iface.Recomp.Binary GHC.Iface.Recomp.Flags GHC.Iface.Rename

722+ GHC.Iface.Syntax GHC.Iface.Tidy GHC.Iface.Tidy.StaticPtrTable

723+ GHC.Iface.Type GHC.IfaceToCore GHC.Llvm GHC.Llvm.MetaData

724+ GHC.Llvm.Ppr GHC.Llvm.Syntax GHC.Llvm.Types GHC.Parser

725+ GHC.Parser.Annotation GHC.Parser.CharClass GHC.Parser.Header

726+ GHC.Parser.Lexer GHC.Parser.PostProcess

727+ GHC.Parser.PostProcess.Haddock GHC.Platform.AArch64

728+ GHC.Platform.ARM GHC.Platform.NoRegs GHC.Platform.PPC

729+ GHC.Platform.Reg GHC.Platform.Reg.Class GHC.Platform.Regs

730+ GHC.Platform.S390X GHC.Platform.SPARC GHC.Platform.X86

731+ GHC.Platform.X86_64 GHC.Plugins GHC.Prelude GHC.Rename.Bind

732+ GHC.Rename.Doc GHC.Rename.Env GHC.Rename.Expr GHC.Rename.Fixity

733+ GHC.Rename.HsType GHC.Rename.Module GHC.Rename.Names GHC.Rename.Pat

734+ GHC.Rename.Splice GHC.Rename.Unbound GHC.Rename.Utils

735+ GHC.Runtime.Debugger GHC.Runtime.Eval GHC.Runtime.Eval.Types

736+ GHC.Runtime.Heap.Inspect GHC.Runtime.Heap.Layout

737+ GHC.Runtime.Interpreter GHC.Runtime.Interpreter.Types

738+ GHC.Runtime.Linker GHC.Runtime.Linker.Types GHC.Runtime.Loader

739+ GHC.Settings GHC.Settings.Config GHC.Settings.Constants

740+ GHC.Settings.IO GHC.Stg.CSE GHC.Stg.DepAnal GHC.Stg.FVs

741+ GHC.Stg.Lift GHC.Stg.Lift.Analysis GHC.Stg.Lift.Monad GHC.Stg.Lint

742+ GHC.Stg.Pipeline GHC.Stg.Stats GHC.Stg.Subst GHC.Stg.Syntax

743+ GHC.Stg.Unarise GHC.StgToCmm GHC.StgToCmm.ArgRep GHC.StgToCmm.Bind

744+ GHC.StgToCmm.CgUtils GHC.StgToCmm.Closure GHC.StgToCmm.DataCon

745+ GHC.StgToCmm.Env GHC.StgToCmm.Expr GHC.StgToCmm.ExtCode

746+ GHC.StgToCmm.Foreign GHC.StgToCmm.Heap GHC.StgToCmm.Hpc

747+ GHC.StgToCmm.Layout GHC.StgToCmm.Monad GHC.StgToCmm.Prim

748+ GHC.StgToCmm.Prof GHC.StgToCmm.Ticky GHC.StgToCmm.Types

749+ GHC.StgToCmm.Utils GHC.SysTools GHC.SysTools.Ar

750+ GHC.SysTools.BaseDir GHC.SysTools.Elf GHC.SysTools.ExtraObj

751+ GHC.SysTools.FileCleanup GHC.SysTools.Info GHC.SysTools.Process

752+ GHC.SysTools.Tasks GHC.SysTools.Terminal GHC.Tc.Deriv

753+ GHC.Tc.Deriv.Functor GHC.Tc.Deriv.Generate GHC.Tc.Deriv.Generics

754+ GHC.Tc.Deriv.Infer GHC.Tc.Deriv.Utils GHC.Tc.Errors

755+ GHC.Tc.Errors.Hole GHC.Tc.Errors.Hole.FitTypes

756+ GHC.Tc.Gen.Annotation GHC.Tc.Gen.Arrow GHC.Tc.Gen.Bind

757+ GHC.Tc.Gen.Default GHC.Tc.Gen.Export GHC.Tc.Gen.Expr

758+ GHC.Tc.Gen.Foreign GHC.Tc.Gen.HsType GHC.Tc.Gen.Match

759+ GHC.Tc.Gen.Pat GHC.Tc.Gen.Rule GHC.Tc.Gen.Sig GHC.Tc.Gen.Splice

760+ GHC.Tc.Instance.Class GHC.Tc.Instance.Family

761+ GHC.Tc.Instance.FunDeps GHC.Tc.Instance.Typeable GHC.Tc.Module

762+ GHC.Tc.Plugin GHC.Tc.Solver GHC.Tc.Solver.Canonical

763+ GHC.Tc.Solver.Flatten GHC.Tc.Solver.Interact GHC.Tc.Solver.Monad

764+ GHC.Tc.TyCl GHC.Tc.TyCl.Build GHC.Tc.TyCl.Class

765+ GHC.Tc.TyCl.Instance GHC.Tc.TyCl.PatSyn GHC.Tc.TyCl.Utils

766+ GHC.Tc.Types GHC.Tc.Types.Constraint GHC.Tc.Types.EvTerm

767+ GHC.Tc.Types.Evidence GHC.Tc.Types.Origin GHC.Tc.Utils.Backpack

768+ GHC.Tc.Utils.Env GHC.Tc.Utils.Instantiate GHC.Tc.Utils.Monad

769+ GHC.Tc.Utils.TcMType GHC.Tc.Utils.TcType GHC.Tc.Utils.Unify

770+ GHC.Tc.Utils.Zonk GHC.Tc.Validity GHC.ThToHs GHC.Types.Annotations

771+ GHC.Types.Avail GHC.Types.Basic GHC.Types.CostCentre

772+ GHC.Types.CostCentre.State GHC.Types.Cpr GHC.Types.Demand

773+ GHC.Types.FieldLabel GHC.Types.ForeignCall GHC.Types.Id

774+ GHC.Types.Id.Info GHC.Types.Id.Make GHC.Types.Literal

775+ GHC.Types.Name GHC.Types.Name.Cache GHC.Types.Name.Env

776+ GHC.Types.Name.Occurrence GHC.Types.Name.Reader GHC.Types.Name.Set

777+ GHC.Types.Name.Shape GHC.Types.RepType GHC.Types.SrcLoc

778+ GHC.Types.Unique GHC.Types.Unique.DFM GHC.Types.Unique.DSet

779+ GHC.Types.Unique.FM GHC.Types.Unique.Set GHC.Types.Unique.Supply

780+ GHC.Types.Var GHC.Types.Var.Env GHC.Types.Var.Set GHC.Unit

781+ GHC.Unit.Info GHC.Unit.Module GHC.Unit.Module.Env

782+ GHC.Unit.Module.Location GHC.Unit.Module.Name GHC.Unit.Parser

783+ GHC.Unit.Ppr GHC.Unit.State GHC.Unit.Types GHC.Utils.Asm

784+ GHC.Utils.Binary GHC.Utils.BufHandle GHC.Utils.CliOption

785+ GHC.Utils.Encoding GHC.Utils.Error GHC.Utils.Exception GHC.Utils.FV

786+ GHC.Utils.Fingerprint GHC.Utils.IO.Unsafe GHC.Utils.Json

787+ GHC.Utils.Lexeme GHC.Utils.Misc GHC.Utils.Monad

788+ GHC.Utils.Monad.State GHC.Utils.Outputable GHC.Utils.Panic

789+ GHC.Utils.Panic.Plain GHC.Utils.Ppr GHC.Utils.Ppr.Colour

790+import-dirs:

791+library-dirs:

792+dynamic-library-dirs:

793+data-dir:

794+hs-libraries: HSghc-9.0.2

795+include-dirs:

796+depends:

797+ array-0.5.4.0 base-4.15.1.0 binary-0.8.8.0 bytestring-0.10.12.1

798+ containers-0.6.4.1 deepseq-1.4.5.0 directory-1.3.6.2

799+ exceptions-0.10.4 filepath-1.4.2.1 ghc-boot-9.0.2 ghc-boot-th-9.0.2

800+ ghc-heap-9.0.2 ghci-9.0.2 hpc-0.6.1.0 process-1.6.13.2

801+ template-haskell-2.17.0.0 terminfo-0.4.1.5 time-1.9.3

802+ transformers-0.5.6.2 unix-2.7.2.2

803+haddock-interfaces:

804+haddock-html:

805+---

806+name: ghc-bignum

807+version: 1.1

808+visibility: public

809+id: ghc-bignum-1.1

810+key: ghc-bignum-1.1

811+license: BSD-3-Clause

812+maintainer: libraries@haskell.org

813+author: Sylvain Henry

814+synopsis: GHC BigNum library

815+description:

816+ This package provides the low-level implementation of the standard

817+ 'BigNat', 'Natural' and 'Integer' types.

818+category: Numeric, Algebra, GHC

819+exposed: True

820+exposed-modules:

821+ GHC.Num.Backend GHC.Num.Backend.Native GHC.Num.Backend.Selected

822+ GHC.Num.BigNat GHC.Num.Integer GHC.Num.Natural GHC.Num.Primitives

823+ GHC.Num.WordArray

824+hidden-modules: GHC.Num.Backend.GMP

825+import-dirs:

826+library-dirs:

827+dynamic-library-dirs:

828+data-dir:

829+hs-libraries: HSghc-bignum-1.1

830+extra-libraries: gmp

831+include-dirs:

832+depends: ghc-prim-0.7.0

833+haddock-interfaces:

834+haddock-html:

835+---

836+name: ghc-boot

837+version: 9.0.2

838+visibility: public

839+id: ghc-boot-9.0.2

840+key: ghc-boot-9.0.2

841+license: BSD-3-Clause

842+maintainer: ghc-devs@haskell.org

843+synopsis: Shared functionality between GHC and its boot libraries

844+description:

845+ This library is shared between GHC, ghc-pkg, and other boot

846+ libraries.

847+ .

848+ A note about "GHC.Unit.Database": it only deals with the subset of

849+ the package database that the compiler cares about: modules

850+ paths etc and not package metadata like description, authors

851+ etc. It is thus not a library interface to ghc-pkg and is *not*

852+ suitable for modifying GHC package databases.

853+ .

854+ The package database format and this library are constructed in

855+ such a way that while ghc-pkg depends on Cabal, the GHC library

856+ and program do not have to depend on Cabal.

857+category: GHC

858+exposed: True

859+exposed-modules:

860+ GHC.BaseDir GHC.ForeignSrcLang GHC.HandleEncoding

861+ GHC.LanguageExtensions GHC.Platform GHC.Platform.Host

862+ GHC.Serialized GHC.Settings.Platform GHC.Settings.Utils

863+ GHC.UniqueSubdir GHC.Unit.Database GHC.Version

864+import-dirs:

865+library-dirs:

866+dynamic-library-dirs:

867+data-dir:

868+hs-libraries: HSghc-boot-9.0.2

869+depends:

870+ base-4.15.1.0 binary-0.8.8.0 bytestring-0.10.12.1

871+ containers-0.6.4.1 directory-1.3.6.2 filepath-1.4.2.1

872+ ghc-boot-th-9.0.2

873+haddock-interfaces:

874+haddock-html:

875+---

876+name: ghc-boot-th

877+version: 9.0.2

878+visibility: public

879+id: ghc-boot-th-9.0.2

880+key: ghc-boot-th-9.0.2

881+license: BSD-3-Clause

882+maintainer: ghc-devs@haskell.org

883+synopsis:

884+ Shared functionality between GHC and the @template-haskell@

885+ library

886+description:

887+ This library contains various bits shared between the @ghc@ and

888+ @template-haskell@ libraries.

889+ This package exists to ensure that @template-haskell@ has a

890+ minimal set of transitive dependencies, since it is intended to

891+ be depended upon by user code.

892+category: GHC

893+exposed: True

894+exposed-modules:

895+ GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme

896+import-dirs:

897+library-dirs:

898+dynamic-library-dirs:

899+data-dir:

900+hs-libraries: HSghc-boot-th-9.0.2

901+depends: base-4.15.1.0

902+haddock-interfaces:

903+haddock-html:

904+---

905+name: ghc-compact

906+version: 0.1.0.0

907+visibility: public

908+id: ghc-compact-0.1.0.0

909+key: ghc-compact-0.1.0.0

910+license: BSD-3-Clause

911+maintainer: libraries@haskell.org

912+synopsis: In memory storage of deeply evaluated data structure

913+description:

914+ This package provides minimal functionality for working with

915+ "compact regions", which hold a fully evaluated Haskell object graph.

916+ These regions maintain the invariant that no pointers live inside the struct

917+ that point outside it, which ensures efficient garbage collection without

918+ ever reading the structure contents (effectively, it works as a manually

919+ managed "oldest generation" which is never freed until the whole is

920+ released).

921+ Internally, the struct is stored a single contiguous block of memory,

922+ which allows efficient serialization and deserialization of structs

923+ for distributed computing.

924+ This package provides a low-level API; see also the </package/compact

925+ compact package> which provides a user-facing API.

926+category: Data

927+exposed: True

928+exposed-modules: GHC.Compact GHC.Compact.Serialized

929+import-dirs:

930+library-dirs:

931+dynamic-library-dirs:

932+data-dir:

933+hs-libraries: HSghc-compact-0.1.0.0

934+depends: base-4.15.1.0 bytestring-0.10.12.1 ghc-prim-0.7.0

935+haddock-interfaces:

936+haddock-html:

937+---

938+name: ghc-heap

939+version: 9.0.2

940+visibility: public

941+id: ghc-heap-9.0.2

942+key: ghc-heap-9.0.2

943+license: BSD-3-Clause

944+maintainer: libraries@haskell.org

945+synopsis: Functions for walking GHC's heap

946+description:

947+ This package provides functions for walking the GHC heap data structures

948+ and retrieving information about those data structures.

949+category: GHC

950+exposed: True

951+exposed-modules:

952+ GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures

953+ GHC.Exts.Heap.Constants GHC.Exts.Heap.InfoTable

954+ GHC.Exts.Heap.InfoTable.Types GHC.Exts.Heap.InfoTableProf

955+ GHC.Exts.Heap.Utils

956+import-dirs:

957+library-dirs:

958+dynamic-library-dirs:

959+data-dir:

960+hs-libraries: HSghc-heap-9.0.2

961+depends: base-4.15.1.0 ghc-prim-0.7.0 rts

962+haddock-interfaces:

963+haddock-html:

964+---

965+name: ghc-prim

966+version: 0.7.0

967+visibility: public

968+id: ghc-prim-0.7.0

969+key: ghc-prim-0.7.0

970+license: BSD-3-Clause

971+maintainer: libraries@haskell.org

972+synopsis: GHC primitives

973+description:

974+ This package contains the primitive types and operations supplied by GHC.

975+category: GHC

976+exposed: True

977+exposed-modules:

978+ GHC.CString GHC.Classes GHC.Debug GHC.IntWord64 GHC.Magic

979+ GHC.Prim.Exception GHC.Prim.Ext GHC.Prim.Panic GHC.PrimopWrappers

980+ GHC.Tuple GHC.Types GHC.Prim

981+import-dirs:

982+library-dirs:

983+dynamic-library-dirs:

984+data-dir:

985+hs-libraries: HSghc-prim-0.7.0

986+extra-libraries: gcc c m

987+depends: rts

988+haddock-interfaces:

989+haddock-html:

990+---

991+name: ghci

992+version: 9.0.2

993+visibility: public

994+id: ghci-9.0.2

995+key: ghci-9.0.2

996+license: BSD-3-Clause

997+maintainer: ghc-devs@haskell.org

998+synopsis: The library supporting GHC's interactive interpreter

999+description:

1000+ This library offers interfaces which mediate interactions between the

1001+ @ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter

1002+ backend.

1003+category: GHC

1004+exposed: True

1005+exposed-modules:

1006+ GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI

1007+ GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes

1008+ GHCi.ResolvedBCO GHCi.Run GHCi.Signals GHCi.StaticPtrTable GHCi.TH

1009+ GHCi.TH.Binary SizedSeq

1010+import-dirs:

1011+library-dirs:

1012+dynamic-library-dirs:

1013+data-dir:

1014+hs-libraries: HSghci-9.0.2

1015+include-dirs:

1016+depends:

1017+ array-0.5.4.0 base-4.15.1.0 binary-0.8.8.0 bytestring-0.10.12.1

1018+ containers-0.6.4.1 deepseq-1.4.5.0 filepath-1.4.2.1 ghc-boot-9.0.2

1019+ ghc-boot-th-9.0.2 ghc-heap-9.0.2 rts template-haskell-2.17.0.0

1020+ transformers-0.5.6.2 unix-2.7.2.2

1021+haddock-interfaces:

1022+haddock-html:

1023+---

1024+name: haskeline

1025+version: 0.8.2

1026+visibility: public

1027+id: haskeline-0.8.2

1028+key: haskeline-0.8.2

1029+license: BSD-3-Clause

1030+copyright: (c) Judah Jacobson

1031+maintainer: Judah Jacobson <judah.jacobson@gmail.com>

1032+author: Judah Jacobson

1033+stability: Stable

1034+homepage: https://github.com/judah/haskeline

1035+synopsis:

1036+ A command-line interface for user input, written in Haskell.

1037+description:

1038+ Haskeline provides a user interface for line input in command-line

1039+ programs. This library is similar in purpose to readline, but since

1040+ it is written in Haskell it is (hopefully) more easily used in other

1041+ Haskell programs.

1042+ Haskeline runs both on POSIX-compatible systems and on Windows.

1043+category: User Interfaces

1044+exposed: True

1045+exposed-modules:

1046+ System.Console.Haskeline System.Console.Haskeline.Completion

1047+ System.Console.Haskeline.History System.Console.Haskeline.IO

1048+ System.Console.Haskeline.Internal

1049+hidden-modules:

1050+ System.Console.Haskeline.Backend

1051+ System.Console.Haskeline.Backend.WCWidth

1052+ System.Console.Haskeline.Command

1053+ System.Console.Haskeline.Command.Completion

1054+ System.Console.Haskeline.Command.History

1055+ System.Console.Haskeline.Command.KillRing

1056+ System.Console.Haskeline.Directory System.Console.Haskeline.Emacs

1057+ System.Console.Haskeline.InputT System.Console.Haskeline.Key

1058+ System.Console.Haskeline.LineState System.Console.Haskeline.Monads

1059+ System.Console.Haskeline.Prefs System.Console.Haskeline.Recover

1060+ System.Console.Haskeline.RunCommand System.Console.Haskeline.Term

1061+ System.Console.Haskeline.Command.Undo System.Console.Haskeline.Vi

1062+ System.Console.Haskeline.Backend.Posix

1063+ System.Console.Haskeline.Backend.Posix.Encoder

1064+ System.Console.Haskeline.Backend.DumbTerm

1065+ System.Console.Haskeline.Backend.Terminfo

1066+import-dirs:

1067+library-dirs:

1068+dynamic-library-dirs:

1069+data-dir:

1070+hs-libraries: HShaskeline-0.8.2

1071+depends:

1072+ base-4.15.1.0 bytestring-0.10.12.1 containers-0.6.4.1

1073+ directory-1.3.6.2 exceptions-0.10.4 filepath-1.4.2.1

1074+ process-1.6.13.2 stm-2.5.0.0 terminfo-0.4.1.5 transformers-0.5.6.2

1075+ unix-2.7.2.2

1076+haddock-interfaces:

1077+haddock-html:

1078+---

1079+name: hpc

1080+version: 0.6.1.0

1081+visibility: public

1082+id: hpc-0.6.1.0

1083+key: hpc-0.6.1.0

1084+license: BSD-3-Clause

1085+maintainer: ghc-devs@haskell.org

1086+author: Andy Gill

1087+synopsis: Code Coverage Library for Haskell

1088+description:

1089+ This package provides the code coverage library for Haskell.

1090+ See <http://www.haskell.org/haskellwiki/Haskell_program_coverage> for more

1091+ information.

1092+category: Control

1093+exposed: True

1094+exposed-modules:

1095+ Trace.Hpc.Mix Trace.Hpc.Reflect Trace.Hpc.Tix Trace.Hpc.Util

1096+import-dirs:

1097+library-dirs:

1098+dynamic-library-dirs:

1099+data-dir:

1100+hs-libraries: HShpc-0.6.1.0

1101+depends:

1102+ base-4.15.1.0 containers-0.6.4.1 deepseq-1.4.5.0 directory-1.3.6.2

1103+ filepath-1.4.2.1 time-1.9.3

1104+haddock-interfaces:

1105+haddock-html:

1106+---

1107+name: integer-gmp

1108+version: 1.1

1109+visibility: public

1110+id: integer-gmp-1.1

1111+key: integer-gmp-1.1

1112+license: BSD-3-Clause

1113+maintainer: hvr@gnu.org

1114+author: Herbert Valerio Riedel

1115+synopsis: Integer library based on GMP

1116+description:

1117+ This package used to provide an implementation of the standard 'Integer'

1118+ type based on the

1119+ <http://gmplib.org/ GNU Multiple Precision Arithmetic Library (GMP)>.

1120+ It is now deprecated in favor of the 'ghc-bignum' package.

1121+ Its purpose is to provide backward compatibility for codes directly

1122+ depending on the `integer-gmp` package.

1123+category: Numeric, Algebra

1124+exposed: True

1125+exposed-modules: GHC.Integer.GMP.Internals

1126+import-dirs:

1127+library-dirs:

1128+dynamic-library-dirs:

1129+data-dir:

1130+hs-libraries: HSinteger-gmp-1.1

1131+depends: base-4.15.1.0 ghc-bignum-1.1 ghc-prim-0.7.0

1132+haddock-interfaces:

1133+haddock-html:

1134+---

1135+name: libiserv

1136+version: 9.0.2

1137+visibility: public

1138+id: libiserv-9.0.2

1139+key: libiserv-9.0.2

1140+license: BSD-3-Clause

1141+copyright: XXX

1142+maintainer: XXX

1143+author: XXX

1144+synopsis:

1145+ Provides shared functionality between iserv and iserv-proxy.

1146+description:

1147+ Provides shared functionality between iserv and iserv-proxy.

1148+category: Development

1149+exposed: True

1150+exposed-modules: GHCi.Utils Lib

1151+import-dirs:

1152+library-dirs:

1153+dynamic-library-dirs:

1154+data-dir:

1155+hs-libraries: HSlibiserv-9.0.2

1156+depends:

1157+ base-4.15.1.0 binary-0.8.8.0 bytestring-0.10.12.1

1158+ containers-0.6.4.1 deepseq-1.4.5.0 ghci-9.0.2 unix-2.7.2.2

1159+haddock-interfaces:

1160+haddock-html:

1161+---

1162+name: mtl

1163+version: 2.2.2

1164+visibility: public

1165+id: mtl-2.2.2

1166+key: mtl-2.2.2

1167+license: BSD-3-Clause

1168+maintainer: Edward Kmett <ekmett@gmail.com>

1169+author: Andy Gill

1170+homepage: http://github.com/haskell/mtl

1171+synopsis: Monad classes, using functional dependencies

1172+description:

1173+ Monad classes using functional dependencies, with instances

1174+ for various monad transformers, inspired by the paper

1175+ /Functional Programming with Overloading and Higher-Order Polymorphism/,

1176+ by Mark P Jones, in /Advanced School of Functional Programming/, 1995

1177+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1178+category: Control

1179+exposed: True

1180+exposed-modules:

1181+ Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error

1182+ Control.Monad.Error.Class Control.Monad.Except

1183+ Control.Monad.Identity Control.Monad.List Control.Monad.RWS

1184+ Control.Monad.RWS.Class Control.Monad.RWS.Lazy

1185+ Control.Monad.RWS.Strict Control.Monad.Reader

1186+ Control.Monad.Reader.Class Control.Monad.State

1187+ Control.Monad.State.Class Control.Monad.State.Lazy

1188+ Control.Monad.State.Strict Control.Monad.Trans Control.Monad.Writer

1189+ Control.Monad.Writer.Class Control.Monad.Writer.Lazy

1190+ Control.Monad.Writer.Strict

1191+import-dirs:

1192+library-dirs:

1193+dynamic-library-dirs:

1194+data-dir:

1195+hs-libraries: HSmtl-2.2.2

1196+depends: base-4.15.1.0 transformers-0.5.6.2

1197+haddock-interfaces:

1198+haddock-html:

1199+---

1200+name: parsec

1201+version: 3.1.14.0

1202+visibility: public

1203+id: parsec-3.1.14.0

1204+key: parsec-3.1.14.0

1205+license: BSD-3-Clause

1206+maintainer: Herbert Valerio Riedel <hvr@gnu.org>

1207+author:

1208+ Daan Leijen <daan@microsoft.com>, Paolo Martini <paolo@nemail.it>, Antoine Latter <aslatter@gmail.com>

1209+homepage: https://github.com/haskell/parsec

1210+synopsis: Monadic parser combinators

1211+description:

1212+ Parsec is designed from scratch as an industrial-strength parser

1213+ library. It is simple, safe, well documented (on the package

1214+ homepage), has extensive libraries, good error messages,

1215+ and is fast. It is defined as a monad transformer that can be

1216+ stacked on arbitrary monads, and it is also parametric in the

1217+ input stream type.

1218+ The main entry point is the "Text.Parsec" module which provides

1219+ defaults for parsing 'Char'acter data.

1220+ The "Text.ParserCombinators.Parsec" module hierarchy contains

1221+ the legacy @parsec-2@ API and may be removed at some point in

1222+ the future.

1223+category: Parsing

1224+exposed: True

1225+exposed-modules:

1226+ Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy

1227+ Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error

1228+ Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm

1229+ Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String

1230+ Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token

1231+ Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char

1232+ Text.ParserCombinators.Parsec.Combinator

1233+ Text.ParserCombinators.Parsec.Error

1234+ Text.ParserCombinators.Parsec.Expr

1235+ Text.ParserCombinators.Parsec.Language

1236+ Text.ParserCombinators.Parsec.Perm

1237+ Text.ParserCombinators.Parsec.Pos

1238+ Text.ParserCombinators.Parsec.Prim

1239+ Text.ParserCombinators.Parsec.Token

1240+import-dirs:

1241+library-dirs:

1242+dynamic-library-dirs:

1243+data-dir:

1244+hs-libraries: HSparsec-3.1.14.0

1245+depends:

1246+ base-4.15.1.0 bytestring-0.10.12.1 mtl-2.2.2 text-1.2.5.0

1247+haddock-interfaces:

1248+haddock-html:

1249+---

1250+name: pretty

1251+version: 1.1.3.6

1252+visibility: public

1253+id: pretty-1.1.3.6

1254+key: pretty-1.1.3.6

1255+license: BSD-3-Clause

1256+maintainer: David Terei <code@davidterei.com>

1257+stability: Stable

1258+homepage: http://github.com/haskell/pretty

1259+synopsis: Pretty-printing library

1260+description:

1261+ This package contains a pretty-printing library, a set of API's

1262+ that provides a way to easily print out text in a consistent

1263+ format of your choosing. This is useful for compilers and related

1264+ tools.

1265+ This library was originally designed by John Hughes's and has since

1266+ been heavily modified by Simon Peyton Jones.

1267+category: Text

1268+exposed: True

1269+exposed-modules:

1270+ Text.PrettyPrint Text.PrettyPrint.Annotated

1271+ Text.PrettyPrint.Annotated.HughesPJ

1272+ Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ

1273+ Text.PrettyPrint.HughesPJClass

1274+import-dirs:

1275+library-dirs:

1276+dynamic-library-dirs:

1277+data-dir:

1278+hs-libraries: HSpretty-1.1.3.6

1279+depends: base-4.15.1.0 deepseq-1.4.5.0 ghc-prim-0.7.0

1280+haddock-interfaces:

1281+haddock-html:

1282+---

1283+name: process

1284+version: 1.6.13.2

1285+visibility: public

1286+id: process-1.6.13.2

1287+key: process-1.6.13.2

1288+license: BSD-3-Clause

1289+maintainer: libraries@haskell.org

1290+synopsis: Process libraries

1291+description:

1292+ This package contains libraries for dealing with system processes.

1293+ The typed-process package is a more recent take on a process API,

1294+ which uses this package internally. It features better binary

1295+ support, easier concurrency, and a more composable API. You can

1296+ read more about it at

1297+ <https://github.com/fpco/typed-process/#readme>.

1298+category: System

1299+exposed: True

1300+exposed-modules: System.Cmd System.Process System.Process.Internals

1301+hidden-modules: System.Process.Common System.Process.Posix

1302+import-dirs:

1303+library-dirs:

1304+dynamic-library-dirs:

1305+data-dir:

1306+hs-libraries: HSprocess-1.6.13.2

1307+include-dirs:

1308+includes: runProcess.h

1309+depends:

1310+ base-4.15.1.0 deepseq-1.4.5.0 directory-1.3.6.2 filepath-1.4.2.1

1311+ unix-2.7.2.2

1312+haddock-interfaces:

1313+haddock-html:

1314+---

1315+name: stm

1316+version: 2.5.0.0

1317+visibility: public

1318+id: stm-2.5.0.0

1319+key: stm-2.5.0.0

1320+license: BSD-3-Clause

1321+maintainer: libraries@haskell.org

1322+homepage: https://wiki.haskell.org/Software_transactional_memory

1323+synopsis: Software Transactional Memory

1324+description:

1325+ Software Transactional Memory, or STM, is an abstraction for

1326+ concurrent communication. The main benefits of STM are

1327+ /composability/ and /modularity/. That is, using STM you can write

1328+ concurrent abstractions that can be easily composed with any other

1329+ abstraction built using STM, without exposing the details of how

1330+ your abstraction ensures safety. This is typically not the case

1331+ with other forms of concurrent communication, such as locks or

1332+ 'MVar's.

1333+category: Concurrency

1334+exposed: True

1335+exposed-modules:

1336+ Control.Concurrent.STM Control.Concurrent.STM.TArray

1337+ Control.Concurrent.STM.TBQueue Control.Concurrent.STM.TChan

1338+ Control.Concurrent.STM.TMVar Control.Concurrent.STM.TQueue

1339+ Control.Concurrent.STM.TSem Control.Concurrent.STM.TVar

1340+ Control.Monad.STM

1341+hidden-modules: Control.Sequential.STM

1342+import-dirs:

1343+library-dirs:

1344+dynamic-library-dirs:

1345+data-dir:

1346+hs-libraries: HSstm-2.5.0.0

1347+depends: array-0.5.4.0 base-4.15.1.0

1348+haddock-interfaces:

1349+haddock-html:

1350+---

1351+name: template-haskell

1352+version: 2.17.0.0

1353+visibility: public

1354+id: template-haskell-2.17.0.0

1355+key: template-haskell-2.17.0.0

1356+license: BSD-3-Clause

1357+maintainer: libraries@haskell.org

1358+synopsis: Support library for Template Haskell

1359+description:

1360+ This package provides modules containing facilities for manipulating

1361+ Haskell source code using Template Haskell.

1362+ See <http://www.haskell.org/haskellwiki/Template_Haskell> for more

1363+ information.

1364+category: Template Haskell

1365+exposed: True

1366+exposed-modules:

1367+ Language.Haskell.TH Language.Haskell.TH.CodeDo

1368+ Language.Haskell.TH.LanguageExtensions Language.Haskell.TH.Lib

1369+ Language.Haskell.TH.Lib.Internal Language.Haskell.TH.Ppr

1370+ Language.Haskell.TH.PprLib Language.Haskell.TH.Quote

1371+ Language.Haskell.TH.Syntax

1372+hidden-modules: Language.Haskell.TH.Lib.Map

1373+import-dirs:

1374+library-dirs:

1375+dynamic-library-dirs:

1376+data-dir:

1377+hs-libraries: HStemplate-haskell-2.17.0.0

1378+depends:

1379+ base-4.15.1.0 ghc-boot-th-9.0.2 ghc-prim-0.7.0 pretty-1.1.3.6

1380+haddock-interfaces:

1381+haddock-html:

1382+---

1383+name: terminfo

1384+version: 0.4.1.5

1385+visibility: public

1386+id: terminfo-0.4.1.5

1387+key: terminfo-0.4.1.5

1388+license: BSD-3-Clause

1389+copyright: (c) Judah Jacobson

1390+maintainer: Judah Jacobson <judah.jacobson@gmail.com>

1391+author: Judah Jacobson

1392+stability: Stable

1393+homepage: https://github.com/judah/terminfo

1394+synopsis: Haskell bindings to the terminfo library.

1395+description:

1396+ This library provides an interface to the terminfo database (via bindings to the

1397+ curses library). <http://en.wikipedia.org/wiki/Terminfo Terminfo> allows POSIX

1398+ systems to interact with a variety of terminals using a standard set of capabilities.

1399+category: User Interfaces

1400+exposed: True

1401+exposed-modules:

1402+ System.Console.Terminfo System.Console.Terminfo.Base

1403+ System.Console.Terminfo.Color System.Console.Terminfo.Cursor

1404+ System.Console.Terminfo.Edit System.Console.Terminfo.Effects

1405+ System.Console.Terminfo.Keys

1406+import-dirs:

1407+library-dirs:

1408+dynamic-library-dirs:

1409+data-dir:

1410+hs-libraries: HSterminfo-0.4.1.5

1411+extra-libraries: tinfo

1412+depends: base-4.15.1.0

1413+haddock-interfaces:

1414+haddock-html:

1415+---

1416+name: text

1417+version: 1.2.5.0

1418+visibility: public

1419+id: text-1.2.5.0

1420+key: text-1.2.5.0

1421+license: BSD-2-Clause

1422+copyright: 2009-2011 Bryan O'Sullivan, 2008-2009 Tom Harper

1423+maintainer:

1424+ Haskell Text Team <andrew.lelechenko@gmail.com>, Core Libraries Committee

1425+author: Bryan O'Sullivan <bos@serpentine.com>

1426+homepage: https://github.com/haskell/text

1427+synopsis: An efficient packed Unicode text type.

1428+description:

1429+ An efficient packed, immutable Unicode text type (both strict and

1430+ lazy), with a powerful loop fusion optimization framework.

1431+ The 'Text' type represents Unicode character strings, in a time and

1432+ space-efficient manner. This package provides text processing

1433+ capabilities that are optimized for performance critical use, both

1434+ in terms of large data quantities and high speed.

1435+ The 'Text' type provides character-encoding, type-safe case

1436+ conversion via whole-string case conversion functions (see "Data.Text").

1437+ It also provides a range of functions for converting 'Text' values to

1438+ and from 'ByteStrings', using several standard encodings

1439+ (see "Data.Text.Encoding").

1440+ Efficient locale-sensitive support for text IO is also supported

1441+ (see "Data.Text.IO").

1442+ These modules are intended to be imported qualified, to avoid name

1443+ clashes with Prelude functions, e.g.

1444+ > import qualified Data.Text as T

1445+ == ICU Support

1446+ To use an extended and very rich family of functions for working

1447+ with Unicode text (including normalization, regular expressions,

1448+ non-standard encodings, text breaking, and locales), see

1449+ the [text-icu package](https://hackage.haskell.org/package/text-icu)

1450+ based on the well-respected and liberally

1451+ licensed [ICU library](http://site.icu-project.org/).

1452+ == Internal Representation: UTF-16 vs. UTF-8

1453+ Currently the @text@ library uses UTF-16 as its internal representation

1454+ which is [neither a fixed-width nor always the most dense representation](http://utf8everywhere.org/)

1455+ for Unicode text. We're currently investigating the feasibility

1456+ of [changing Text's internal representation to UTF-8](https://github.com/text-utf8)

1457+ and if you need such a 'Text' type right now you might be interested in using the spin-off

1458+ packages <https://hackage.haskell.org/package/text-utf8 text-utf8> and

1459+ <https://hackage.haskell.org/package/text-short text-short>.

1460+category: Data, Text

1461+exposed: True

1462+exposed-modules:

1463+ Data.Text Data.Text.Array Data.Text.Encoding

1464+ Data.Text.Encoding.Error Data.Text.Foreign Data.Text.IO

1465+ Data.Text.Internal Data.Text.Internal.Builder

1466+ Data.Text.Internal.Builder.Functions

1467+ Data.Text.Internal.Builder.Int.Digits

1468+ Data.Text.Internal.Builder.RealFloat.Functions

1469+ Data.Text.Internal.ByteStringCompat

1470+ Data.Text.Internal.Encoding.Fusion

1471+ Data.Text.Internal.Encoding.Fusion.Common

1472+ Data.Text.Internal.Encoding.Utf16 Data.Text.Internal.Encoding.Utf32

1473+ Data.Text.Internal.Encoding.Utf8 Data.Text.Internal.Functions

1474+ Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping

1475+ Data.Text.Internal.Fusion.Common Data.Text.Internal.Fusion.Size

1476+ Data.Text.Internal.Fusion.Types Data.Text.Internal.IO

1477+ Data.Text.Internal.Lazy Data.Text.Internal.Lazy.Encoding.Fusion

1478+ Data.Text.Internal.Lazy.Fusion Data.Text.Internal.Lazy.Search

1479+ Data.Text.Internal.PrimCompat Data.Text.Internal.Private

1480+ Data.Text.Internal.Read Data.Text.Internal.Search

1481+ Data.Text.Internal.Unsafe Data.Text.Internal.Unsafe.Char

1482+ Data.Text.Internal.Unsafe.Shift Data.Text.Lazy

1483+ Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int

1484+ Data.Text.Lazy.Builder.RealFloat Data.Text.Lazy.Encoding

1485+ Data.Text.Lazy.IO Data.Text.Lazy.Internal Data.Text.Lazy.Read

1486+ Data.Text.Read Data.Text.Unsafe

1487+hidden-modules: Data.Text.Show

1488+import-dirs:

1489+library-dirs:

1490+dynamic-library-dirs:

1491+data-dir:

1492+hs-libraries: HStext-1.2.5.0

1493+depends:

1494+ array-0.5.4.0 base-4.15.1.0 binary-0.8.8.0 bytestring-0.10.12.1

1495+ deepseq-1.4.5.0 ghc-prim-0.7.0 template-haskell-2.17.0.0

1496+haddock-interfaces:

1497+haddock-html:

1498+---

1499+name: time

1500+version: 1.9.3

1501+visibility: public

1502+id: time-1.9.3

1503+key: time-1.9.3

1504+license: BSD-3-Clause

1505+maintainer: <ashley@semantic.org>

1506+author: Ashley Yakeley

1507+stability: stable

1508+homepage: https://github.com/haskell/time

1509+synopsis: A time library

1510+description: Time, clocks and calendars

1511+category: Time

1512+exposed: True

1513+exposed-modules:

1514+ Data.Time Data.Time.Calendar Data.Time.Calendar.Easter

1515+ Data.Time.Calendar.Julian Data.Time.Calendar.MonthDay

1516+ Data.Time.Calendar.OrdinalDate Data.Time.Calendar.WeekDate

1517+ Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System

1518+ Data.Time.Clock.TAI Data.Time.Format Data.Time.Format.ISO8601

1519+ Data.Time.Format.Internal Data.Time.LocalTime

1520+hidden-modules:

1521+ Data.Format Data.Time.Calendar.Private Data.Time.Calendar.Days

1522+ Data.Time.Calendar.Gregorian Data.Time.Calendar.CalendarDiffDays

1523+ Data.Time.Calendar.Week Data.Time.Calendar.JulianYearDay

1524+ Data.Time.Clock.Internal.DiffTime

1525+ Data.Time.Clock.Internal.AbsoluteTime

1526+ Data.Time.Clock.Internal.NominalDiffTime

1527+ Data.Time.Clock.Internal.POSIXTime

1528+ Data.Time.Clock.Internal.UniversalTime

1529+ Data.Time.Clock.Internal.SystemTime

1530+ Data.Time.Clock.Internal.UTCTime Data.Time.Clock.Internal.CTimeval

1531+ Data.Time.Clock.Internal.CTimespec Data.Time.Clock.Internal.UTCDiff

1532+ Data.Time.LocalTime.Internal.TimeZone

1533+ Data.Time.LocalTime.Internal.TimeOfDay

1534+ Data.Time.LocalTime.Internal.CalendarDiffTime

1535+ Data.Time.LocalTime.Internal.LocalTime

1536+ Data.Time.LocalTime.Internal.ZonedTime Data.Time.Format.Parse

1537+ Data.Time.Format.Locale Data.Time.Format.Format.Class

1538+ Data.Time.Format.Format.Instances Data.Time.Format.Parse.Class

1539+ Data.Time.Format.Parse.Instances

1540+import-dirs:

1541+library-dirs:

1542+dynamic-library-dirs:

1543+data-dir:

1544+hs-libraries: HStime-1.9.3

1545+include-dirs:

1546+depends: base-4.15.1.0 deepseq-1.4.5.0

1547+haddock-interfaces:

1548+haddock-html:

1549+---

1550+name: transformers

1551+version: 0.5.6.2

1552+visibility: public

1553+id: transformers-0.5.6.2

1554+key: transformers-0.5.6.2

1555+license: BSD-3-Clause

1556+maintainer: Ross Paterson <R.Paterson@city.ac.uk>

1557+author: Andy Gill, Ross Paterson

1558+synopsis: Concrete functor and monad transformers

1559+description:

1560+ A portable library of functor and monad transformers, inspired by

1561+ the paper

1562+ * \"Functional Programming with Overloading and Higher-Order

1563+ Polymorphism\", by Mark P Jones,

1564+ in /Advanced School of Functional Programming/, 1995

1565+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1566+ This package contains:

1567+ * the monad transformer class (in "Control.Monad.Trans.Class")

1568+ * concrete functor and monad transformers, each with associated

1569+ operations and functions to lift operations associated with other

1570+ transformers.

1571+ The package can be used on its own in portable Haskell code, in

1572+ which case operations need to be manually lifted through transformer

1573+ stacks (see "Control.Monad.Trans.Class" for some examples).

1574+ Alternatively, it can be used with the non-portable monad classes in

1575+ the @mtl@ or @monads-tf@ packages, which automatically lift operations

1576+ introduced by monad transformers through other transformers.

1577+category: Control

1578+exposed: True

1579+exposed-modules:

1580+ Control.Applicative.Backwards Control.Applicative.Lift

1581+ Control.Monad.Signatures Control.Monad.Trans.Accum

1582+ Control.Monad.Trans.Class Control.Monad.Trans.Cont

1583+ Control.Monad.Trans.Error Control.Monad.Trans.Except

1584+ Control.Monad.Trans.Identity Control.Monad.Trans.List

1585+ Control.Monad.Trans.Maybe Control.Monad.Trans.RWS

1586+ Control.Monad.Trans.RWS.CPS Control.Monad.Trans.RWS.Lazy

1587+ Control.Monad.Trans.RWS.Strict Control.Monad.Trans.Reader

1588+ Control.Monad.Trans.Select Control.Monad.Trans.State

1589+ Control.Monad.Trans.State.Lazy Control.Monad.Trans.State.Strict

1590+ Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS

1591+ Control.Monad.Trans.Writer.Lazy Control.Monad.Trans.Writer.Strict

1592+ Data.Functor.Constant Data.Functor.Reverse

1593+import-dirs:

1594+library-dirs:

1595+dynamic-library-dirs:

1596+data-dir:

1597+hs-libraries: HStransformers-0.5.6.2

1598+depends: base-4.15.1.0

1599+haddock-interfaces:

1600+haddock-html:

1601+---

1602+name: unix

1603+version: 2.7.2.2

1604+visibility: public

1605+id: unix-2.7.2.2

1606+key: unix-2.7.2.2

1607+license: BSD-3-Clause

1608+maintainer: libraries@haskell.org

1609+homepage: https://github.com/haskell/unix

1610+synopsis: POSIX functionality

1611+description:

1612+ This package gives you access to the set of operating system

1613+ services standardised by

1614+ <http://pubs.opengroup.org/onlinepubs/9699919799/ POSIX.1-2008>

1615+ (or the IEEE Portable Operating System Interface for Computing

1616+ Environments - IEEE Std. 1003.1).

1617+ The package is not supported under Windows.

1618+category: System

1619+exposed: True

1620+exposed-modules:

1621+ System.Posix System.Posix.ByteString

1622+ System.Posix.ByteString.FilePath System.Posix.Directory

1623+ System.Posix.Directory.ByteString System.Posix.DynamicLinker

1624+ System.Posix.DynamicLinker.ByteString

1625+ System.Posix.DynamicLinker.Module

1626+ System.Posix.DynamicLinker.Module.ByteString

1627+ System.Posix.DynamicLinker.Prim System.Posix.Env

1628+ System.Posix.Env.ByteString System.Posix.Error System.Posix.Fcntl

1629+ System.Posix.Files System.Posix.Files.ByteString System.Posix.IO

1630+ System.Posix.IO.ByteString System.Posix.Process

1631+ System.Posix.Process.ByteString System.Posix.Process.Internals

1632+ System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem

1633+ System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp

1634+ System.Posix.Temp.ByteString System.Posix.Terminal

1635+ System.Posix.Terminal.ByteString System.Posix.Time

1636+ System.Posix.Unistd System.Posix.User

1637+hidden-modules:

1638+ System.Posix.Directory.Common System.Posix.DynamicLinker.Common

1639+ System.Posix.Files.Common System.Posix.IO.Common

1640+ System.Posix.Process.Common System.Posix.Terminal.Common

1641+import-dirs:

1642+library-dirs:

1643+dynamic-library-dirs:

1644+data-dir:

1645+hs-libraries: HSunix-2.7.2.2

1646+extra-libraries: rt util dl pthread

1647+include-dirs:

1648+includes: HsUnix.h execvpe.h

1649+depends: base-4.15.1.0 bytestring-0.10.12.1 time-1.9.3

1650+haddock-interfaces:

1651+haddock-html:

1652+---

1653+name: xhtml

1654+version: 3000.2.2.1

1655+visibility: public

1656+id: xhtml-3000.2.2.1

1657+key: xhtml-3000.2.2.1

1658+license: BSD-3-Clause

1659+copyright:

1660+ Bjorn Bringert 2004-2006, Andy Gill and the Oregon

1661+ Graduate Institute of Science and Technology, 1999-2001

1662+maintainer: Chris Dornan <chris@chrisdornan.com>

1663+author: Bjorn Bringert

1664+stability: Stable

1665+homepage: https://github.com/haskell/xhtml

1666+synopsis: An XHTML combinator library

1667+description:

1668+ This package provides combinators for producing

1669+ XHTML 1.0, including the Strict, Transitional and

1670+ Frameset variants.

1671+category: Web, XML, Pretty Printer

1672+exposed: True

1673+exposed-modules:

1674+ Text.XHtml Text.XHtml.Debug Text.XHtml.Frameset Text.XHtml.Strict

1675+ Text.XHtml.Table Text.XHtml.Transitional

1676+hidden-modules:

1677+ Text.XHtml.Strict.Attributes Text.XHtml.Strict.Elements

1678+ Text.XHtml.Frameset.Attributes Text.XHtml.Frameset.Elements

1679+ Text.XHtml.Transitional.Attributes Text.XHtml.Transitional.Elements

1680+ Text.XHtml.BlockTable Text.XHtml.Extras Text.XHtml.Internals

1681+import-dirs:

1682+library-dirs:

1683+dynamic-library-dirs:

1684+data-dir:

1685+hs-libraries: HSxhtml-3000.2.2.1

1686+depends: base-4.15.1.0

1687+haddock-interfaces:

1688+haddock-html:

1689+---

1690+name: rts

1691+version: 1.0.2

1692+visibility: public

1693+id: rts

1694+key: rts

1695+license: BSD-3-Clause

1696+maintainer: glasgow-haskell-users@haskell.org

1697+exposed: True

1698+library-dirs:

1699+hs-libraries: HSrts

1700+extra-libraries: m rt dl ffi numa pthread

1701+include-dirs:

1702+includes: Stg.h

1703+ld-options:

1704+ "-Wl,-u,base_GHCziTopHandler_runIO_closure"

1705+ "-Wl,-u,base_GHCziTopHandler_runNonIO_closure"

1706+ "-Wl,-u,ghczmprim_GHCziTuple_Z0T_closure"

1707+ "-Wl,-u,ghczmprim_GHCziTypes_True_closure"

1708+ "-Wl,-u,ghczmprim_GHCziTypes_False_closure"

1709+ "-Wl,-u,base_GHCziPack_unpackCString_closure"

1710+ "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure"

1711+ "-Wl,-u,base_GHCziIOziException_stackOverflow_closure"

1712+ "-Wl,-u,base_GHCziIOziException_heapOverflow_closure"

1713+ "-Wl,-u,base_GHCziIOziException_allocationLimitExceeded_closure"

1714+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"

1715+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"

1716+ "-Wl,-u,base_GHCziIOziException_cannotCompactFunction_closure"

1717+ "-Wl,-u,base_GHCziIOziException_cannotCompactPinned_closure"

1718+ "-Wl,-u,base_GHCziIOziException_cannotCompactMutable_closure"

1719+ "-Wl,-u,base_GHCziIOPort_doubleReadException_closure"

1720+ "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure"

1721+ "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure"

1722+ "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure"

1723+ "-Wl,-u,base_GHCziExceptionziType_divZZeroException_closure"

1724+ "-Wl,-u,base_GHCziExceptionziType_underflowException_closure"

1725+ "-Wl,-u,base_GHCziExceptionziType_overflowException_closure"

1726+ "-Wl,-u,base_GHCziConcziSync_runSparks_closure"

1727+ "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure"

1728+ "-Wl,-u,base_GHCziConcziIO_interruptIOManager_closure"

1729+ "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"

1730+ "-Wl,-u,base_GHCziConcziSignal_runHandlersPtr_closure"

1731+ "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure"

1732+ "-Wl,-u,base_GHCziTopHandler_runMainIO_closure"

1733+ "-Wl,-u,ghczmprim_GHCziTypes_Czh_con_info"

1734+ "-Wl,-u,ghczmprim_GHCziTypes_Izh_con_info"

1735+ "-Wl,-u,ghczmprim_GHCziTypes_Fzh_con_info"

1736+ "-Wl,-u,ghczmprim_GHCziTypes_Dzh_con_info"

1737+ "-Wl,-u,ghczmprim_GHCziTypes_Wzh_con_info"

1738+ "-Wl,-u,base_GHCziPtr_Ptr_con_info"

1739+ "-Wl,-u,base_GHCziPtr_FunPtr_con_info"

1740+ "-Wl,-u,base_GHCziInt_I8zh_con_info"

1741+ "-Wl,-u,base_GHCziInt_I16zh_con_info"

1742+ "-Wl,-u,base_GHCziInt_I32zh_con_info"

1743+ "-Wl,-u,base_GHCziInt_I64zh_con_info"

1744+ "-Wl,-u,base_GHCziWord_W8zh_con_info"

1745+ "-Wl,-u,base_GHCziWord_W16zh_con_info"

1746+ "-Wl,-u,base_GHCziWord_W32zh_con_info"

1747+ "-Wl,-u,base_GHCziWord_W64zh_con_info"

1748+ "-Wl,-u,base_GHCziStable_StablePtr_con_info"

1749+ "-Wl,-u,hs_atomic_add8" "-Wl,-u,hs_atomic_add16"

1750+ "-Wl,-u,hs_atomic_add32" "-Wl,-u,hs_atomic_add64"

1751+ "-Wl,-u,hs_atomic_sub8" "-Wl,-u,hs_atomic_sub16"

1752+ "-Wl,-u,hs_atomic_sub32" "-Wl,-u,hs_atomic_sub64"

1753+ "-Wl,-u,hs_atomic_and8" "-Wl,-u,hs_atomic_and16"

1754+ "-Wl,-u,hs_atomic_and32" "-Wl,-u,hs_atomic_and64"

1755+ "-Wl,-u,hs_atomic_nand8" "-Wl,-u,hs_atomic_nand16"

1756+ "-Wl,-u,hs_atomic_nand32" "-Wl,-u,hs_atomic_nand64"

1757+ "-Wl,-u,hs_atomic_or8" "-Wl,-u,hs_atomic_or16"

1758+ "-Wl,-u,hs_atomic_or32" "-Wl,-u,hs_atomic_or64"

1759+ "-Wl,-u,hs_atomic_xor8" "-Wl,-u,hs_atomic_xor16"

1760+ "-Wl,-u,hs_atomic_xor32" "-Wl,-u,hs_atomic_xor64"

1761+ "-Wl,-u,hs_cmpxchg8" "-Wl,-u,hs_cmpxchg16" "-Wl,-u,hs_cmpxchg32"

1762+ "-Wl,-u,hs_cmpxchg64" "-Wl,-u,hs_xchg8" "-Wl,-u,hs_xchg16"

1763+ "-Wl,-u,hs_xchg32" "-Wl,-u,hs_xchg64" "-Wl,-u,hs_atomicread8"

1764+ "-Wl,-u,hs_atomicread16" "-Wl,-u,hs_atomicread32"

1765+ "-Wl,-u,hs_atomicread64" "-Wl,-u,hs_atomicwrite8"

1766+ "-Wl,-u,hs_atomicwrite16" "-Wl,-u,hs_atomicwrite32"

1767+ "-Wl,-u,hs_atomicwrite64"

materialized/dummy-ghc/ghc-9.0.2-aarch64-linux/ghc-pkg/versionnew file+1

@@ -0,0 +1 @@

1+GHC package manager version 9.0.2

materialized/dummy-ghc/ghc-9.0.2-aarch64-linux/ghc/infonew file+74

@@ -0,0 +1,74 @@

1+ [("Project name","The Glorious Glasgow Haskell Compilation System")

2+ ,("GCC extra via C opts","")

3+ ,("C compiler command","gcc")

4+ ,("C compiler flags","")

5+ ,("C++ compiler flags","")

6+ ,("C compiler link flags","-Wl,-z,noexecstack")

7+ ,("C compiler supports -no-pie","YES")

8+ ,("Haskell CPP command","gcc")

9+ ,("Haskell CPP flags","-E -undef -traditional")

10+ ,("ld command","ld")

11+ ,("ld flags","-z noexecstack")

12+ ,("ld supports compact unwind","YES")

13+ ,("ld supports build-id","YES")

14+ ,("ld supports filelist","NO")

15+ ,("ld is GNU ld","YES")

16+ ,("Merge objects command","ld")

17+ ,("Merge objects flags","-r")

18+ ,("ar command","ar")

19+ ,("ar flags","q")

20+ ,("ar supports at file","YES")

21+ ,("ranlib command","ranlib")

22+ ,("otool command","otool")

23+ ,("install_name_tool command","install_name_tool")

24+ ,("touch command","touch")

25+ ,("dllwrap command","/bin/false")

26+ ,("windres command","/bin/false")

27+ ,("libtool command","libtool")

28+ ,("cross compiling","NO")

29+ ,("target platform string","aarch64-unknown-linux")

30+ ,("target os","OSLinux")

31+ ,("target arch","ArchAArch64")

32+ ,("target word size","8")

33+ ,("target word big endian","NO")

34+ ,("target has GNU nonexec stack","YES")

35+ ,("target has .ident directive","YES")

36+ ,("target has subsections via symbols","NO")

37+ ,("target has RTS linker","YES")

38+ ,("Unregisterised","NO")

39+ ,("LLVM target","aarch64-unknown-linux")

40+ ,("LLVM clang command","clang")

41+ ,("bignum backend","gmp")

42+ ,("Use interpreter","YES")

43+ ,("Support SMP","YES")

44+ ,("RTS ways","l debug thr thr_debug thr_l thr_p dyn debug_dyn thr_dyn thr_debug_dyn l_dyn thr_l_dyn thr_debug_p debug_p")

45+ ,("Tables next to code","YES")

46+ ,("Leading underscore","NO")

47+ ,("Use LibFFI","YES")

48+ ,("Use Threads","YES")

49+ ,("Use Debugging","NO")

50+ ,("RTS expects libdw","NO")

51+ ,("Project version","9.0.2")

52+ ,("Project Git commit id","6554ff2843d53dddeb875cb145ab892725eac54c")

53+ ,("Booter version","8.8.4")

54+ ,("Stage","2")

55+ ,("Build platform","aarch64-unknown-linux")

56+ ,("Host platform","aarch64-unknown-linux")

57+ ,("Target platform","aarch64-unknown-linux")

58+ ,("Have interpreter","YES")

59+ ,("Object splitting supported","NO")

60+ ,("Have native code generator","NO")

61+ ,("Target default backend","LLVM")

62+ ,("Support dynamic-too","YES")

63+ ,("Support parallel --make","YES")

64+ ,("Support reexported-modules","YES")

65+ ,("Support thinning and renaming package flags","YES")

66+ ,("Support Backpack","YES")

67+ ,("Requires unified installed package IDs","YES")

68+ ,("Uses package keys","YES")

69+ ,("Uses unit IDs","YES")

70+ ,("Dynamic by default","NO")

71+ ,("GHC Dynamic","YES")

72+ ,("GHC Profiled","NO")

73+ ,("Debug on","NO")

74+ ]

materialized/dummy-ghc/ghc-9.0.2-aarch64-linux/ghc/numeric-versionnew file+1

@@ -0,0 +1 @@

1+9.0.2

materialized/dummy-ghc/ghc-9.0.2-aarch64-linux/ghc/supported-languagesnew file+261

@@ -0,0 +1,261 @@

1+Haskell98

2+Haskell2010

3+Unsafe

4+Trustworthy

5+Safe

6+AllowAmbiguousTypes

7+NoAllowAmbiguousTypes

8+AlternativeLayoutRule

9+NoAlternativeLayoutRule

10+AlternativeLayoutRuleTransitional

11+NoAlternativeLayoutRuleTransitional

12+Arrows

13+NoArrows

14+AutoDeriveTypeable

15+NoAutoDeriveTypeable

16+BangPatterns

17+NoBangPatterns

18+BinaryLiterals

19+NoBinaryLiterals

20+CApiFFI

21+NoCApiFFI

22+CPP

23+NoCPP

24+CUSKs

25+NoCUSKs

26+ConstrainedClassMethods

27+NoConstrainedClassMethods

28+ConstraintKinds

29+NoConstraintKinds

30+DataKinds

31+NoDataKinds

32+DatatypeContexts

33+NoDatatypeContexts

34+DefaultSignatures

35+NoDefaultSignatures

36+DeriveAnyClass

37+NoDeriveAnyClass

38+DeriveDataTypeable

39+NoDeriveDataTypeable

40+DeriveFoldable

41+NoDeriveFoldable

42+DeriveFunctor

43+NoDeriveFunctor

44+DeriveGeneric

45+NoDeriveGeneric

46+DeriveLift

47+NoDeriveLift

48+DeriveTraversable

49+NoDeriveTraversable

50+DerivingStrategies

51+NoDerivingStrategies

52+DerivingVia

53+NoDerivingVia

54+DisambiguateRecordFields

55+NoDisambiguateRecordFields

56+DoAndIfThenElse

57+NoDoAndIfThenElse

58+BlockArguments

59+NoBlockArguments

60+DoRec

61+NoDoRec

62+DuplicateRecordFields

63+NoDuplicateRecordFields

64+EmptyCase

65+NoEmptyCase

66+EmptyDataDecls

67+NoEmptyDataDecls

68+EmptyDataDeriving

69+NoEmptyDataDeriving

70+ExistentialQuantification

71+NoExistentialQuantification

72+ExplicitForAll

73+NoExplicitForAll

74+ExplicitNamespaces

75+NoExplicitNamespaces

76+ExtendedDefaultRules

77+NoExtendedDefaultRules

78+FlexibleContexts

79+NoFlexibleContexts

80+FlexibleInstances

81+NoFlexibleInstances

82+ForeignFunctionInterface

83+NoForeignFunctionInterface

84+FunctionalDependencies

85+NoFunctionalDependencies

86+GADTSyntax

87+NoGADTSyntax

88+GADTs

89+NoGADTs

90+GHCForeignImportPrim

91+NoGHCForeignImportPrim

92+GeneralizedNewtypeDeriving

93+NoGeneralizedNewtypeDeriving

94+GeneralisedNewtypeDeriving

95+NoGeneralisedNewtypeDeriving

96+ImplicitParams

97+NoImplicitParams

98+ImplicitPrelude

99+NoImplicitPrelude

100+ImportQualifiedPost

101+NoImportQualifiedPost

102+ImpredicativeTypes

103+NoImpredicativeTypes

104+IncoherentInstances

105+NoIncoherentInstances

106+TypeFamilyDependencies

107+NoTypeFamilyDependencies

108+InstanceSigs

109+NoInstanceSigs

110+ApplicativeDo

111+NoApplicativeDo

112+InterruptibleFFI

113+NoInterruptibleFFI

114+JavaScriptFFI

115+NoJavaScriptFFI

116+KindSignatures

117+NoKindSignatures

118+LambdaCase

119+NoLambdaCase

120+LexicalNegation

121+NoLexicalNegation

122+LiberalTypeSynonyms

123+NoLiberalTypeSynonyms

124+LinearTypes

125+NoLinearTypes

126+MagicHash

127+NoMagicHash

128+MonadComprehensions

129+NoMonadComprehensions

130+MonadFailDesugaring

131+NoMonadFailDesugaring

132+MonoLocalBinds

133+NoMonoLocalBinds

134+MonoPatBinds

135+NoMonoPatBinds

136+MonomorphismRestriction

137+NoMonomorphismRestriction

138+MultiParamTypeClasses

139+NoMultiParamTypeClasses

140+MultiWayIf

141+NoMultiWayIf

142+NumericUnderscores

143+NoNumericUnderscores

144+NPlusKPatterns

145+NoNPlusKPatterns

146+NamedFieldPuns

147+NoNamedFieldPuns

148+NamedWildCards

149+NoNamedWildCards

150+NegativeLiterals

151+NoNegativeLiterals

152+HexFloatLiterals

153+NoHexFloatLiterals

154+NondecreasingIndentation

155+NoNondecreasingIndentation

156+NullaryTypeClasses

157+NoNullaryTypeClasses

158+NumDecimals

159+NoNumDecimals

160+OverlappingInstances

161+NoOverlappingInstances

162+OverloadedLabels

163+NoOverloadedLabels

164+OverloadedLists

165+NoOverloadedLists

166+OverloadedStrings

167+NoOverloadedStrings

168+PackageImports

169+NoPackageImports

170+ParallelArrays

171+NoParallelArrays

172+ParallelListComp

173+NoParallelListComp

174+PartialTypeSignatures

175+NoPartialTypeSignatures

176+PatternGuards

177+NoPatternGuards

178+PatternSignatures

179+NoPatternSignatures

180+PatternSynonyms

181+NoPatternSynonyms

182+PolyKinds

183+NoPolyKinds

184+PolymorphicComponents

185+NoPolymorphicComponents

186+QuantifiedConstraints

187+NoQuantifiedConstraints

188+PostfixOperators

189+NoPostfixOperators

190+QuasiQuotes

191+NoQuasiQuotes

192+QualifiedDo

193+NoQualifiedDo

194+Rank2Types

195+NoRank2Types

196+RankNTypes

197+NoRankNTypes

198+RebindableSyntax

199+NoRebindableSyntax

200+RecordPuns

201+NoRecordPuns

202+RecordWildCards

203+NoRecordWildCards

204+RecursiveDo

205+NoRecursiveDo

206+RelaxedLayout

207+NoRelaxedLayout

208+RelaxedPolyRec

209+NoRelaxedPolyRec

210+RoleAnnotations

211+NoRoleAnnotations

212+ScopedTypeVariables

213+NoScopedTypeVariables

214+StandaloneDeriving

215+NoStandaloneDeriving

216+StarIsType

217+NoStarIsType

218+StaticPointers

219+NoStaticPointers

220+Strict

221+NoStrict

222+StrictData

223+NoStrictData

224+TemplateHaskell

225+NoTemplateHaskell

226+TemplateHaskellQuotes

227+NoTemplateHaskellQuotes

228+StandaloneKindSignatures

229+NoStandaloneKindSignatures

230+TraditionalRecordSyntax

231+NoTraditionalRecordSyntax

232+TransformListComp

233+NoTransformListComp

234+TupleSections

235+NoTupleSections

236+TypeApplications

237+NoTypeApplications

238+TypeInType

239+NoTypeInType

240+TypeFamilies

241+NoTypeFamilies

242+TypeOperators

243+NoTypeOperators

244+TypeSynonymInstances

245+NoTypeSynonymInstances

246+UnboxedTuples

247+NoUnboxedTuples

248+UnboxedSums

249+NoUnboxedSums

250+UndecidableInstances

251+NoUndecidableInstances

252+UndecidableSuperClasses

253+NoUndecidableSuperClasses

254+UnicodeSyntax

255+NoUnicodeSyntax

256+UnliftedFFITypes

257+NoUnliftedFFITypes

258+UnliftedNewtypes

259+NoUnliftedNewtypes

260+ViewPatterns

261+NoViewPatterns

materialized/dummy-ghc/ghc-9.0.2-aarch64-linux/ghc/versionnew file+1

@@ -0,0 +1 @@

1+The Glorious Glasgow Haskell Compilation System, version 9.0.2

materialized/dummy-ghc/ghc-9.0.2-x86_64-darwin/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","clang")

34 ,("C compiler flags","--target=x86_64-apple-darwin ")

45 ,("C++ compiler flags","--target=x86_64-apple-darwin ")

56 ,("C compiler link flags","--target=x86_64-apple-darwin ")

67 ,("C compiler supports -no-pie","NO")

8+ ,("Haskell CPP command","clang")

79 ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","NO")

1114 ,("ld supports filelist","YES")

1215 ,("ld is GNU ld","NO")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","qcls")

1520 ,("ar supports at file","NO")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-9.0.2-x86_64-linux/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","gcc")

34 ,("C compiler flags","")

45 ,("C++ compiler flags","")

56 ,("C compiler link flags","")

67 ,("C compiler supports -no-pie","YES")

8+ ,("Haskell CPP command","gcc")

79 ,("Haskell CPP flags","-E -undef -traditional")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","YES")

1114 ,("ld supports filelist","NO")

1215 ,("ld is GNU ld","YES")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","q")

1520 ,("ar supports at file","YES")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-9.2.1-aarch64-darwin/ghc/info+6

@@ -1,18 +1,24 @@

11 [("Project name","The Glorious Glasgow Haskell Compilation System")

22 ,("GCC extra via C opts","")

3+ ,("C compiler command","clang")

34 ,("C compiler flags","--target=arm64-apple-darwin ")

45 ,("C++ compiler flags","--target=arm64-apple-darwin ")

56 ,("C compiler link flags","--target=arm64-apple-darwin ")

67 ,("C compiler supports -no-pie","NO")

8+ ,("Haskell CPP command","clang")

79 ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

10+ ,("ld command","ld")

811 ,("ld flags","")

912 ,("ld supports compact unwind","YES")

1013 ,("ld supports build-id","NO")

1114 ,("ld supports filelist","YES")

1215 ,("ld is GNU ld","NO")

16+ ,("Merge objects command","ld")

1317 ,("Merge objects flags","-r")

18+ ,("ar command","ar")

1419 ,("ar flags","qcls")

1520 ,("ar supports at file","NO")

21+ ,("ranlib command","ranlib")

1622 ,("otool command","otool")

1723 ,("install_name_tool command","install_name_tool")

1824 ,("touch command","touch")

materialized/dummy-ghc/ghc-9.2.1-aarch64-linux/ghc-pkg/dump-globalnew file+1826

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.1-aarch64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.1-aarch64-linux/ghc/infonew file+73

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.1-aarch64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.1-aarch64-linux/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.1-aarch64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.1-x86_64-darwin/ghc/info+6

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.1-x86_64-linux/ghc/info+6

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-aarch64-darwin/ghc-pkg/dump-globalnew file+1834

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-aarch64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-aarch64-darwin/ghc/infonew file+72

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-aarch64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-aarch64-darwin/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-aarch64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-aarch64-linux/ghc-pkg/dump-globalnew file+1834

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-aarch64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-aarch64-linux/ghc/infonew file+72

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-aarch64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-aarch64-linux/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-aarch64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-x86_64-darwin/ghc-pkg/dump-globalnew file+1834

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-x86_64-darwin/ghc/infonew file+72

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-x86_64-darwin/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-x86_64-linux/ghc-pkg/dump-globalnew file+1834

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-x86_64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-x86_64-linux/ghc/infonew file+72

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-x86_64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-x86_64-linux/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-x86_64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-aarch64-darwin/ghc-pkg/dump-globalnew file+1834

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-aarch64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-aarch64-darwin/ghc/infonew file+72

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-aarch64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-aarch64-darwin/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-aarch64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-aarch64-linux/ghc-pkg/dump-globalnew file+1834

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-aarch64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-aarch64-linux/ghc/infonew file+72

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-aarch64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-aarch64-linux/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-aarch64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-x86_64-darwin/ghc-pkg/dump-globalnew file+1834

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-x86_64-darwin/ghc/infonew file+72

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-x86_64-darwin/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-x86_64-linux/ghc-pkg/dump-globalnew file+1834

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-x86_64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-x86_64-linux/ghc/infonew file+72

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-x86_64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-x86_64-linux/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.3-x86_64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-aarch64-darwin/ghc-pkg/dump-globalnew file+1834

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-aarch64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-aarch64-darwin/ghc/infonew file+72

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-aarch64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-aarch64-darwin/ghc/supported-languagesnew file+268

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-aarch64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-aarch64-linux/ghc-pkg/dump-globalnew file+1833

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-aarch64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-aarch64-linux/ghc/infonew file+72

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-aarch64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-aarch64-linux/ghc/supported-languagesnew file+268

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-aarch64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-x86_64-darwin/ghc-pkg/dump-globalnew file+1834

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-x86_64-darwin/ghc/infonew file+72

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-x86_64-darwin/ghc/supported-languagesnew file+268

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-x86_64-linux/ghc-pkg/dump-globalnew file+1833

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-x86_64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-x86_64-linux/ghc/infonew file+72

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-x86_64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-x86_64-linux/ghc/supported-languagesnew file+268

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.4-x86_64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.10.5-x86_64-darwin/ghc-pkg/dump-global+183−183

This diff is too big to show here.

materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.10.6-x86_64-darwin/ghc-pkg/dump-global+183−183

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-8.10.4-x86_64-linux/ghc-pkg/dump-global+38−3

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-8.10.5-x86_64-linux/ghc-pkg/dump-global+38−3

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-8.10.6-x86_64-linux/ghc-pkg/dump-global+38−3

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-8.10.7-x86_64-linux/ghc-pkg/dump-global+38−3

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-8.6.5-x86_64-linux/ghc-pkg/dump-global+31−2

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-8.8.2-x86_64-linux/ghc-pkg/dump-global+37−3

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-8.8.3-x86_64-linux/ghc-pkg/dump-global+37−3

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-8.8.4-x86_64-linux/ghc-pkg/dump-global+37−3

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.0.1-x86_64-linux/ghc-pkg/dump-global+38−3

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.0.2-x86_64-linux/ghc-pkg/dump-global+38−3

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.1-x86_64-linux/ghc-pkg/dump-global+38−3

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.2-x86_64-linux/ghc-pkg/dump-globalnew file+1796

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.2-x86_64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.2-x86_64-linux/ghc/infonew file+66

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.2-x86_64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.2-x86_64-linux/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.2-x86_64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.3-x86_64-linux/ghc-pkg/dump-globalnew file+1796

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.3-x86_64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.3-x86_64-linux/ghc/infonew file+66

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.3-x86_64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.3-x86_64-linux/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.3-x86_64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.4-x86_64-linux/ghc-pkg/dump-globalnew file+1796

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.4-x86_64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.4-x86_64-linux/ghc/infonew file+66

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.4-x86_64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.4-x86_64-linux/ghc/supported-languagesnew file+268

This diff is too big to show here.

materialized/dummy-ghc/x86_64-unknown-linux-musl-x86_64-unknown-linux-musl-ghc-9.2.4-x86_64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.4-x86_64-darwin/ghc-pkg/dump-globalnew file+1449

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.4-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.4-x86_64-darwin/ghc/infonew file+69

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.4-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.4-x86_64-darwin/ghc/supported-languagesnew file+255

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.4-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.5-x86_64-darwin/ghc-pkg/dump-globalnew file+1449

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.5-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.5-x86_64-darwin/ghc/infonew file+69

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.5-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.5-x86_64-darwin/ghc/supported-languagesnew file+255

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.5-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.6-x86_64-darwin/ghc-pkg/dump-globalnew file+1450

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.6-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.6-x86_64-darwin/ghc/infonew file+69

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.6-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.6-x86_64-darwin/ghc/supported-languagesnew file+255

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.6-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.7-x86_64-darwin/ghc-pkg/dump-globalnew file+1450

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.7-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.7-x86_64-darwin/ghc/infonew file+69

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.7-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.7-x86_64-darwin/ghc/supported-languagesnew file+255

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.10.7-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.2-x86_64-darwin/ghc-pkg/dump-globalnew file+1411

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.2-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.2-x86_64-darwin/ghc/infonew file+57

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.2-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.2-x86_64-darwin/ghc/supported-languagesnew file+247

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.2-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.3-x86_64-darwin/ghc-pkg/dump-globalnew file+1411

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.3-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.3-x86_64-darwin/ghc/infonew file+57

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.3-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.3-x86_64-darwin/ghc/supported-languagesnew file+247

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.3-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.4-x86_64-darwin/ghc-pkg/dump-globalnew file+1411

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.4-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.4-x86_64-darwin/ghc/infonew file+57

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.4-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.4-x86_64-darwin/ghc/supported-languagesnew file+247

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-8.8.4-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.1-x86_64-darwin/ghc-pkg/dump-globalnew file+1504

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.1-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.1-x86_64-darwin/ghc/infonew file+70

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.1-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.1-x86_64-darwin/ghc/supported-languagesnew file+261

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.1-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.1-x86_64-linux/ghc-pkg/dump-globalnew file+1504

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.1-x86_64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.1-x86_64-linux/ghc/infonew file+70

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.1-x86_64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.1-x86_64-linux/ghc/supported-languagesnew file+261

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.1-x86_64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.2-x86_64-darwin/ghc-pkg/dump-globalnew file+1512

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.2-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.2-x86_64-darwin/ghc/infonew file+70

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.2-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.2-x86_64-darwin/ghc/supported-languagesnew file+261

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.2-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.2-x86_64-linux/ghc-pkg/dump-globalnew file+1512

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.2-x86_64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.2-x86_64-linux/ghc/infonew file+70

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.2-x86_64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.2-x86_64-linux/ghc/supported-languagesnew file+261

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.0.2-x86_64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.1-x86_64-darwin/ghc-pkg/dump-globalnew file+1522

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.1-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.1-x86_64-darwin/ghc/infonew file+67

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.1-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.1-x86_64-darwin/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.1-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.1-x86_64-linux/ghc-pkg/dump-globalnew file+1522

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.1-x86_64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.1-x86_64-linux/ghc/infonew file+67

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.1-x86_64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.1-x86_64-linux/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.1-x86_64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.2-x86_64-darwin/ghc-pkg/dump-globalnew file+1533

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.2-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.2-x86_64-darwin/ghc/infonew file+66

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.2-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.2-x86_64-darwin/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.2-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.2-x86_64-linux/ghc-pkg/dump-globalnew file+1533

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.2-x86_64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.2-x86_64-linux/ghc/infonew file+66

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.2-x86_64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.2-x86_64-linux/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.2-x86_64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.3-x86_64-darwin/ghc-pkg/dump-globalnew file+1533

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.3-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.3-x86_64-darwin/ghc/infonew file+66

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.3-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.3-x86_64-darwin/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.3-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.3-x86_64-linux/ghc-pkg/dump-globalnew file+1533

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.3-x86_64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.3-x86_64-linux/ghc/infonew file+66

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.3-x86_64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.3-x86_64-linux/ghc/supported-languagesnew file+266

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.3-x86_64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.4-x86_64-darwin/ghc-pkg/dump-globalnew file+1533

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.4-x86_64-darwin/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.4-x86_64-darwin/ghc/infonew file+66

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.4-x86_64-darwin/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.4-x86_64-darwin/ghc/supported-languagesnew file+268

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.4-x86_64-darwin/ghc/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.4-x86_64-linux/ghc-pkg/dump-globalnew file+1533

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.4-x86_64-linux/ghc-pkg/versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.4-x86_64-linux/ghc/infonew file+66

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.4-x86_64-linux/ghc/numeric-versionnew file+1

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.4-x86_64-linux/ghc/supported-languagesnew file+268

This diff is too big to show here.

materialized/dummy-ghc/x86_64-w64-mingw32-x86_64-w64-mingw32-ghc-9.2.4-x86_64-linux/ghc/versionnew file+1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8102/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8103/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8104/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc810420210212/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/Win32.nixnew file+46

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/base.nixnew file+43

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/bytestring.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/ghc-boot.nixnew file+39

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/ghc-heap.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/ghc-prim.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/ghc.nixnew file+62

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/ghci.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/hpc.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/integer-gmp.nixnew file+33

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105-aarch64/template-haskell.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8105/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/Win32.nixnew file+46

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/base.nixnew file+43

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/bytestring.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/ghc-boot.nixnew file+39

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/ghc-heap.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/ghc-prim.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/ghc.nixnew file+62

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/ghci.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/hpc.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/integer-gmp.nixnew file+33

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106-aarch64/template-haskell.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8106/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/Win32.nixnew file+46

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/base.nixnew file+43

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/bytestring.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/ghc-boot.nixnew file+39

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/ghc-heap.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/ghc-prim.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/ghc.nixnew file+62

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/ghci.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/hpc.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/integer-gmp.nixnew file+33

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107-aarch64/template-haskell.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc8107/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc844/ghc.nix−4

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/Win32.nixnew file+46

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/base.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/bytestring.nixnew file+80

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/ghc-boot.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/ghc-heap.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/ghc-prim.nixnew file+40

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/ghc.nixnew file+59

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/ghci.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/hpc.nixnew file+37

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/integer-gmp.nixnew file+33

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc863/template-haskell.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/Win32.nixnew file+46

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/base.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/bytestring.nixnew file+80

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/ghc-boot.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/ghc-heap.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/ghc-prim.nixnew file+40

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/ghc.nixnew file+60

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/ghci.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/hpc.nixnew file+37

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/integer-gmp.nixnew file+33

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc864/template-haskell.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc865/ghc.nix−4

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc865/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc882/ghc.nix−4

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc882/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/Win32.nixnew file+46

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/base.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/bytestring.nixnew file+80

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/ghc-boot.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/ghc-heap.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/ghc-prim.nixnew file+40

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/ghc.nixnew file+61

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/ghci.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/hpc.nixnew file+37

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/integer-gmp.nixnew file+33

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883-aarch64/template-haskell.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883/ghc.nix−4

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc883/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/Win32.nixnew file+46

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/base.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/bytestring.nixnew file+80

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/ghc-boot.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/ghc-heap.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/ghc-prim.nixnew file+43

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/ghc.nixnew file+61

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/ghci.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/hpc.nixnew file+37

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/integer-gmp.nixnew file+33

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884-aarch64/template-haskell.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884/ghc.nix−4

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc884/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/Win32.nixnew file+49

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/base.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/bytestring.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/ghc-bignum.nixnew file+37

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/ghc-boot.nixnew file+39

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/ghc-heap.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/ghc-prim.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/ghc.nixnew file+61

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/ghci.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/hpc.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/integer-gmp.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901-aarch64/template-haskell.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc901/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/Win32.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/base.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/bytestring.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/ghc-bignum.nixnew file+37

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/ghc-boot.nixnew file+39

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/ghc-heap.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/ghc-prim.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/ghc.nixnew file+61

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/ghci.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/hpc.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/integer-gmp.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902-aarch64/template-haskell.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc902/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/Win32.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/base.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/bytestring.nixnew file+86

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/deepseq.nixnew file+47

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/ghc-bignum.nixnew file+37

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/ghc-boot.nixnew file+40

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/ghc-heap.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/ghc-prim.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/ghc.nixnew file+61

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/ghci.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/hpc.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/integer-gmp.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/pretty.nixnew file+56

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921-aarch64/template-haskell.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc921/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/Win32.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/base.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/bytestring.nixnew file+68

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/deepseq.nixnew file+47

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/ghc-bignum.nixnew file+37

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/ghc-boot.nixnew file+40

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/ghc-heap.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/ghc-prim.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/ghc.nixnew file+60

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/ghci.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/hpc.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/integer-gmp.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/pretty.nixnew file+56

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922-aarch64/template-haskell.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/Win32.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/base.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/bytestring.nixnew file+68

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/deepseq.nixnew file+47

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/ghc-bignum.nixnew file+37

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/ghc-boot.nixnew file+40

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/ghc-heap.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/ghc-prim.nixnew file+43

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/ghc.nixnew file+60

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/ghci.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/hpc.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/integer-gmp.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/pretty.nixnew file+56

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc922/template-haskell.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/Win32.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/base.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/bytestring.nixnew file+65

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/deepseq.nixnew file+47

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/ghc-bignum.nixnew file+37

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/ghc-boot.nixnew file+40

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/ghc-heap.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/ghc-prim.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/ghc.nixnew file+60

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/ghci.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/hpc.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/integer-gmp.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/pretty.nixnew file+56

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923-aarch64/template-haskell.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/Win32.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/base.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/bytestring.nixnew file+65

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/deepseq.nixnew file+47

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/ghc-bignum.nixnew file+37

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/ghc-boot.nixnew file+40

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/ghc-heap.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/ghc-prim.nixnew file+43

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/ghc.nixnew file+60

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/ghci.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/hpc.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/integer-gmp.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/pretty.nixnew file+56

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc923/template-haskell.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/Win32.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/base.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/bytestring.nixnew file+65

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/deepseq.nixnew file+47

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/ghc-bignum.nixnew file+37

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/ghc-boot.nixnew file+40

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/ghc-heap.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/ghc-prim.nixnew file+44

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/ghc.nixnew file+60

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/ghci.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/hpc.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/integer-gmp.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/pretty.nixnew file+56

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924-aarch64/template-haskell.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/Win32.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/base.nixnew file+48

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/bytestring.nixnew file+65

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/deepseq.nixnew file+47

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/ghc-bignum.nixnew file+37

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/ghc-boot.nixnew file+40

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/ghc-heap.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/ghc-prim.nixnew file+43

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/ghc.nixnew file+60

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/ghci.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/hpc.nixnew file+38

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/integer-gmp.nixnew file+35

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/iserv-proxy.nixnew file+45

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/iserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/libiserv.nixnew file+42

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/pretty.nixnew file+56

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/remote-iserv.nixnew file+36

This diff is too big to show here.

materialized/ghc-boot-packages-nix/ghc924/template-haskell.nixnew file+36

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc8102/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc8102/default.nix+40−40

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc8103/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc8103/default.nix+40−40

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc8104/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc8104/default.nix+40−40

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc810420210212/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc810420210212/default.nix+40−40

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc8105/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc8105/default.nix+40−40

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc8106/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc8106/default.nix+40−40

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc8107/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc8107/default.nix+40−40

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc865/.plan.nix/ghc.nix−4

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc865/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc865/default.nix+40−47

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc882/.plan.nix/ghc.nix−4

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc882/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc882/default.nix+40−48

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc883/.plan.nix/ghc.nix−4

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc883/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc883/default.nix+40−48

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc884/.plan.nix/ghc.nix−4

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc884/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc884/default.nix+40−48

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc901/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc901/default.nix+48−48

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc902/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc902/default.nix+49−48

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc921/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc921/default.nix+51−51

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc922/.plan.nix/Win32.nixnew file+158

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc922/.plan.nix/ghc-boot.nixnew file+64

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc922/.plan.nix/ghc.nixnew file+661

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc922/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc922/.plan.nix/hpc.nixnew file+52

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc922/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc922/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc922/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc922/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc922/default.nixnew file+138

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc923/.plan.nix/Win32.nixnew file+158

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc923/.plan.nix/ghc-boot.nixnew file+64

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc923/.plan.nix/ghc.nixnew file+661

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc923/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc923/.plan.nix/hpc.nixnew file+52

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc923/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc923/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc923/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc923/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc923/default.nixnew file+138

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc924/.plan.nix/Win32.nixnew file+158

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc924/.plan.nix/ghc-boot.nixnew file+64

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc924/.plan.nix/ghc.nixnew file+661

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc924/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc924/.plan.nix/hpc.nixnew file+52

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc924/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc924/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc924/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc924/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc924/default.nixnew file+137

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc8102/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc8102/default.nix+41−41

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc8103/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc8103/default.nix+41−41

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc8104/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc8104/default.nix+41−41

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc810420210212/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc810420210212/default.nix+41−41

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc8105/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc8105/default.nix+41−41

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc8106/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc8106/default.nix+41−41

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc8107/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc8107/default.nix+41−41

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc863/.plan.nix/Win32.nixnew file+155

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc863/.plan.nix/ghc-boot.nixnew file+53

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc863/.plan.nix/ghc.nixnew file+555

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc863/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc863/.plan.nix/hpc.nixnew file+51

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc863/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc863/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc863/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc863/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc863/default.nixnew file+126

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc864/.plan.nix/Win32.nixnew file+155

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc864/.plan.nix/ghc-boot.nixnew file+53

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc864/.plan.nix/ghc.nixnew file+556

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc864/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc864/.plan.nix/hpc.nixnew file+51

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc864/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc864/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc864/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc864/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc864/default.nixnew file+127

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc865/.plan.nix/ghc.nix−4

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc865/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc865/default.nix+40−48

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc882/.plan.nix/ghc.nix−4

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc882/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc882/default.nix+41−49

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc883/.plan.nix/ghc.nix−4

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc883/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc883/default.nix+41−49

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc884/.plan.nix/ghc.nix−4

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc884/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc884/default.nix+41−49

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc901/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc901/default.nix+49−49

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc902/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc902/default.nix+49−49

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc921/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc921/default.nix+52−52

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc922/.plan.nix/Win32.nixnew file+158

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc922/.plan.nix/ghc-boot.nixnew file+64

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc922/.plan.nix/ghc.nixnew file+661

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc922/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc922/.plan.nix/hpc.nixnew file+52

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc922/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc922/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc922/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc922/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc922/default.nixnew file+138

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc923/.plan.nix/Win32.nixnew file+158

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc923/.plan.nix/ghc-boot.nixnew file+64

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc923/.plan.nix/ghc.nixnew file+661

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc923/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc923/.plan.nix/hpc.nixnew file+52

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc923/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc923/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc923/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc923/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc923/default.nixnew file+138

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc924/.plan.nix/Win32.nixnew file+158

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc924/.plan.nix/ghc-boot.nixnew file+64

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc924/.plan.nix/ghc.nixnew file+661

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc924/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc924/.plan.nix/hpc.nixnew file+52

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc924/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc924/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc924/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc924/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/default/ghc924/default.nixnew file+138

This diff is too big to show here.

materialized/ghc-extra-projects/ghcjs/ghc8105/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/ghcjs/ghc8105/default.nix+43−43

This diff is too big to show here.

materialized/ghc-extra-projects/ghcjs/ghc8106/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/ghcjs/ghc8106/default.nix+43−43

This diff is too big to show here.

materialized/ghc-extra-projects/ghcjs/ghc8107/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/ghcjs/ghc8107/default.nix+43−43

This diff is too big to show here.

materialized/ghc-extra-projects/ghcjs/ghc865/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/ghcjs/ghc865/default.nix+40−40

This diff is too big to show here.

materialized/ghc-extra-projects/ghcjs/ghc884/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/ghcjs/ghc884/default.nix+41−41

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc8102/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc8102/default.nix+39−39

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc8103/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc8103/default.nix+39−39

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc8104/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc8104/default.nix+39−39

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc810420210212/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc810420210212/default.nix+39−39

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc8105/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc8105/default.nix+39−39

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc8106/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc8106/default.nix+39−39

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc8107/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc8107/default.nix+39−39

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc863/.plan.nix/Win32.nixnew file+155

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc863/.plan.nix/ghc-boot.nixnew file+53

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc863/.plan.nix/ghc.nixnew file+555

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc863/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc863/.plan.nix/hpc.nixnew file+51

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc863/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc863/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc863/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc863/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc863/default.nixnew file+118

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc864/.plan.nix/Win32.nixnew file+155

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc864/.plan.nix/ghc-boot.nixnew file+53

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc864/.plan.nix/ghc.nixnew file+556

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc864/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc864/.plan.nix/hpc.nixnew file+51

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc864/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc864/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc864/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc864/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc864/default.nixnew file+119

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc865/.plan.nix/ghc.nix−4

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc865/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc865/default.nix+38−46

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc882/.plan.nix/ghc.nix−4

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc882/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc882/default.nix+39−47

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc883/.plan.nix/ghc.nix−4

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc883/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc883/default.nix+39−47

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc884/.plan.nix/ghc.nix−4

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc884/.plan.nix/iserv-proxy.nix+1−1

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc884/default.nix+39−47

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc901/.plan.nix/Win32.nixnew file+158

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc901/.plan.nix/ghc-boot.nixnew file+61

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc901/.plan.nix/ghc.nixnew file+572

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc901/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc901/.plan.nix/hpc.nixnew file+52

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc901/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc901/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc901/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc901/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc901/default.nixnew file+132

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc902/.plan.nix/Win32.nixnew file+158

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc902/.plan.nix/ghc-boot.nixnew file+61

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc902/.plan.nix/ghc.nixnew file+572

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc902/.plan.nix/ghci.nixnew file+71

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc902/.plan.nix/hpc.nixnew file+52

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc902/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc902/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc902/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc902/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc902/default.nixnew file+132

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc921/.plan.nix/Win32.nixnew file+158

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc921/.plan.nix/ghc-boot.nixnew file+64

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc921/.plan.nix/ghc.nixnew file+663

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc921/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc921/.plan.nix/hpc.nixnew file+52

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc921/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc921/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc921/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc921/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc921/default.nixnew file+140

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc922/.plan.nix/Win32.nixnew file+158

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc922/.plan.nix/ghc-boot.nixnew file+64

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc922/.plan.nix/ghc.nixnew file+661

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc922/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc922/.plan.nix/hpc.nixnew file+52

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc922/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc922/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc922/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc922/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc922/default.nixnew file+134

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc923/.plan.nix/Win32.nixnew file+158

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc923/.plan.nix/ghc-boot.nixnew file+64

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc923/.plan.nix/ghc.nixnew file+661

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc923/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc923/.plan.nix/hpc.nixnew file+52

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc923/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc923/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc923/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc923/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc923/default.nixnew file+134

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc924/.plan.nix/Win32.nixnew file+158

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc924/.plan.nix/ghc-boot.nixnew file+64

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc924/.plan.nix/ghc.nixnew file+661

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc924/.plan.nix/ghci.nixnew file+70

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc924/.plan.nix/hpc.nixnew file+52

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc924/.plan.nix/iserv-proxy.nixnew file+55

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc924/.plan.nix/iserv.nixnew file+54

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc924/.plan.nix/libiserv.nixnew file+58

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc924/.plan.nix/remote-iserv.nixnew file+46

This diff is too big to show here.

materialized/ghc-extra-projects/windows/ghc924/default.nixnew file+134

This diff is too big to show here.

materialized/ghc8102/cabal-install/default.nix+65−65

This diff is too big to show here.

materialized/ghc8102/nix-tools/.plan.nix/nix-tools.nix+1

This diff is too big to show here.

materialized/ghc8102/nix-tools/default.nix+324−318

This diff is too big to show here.

materialized/ghc8103/cabal-install/default.nix+65−65

This diff is too big to show here.

materialized/ghc8103/nix-tools/.plan.nix/nix-tools.nix+1

This diff is too big to show here.

materialized/ghc8103/nix-tools/default.nix+324−318

This diff is too big to show here.

materialized/ghc8104/cabal-install/default.nix+65−65

This diff is too big to show here.

materialized/ghc8104/nix-tools/.plan.nix/nix-tools.nix+1

This diff is too big to show here.

materialized/ghc8104/nix-tools/default.nix+324−318

This diff is too big to show here.

materialized/ghc810420210212/cabal-install/default.nix+65−65

This diff is too big to show here.

materialized/ghc810420210212/nix-tools/.plan.nix/nix-tools.nix+1

This diff is too big to show here.

materialized/ghc810420210212/nix-tools/default.nix+324−318

This diff is too big to show here.

materialized/ghc8105/cabal-install/default.nix+65−65

This diff is too big to show here.

materialized/ghc8105/nix-tools/.plan.nix/nix-tools.nix+1

This diff is too big to show here.

materialized/ghc8105/nix-tools/default.nix+324−318

This diff is too big to show here.

materialized/ghc8106/cabal-install/default.nix+65−65

This diff is too big to show here.

materialized/ghc8106/nix-tools/.plan.nix/nix-tools.nix+1

This diff is too big to show here.

materialized/ghc8106/nix-tools/default.nix+324−318

This diff is too big to show here.

materialized/ghc8107/cabal-install/default.nix+65−65

This diff is too big to show here.

materialized/ghc8107/nix-tools/.plan.nix/nix-tools.nix+1

This diff is too big to show here.

materialized/ghc8107/nix-tools/default.nix+324−318

This diff is too big to show here.

materialized/ghc863/cabal-install/.plan.nix/cabal-install.nixnew file+292

This diff is too big to show here.

materialized/ghc863/cabal-install/default.nixnew file+180

This diff is too big to show here.

materialized/ghc8101/nix-tools/.plan.nix/hackage-db.nix → materialized/ghc863/nix-tools/.plan.nix/hackage-db.nixrenamed

The content is the same.

materialized/ghc8101/nix-tools/.plan.nix/nix-tools.nix → materialized/ghc863/nix-tools/.plan.nix/nix-tools.nixrenamed+1

This diff is too big to show here.

materialized/ghc863/nix-tools/default.nixnew file+509

This diff is too big to show here.

materialized/ghc864/cabal-install/.plan.nix/cabal-install.nixnew file+292

This diff is too big to show here.

materialized/ghc864/cabal-install/default.nixnew file+180

This diff is too big to show here.

materialized/ghc901/nix-tools/.plan.nix/hackage-db.nix → materialized/ghc864/nix-tools/.plan.nix/hackage-db.nixrenamed

The content is the same.

materialized/ghc901/nix-tools/.plan.nix/nix-tools.nix → materialized/ghc864/nix-tools/.plan.nix/nix-tools.nixrenamed+1

This diff is too big to show here.

materialized/ghc8101/nix-tools/default.nix → materialized/ghc864/nix-tools/default.nixrenamed+329−332

This diff is too big to show here.

materialized/ghc865/cabal-install/default.nix+65−65

This diff is too big to show here.

materialized/ghc865/nix-tools/.plan.nix/nix-tools.nix+1

This diff is too big to show here.

materialized/ghc865/nix-tools/default.nix+315−309

This diff is too big to show here.

materialized/ghc882/cabal-install/default.nix+65−65

This diff is too big to show here.

materialized/ghc882/nix-tools/.plan.nix/nix-tools.nix+1

This diff is too big to show here.

materialized/ghc882/nix-tools/default.nix+315−309

This diff is too big to show here.

materialized/ghc883/cabal-install/default.nix+65−65

This diff is too big to show here.

materialized/ghc883/nix-tools/.plan.nix/nix-tools.nix+1

This diff is too big to show here.

materialized/ghc883/nix-tools/default.nix+315−309

This diff is too big to show here.

materialized/ghc884/cabal-install/default.nix+65−65

This diff is too big to show here.

materialized/ghc884/nix-tools/.plan.nix/nix-tools.nix+1

This diff is too big to show here.

materialized/ghc884/nix-tools/default.nix+315−309

This diff is too big to show here.

materialized/ghc901/cabal-install/default.nix+64−64

This diff is too big to show here.

materialized/ghc901/nix-tools/default.nixdeleted−363

This diff is too big to show here.

materialized/ghc902/cabal-install/default.nix+65−65

This diff is too big to show here.

materialized/ghc921/cabal-install/default.nix+63−63

This diff is too big to show here.

materialized/ghc922/cabal-install/.plan.nix/cabal-install.nixnew file+292

This diff is too big to show here.

materialized/ghc922/cabal-install/default.nixnew file+174

This diff is too big to show here.

materialized/ghc923/cabal-install/.plan.nix/cabal-install.nixnew file+292

This diff is too big to show here.

materialized/ghc923/cabal-install/default.nixnew file+174

This diff is too big to show here.

materialized/ghc924/cabal-install/.plan.nix/cabal-install.nixnew file+292

This diff is too big to show here.

materialized/ghc924/cabal-install/default.nixnew file+174

This diff is too big to show here.

materialized/ghcjs/alex/ghc8105/default.nix+9−9

This diff is too big to show here.

materialized/ghcjs/alex/ghc8106/default.nix+9−9

This diff is too big to show here.

materialized/ghcjs/alex/ghc8107/default.nix+9−9

This diff is too big to show here.

materialized/ghcjs/alex/ghc865/default.nix+9−9

This diff is too big to show here.

materialized/ghcjs/alex/ghc884/default.nix+9−9

This diff is too big to show here.

materialized/ghcjs/cabal/ghc8105/.plan.nix/cabal-install.nix+9−78

This diff is too big to show here.

materialized/ghcjs/cabal/ghc8105/default.nix+66−66

This diff is too big to show here.

materialized/ghcjs/cabal/ghc8106/.plan.nix/cabal-install.nix+9−78

This diff is too big to show here.

materialized/ghcjs/cabal/ghc8106/default.nix+66−66

This diff is too big to show here.

materialized/ghcjs/cabal/ghc8107/default.nix+65−65

This diff is too big to show here.

materialized/ghcjs/cabal/ghc865/default.nix+61−61

This diff is too big to show here.

materialized/ghcjs/cabal/ghc884/default.nix+61−61

This diff is too big to show here.

materialized/ghcjs/ghc8105/default.nix+350−350

This diff is too big to show here.

materialized/ghcjs/ghc8106/default.nix+350−350

This diff is too big to show here.

materialized/ghcjs/ghc8107/default.nix+350−350

This diff is too big to show here.

materialized/ghcjs/ghc865/default.nix+385−385

This diff is too big to show here.

materialized/ghcjs/ghc884/default.nix+350−350

This diff is too big to show here.

materialized/ghcjs/happy/ghc8105/default.nix+8−8

This diff is too big to show here.

materialized/ghcjs/happy/ghc8106/default.nix+8−8

This diff is too big to show here.

materialized/ghcjs/happy/ghc8107/default.nix+8−8

This diff is too big to show here.

materialized/ghcjs/happy/ghc865/default.nix+8−8

This diff is too big to show here.

materialized/ghcjs/happy/ghc884/default.nix+8−8

This diff is too big to show here.

materialized/spdx-3.12/licenses.jsonnew file+5622

This diff is too big to show here.

materialized/spdx-3.14/licenses.jsonnew file+5937

This diff is too big to show here.

materialized/spdx-3.16/licenses.jsonnew file+6090

This diff is too big to show here.

materialized/spdx-3.17/licenses.json+6155

This diff is too big to show here.

mk-local-hackage-repo/default.nix+9−9

This diff is too big to show here.

modules/cabal-project.nix+9−12

This diff is too big to show here.

modules/component-driver.nix+8−6

This diff is too big to show here.

modules/configuration-nix.nix+66−2

This diff is too big to show here.

modules/hackage-project.nix+60

This diff is too big to show here.

modules/hackage-quirks.nix+88

This diff is too big to show here.

modules/package.nix+19−2

This diff is too big to show here.

modules/plan.nix+16−1

This diff is too big to show here.

modules/project-common.nix+35−1

This diff is too big to show here.

modules/stack-project.nix+2−13

This diff is too big to show here.

overlays/armv6l-linux.nix+2−1

This diff is too big to show here.

overlays/bootstrap.nix+183−59

This diff is too big to show here.

overlays/default.nix+2−4

This diff is too big to show here.

overlays/eval-packages.nix−14

This diff is too big to show here.

overlays/ghc-packages.nix+66−35

This diff is too big to show here.

overlays/ghc.nix+12−8

This diff is too big to show here.

overlays/ghcjs.nix+34−4

This diff is too big to show here.

overlays/hackage-quirks.nix−72

This diff is too big to show here.

overlays/haskell.nix+92−97

This diff is too big to show here.

overlays/hix.nix+3−3

This diff is too big to show here.

overlays/hydra.nix+9

This diff is too big to show here.

overlays/mingw_w64.nix+21−21

This diff is too big to show here.

overlays/musl.nix+7−2

This diff is too big to show here.

overlays/nix-prefetch-git-minimal.nix+14

This diff is too big to show here.

overlays/patches/ghc-lib-parser-9.2-global-unique-counters-in-rts.patch+20

This diff is too big to show here.

overlays/patches/ghc/external-static-8.10.4.patch+219

This diff is too big to show here.

overlays/patches/ghc/ghc-8.10-3434.patch

This diff is too big to show here.

overlays/patches/ghc/ghc-8.4.4-reinstallable-lib-ghc.patch−10

This diff is too big to show here.

overlays/patches/ghc/ghc-8.6.3-reinstallable-lib-ghc.patch−10

This diff is too big to show here.

overlays/patches/ghc/ghc-8.6.4-reinstallable-lib-ghc.patch−10

This diff is too big to show here.

overlays/patches/ghc/ghc-8.6.5-reinstallable-lib-ghc.patch−10

This diff is too big to show here.

overlays/patches/ghc/ghc-8.8.1-reinstallable-lib-ghc.patch−10

This diff is too big to show here.

overlays/patches/ghc/ghc-8.8.2-reinstallable-lib-ghc.patch−10

This diff is too big to show here.

overlays/patches/ghc/ghc-9.0-macOS-loadArchive-fix.patch+9

This diff is too big to show here.

overlays/patches/ghc/ghc-9.2-3434.patch+68

This diff is too big to show here.

overlays/patches/ghc/ghc-9.2-Cabal-3886.patch+170

This diff is too big to show here.

overlays/patches/ghc/ghc-9.2-cabal-host.patch+13

This diff is too big to show here.

overlays/patches/ghc/ghc-9.2-global-unique-counters-in-rts.patch+83

This diff is too big to show here.

overlays/patches/ghc/ghc-9.2-macOS-loadArchive-fix.patch+9

This diff is too big to show here.

overlays/tools.nix+28−42

This diff is too big to show here.

overlays/windows.nix+14−38

This diff is too big to show here.

overlays/wine.nix+9−8

This diff is too big to show here.

patches/default.nix+1

This diff is too big to show here.

patches/ghc862/default.nix+1−1

This diff is too big to show here.

patches/ghc863/default.nix+1−1

This diff is too big to show here.

patches/ghc864/default.nix+1−1

This diff is too big to show here.

patches/ghc865/default.nix+1−1

This diff is too big to show here.

patches/ghcide-1.7-plutus-ghc.patch+13

This diff is too big to show here.

patches/ghcide-1.7-unboxed-tuple-fix-issue-1455.patch+76

This diff is too big to show here.

patches/hnix.patch+13

This diff is too big to show here.

patches/js-ghc8107/buffer-builder.patch+79

This diff is too big to show here.

patches/js-ghc8107/conduit-extra.patch+48

This diff is too big to show here.

patches/js-ghc8107/default.nix+7

This diff is too big to show here.

patches/js-ghc8107/double-conversion.patch+64

This diff is too big to show here.

patches/js-ghc8107/network.patch+16

This diff is too big to show here.

patches/js-ghc8107/say.patch+22

This diff is too big to show here.

patches/languge-c-int128.patch+146

This diff is too big to show here.

patches/update-patches.sh+6−2

This diff is too big to show here.

release.nix+13

This diff is too big to show here.

scripts/check-compiler-materialization/default.nix+31−16

This diff is too big to show here.

scripts/check-hydra.nix+2−1

This diff is too big to show here.

scripts/options-doc.nix+1−1

This diff is too big to show here.

snapshots.nix−1

This diff is too big to show here.

test/buildable/default.nix+2−2

This diff is too big to show here.

test/builder-haddock/default.nix+3−1

This diff is too big to show here.

test/c-ffi/default.nix+3−3

This diff is too big to show here.

test/ca-derivations-include/default.nix+57

This diff is too big to show here.

test/ca-derivations/default.nix+59

This diff is too big to show here.

test/cabal-22/default.nix+4−19

This diff is too big to show here.

test/cabal-doctests/default.nix+2−2

This diff is too big to show here.

test/cabal-hpack/default.nix+3−3

This diff is too big to show here.

test/cabal-simple-debug/default.nix+3−3

This diff is too big to show here.

test/cabal-simple-prof/default.nix+2−2

This diff is too big to show here.

test/cabal-simple/default.nix+4−4

This diff is too big to show here.

test/cabal-source-repo-comments/default.nix+2−2

This diff is too big to show here.

test/cabal-source-repo/default.nix+2−2

This diff is too big to show here.

test/cabal-sublib/default.nix+2−2

This diff is too big to show here.

test/call-cabal-project-to-nix/default.nix+3−2

This diff is too big to show here.

test/call-stack-to-nix/default.nix+3−2

This diff is too big to show here.

test/coverage-golden/default.nix+2−2

This diff is too big to show here.

test/coverage-no-libs/default.nix+2−1

This diff is too big to show here.

test/coverage/default.nix+2−1

This diff is too big to show here.

test/default.nix+60−46

This diff is too big to show here.

test/exe-dlls/default.nix+25

This diff is too big to show here.

test/exe-dlls/exe-dlls.cabal+18

This diff is too big to show here.

test/exe-dlls/src/Main.hs+14

This diff is too big to show here.

test/exe-lib-dlls/default.nix+25

This diff is too big to show here.

test/exe-lib-dlls/exe-lib-dlls.cabal+24

This diff is too big to show here.

test/exe-lib-dlls/exes/Main.hs+6

This diff is too big to show here.

test/exe-lib-dlls/src/Lib.hs+14

This diff is too big to show here.

test/exe-only/default.nix+3−3

This diff is too big to show here.

test/external-static-plugin/cabal.project+1

This diff is too big to show here.

test/external-static-plugin/default.nix+27

This diff is too big to show here.

test/external-static-plugin/plugin/CHANGELOG.md+5

This diff is too big to show here.

test/external-static-plugin/plugin/plugin.cabal+12

This diff is too big to show here.

test/external-static-plugin/plugin/src/Plugin.hs+16

This diff is too big to show here.

test/external-static-plugin/prog/CHANGELOG.md+5

This diff is too big to show here.

test/external-static-plugin/prog/app/Main.hs+4

This diff is too big to show here.

test/external-static-plugin/prog/prog.cabal+12

This diff is too big to show here.

test/extra-hackage/default.nix+6−7

This diff is too big to show here.

test/extra-hackage/external-package-user/cabal.project+6−2

This diff is too big to show here.

test/fully-static/default.nix+5

This diff is too big to show here.

test/ghc-options/cabal.nix+2−2

This diff is too big to show here.

test/ghc-options/stack.nix+7−2

This diff is too big to show here.

test/ghcjs-overlay/CHANGELOG.md+5

This diff is too big to show here.

test/ghcjs-overlay/Main.hs+8

This diff is too big to show here.

test/ghcjs-overlay/MyLib.hs+4

This diff is too big to show here.

test/ghcjs-overlay/Setup.hs+2

This diff is too big to show here.

test/ghcjs-overlay/cabal.project+2

This diff is too big to show here.

test/ghcjs-overlay/default.nix+60

This diff is too big to show here.

test/ghcjs-overlay/ghcjs-overlay-test.cabal+21

This diff is too big to show here.

test/githash/default.nix+2−2

This diff is too big to show here.

test/haskell-language-server/cabal.nix+4−4

This diff is too big to show here.

test/haskell-language-server/stack.nix+4−4

This diff is too big to show here.

test/index-state/default.nix+3−3

This diff is too big to show here.

test/project-flags/cabal.nix+2−2

This diff is too big to show here.

test/project-flags/stack.nix+2−1

This diff is too big to show here.

test/setup-deps/default.nix+6−9

This diff is too big to show here.

test/setup-deps/pkg/Setup.hs+5

This diff is too big to show here.

test/sha256map/default.nix+4−5

This diff is too big to show here.

test/shell-for-setup-deps/default.nix+3−3

This diff is too big to show here.

test/shell-for/default.nix+2−1

This diff is too big to show here.

test/snapshots/default.nix+1−1

This diff is too big to show here.

test/stack-local-resolver-subdir/default.nix+2−1

This diff is too big to show here.

test/stack-local-resolver/default.nix+2−1

This diff is too big to show here.

test/stack-remote-resolver/default.nix+2−1

This diff is too big to show here.

test/stack-simple/default.nix+2−2

This diff is too big to show here.

test/stack-source-repo/default.nix+2−1

This diff is too big to show here.

test/sublib-docs/default.nix+2−2

This diff is too big to show here.

test/tests.sh+4−1

This diff is too big to show here.

test/th-dlls/apps/Main.hs+9

This diff is too big to show here.

test/th-dlls/default.nix+24

This diff is too big to show here.

test/th-dlls/src/Lib.hs+14

This diff is too big to show here.

test/th-dlls/th-dlls.cabal+24

This diff is too big to show here.

test/unit.nix+116−5

This diff is too big to show here.

test/with-packages/default.nix+4−2

This diff is too big to show here.