git.iko.soy/haskell.nix

on iko/ghcjs-patch-master help sign in

from

swap

to9755ab7139 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

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+16−7

@@ -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" "ghc922"]) {

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

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

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

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

8089 maintainer-script-cache = pkgs.recurseIntoAttrs (

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

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

8291 inherit (maintainer-scripts) check-hydra;

8392 })

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

builder/comp-builder.nix+52−16

@@ -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));

@@ -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 =

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

307317 componentDrv = drv;

308318 };

309319

310− 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 // {

311327 pname = nameOnly;

312328 inherit (package.identifier) version;

313329

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

340356 description = package.synopsis or "";

341357 license = haskellLib.cabalToNixpkgsLicense package.license;

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

343367 };

344368

345369 propagatedBuildInputs =

346370 frameworks # Frameworks will be needed at link time

347371 # Not sure why pkgconfig needs to be propagatedBuildInputs but

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

349− ++ builtins.concatLists pkgconfig;

373+ ++ builtins.concatLists pkgconfig

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

375+ (lib.flatten component.libs

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

350377

351− buildInputs = component.libs

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

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

379+ (lib.flatten component.libs

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

353381

354382 nativeBuildInputs =

355383 [shellWrappers buildPackages.removeReferencesTo]

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

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

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

394422 '') +

395− (if stdenv.hostPlatform.isGhcjs then ''

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

396434 runHook preBuild

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

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

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

482520 fi

483521 '')

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

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

523+ + (lib.optionalString enableSeparateDataOutput ''

524+ mkdir -p $data

525+ '')

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

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

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

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

490530 done

491531 ''

492532 # symlink all .dlls into the local directory.

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

494− # to symlink over dlls as needed.

495533 + ''

496− echo "Symlink library dependencies..."

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

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

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

500− 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 \;

501537 done

502538 ''))

503539 + (lib.optionalString doCoverage ''

builder/default.nix+3−2

@@ -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,6 +46,7 @@ let

4646 hoogleLocal = let

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

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

49+ inherit evalPackages;

4950 version = "5.0.18.3";

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

5152 }

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

6667

6768 # Same as haskellPackages.shellFor in nixpkgs.

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

69− inherit hsPkgs ghcForComponent makeConfigFiles hoogleLocal haskellLib buildPackages compiler;

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

7071 inherit (buildPackages) glibcLocales;

7172 };

7273

builder/hspkg-builder.nix+22−29

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

3939

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

4141

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

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

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

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

46− cabalLibDepends = lib.optional (

47− stdenv.hostPlatform.isGhcjs || (

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

49− &&

50− !builtins.elem package.identifier.name

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

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

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

54− )

55− )

56− 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;

5747

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

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

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

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

62− nonReinstallablePkgs = if (

63− stdenv.hostPlatform.isGhcjs || (

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

65− &&

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`

6655 !builtins.elem package.identifier.name

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

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

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

70− )

71− ) then [] else null;

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

7259

7360 defaultSetup = setup-builder ({

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

7562 component = {

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

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

7764 libs = [];

7865 frameworks = [];

7966 doExactConfig = false;

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

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

10895 '';

10996 inherit defaultSetupSrc;

110− } // (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+ });

111104

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

113106 # cat ${defaultSetupSrc} > Setup.hs

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

138131 checks = pkgs.recurseIntoAttrs (builtins.mapAttrs

139132 (_: d: haskellLib.check d)

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

141− inherit (package) identifier detailLevel isLocal isProject;

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

142135 inherit setup cabalFile;

143136 isHaskell = true;

144137 inherit src;

builder/make-config-files.nix+5−4

@@ -85,13 +85,14 @@ let

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

8686

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

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

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

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

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

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

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

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

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

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

9596 })}

9697

9798 ghc=${ghc}

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+13−5

@@ -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}"

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

130133 # inherit (hsPkgs) hoogle;

131134 } // (

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

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

134142 }

135143 ));

136144

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

144152 nativeBuildInputs = [ ghcEnv ]

145153 ++ nativeBuildInputs

146154 ++ mkDrvArgs.nativeBuildInputs or []

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

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

148156 # If this shell is a cross compilation shell include

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

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

changelog.md+26

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

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+

430## Feb 16, 2022

531* Removed lookupSha256 argument from project functions.

632 Pass a `sha256map` instead.

ci.nix+33−31

@@ -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,49 +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 = false;

43− ghc922 = true;

44− ghc810420210212 = true;

44+ ghc924 = true;

4545 });

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

4747 nixpkgs.lib.filter (v:

48− # We have less x86_64-darwin build capacity so build fewer GhC versions and no R2105

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

4949 (v != "x86_64-darwin" || (

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

51− && !__elem nixpkgsName ["R2105"]))

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

5251 &&

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

52+ # aarch64-darwin requires ghc 8.10.7

5453 (v != "aarch64-darwin" || (

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

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

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

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

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

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

6063 let lib = nixpkgs.lib;

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

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

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

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

6467 inherit (lib.systems.examples) ghcjs;

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

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

67− # 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

6871 inherit (lib.systems.examples) mingwW64;

69− } // 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"]) {

7073 # Musl cross only works on linux

7174 # aarch64 cross only works on linux

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

@@ -75,12 +78,11 @@

7578in

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

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

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

79− genericPkgs = import pinnedNixpkgsSrc {};

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

81− 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:

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

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

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

8486 platformFilter = platformFilterGeneric pkgs system;

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

8688 # Native builds

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

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

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

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

96− 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";

9799 });

98100 }

99101 //

100− 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:

101103 # Cross builds

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

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

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

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

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

106108 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+175−59

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

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

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

104125 endif

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

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

127+ '' + bignumSpec + ''

107128 EXTRA_HADDOCK_OPTS += --quickjump --hyperlinked-source

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

109130 CrossCompilePrefix = ${targetPrefix}

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

118139 '' + lib.optionalString enableRelocatedStaticLibs ''

119140 GhcLibHcOpts += -fPIC

120141 GhcRtsHcOpts += -fPIC

142+ GhcRtsCcOpts += -fPIC

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

144+ GhcLibHcOpts += -fexternal-dynamic-refs

145+ GhcRtsHcOpts += -fexternal-dynamic-refs

121146 '' + lib.optionalString enableDWARF ''

122147 GhcLibHcOpts += -g3

123148 GhcRtsHcOpts += -g3

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

144169 '';

145170

146171 # Splicer will pull out correct variations

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

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

148173 ++ [targetLibffi]

149174 ++ lib.optional (!enableIntegerSimple) gmp

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

151− ++ 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;

152179

153180 toolsForTarget =

154181 if hostPlatform == buildPlatform then

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

158185

159186 targetCC = builtins.head toolsForTarget;

160187

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

162− inherit stdenv lib fetchurl

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

164− targetPrefix

165− targetPlatform hostPlatform

166− targetPackages

167− perl autoconf automake m4 python3 sphinx ghc bootPkgs

168− autoreconfHook toolsForTarget bash

169− libDeps

170− useLLVM llvmPackages

171− targetCC

172− enableIntegerSimple targetGmp

173− enableDWARF elfutils

174− ncurses targetLibffi libiconv targetIconv

175− disableLargeAddressSpace

176− buildMK

177− ;

178− };

179188in

180189stdenv.mkDerivation (rec {

181190 version = ghc-version;

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

183192

184193 patches = ghc-patches;

185194

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

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

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

189− # attrset.

190− src = configured-src;

195+ src = if src-spec ? file

196+ then src-spec.file

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

191198

192199 # configure was run by configured-src already.

193− phases = [ "unpackPhase" "buildPhase"

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

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

202+ ++ [ "configurePhase" "buildPhase"

194203 "checkPhase" "installPhase"

195204 "fixupPhase"

196205 "installCheckPhase"

197206 "distPhase"

198207 ];

199208

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

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

202− postUnpack = ''

203− (cd $sourceRoot

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

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

206−

207− # these two are required

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

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

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

211−

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

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

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

215−

216− # these two only for convencience.

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

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

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

220−

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

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

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

224− '';

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

225291

226292 enableParallelBuilding = true;

227293 postPatch = "patchShebangs .";

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

351417 # Our Cabal compiler name

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

353419

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

355454

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

357456 isHaskellNixCompiler = true;

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

384483 dontStrip = true;

385484 dontPatchELF = true;

386485 noAuditTmpdir = true;

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

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

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

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

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

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

392− preBuild = ''

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

393492 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

394510 '';

395511});

396512in 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+2−8

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

2121

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

2323|------------------|--------------------|-------------|-----------------------|---------------|

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

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

2624| 21.11 | `nixpkgs-2111` | 8.6.5 | `ghc865` | No |

2725| 21.11 | `nixpkgs-2111` | 8.10.7 | `ghc8107` | Yes |

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

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

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

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

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

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

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

35−| unstable | `nixpkgs-unstable` | 9.2.1 | `ghc921` | No |

36−| unstable | `nixpkgs-unstable` | 9.2.2 | `ghc922` | Yes |

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

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

3731

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

3933for 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+25−1

@@ -22,7 +22,31 @@ 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 [...]

26+```

27+

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

2650```

2751

2852This 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).

docs/tutorials/getting-started-hix.md+25−1

@@ -29,7 +29,31 @@ 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 [...]

33+```

34+

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

3357```

3458

3559This 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).

docs/tutorials/getting-started.md+3−3

@@ -18,7 +18,7 @@ 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.

@@ -29,7 +29,7 @@ nix.settings.trusted-public-keys = [

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

3030];

3131nix.settings.substituters = [

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

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

3333];

3434```

3535

@@ -41,7 +41,7 @@ nix.binaryCachePublicKeys = [

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

4242];

4343nix.binaryCaches = [

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

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

4545];

4646```

4747

flake.lock+35−18

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

118118 "hackage": {

119119 "flake": false,

120120 "locked": {

121− "lastModified": 1652231878,

122− "narHash": "sha256-6sDIuvWpS5bL4M/vaxcKo93Wry4QRiexTZr+J9HFkKM=",

121+ "lastModified": 1659402819,

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

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

124124 "repo": "hackage.nix",

125− "rev": "d85d73728618f81a22304faa6133b1e18f30a9d9",

125+ "rev": "2f6f97ca3db96f91eea674ef46f4a0785d1e9d9c",

126126 "type": "github"

127127 },

128128 "original": {

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

209209 "nix-tools": {

210210 "flake": false,

211211 "locked": {

212− "lastModified": 1649424170,

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

212+ "lastModified": 1658968505,

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

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

215215 "repo": "nix-tools",

216− "rev": "e109c94016e3b6e0db7ed413c793e2d4bdb24aa7",

216+ "rev": "8a754bdcf20b20e116409c2341cf69065d083053",

217217 "type": "github"

218218 },

219219 "original": {

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

255255 },

256256 "nixpkgs-2105": {

257257 "locked": {

258− "lastModified": 1645296114,

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

258+ "lastModified": 1655034179,

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

260260 "owner": "NixOS",

261261 "repo": "nixpkgs",

262− "rev": "530a53dcbc9437363471167a5e4762c5fcfa34a1",

262+ "rev": "046ee4af7a9f016a364f8f78eeaa356ba524ac31",

263263 "type": "github"

264264 },

265265 "original": {

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

271271 },

272272 "nixpkgs-2111": {

273273 "locked": {

274− "lastModified": 1648744337,

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

274+ "lastModified": 1656782578,

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

276276 "owner": "NixOS",

277277 "repo": "nixpkgs",

278− "rev": "0a58eebd8ec65ffdef2ce9562784123a73922052",

278+ "rev": "573603b7fdb9feb0eb8efc16ee18a015c667ab1b",

279279 "type": "github"

280280 },

281281 "original": {

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

285285 "type": "github"

286286 }

287287 },

288+ "nixpkgs-2205": {

289+ "locked": {

290+ "lastModified": 1657876628,

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

292+ "owner": "NixOS",

293+ "repo": "nixpkgs",

294+ "rev": "549d82bdd40f760a438c3c3497c1c61160f3de55",

295+ "type": "github"

296+ },

297+ "original": {

298+ "owner": "NixOS",

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

300+ "repo": "nixpkgs",

301+ "type": "github"

302+ }

303+ },

288304 "nixpkgs-regression": {

289305 "locked": {

290306 "lastModified": 1643052045,

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

302318 },

303319 "nixpkgs-unstable": {

304320 "locked": {

305− "lastModified": 1648219316,

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

321+ "lastModified": 1657888067,

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

307323 "owner": "NixOS",

308324 "repo": "nixpkgs",

309− "rev": "30d3d79b7d3607d56546dd2a6b49e156ba0ec634",

325+ "rev": "65fae659e31098ca4ac825a6fef26d890aaf3f4e",

310326 "type": "github"

311327 },

312328 "original": {

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

352368 "nixpkgs-2003": "nixpkgs-2003",

353369 "nixpkgs-2105": "nixpkgs-2105",

354370 "nixpkgs-2111": "nixpkgs-2111",

371+ "nixpkgs-2205": "nixpkgs-2205",

355372 "nixpkgs-unstable": "nixpkgs-unstable",

356373 "old-ghc-nix": "old-ghc-nix",

357374 "stackage": "stackage"

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

360377 "stackage": {

361378 "flake": false,

362379 "locked": {

363− "lastModified": 1651799909,

364− "narHash": "sha256-O7s14Kl4Je7nwJcrt4Y8UhR0wNFteoMKNeLXj9rz9aQ=",

380+ "lastModified": 1659402917,

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

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

366383 "repo": "stackage.nix",

367− "rev": "900cc0efd1c773095c39d14454f82ef6f367bebd",

384+ "rev": "778df3c4b35eac853d57fac7bafc7c9f2dde917f",

368385 "type": "github"

369386 },

370387 "original": {

flake.nix+12−3

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

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

1112 hydra.url = "hydra";

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

5859 };

5960 };

6061

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

62− let compiler = "ghc884";

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

63+ let compiler = "ghc924";

6364 config = import ./config.nix;

6465 in {

6566 inherit config;

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

100101 };

101102 pkgs = import nixpkgs

102103 (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; }; });

103110 pkgs-unstable = import nixpkgs-unstable

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

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

@@ -111,7 +118,7 @@

111118 # supported by haskell.nix, e.g. with remote builders, in order to check this flake.

112119 # If you want to run the tests for just your platform, run `./test/tests.sh` or

113120 # `nix-build -A checks.$PLATFORM`

114− } // 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 {

115122 legacyPackages = (self.internal.compat { inherit system; }).pkgs;

116123 legacyPackagesUnstable = (self.internal.compat { inherit system; }).pkgs-unstable;

117124

@@ -125,6 +132,8 @@

125132 compiler-nix-name = compiler;

126133 pkgs = haskellNix.pkgs;

127134 })));

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;

128137

129138 devShell = with self.legacyPackages.${system};

130139 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+11−11

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

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

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

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

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

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

126126 let

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

128128 # The first line will contain the repository name.

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

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

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

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

141− then pkgs.evalPackages.runCommand name ({

141+ then evalPackages.runCommand name ({

142142 nativeBuildInputs = [ cabal-install ];

143143 preferLocalBuild = true;

144144 }) ''

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

155155 cabal v2-update ${name}

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

157157 ''

158− else pkgs.evalPackages.runCommand name ({

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

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

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

161161 LANG = "en_US.UTF-8";

162162 preferLocalBuild = true;

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

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

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

176176 EOF

177177

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

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

179179 cabal v2-update ${name}

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

181181 '';

182182 # Output of hackage-to-nix

183183 hackage = import (

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

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

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

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

187187 LANG = "en_US.UTF-8";

188188 preferLocalBuild = true;

189189 } ''

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

196196 };

197197 };

198198

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

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

200200 let

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

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

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

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

204204 in {

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

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

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

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

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

6464 # would result in the "foo" subdirectory of

6565 # any plutus-apps input being used for a

6666 # package.

67+, evalPackages

6768, ...

6869}@args:

6970

7071let

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

73+

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

7275 # lazy enough to avoid infinite recursion issues.

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

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

219222 in {

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

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

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

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

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

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

224227 } ''

225228 mkdir $out

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

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

241244

242245 # Parse the `repository` blocks

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

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

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

245248

246249 # we need the repository content twice:

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

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

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

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

250253 # * at built time (passed out)

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

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

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

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

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

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

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

257260 in {

258261 sourceRepos = sourceReposBuild;

259262 inherit (repoResult) repos extra-hackages;

260263 makeFixedProjectFile = ''

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

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

262265 '' +

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

264267 chmod +w -R ./cabal.project

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

365368 '');

366369

367370 # Dummy `ghc` that uses the captured output

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

371+ dummy-ghc = evalPackages.writeTextFile {

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

370373 executable = true;

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

372375 text = ''

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

376+ #!${evalPackages.runtimeShell}

374377 case "$*" in

375378 --version*)

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

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

408411 };

409412

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

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

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

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

413416 executable = true;

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

415418 text = ''

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

419+ #!${evalPackages.runtimeShell}

417420 case "$*" in

418421 --version)

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

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

449452 else null;

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

451454 inherit checkMaterialization;

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

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

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

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

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

455− 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";

456459 LANG = "en_US.UTF-8";

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

458461 preferLocalBuild = false;

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

474477 '';

475478 in {

476479 # These check for cabal configure failure

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

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

478481 ${checkCabalConfigure}

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

480483 '';

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

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

482485 ${checkCabalConfigure}

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

484487 '';

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

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

521524 ${fixedProject.makeFixedProjectFile}

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

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

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

524527 cabal.project.freeze

525528 chmod +w cabal.project.freeze

526529 ''}

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

@@ -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,21 +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';

28+ subDir = evalPackages.lib.strings.removePrefix "/" subDir';

2729 cleanedSource = (haskellLib.cleanSourceWith {

2830 name = if name != null then "${name}-root-cabal-files" else "source-root-cabal-files";

2931 src = src.origSrc or src;

3032 filter = path: type: (!(src ? filter) || src.filter path type) && (

3133 type == "directory" ||

32− pkgs.lib.any (i: (pkgs.lib.hasSuffix i path)) [ stackYaml ".cabal" "package.yaml" ]); });

34+ evalPackages.lib.any (i: (evalPackages.lib.hasSuffix i path)) [ stackYaml ".cabal" "package.yaml" ]); });

3335

3436 stackToNixArgs = builtins.concatStringsSep " " [

3537 "--full"

@@ -43,12 +45,12 @@ let

4345 sha256Arg = "stack-sha256";

4446 reasonNotSafe = null;

4547 this = "project.stack-nix" + (if name != null then " for ${name}" else "");

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

48+ } // evalPackages.lib.optionalAttrs (checkMaterialization != null) {

4749 inherit checkMaterialization;

4850 }) (runCommand (if name == null then "stack-to-nix-pkgs" else name + "-stack-to-nix-pkgs") {

49− 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 ];

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

51− 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";

5254 LANG = "en_US.UTF-8";

5355 LC_ALL = "en_US.UTF-8";

5456 preferLocalBuild = false;

@@ -64,10 +66,10 @@ let

6466 echo "cleaned source is empty. Did you forget to 'git add -A'?"; exit 1;

6567 fi

6668 lndir -silent "${cleanedSource}/." $SRC

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

69+ ${evalPackages.lib.optionalString (subDir != "") "cd ${subDir}"}

6870 ${

6971 # If a resolver was fetched use the it instead of the original stack.yaml

70− pkgs.lib.optionalString (fetchedResolver != null)

72+ evalPackages.lib.optionalString (fetchedResolver != null)

7173 # Replace the resolver path in the stack.yaml with the fetched version

7274 ''

7375 rm ${stackYaml}

@@ -75,7 +77,7 @@ let

7577 chmod +w ${stackYaml}

7678 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

7779 ''}

78− ${pkgs.lib.optionalString (cache != null) ''

80+ ${evalPackages.lib.optionalString (cache != null) ''

7981 cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}

8082 ''}

8183 (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-git.nix+5−1

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

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+18−15

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

@@ -202,7 +199,7 @@ in {

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,17 +257,19 @@ 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 {

@@ -340,4 +339,8 @@ in {

340339 # Converts from a `compoent.depends` value to a library derivation.

341340 # In the case of sublibs the `depends` value should already be the derivation.

342341 dependToLib = d: d.components.library or d;

342+

343+ projectOverlays = import ./project-overlays.nix {

344+ inherit lib haskellLib;

345+ };

343346}

lib/ghcjs-project.nix+36−8

@@ -50,9 +50,10 @@

5050 cabalProjectLocal = ''

5151 constraints: Cabal <3.2.1.0

5252 '';

53− modules = [{ reinstallableLibGhc = true; }];

5453 materialized = ../materialized/ghcjs/cabal + "/${compiler-nix-name}";

5554 }

55+, overrideBootPackages ? []

56+, patches ? []

5657, ...

5758}@args:

5859let

@@ -76,9 +77,11 @@ let

7677

7778 # Inputs needed to boot the GHCJS compiler

7879 bootInputs = with pkgs.buildPackages; [

79− # pin nodejs to the 12 series for now, as strings can only be half the length in node 14+

80− # see https://github.com/nodejs/node/issues/33960, this can break large TH splices for now.

81− nodejs-12_x

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

8285 makeWrapper

8386 xorg.lndir

8487 gmp

@@ -86,9 +89,9 @@ let

8689 ]

8790 ++ [ ghc cabal-install emsdk ];

8891 # Configured the GHCJS source

89− configured-src = pkgs.runCommandCC "configured-ghcjs-src" {

92+ configured-src = (pkgs.runCommandCC "configured-ghcjs-src" {

9093 buildInputs = configureInputs;

91− inherit src;

94+ inherit src patches;

9295 } ''

9396 export HOME=$(pwd)

9497 mkdir $HOME/.cabal

@@ -97,6 +100,11 @@ let

97100 chmod -R +w "$out"

98101 cd "$out"

99102

103+ for p in $patches

104+ do

105+ patch -p1 <$p

106+ done

107+

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

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

102110 sed -i 's/${ghcjsVersion}/${ghcVersion}/' ghcjs.cabal

@@ -129,13 +137,32 @@ let

129137 for a in integer-gmp base unix; do

130138 cp ${../overlays/patches/config.sub} lib/boot/pkg/$a/config.sub

131139 done

132− '';

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

133159 # see https://github.com/ghcjs/ghcjs/issues/751 for the happy upper bound.

134160

135161 ghcjsProject = pkgs.haskell-nix.cabalProject' (

136162 (pkgs.lib.filterAttrs

137163 (n: _: !(builtins.any (x: x == n)

138− ["src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"])) args) // {

164+ [ "src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"

165+ "overrideBootPackages" "patches"])) args) // {

139166 src = configured-src;

140167 index-state = "2021-03-20T00:00:00Z";

141168 inherit compiler-nix-name;

@@ -159,6 +186,7 @@ let

159186 packages.Cabal.patches = [ ./../overlays/patches/Cabal/fix-data-dir.patch ];

160187 })

161188 {

189+ ghcOptions = ["-O2"];

162190 packages.ghcjs.doHaddock = false;

163191 packages.haddock-ghcjs.doHaddock = false;

164192 packages.haddock-api-ghcjs.doHaddock = false;

lib/import-and-filter-project.nix+2−2

@@ -33,7 +33,7 @@ in project // {

3333 isProject = false;

3434 packageSrc = pkgs.lib.lists.elemAt sourceRepos (toInt oldPkg.src.url);

3535 }

36− else if !hasPrefix (toString projectNix) (toString oldPkg.src.content)

36+ else if !hasPrefix "${projectNix}" (toString oldPkg.src.content)

3737 then {

3838 # Source location does not match project prefix

3939 isProject = false;

@@ -44,7 +44,7 @@ in project // {

4444 isProject = true;

4545 packageSrc = haskellLib.appendSubDir {

4646 src = srcRoot;

47− subDir = removePrefix "/" (removePrefix (toString projectNix)

47+ subDir = removePrefix "/" (removePrefix "${projectNix}"

4848 (toString oldPkg.src.content));

4949 includeSiblings = true; # Filtering sibling dirs of the package dir is done in the

5050 # component builder so that relative paths can be used to

lib/materialize.nix+11−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

lib/pkgconf-nixpkgs-map.nix+4

@@ -27,6 +27,7 @@ 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" ];

@@ -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" ];

@@ -82,7 +84,9 @@ pkgs:

8284 "ldap" = [ pkgs."openldap" ];

8385 "libavutil" = [ pkgs."ffmpeg" ];

8486 "libcrypto" = [ pkgs."openssl".dev ];

87+ "libfreenect" = [ pkgs."freenect" ];

8588 "libgsasl" = [ pkgs."gsasl" ];

89+ "liboath" = [ pkgs."liboauth" ];

8690 "libpcre" = [ pkgs."pcre" ];

8791 "libqrencode" = [ pkgs."qrencode" ];

8892 "libR" = [ pkgs."R" ];

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 or 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+17−14

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

@@ -17,10 +16,14 @@

1716 then { location, tag, ...}: branchMap."${location}"."${tag}" or null

1817 else _: null

1918, resolverSha256 ? null

20−, nix-tools ? pkgs.haskell-nix.internal-nix-tools # When building stack projects we use the internal nix-tools (compiled with a fixed GHC version)

19+, nix-tools

20+, evalPackages

2121, ...

22−}:

22+}@args:

2323let

24+ inherit (evalPackages) runCommand;

25+ inherit (evalPackages.haskell-nix) haskellLib;

26+

2427 # We only care about the stackYaml file. If src is a local directory

2528 # we want to avoid recalculating the cache unless the stack.yaml file

2629 # changes.

@@ -36,10 +39,10 @@ let

3639 let

3740 origSrc = if src ? _isLibCleanSourceWith then src.origSrc else src;

3841 origSubDir = if src ? _isLibCleanSourceWithEx then src.origSubDir else "";

39− relPath = pkgs.lib.removePrefix (toString origSrc + origSubDir + "/") path;

42+ relPath = evalPackages.lib.removePrefix (toString origSrc + origSubDir + "/") path;

4043

4144 # checks if path1 is a parent directory for path2

42− isParent = path1: path2: pkgs.lib.hasPrefix "${path1}/" path2;

45+ isParent = path1: path2: evalPackages.lib.hasPrefix "${path1}/" path2;

4346

4447 in

4548 (relPath == stackYaml)

@@ -48,9 +51,9 @@ let

4851 };

4952

5053 # All repos served via ssh or git protocols are usually private

51− private = url: pkgs.lib.substring 0 4 url != "http";

54+ private = url: evalPackages.lib.substring 0 4 url != "http";

5255

53− repos = builtins.fromJSON (builtins.readFile (pkgs.runCommand "stack-repos" {

56+ repos = builtins.fromJSON (builtins.readFile (evalPackages.runCommand "stack-repos" {

5457 buildInputs = [ nix-tools ];

5558 } ''

5659 TMP=$(mktemp -d)

@@ -58,23 +61,23 @@ let

5861 cp -r "${maybeCleanedSource}/." $TMP

5962 chmod -R +w $TMP

6063 substituteInPlace ${stackYaml} --replace "# nix-sha256:" "nix-sha256:"

61− ${pkgs.lib.optionalString (fetchedResolver != null) ''

64+ ${evalPackages.lib.optionalString (fetchedResolver != null) ''

6265 substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"

6366 ''}

6467 stack-repos --stack-yaml ${stackYaml}

6568 cp repos.json $out

6669 ''));

6770

68− cabalName = path: builtins.readFile (pkgs.runCommand "cabal-name" {

71+ cabalName = path: builtins.readFile (evalPackages.runCommand "cabal-name" {

6972 buildInputs = [ nix-tools ];

7073 } ''

7174 cabal-name ${path} > $out

7275 '');

7376

7477 hashPath = path:

75− builtins.readFile (pkgs.runCommand "hash-path" { preferLocalBuild = true; }

76− "echo -n $(${pkgs.nix}/bin/nix-hash --type sha256 --base32 ${path}) > $out");

77−in with pkgs.lib;

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;

7881concatMap (dep:

7982 let

8083 is-private = private dep.url;

@@ -88,13 +91,13 @@ concatMap (dep:

8891 };

8992 pkgsrc =

9093 if !is-private && sha256 != null

91− then pkgs.fetchgit {

94+ then evalPackages.fetchgit {

9295 inherit (dep) url rev;

9396 inherit sha256;

9497 }

9598 else builtins.fetchGit ({

9699 inherit (dep) url rev;

97− } // pkgs.lib.optionalAttrs (branch != null) { ref = branch; });

100+ } // evalPackages.lib.optionalAttrs (branch != null) { ref = branch; });

98101 in map (subdir: {

99102 name = cabalName "${pkgsrc}/${subdir}";

100103 inherit (dep) url rev;

lib/system-nixpkgs-map.nix+31−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 ];

@@ -87,6 +104,16 @@ with pkgs;

87104 gfortran = [ gfortran.cc.lib ];

88105 ssh2 = [ libssh2 ];

89106 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 ];

90117}

91118# -- windows

92119// { advapi32 = null; gdi32 = null; imm32 = null; msimg32 = null;

@@ -97,13 +124,12 @@ with pkgs;

97124 # this should be bundled with gcc.

98125 # if it's not we have more severe

99126 # issues anyway.

100− gcc_s_seh-1 = null;

101− gcc_s = null;

102127 ssl32 = null; eay32 = [ openssl ];

103128 iphlpapi = null; # IP Help API

104129 msvcrt = null; # this is the libc

105130 Crypt32 = null;

106131 mswsock = null;

132+ bcrypt = null;

107133 }

108134# -- os x

109135# 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/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

@@ -0,0 +1,1826 @@

1+name: Cabal

2+version: 3.6.0.0

3+visibility: public

4+id: Cabal-3.6.0.0

5+key: Cabal-3.6.0.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.0.0

176+depends:

177+ array-0.5.4.0 base-4.16.0.0 binary-0.8.9.0 bytestring-0.11.1.0

178+ containers-0.6.5.1 deepseq-1.4.6.0 directory-1.3.6.2

179+ filepath-1.4.2.1 mtl-2.2.2 parsec-3.1.14.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.0.0

213+haddock-interfaces:

214+haddock-html:

215+---

216+name: base

217+version: 4.16.0.0

218+visibility: public

219+id: base-4.16.0.0

220+key: base-4.16.0.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.Internal.Types

305+ System.Environment.ExecutablePath System.CPUTime.Utils

306+ GHC.Event.Arr GHC.Event.Array GHC.Event.Control GHC.Event.EPoll

307+ GHC.Event.IntTable GHC.Event.IntVar GHC.Event.Internal

308+ GHC.Event.KQueue GHC.Event.Manager GHC.Event.PSQ GHC.Event.Poll

309+ GHC.Event.Thread GHC.Event.TimerManager GHC.Event.Unique

310+ System.CPUTime.Posix.ClockGetTime System.CPUTime.Posix.Times

311+ System.CPUTime.Posix.RUsage System.CPUTime.Unsupported

312+import-dirs:

313+library-dirs:

314+dynamic-library-dirs:

315+data-dir:

316+hs-libraries: HSbase-4.16.0.0

317+include-dirs:

318+includes: HsBase.h

319+depends: ghc-bignum-1.2 ghc-prim-0.8.0 rts

320+haddock-interfaces:

321+haddock-html:

322+---

323+name: binary

324+version: 0.8.9.0

325+visibility: public

326+id: binary-0.8.9.0

327+key: binary-0.8.9.0

328+license: BSD-3-Clause

329+maintainer: Lennart Kolmodin, Don Stewart <dons00@gmail.com>

330+author: Lennart Kolmodin <kolmodin@gmail.com>

331+stability: provisional

332+homepage: https://github.com/kolmodin/binary

333+synopsis:

334+ Binary serialisation for Haskell values using lazy ByteStrings

335+description:

336+ Efficient, pure binary serialisation using lazy ByteStrings.

337+ Haskell values may be encoded to and from binary formats,

338+ written to disk as binary, or sent over the network.

339+ The format used can be automatically generated, or

340+ you can choose to implement a custom format if needed.

341+ Serialisation speeds of over 1 G\/sec have been observed,

342+ so this library should be suitable for high performance

343+ scenarios.

344+category: Data, Parsing

345+exposed: True

346+exposed-modules:

347+ Data.Binary Data.Binary.Builder Data.Binary.Get

348+ Data.Binary.Get.Internal Data.Binary.Put

349+hidden-modules:

350+ Data.Binary.Class Data.Binary.Internal Data.Binary.Generic

351+ Data.Binary.FloatCast

352+import-dirs:

353+library-dirs:

354+dynamic-library-dirs:

355+data-dir:

356+hs-libraries: HSbinary-0.8.9.0

357+depends:

358+ array-0.5.4.0 base-4.16.0.0 bytestring-0.11.1.0 containers-0.6.5.1

359+haddock-interfaces:

360+haddock-html:

361+---

362+name: bytestring

363+version: 0.11.1.0

364+visibility: public

365+id: bytestring-0.11.1.0

366+key: bytestring-0.11.1.0

367+license: BSD-3-Clause

368+copyright:

369+ Copyright (c) Don Stewart 2005-2009,

370+ (c) Duncan Coutts 2006-2015,

371+ (c) David Roundy 2003-2005,

372+ (c) Jasper Van der Jeugt 2010,

373+ (c) Simon Meier 2010-2013.

374+maintainer:

375+ Haskell Bytestring Team <andrew.lelechenko@gmail.com>, Core Libraries Committee

376+author:

377+ Don Stewart,

378+ Duncan Coutts

379+homepage: https://github.com/haskell/bytestring

380+synopsis:

381+ Fast, compact, strict and lazy byte strings with a list interface

382+description:

383+ An efficient compact, immutable byte string type (both strict and lazy)

384+ suitable for binary or 8-bit character data.

385+ The 'ByteString' type represents sequences of bytes or 8-bit characters.

386+ It is suitable for high performance use, both in terms of large data

387+ quantities, or high speed requirements. The 'ByteString' functions follow

388+ the same style as Haskell\'s ordinary lists, so it is easy to convert code

389+ from using 'String' to 'ByteString'.

390+ Two 'ByteString' variants are provided:

391+ * Strict 'ByteString's keep the string as a single large array. This

392+ makes them convenient for passing data between C and Haskell.

393+ * Lazy 'ByteString's use a lazy list of strict chunks which makes it

394+ suitable for I\/O streaming tasks.

395+ The @Char8@ modules provide a character-based view of the same

396+ underlying 'ByteString' types. This makes it convenient to handle mixed

397+ binary and 8-bit character content (which is common in many file formats

398+ and network protocols).

399+ The 'Builder' module provides an efficient way to build up 'ByteString's

400+ in an ad-hoc way by repeated concatenation. This is ideal for fast

401+ serialisation or pretty printing.

402+ There is also a 'ShortByteString' type which has a lower memory overhead

403+ and can can be converted to or from a 'ByteString', but supports very few

404+ other operations. It is suitable for keeping many short strings in memory.

405+ 'ByteString's are not designed for Unicode. For Unicode strings you should

406+ use the 'Text' type from the @text@ package.

407+ These modules are intended to be imported qualified, to avoid name clashes

408+ with "Prelude" functions, e.g.

409+ > import qualified Data.ByteString as BS

410+category: Data

411+exposed: True

412+exposed-modules:

413+ Data.ByteString Data.ByteString.Builder

414+ Data.ByteString.Builder.Extra Data.ByteString.Builder.Internal

415+ Data.ByteString.Builder.Prim Data.ByteString.Builder.Prim.Internal

416+ Data.ByteString.Char8 Data.ByteString.Internal Data.ByteString.Lazy

417+ Data.ByteString.Lazy.Char8 Data.ByteString.Lazy.Internal

418+ Data.ByteString.Short Data.ByteString.Short.Internal

419+ Data.ByteString.Unsafe

420+hidden-modules:

421+ Data.ByteString.Builder.ASCII Data.ByteString.Builder.Prim.Binary

422+ Data.ByteString.Builder.Prim.ASCII

423+ Data.ByteString.Builder.Prim.Internal.Floating

424+ Data.ByteString.Builder.Prim.Internal.Base16

425+import-dirs:

426+library-dirs:

427+dynamic-library-dirs:

428+data-dir:

429+hs-libraries: HSbytestring-0.11.1.0

430+include-dirs:

431+includes: fpstring.h

432+depends:

433+ base-4.16.0.0 deepseq-1.4.6.0 ghc-bignum-1.2 ghc-prim-0.8.0

434+haddock-interfaces:

435+haddock-html:

436+---

437+name: containers

438+version: 0.6.5.1

439+visibility: public

440+id: containers-0.6.5.1

441+key: containers-0.6.5.1

442+license: BSD-3-Clause

443+maintainer: libraries@haskell.org

444+synopsis: Assorted concrete container types

445+description:

446+ This package contains efficient general-purpose implementations

447+ of various immutable container types including sets, maps, sequences,

448+ trees, and graphs.

449+ For a walkthrough of what this package provides with examples of common

450+ operations see the [containers

451+ introduction](https://haskell-containers.readthedocs.io).

452+ The declared cost of each operation is either worst-case or amortized, but

453+ remains valid even if structures are shared.

454+category: Data Structures

455+exposed: True

456+exposed-modules:

457+ Data.Containers.ListUtils Data.Graph Data.IntMap

458+ Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy

459+ Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict

460+ Data.IntMap.Strict.Internal Data.IntSet Data.IntSet.Internal

461+ Data.Map Data.Map.Internal Data.Map.Internal.Debug Data.Map.Lazy

462+ Data.Map.Merge.Lazy Data.Map.Merge.Strict Data.Map.Strict

463+ Data.Map.Strict.Internal Data.Sequence Data.Sequence.Internal

464+ Data.Sequence.Internal.Sorting Data.Set Data.Set.Internal Data.Tree

465+ Utils.Containers.Internal.BitQueue

466+ Utils.Containers.Internal.BitUtil

467+ Utils.Containers.Internal.StrictPair

468+hidden-modules:

469+ Utils.Containers.Internal.State

470+ Utils.Containers.Internal.StrictMaybe

471+ Utils.Containers.Internal.PtrEquality

472+ Utils.Containers.Internal.Coercions

473+ Utils.Containers.Internal.TypeError

474+ Data.Map.Internal.DeprecatedShowTree

475+ Data.IntMap.Internal.DeprecatedDebug

476+import-dirs:

477+library-dirs:

478+dynamic-library-dirs:

479+data-dir:

480+hs-libraries: HScontainers-0.6.5.1

481+depends: array-0.5.4.0 base-4.16.0.0 deepseq-1.4.6.0

482+haddock-interfaces:

483+haddock-html:

484+---

485+name: deepseq

486+version: 1.4.6.0

487+visibility: public

488+id: deepseq-1.4.6.0

489+key: deepseq-1.4.6.0

490+license: BSD-3-Clause

491+maintainer: libraries@haskell.org

492+synopsis: Deep evaluation of data structures

493+description:

494+ This package provides methods for fully evaluating data structures

495+ (\"deep evaluation\"). Deep evaluation is often used for adding

496+ strictness to a program, e.g. in order to force pending exceptions,

497+ remove space leaks, or force lazy I/O to happen. It is also useful

498+ in parallel programs, to ensure pending work does not migrate to the

499+ wrong thread.

500+ The primary use of this package is via the 'deepseq' function, a

501+ \"deep\" version of 'seq'. It is implemented on top of an 'NFData'

502+ typeclass (\"Normal Form Data\", data structures with no unevaluated

503+ components) which defines strategies for fully evaluating different

504+ data types. See module documentation in "Control.DeepSeq" for more

505+ details.

506+category: Control

507+exposed: True

508+exposed-modules: Control.DeepSeq

509+hidden-modules: Control.DeepSeq.BackDoor

510+import-dirs:

511+library-dirs:

512+dynamic-library-dirs:

513+data-dir:

514+hs-libraries: HSdeepseq-1.4.6.0

515+depends: array-0.5.4.0 base-4.16.0.0

516+haddock-interfaces:

517+haddock-html:

518+---

519+name: directory

520+version: 1.3.6.2

521+visibility: public

522+id: directory-1.3.6.2

523+key: directory-1.3.6.2

524+license: BSD-3-Clause

525+maintainer: libraries@haskell.org

526+synopsis: Platform-agnostic library for filesystem operations

527+description:

528+ This library provides a basic set of operations for manipulating files and

529+ directories in a portable way.

530+category: System

531+exposed: True

532+exposed-modules:

533+ System.Directory System.Directory.Internal

534+ System.Directory.Internal.Prelude

535+hidden-modules:

536+ System.Directory.Internal.C_utimensat

537+ System.Directory.Internal.Common System.Directory.Internal.Config

538+ System.Directory.Internal.Posix System.Directory.Internal.Windows

539+import-dirs:

540+library-dirs:

541+dynamic-library-dirs:

542+data-dir:

543+hs-libraries: HSdirectory-1.3.6.2

544+depends:

545+ base-4.16.0.0 filepath-1.4.2.1 time-1.11.1.1 unix-2.7.2.2

546+haddock-interfaces:

547+haddock-html:

548+---

549+name: exceptions

550+version: 0.10.4

551+visibility: public

552+id: exceptions-0.10.4

553+key: exceptions-0.10.4

554+license: BSD-3-Clause

555+copyright:

556+ Copyright (C) 2013-2015 Edward A. Kmett

557+ Copyright (C) 2012 Google Inc.

558+maintainer: Edward A. Kmett <ekmett@gmail.com>

559+author: Edward A. Kmett

560+stability: provisional

561+homepage: http://github.com/ekmett/exceptions/

562+synopsis: Extensible optionally-pure exceptions

563+description: Extensible optionally-pure exceptions.

564+category: Control, Exceptions, Monad

565+exposed: True

566+exposed-modules: Control.Monad.Catch Control.Monad.Catch.Pure

567+import-dirs:

568+library-dirs:

569+dynamic-library-dirs:

570+data-dir:

571+hs-libraries: HSexceptions-0.10.4

572+depends:

573+ base-4.16.0.0 mtl-2.2.2 stm-2.5.0.0 template-haskell-2.18.0.0

574+ transformers-0.5.6.2

575+haddock-interfaces:

576+haddock-html:

577+---

578+name: filepath

579+version: 1.4.2.1

580+visibility: public

581+id: filepath-1.4.2.1

582+key: filepath-1.4.2.1

583+license: BSD-3-Clause

584+copyright: Neil Mitchell 2005-2020

585+maintainer: Neil Mitchell <ndmitchell@gmail.com>

586+author: Neil Mitchell <ndmitchell@gmail.com>

587+homepage: https://github.com/haskell/filepath#readme

588+synopsis: Library for manipulating FilePaths in a cross platform way.

589+description:

590+ 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:

591+ * "System.FilePath.Posix" manipulates POSIX\/Linux style @FilePath@ values (with @\/@ as the path separator).

592+ * "System.FilePath.Windows" manipulates Windows style @FilePath@ values (with either @\\@ or @\/@ as the path separator, and deals with drives).

593+ * "System.FilePath" is an alias for the module appropriate to your platform.

594+ All three modules provide the same API, and the same documentation (calling out differences in the different variants).

595+category: System

596+exposed: True

597+exposed-modules:

598+ System.FilePath System.FilePath.Posix System.FilePath.Windows

599+import-dirs:

600+library-dirs:

601+dynamic-library-dirs:

602+data-dir:

603+hs-libraries: HSfilepath-1.4.2.1

604+depends: base-4.16.0.0

605+haddock-interfaces:

606+haddock-html:

607+---

608+name: ghc

609+version: 9.2.1

610+visibility: public

611+id: ghc-9.2.1

612+key: ghc-9.2.1

613+license: BSD-3-Clause

614+maintainer: glasgow-haskell-users@haskell.org

615+author: The GHC Team

616+homepage: http://www.haskell.org/ghc/

617+synopsis: The GHC API

618+description:

619+ GHC's functionality can be useful for more things than just

620+ compiling Haskell programs. Important use cases are programs

621+ that analyse (and perhaps transform) Haskell code. Others

622+ include loading Haskell code dynamically in a GHCi-like manner.

623+ For this reason, a lot of GHC's functionality is made available

624+ through this package.

625+ See <https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler>

626+ for more information.

627+category: Development

628+exposed-modules:

629+ GHC, GHC.Builtin.Names, GHC.Builtin.Names.TH, GHC.Builtin.PrimOps,

630+ GHC.Builtin.Types, GHC.Builtin.Types.Literals,

631+ GHC.Builtin.Types.Prim, GHC.Builtin.Uniques, GHC.Builtin.Utils,

632+ GHC.ByteCode.Asm, GHC.ByteCode.InfoTable, GHC.ByteCode.Instr,

633+ GHC.ByteCode.Linker, GHC.ByteCode.Types, GHC.Cmm, GHC.Cmm.BlockId,

634+ GHC.Cmm.CLabel, GHC.Cmm.CallConv, GHC.Cmm.CommonBlockElim,

635+ GHC.Cmm.ContFlowOpt, 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.LRegSet,

639+ GHC.Cmm.LayoutStack, GHC.Cmm.Lexer, GHC.Cmm.Lint, GHC.Cmm.Liveness,

640+ GHC.Cmm.MachOp, GHC.Cmm.Node, GHC.Cmm.Opt, GHC.Cmm.Parser,

641+ GHC.Cmm.Parser.Monad, GHC.Cmm.Pipeline, GHC.Cmm.Ppr,

642+ GHC.Cmm.Ppr.Decl, GHC.Cmm.Ppr.Expr, GHC.Cmm.ProcPoint,

643+ GHC.Cmm.Sink, GHC.Cmm.Switch, GHC.Cmm.Switch.Implement,

644+ GHC.Cmm.Type, GHC.Cmm.Utils, GHC.CmmToAsm, GHC.CmmToAsm.AArch64,

645+ GHC.CmmToAsm.AArch64.CodeGen, GHC.CmmToAsm.AArch64.Cond,

646+ GHC.CmmToAsm.AArch64.Instr, GHC.CmmToAsm.AArch64.Ppr,

647+ GHC.CmmToAsm.AArch64.RegInfo, GHC.CmmToAsm.AArch64.Regs,

648+ GHC.CmmToAsm.BlockLayout, GHC.CmmToAsm.CFG,

649+ GHC.CmmToAsm.CFG.Dominators, GHC.CmmToAsm.CFG.Weight,

650+ GHC.CmmToAsm.CPrim, GHC.CmmToAsm.Config, GHC.CmmToAsm.Dwarf,

651+ GHC.CmmToAsm.Dwarf.Constants, GHC.CmmToAsm.Dwarf.Types,

652+ GHC.CmmToAsm.Format, GHC.CmmToAsm.Instr, GHC.CmmToAsm.Monad,

653+ GHC.CmmToAsm.PIC, GHC.CmmToAsm.PPC, GHC.CmmToAsm.PPC.CodeGen,

654+ GHC.CmmToAsm.PPC.Cond, GHC.CmmToAsm.PPC.Instr,

655+ GHC.CmmToAsm.PPC.Ppr, GHC.CmmToAsm.PPC.RegInfo,

656+ GHC.CmmToAsm.PPC.Regs, GHC.CmmToAsm.Ppr, GHC.CmmToAsm.Reg.Graph,

657+ GHC.CmmToAsm.Reg.Graph.Base, GHC.CmmToAsm.Reg.Graph.Coalesce,

658+ GHC.CmmToAsm.Reg.Graph.Spill, GHC.CmmToAsm.Reg.Graph.SpillClean,

659+ GHC.CmmToAsm.Reg.Graph.SpillCost, GHC.CmmToAsm.Reg.Graph.Stats,

660+ GHC.CmmToAsm.Reg.Graph.TrivColorable, GHC.CmmToAsm.Reg.Graph.X86,

661+ GHC.CmmToAsm.Reg.Linear, GHC.CmmToAsm.Reg.Linear.AArch64,

662+ GHC.CmmToAsm.Reg.Linear.Base, GHC.CmmToAsm.Reg.Linear.FreeRegs,

663+ GHC.CmmToAsm.Reg.Linear.JoinToTargets, GHC.CmmToAsm.Reg.Linear.PPC,

664+ GHC.CmmToAsm.Reg.Linear.SPARC, GHC.CmmToAsm.Reg.Linear.StackMap,

665+ GHC.CmmToAsm.Reg.Linear.State, GHC.CmmToAsm.Reg.Linear.Stats,

666+ GHC.CmmToAsm.Reg.Linear.X86, GHC.CmmToAsm.Reg.Linear.X86_64,

667+ GHC.CmmToAsm.Reg.Liveness, GHC.CmmToAsm.Reg.Target,

668+ GHC.CmmToAsm.Reg.Utils, GHC.CmmToAsm.SPARC,

669+ GHC.CmmToAsm.SPARC.AddrMode, GHC.CmmToAsm.SPARC.Base,

670+ GHC.CmmToAsm.SPARC.CodeGen, GHC.CmmToAsm.SPARC.CodeGen.Amode,

671+ GHC.CmmToAsm.SPARC.CodeGen.Base,

672+ GHC.CmmToAsm.SPARC.CodeGen.CondCode,

673+ GHC.CmmToAsm.SPARC.CodeGen.Expand,

674+ GHC.CmmToAsm.SPARC.CodeGen.Gen32, GHC.CmmToAsm.SPARC.CodeGen.Gen64,

675+ GHC.CmmToAsm.SPARC.CodeGen.Sanity, GHC.CmmToAsm.SPARC.Cond,

676+ GHC.CmmToAsm.SPARC.Imm, GHC.CmmToAsm.SPARC.Instr,

677+ GHC.CmmToAsm.SPARC.Ppr, GHC.CmmToAsm.SPARC.Regs,

678+ GHC.CmmToAsm.SPARC.ShortcutJump, GHC.CmmToAsm.SPARC.Stack,

679+ GHC.CmmToAsm.Types, GHC.CmmToAsm.Utils, GHC.CmmToAsm.X86,

680+ GHC.CmmToAsm.X86.CodeGen, GHC.CmmToAsm.X86.Cond,

681+ GHC.CmmToAsm.X86.Instr, GHC.CmmToAsm.X86.Ppr,

682+ GHC.CmmToAsm.X86.RegInfo, GHC.CmmToAsm.X86.Regs, GHC.CmmToC,

683+ GHC.CmmToLlvm, GHC.CmmToLlvm.Base, GHC.CmmToLlvm.CodeGen,

684+ GHC.CmmToLlvm.Data, GHC.CmmToLlvm.Mangler, GHC.CmmToLlvm.Ppr,

685+ GHC.CmmToLlvm.Regs, GHC.Core, GHC.Core.Class, GHC.Core.Coercion,

686+ GHC.Core.Coercion.Axiom, GHC.Core.Coercion.Opt, GHC.Core.ConLike,

687+ GHC.Core.DataCon, GHC.Core.FVs, GHC.Core.FamInstEnv,

688+ GHC.Core.InstEnv, GHC.Core.Lint, GHC.Core.Make, GHC.Core.Map.Expr,

689+ GHC.Core.Map.Type, GHC.Core.Multiplicity, GHC.Core.Opt.Arity,

690+ GHC.Core.Opt.CSE, GHC.Core.Opt.CallArity, GHC.Core.Opt.CallerCC,

691+ GHC.Core.Opt.ConstantFold, GHC.Core.Opt.CprAnal,

692+ GHC.Core.Opt.DmdAnal, GHC.Core.Opt.Exitify, GHC.Core.Opt.FloatIn,

693+ GHC.Core.Opt.FloatOut, GHC.Core.Opt.LiberateCase,

694+ GHC.Core.Opt.Monad, GHC.Core.Opt.OccurAnal, GHC.Core.Opt.Pipeline,

695+ GHC.Core.Opt.SetLevels, GHC.Core.Opt.Simplify,

696+ GHC.Core.Opt.Simplify.Env, GHC.Core.Opt.Simplify.Monad,

697+ GHC.Core.Opt.Simplify.Utils, GHC.Core.Opt.SpecConstr,

698+ GHC.Core.Opt.Specialise, GHC.Core.Opt.StaticArgs,

699+ GHC.Core.Opt.WorkWrap, GHC.Core.Opt.WorkWrap.Utils,

700+ GHC.Core.PatSyn, GHC.Core.Ppr, GHC.Core.Predicate, GHC.Core.Rules,

701+ GHC.Core.Seq, GHC.Core.SimpleOpt, GHC.Core.Stats, GHC.Core.Subst,

702+ GHC.Core.Tidy, GHC.Core.TyCo.FVs, GHC.Core.TyCo.Ppr,

703+ GHC.Core.TyCo.Rep, GHC.Core.TyCo.Subst, GHC.Core.TyCo.Tidy,

704+ GHC.Core.TyCon, GHC.Core.TyCon.Env, GHC.Core.TyCon.RecWalk,

705+ GHC.Core.TyCon.Set, GHC.Core.Type, GHC.Core.Unfold,

706+ GHC.Core.Unfold.Make, GHC.Core.Unify, GHC.Core.UsageEnv,

707+ GHC.Core.Utils, GHC.CoreToIface, GHC.CoreToStg, GHC.CoreToStg.Prep,

708+ GHC.Data.Bag, GHC.Data.Bitmap, GHC.Data.BooleanFormula,

709+ GHC.Data.EnumSet, GHC.Data.FastMutInt, GHC.Data.FastString,

710+ GHC.Data.FastString.Env, GHC.Data.FiniteMap, GHC.Data.Graph.Base,

711+ GHC.Data.Graph.Color, GHC.Data.Graph.Directed, GHC.Data.Graph.Ops,

712+ GHC.Data.Graph.Ppr, GHC.Data.Graph.UnVar, GHC.Data.IOEnv,

713+ GHC.Data.List.SetOps, GHC.Data.Maybe, GHC.Data.OrdList,

714+ GHC.Data.Pair, GHC.Data.Stream, GHC.Data.StringBuffer,

715+ GHC.Data.TrieMap, GHC.Data.UnionFind, GHC.Driver.Backend,

716+ GHC.Driver.Backpack, GHC.Driver.Backpack.Syntax,

717+ GHC.Driver.CmdLine, GHC.Driver.CodeOutput, GHC.Driver.Config,

718+ GHC.Driver.Env, GHC.Driver.Env.Types, GHC.Driver.Errors,

719+ GHC.Driver.Flags, GHC.Driver.Hooks, GHC.Driver.Main,

720+ GHC.Driver.Make, GHC.Driver.MakeFile, GHC.Driver.Monad,

721+ GHC.Driver.Phases, GHC.Driver.Pipeline, GHC.Driver.Pipeline.Monad,

722+ GHC.Driver.Plugins, GHC.Driver.Ppr, GHC.Driver.Session, GHC.Hs,

723+ GHC.Hs.Binds, GHC.Hs.Decls, GHC.Hs.Doc, GHC.Hs.Dump, GHC.Hs.Expr,

724+ GHC.Hs.Extension, GHC.Hs.ImpExp, GHC.Hs.Instances, GHC.Hs.Lit,

725+ GHC.Hs.Pat, GHC.Hs.Stats, GHC.Hs.Type, GHC.Hs.Utils, GHC.HsToCore,

726+ GHC.HsToCore.Arrows, GHC.HsToCore.Binds, GHC.HsToCore.Coverage,

727+ GHC.HsToCore.Docs, GHC.HsToCore.Expr, GHC.HsToCore.Foreign.Call,

728+ GHC.HsToCore.Foreign.Decl, GHC.HsToCore.GuardedRHSs,

729+ GHC.HsToCore.ListComp, GHC.HsToCore.Match,

730+ GHC.HsToCore.Match.Constructor, GHC.HsToCore.Match.Literal,

731+ GHC.HsToCore.Monad, GHC.HsToCore.Pmc, GHC.HsToCore.Pmc.Check,

732+ GHC.HsToCore.Pmc.Desugar, GHC.HsToCore.Pmc.Ppr,

733+ GHC.HsToCore.Pmc.Solver, GHC.HsToCore.Pmc.Solver.Types,

734+ GHC.HsToCore.Pmc.Types, GHC.HsToCore.Pmc.Utils, GHC.HsToCore.Quote,

735+ GHC.HsToCore.Types, GHC.HsToCore.Usage, GHC.HsToCore.Utils,

736+ GHC.Iface.Binary, GHC.Iface.Env, GHC.Iface.Ext.Ast,

737+ GHC.Iface.Ext.Binary, GHC.Iface.Ext.Debug, GHC.Iface.Ext.Fields,

738+ GHC.Iface.Ext.Types, GHC.Iface.Ext.Utils, GHC.Iface.Load,

739+ GHC.Iface.Make, GHC.Iface.Recomp, GHC.Iface.Recomp.Binary,

740+ GHC.Iface.Recomp.Flags, GHC.Iface.Rename, GHC.Iface.Syntax,

741+ GHC.Iface.Tidy, GHC.Iface.Tidy.StaticPtrTable, GHC.Iface.Type,

742+ GHC.Iface.UpdateIdInfos, GHC.IfaceToCore, GHC.Linker,

743+ GHC.Linker.Dynamic, GHC.Linker.ExtraObj, GHC.Linker.Loader,

744+ GHC.Linker.MacOS, GHC.Linker.Static, GHC.Linker.Types,

745+ GHC.Linker.Unit, GHC.Linker.Windows, GHC.Llvm, GHC.Llvm.MetaData,

746+ GHC.Llvm.Ppr, GHC.Llvm.Syntax, GHC.Llvm.Types, GHC.Parser,

747+ GHC.Parser.Annotation, GHC.Parser.CharClass, GHC.Parser.Errors,

748+ GHC.Parser.Errors.Ppr, GHC.Parser.Header, GHC.Parser.Lexer,

749+ GHC.Parser.PostProcess, GHC.Parser.PostProcess.Haddock,

750+ GHC.Parser.Types, GHC.Parser.Utils, GHC.Platform,

751+ GHC.Platform.AArch64, GHC.Platform.ARM,

752+ GHC.Platform.ArchOS from ghc-boot-9.2.1:GHC.Platform.ArchOS,

753+ GHC.Platform.Constants,

754+ GHC.Platform.Host from ghc-boot-9.2.1:GHC.Platform.Host,

755+ GHC.Platform.NoRegs, GHC.Platform.PPC, GHC.Platform.Profile,

756+ GHC.Platform.RISCV64, GHC.Platform.Reg, GHC.Platform.Reg.Class,

757+ GHC.Platform.Regs, GHC.Platform.S390X, GHC.Platform.SPARC,

758+ GHC.Platform.Ways, GHC.Platform.X86, GHC.Platform.X86_64,

759+ GHC.Plugins, GHC.Prelude, GHC.Rename.Bind, GHC.Rename.Env,

760+ GHC.Rename.Expr, GHC.Rename.Fixity, GHC.Rename.HsType,

761+ GHC.Rename.Module, GHC.Rename.Names, GHC.Rename.Pat,

762+ GHC.Rename.Splice, GHC.Rename.Unbound, GHC.Rename.Utils,

763+ GHC.Runtime.Context, GHC.Runtime.Debugger, GHC.Runtime.Eval,

764+ GHC.Runtime.Eval.Types, GHC.Runtime.Heap.Inspect,

765+ GHC.Runtime.Heap.Layout, GHC.Runtime.Interpreter,

766+ GHC.Runtime.Interpreter.Types, GHC.Runtime.Loader, GHC.Settings,

767+ GHC.Settings.Config, GHC.Settings.Constants, GHC.Settings.IO,

768+ GHC.Stg.CSE, GHC.Stg.Debug, GHC.Stg.DepAnal, GHC.Stg.FVs,

769+ GHC.Stg.Lift, GHC.Stg.Lift.Analysis, GHC.Stg.Lift.Monad,

770+ GHC.Stg.Lint, GHC.Stg.Pipeline, GHC.Stg.Stats, GHC.Stg.Subst,

771+ GHC.Stg.Syntax, GHC.Stg.Unarise, GHC.StgToByteCode, GHC.StgToCmm,

772+ GHC.StgToCmm.ArgRep, GHC.StgToCmm.Bind, GHC.StgToCmm.CgUtils,

773+ GHC.StgToCmm.Closure, GHC.StgToCmm.DataCon, GHC.StgToCmm.Env,

774+ GHC.StgToCmm.Expr, GHC.StgToCmm.ExtCode, GHC.StgToCmm.Foreign,

775+ GHC.StgToCmm.Heap, GHC.StgToCmm.Hpc, GHC.StgToCmm.Layout,

776+ GHC.StgToCmm.Monad, GHC.StgToCmm.Prim, GHC.StgToCmm.Prof,

777+ GHC.StgToCmm.Ticky, GHC.StgToCmm.Types, GHC.StgToCmm.Utils,

778+ GHC.SysTools, GHC.SysTools.Ar, GHC.SysTools.BaseDir,

779+ GHC.SysTools.Elf, GHC.SysTools.Info, GHC.SysTools.Process,

780+ GHC.SysTools.Tasks, GHC.SysTools.Terminal, GHC.Tc.Deriv,

781+ GHC.Tc.Deriv.Functor, GHC.Tc.Deriv.Generate, GHC.Tc.Deriv.Generics,

782+ GHC.Tc.Deriv.Infer, GHC.Tc.Deriv.Utils, GHC.Tc.Errors,

783+ GHC.Tc.Errors.Hole, GHC.Tc.Errors.Hole.FitTypes,

784+ GHC.Tc.Gen.Annotation, GHC.Tc.Gen.App, GHC.Tc.Gen.Arrow,

785+ GHC.Tc.Gen.Bind, GHC.Tc.Gen.Default, GHC.Tc.Gen.Export,

786+ GHC.Tc.Gen.Expr, GHC.Tc.Gen.Foreign, GHC.Tc.Gen.Head,

787+ GHC.Tc.Gen.HsType, GHC.Tc.Gen.Match, GHC.Tc.Gen.Pat,

788+ GHC.Tc.Gen.Rule, GHC.Tc.Gen.Sig, GHC.Tc.Gen.Splice,

789+ GHC.Tc.Instance.Class, GHC.Tc.Instance.Family,

790+ GHC.Tc.Instance.FunDeps, GHC.Tc.Instance.Typeable, GHC.Tc.Module,

791+ GHC.Tc.Plugin, GHC.Tc.Solver, GHC.Tc.Solver.Canonical,

792+ GHC.Tc.Solver.Interact, GHC.Tc.Solver.Monad, GHC.Tc.Solver.Rewrite,

793+ GHC.Tc.TyCl, GHC.Tc.TyCl.Build, GHC.Tc.TyCl.Class,

794+ GHC.Tc.TyCl.Instance, GHC.Tc.TyCl.PatSyn, GHC.Tc.TyCl.Utils,

795+ GHC.Tc.Types, GHC.Tc.Types.Constraint, GHC.Tc.Types.EvTerm,

796+ GHC.Tc.Types.Evidence, GHC.Tc.Types.Origin, GHC.Tc.Utils.Backpack,

797+ GHC.Tc.Utils.Env, GHC.Tc.Utils.Instantiate, GHC.Tc.Utils.Monad,

798+ GHC.Tc.Utils.TcMType, GHC.Tc.Utils.TcType, GHC.Tc.Utils.Unify,

799+ GHC.Tc.Utils.Zonk, GHC.Tc.Validity, GHC.ThToHs,

800+ GHC.Types.Annotations, GHC.Types.Avail, GHC.Types.Basic,

801+ GHC.Types.CompleteMatch, GHC.Types.CostCentre,

802+ GHC.Types.CostCentre.State, GHC.Types.Cpr, GHC.Types.Demand,

803+ GHC.Types.Error, GHC.Types.FieldLabel, GHC.Types.Fixity,

804+ GHC.Types.Fixity.Env, GHC.Types.ForeignCall,

805+ GHC.Types.ForeignStubs, GHC.Types.HpcInfo, GHC.Types.IPE,

806+ GHC.Types.Id, GHC.Types.Id.Info, GHC.Types.Id.Make,

807+ GHC.Types.Literal, GHC.Types.Meta, GHC.Types.Name,

808+ GHC.Types.Name.Cache, GHC.Types.Name.Env,

809+ GHC.Types.Name.Occurrence, GHC.Types.Name.Ppr,

810+ GHC.Types.Name.Reader, GHC.Types.Name.Set, GHC.Types.Name.Shape,

811+ GHC.Types.RepType, GHC.Types.SafeHaskell, GHC.Types.SourceError,

812+ GHC.Types.SourceFile, GHC.Types.SourceText, GHC.Types.SrcLoc,

813+ GHC.Types.Target, GHC.Types.Tickish, GHC.Types.TyThing,

814+ GHC.Types.TyThing.Ppr, GHC.Types.TypeEnv, GHC.Types.Unique,

815+ GHC.Types.Unique.DFM, GHC.Types.Unique.DSet, GHC.Types.Unique.FM,

816+ GHC.Types.Unique.Map, GHC.Types.Unique.SDFM, GHC.Types.Unique.Set,

817+ GHC.Types.Unique.Supply, GHC.Types.Var, GHC.Types.Var.Env,

818+ GHC.Types.Var.Set, GHC.Unit, GHC.Unit.Env, GHC.Unit.External,

819+ GHC.Unit.Finder, GHC.Unit.Finder.Types, GHC.Unit.Home,

820+ GHC.Unit.Home.ModInfo, GHC.Unit.Info, GHC.Unit.Module,

821+ GHC.Unit.Module.Deps, GHC.Unit.Module.Env, GHC.Unit.Module.Graph,

822+ GHC.Unit.Module.Imported, GHC.Unit.Module.Location,

823+ GHC.Unit.Module.ModDetails, GHC.Unit.Module.ModGuts,

824+ GHC.Unit.Module.ModIface, GHC.Unit.Module.ModSummary,

825+ GHC.Unit.Module.Name, GHC.Unit.Module.Status,

826+ GHC.Unit.Module.Warnings, GHC.Unit.Parser, GHC.Unit.Ppr,

827+ GHC.Unit.State, GHC.Unit.Types, GHC.Utils.Asm, GHC.Utils.Binary,

828+ GHC.Utils.Binary.Typeable, GHC.Utils.BufHandle,

829+ GHC.Utils.CliOption, GHC.Utils.Error, GHC.Utils.Exception,

830+ GHC.Utils.FV, GHC.Utils.Fingerprint, GHC.Utils.GlobalVars,

831+ GHC.Utils.IO.Unsafe, GHC.Utils.Json, GHC.Utils.Lexeme,

832+ GHC.Utils.Logger, GHC.Utils.Misc, GHC.Utils.Monad,

833+ GHC.Utils.Monad.State, GHC.Utils.Outputable, GHC.Utils.Panic,

834+ GHC.Utils.Panic.Plain, GHC.Utils.Ppr, GHC.Utils.Ppr.Colour,

835+ GHC.Utils.TmpFs, Language.Haskell.Syntax,

836+ Language.Haskell.Syntax.Binds, Language.Haskell.Syntax.Decls,

837+ Language.Haskell.Syntax.Expr, Language.Haskell.Syntax.Extension,

838+ Language.Haskell.Syntax.Lit, Language.Haskell.Syntax.Pat,

839+ Language.Haskell.Syntax.Type

840+import-dirs:

841+library-dirs:

842+dynamic-library-dirs:

843+data-dir:

844+hs-libraries: HSghc-9.2.1

845+include-dirs:

846+depends:

847+ array-0.5.4.0 base-4.16.0.0 binary-0.8.9.0 bytestring-0.11.1.0

848+ containers-0.6.5.1 deepseq-1.4.6.0 directory-1.3.6.2

849+ exceptions-0.10.4 filepath-1.4.2.1 ghc-boot-9.2.1 ghc-heap-9.2.1

850+ ghci-9.2.1 hpc-0.6.1.0 parsec-3.1.14.0 process-1.6.13.2

851+ template-haskell-2.18.0.0 terminfo-0.4.1.5 time-1.11.1.1

852+ transformers-0.5.6.2 unix-2.7.2.2

853+haddock-interfaces:

854+haddock-html:

855+---

856+name: ghc-bignum

857+version: 1.2

858+visibility: public

859+id: ghc-bignum-1.2

860+key: ghc-bignum-1.2

861+license: BSD-3-Clause

862+maintainer: libraries@haskell.org

863+author: Sylvain Henry

864+synopsis: GHC BigNum library

865+description:

866+ This package provides the low-level implementation of the standard

867+ 'BigNat', 'Natural' and 'Integer' types.

868+category: Numeric, Algebra, GHC

869+exposed: True

870+exposed-modules:

871+ GHC.Num.Backend GHC.Num.Backend.Native GHC.Num.Backend.Selected

872+ GHC.Num.BigNat GHC.Num.Integer GHC.Num.Natural GHC.Num.Primitives

873+ GHC.Num.WordArray

874+hidden-modules: GHC.Num.Backend.GMP

875+import-dirs:

876+library-dirs:

877+dynamic-library-dirs:

878+data-dir:

879+hs-libraries: HSghc-bignum-1.2

880+extra-libraries: gmp

881+include-dirs:

882+depends: ghc-prim-0.8.0

883+haddock-interfaces:

884+haddock-html:

885+---

886+name: ghc-boot

887+version: 9.2.1

888+visibility: public

889+id: ghc-boot-9.2.1

890+key: ghc-boot-9.2.1

891+license: BSD-3-Clause

892+maintainer: ghc-devs@haskell.org

893+synopsis: Shared functionality between GHC and its boot libraries

894+description:

895+ This library is shared between GHC, ghc-pkg, and other boot

896+ libraries.

897+ .

898+ A note about "GHC.Unit.Database": it only deals with the subset of

899+ the package database that the compiler cares about: modules

900+ paths etc and not package metadata like description, authors

901+ etc. It is thus not a library interface to ghc-pkg and is *not*

902+ suitable for modifying GHC package databases.

903+ .

904+ The package database format and this library are constructed in

905+ such a way that while ghc-pkg depends on Cabal, the GHC library

906+ and program do not have to depend on Cabal.

907+category: GHC

908+exposed: True

909+exposed-modules:

910+ GHC.BaseDir, GHC.Data.ShortText, GHC.Data.SizedSeq,

911+ GHC.ForeignSrcLang,

912+ GHC.ForeignSrcLang.Type from ghc-boot-th-9.2.1:GHC.ForeignSrcLang.Type,

913+ GHC.HandleEncoding, GHC.LanguageExtensions,

914+ GHC.LanguageExtensions.Type from ghc-boot-th-9.2.1:GHC.LanguageExtensions.Type,

915+ GHC.Lexeme from ghc-boot-th-9.2.1:GHC.Lexeme, GHC.Platform.ArchOS,

916+ GHC.Platform.Host, GHC.Serialized, GHC.Settings.Utils,

917+ GHC.UniqueSubdir, GHC.Unit.Database, GHC.Utils.Encoding,

918+ GHC.Version

919+import-dirs:

920+library-dirs:

921+dynamic-library-dirs:

922+data-dir:

923+hs-libraries: HSghc-boot-9.2.1

924+depends:

925+ base-4.16.0.0 binary-0.8.9.0 bytestring-0.11.1.0 containers-0.6.5.1

926+ deepseq-1.4.6.0 directory-1.3.6.2 filepath-1.4.2.1

927+ ghc-boot-th-9.2.1

928+haddock-interfaces:

929+haddock-html:

930+---

931+name: ghc-boot-th

932+version: 9.2.1

933+visibility: public

934+id: ghc-boot-th-9.2.1

935+key: ghc-boot-th-9.2.1

936+license: BSD-3-Clause

937+maintainer: ghc-devs@haskell.org

938+synopsis:

939+ Shared functionality between GHC and the @template-haskell@

940+ library

941+description:

942+ This library contains various bits shared between the @ghc@ and

943+ @template-haskell@ libraries.

944+ This package exists to ensure that @template-haskell@ has a

945+ minimal set of transitive dependencies, since it is intended to

946+ be depended upon by user code.

947+category: GHC

948+exposed: True

949+exposed-modules:

950+ GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme

951+import-dirs:

952+library-dirs:

953+dynamic-library-dirs:

954+data-dir:

955+hs-libraries: HSghc-boot-th-9.2.1

956+depends: base-4.16.0.0

957+haddock-interfaces:

958+haddock-html:

959+---

960+name: ghc-compact

961+version: 0.1.0.0

962+visibility: public

963+id: ghc-compact-0.1.0.0

964+key: ghc-compact-0.1.0.0

965+license: BSD-3-Clause

966+maintainer: libraries@haskell.org

967+synopsis: In memory storage of deeply evaluated data structure

968+description:

969+ This package provides minimal functionality for working with

970+ "compact regions", which hold a fully evaluated Haskell object graph.

971+ These regions maintain the invariant that no pointers live inside the struct

972+ that point outside it, which ensures efficient garbage collection without

973+ ever reading the structure contents (effectively, it works as a manually

974+ managed "oldest generation" which is never freed until the whole is

975+ released).

976+ Internally, the struct is stored a single contiguous block of memory,

977+ which allows efficient serialization and deserialization of structs

978+ for distributed computing.

979+category: Data

980+exposed: True

981+exposed-modules: GHC.Compact GHC.Compact.Serialized

982+import-dirs:

983+library-dirs:

984+dynamic-library-dirs:

985+data-dir:

986+hs-libraries: HSghc-compact-0.1.0.0

987+depends: base-4.16.0.0 bytestring-0.11.1.0 ghc-prim-0.8.0

988+haddock-interfaces:

989+haddock-html:

990+---

991+name: ghc-heap

992+version: 9.2.1

993+visibility: public

994+id: ghc-heap-9.2.1

995+key: ghc-heap-9.2.1

996+license: BSD-3-Clause

997+maintainer: libraries@haskell.org

998+synopsis: Functions for walking GHC's heap

999+description:

1000+ This package provides functions for walking the GHC heap data structures

1001+ and retrieving information about those data structures.

1002+category: GHC

1003+exposed: True

1004+exposed-modules:

1005+ GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures

1006+ GHC.Exts.Heap.Constants GHC.Exts.Heap.FFIClosures

1007+ GHC.Exts.Heap.FFIClosures_ProfilingDisabled

1008+ GHC.Exts.Heap.FFIClosures_ProfilingEnabled GHC.Exts.Heap.InfoTable

1009+ GHC.Exts.Heap.InfoTable.Types GHC.Exts.Heap.InfoTableProf

1010+ GHC.Exts.Heap.ProfInfo.PeekProfInfo

1011+ GHC.Exts.Heap.ProfInfo.PeekProfInfo_ProfilingDisabled

1012+ GHC.Exts.Heap.ProfInfo.PeekProfInfo_ProfilingEnabled

1013+ GHC.Exts.Heap.ProfInfo.Types GHC.Exts.Heap.Utils

1014+import-dirs:

1015+library-dirs:

1016+dynamic-library-dirs:

1017+data-dir:

1018+hs-libraries: HSghc-heap-9.2.1

1019+depends: base-4.16.0.0 containers-0.6.5.1 ghc-prim-0.8.0 rts

1020+haddock-interfaces:

1021+haddock-html:

1022+---

1023+name: ghc-prim

1024+version: 0.8.0

1025+visibility: public

1026+id: ghc-prim-0.8.0

1027+key: ghc-prim-0.8.0

1028+license: BSD-3-Clause

1029+maintainer: libraries@haskell.org

1030+synopsis: GHC primitives

1031+description:

1032+ This package contains the primitive types and operations supplied by GHC.

1033+category: GHC

1034+exposed: True

1035+exposed-modules:

1036+ GHC.CString GHC.Classes GHC.Debug GHC.Magic GHC.Prim.Exception

1037+ GHC.Prim.Ext GHC.Prim.Panic GHC.PrimopWrappers GHC.Tuple GHC.Types

1038+ GHC.Prim

1039+import-dirs:

1040+library-dirs:

1041+dynamic-library-dirs:

1042+data-dir:

1043+hs-libraries: HSghc-prim-0.8.0

1044+extra-libraries: gcc c m

1045+depends: rts

1046+haddock-interfaces:

1047+haddock-html:

1048+---

1049+name: ghci

1050+version: 9.2.1

1051+visibility: public

1052+id: ghci-9.2.1

1053+key: ghci-9.2.1

1054+license: BSD-3-Clause

1055+maintainer: ghc-devs@haskell.org

1056+synopsis: The library supporting GHC's interactive interpreter

1057+description:

1058+ This library offers interfaces which mediate interactions between the

1059+ @ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter

1060+ backend.

1061+category: GHC

1062+exposed: True

1063+exposed-modules:

1064+ GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI

1065+ GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes

1066+ GHCi.ResolvedBCO GHCi.Run GHCi.Signals GHCi.StaticPtrTable GHCi.TH

1067+ GHCi.TH.Binary

1068+import-dirs:

1069+library-dirs:

1070+dynamic-library-dirs:

1071+data-dir:

1072+hs-libraries: HSghci-9.2.1

1073+include-dirs:

1074+depends:

1075+ array-0.5.4.0 base-4.16.0.0 binary-0.8.9.0 bytestring-0.11.1.0

1076+ containers-0.6.5.1 deepseq-1.4.6.0 filepath-1.4.2.1 ghc-boot-9.2.1

1077+ ghc-heap-9.2.1 ghc-prim-0.8.0 rts template-haskell-2.18.0.0

1078+ transformers-0.5.6.2 unix-2.7.2.2

1079+haddock-interfaces:

1080+haddock-html:

1081+---

1082+name: haskeline

1083+version: 0.8.2

1084+visibility: public

1085+id: haskeline-0.8.2

1086+key: haskeline-0.8.2

1087+license: BSD-3-Clause

1088+copyright: (c) Judah Jacobson

1089+maintainer: Judah Jacobson <judah.jacobson@gmail.com>

1090+author: Judah Jacobson

1091+stability: Stable

1092+homepage: https://github.com/judah/haskeline

1093+synopsis:

1094+ A command-line interface for user input, written in Haskell.

1095+description:

1096+ Haskeline provides a user interface for line input in command-line

1097+ programs. This library is similar in purpose to readline, but since

1098+ it is written in Haskell it is (hopefully) more easily used in other

1099+ Haskell programs.

1100+ Haskeline runs both on POSIX-compatible systems and on Windows.

1101+category: User Interfaces

1102+exposed: True

1103+exposed-modules:

1104+ System.Console.Haskeline System.Console.Haskeline.Completion

1105+ System.Console.Haskeline.History System.Console.Haskeline.IO

1106+ System.Console.Haskeline.Internal

1107+hidden-modules:

1108+ System.Console.Haskeline.Backend

1109+ System.Console.Haskeline.Backend.WCWidth

1110+ System.Console.Haskeline.Command

1111+ System.Console.Haskeline.Command.Completion

1112+ System.Console.Haskeline.Command.History

1113+ System.Console.Haskeline.Command.KillRing

1114+ System.Console.Haskeline.Directory System.Console.Haskeline.Emacs

1115+ System.Console.Haskeline.InputT System.Console.Haskeline.Key

1116+ System.Console.Haskeline.LineState System.Console.Haskeline.Monads

1117+ System.Console.Haskeline.Prefs System.Console.Haskeline.Recover

1118+ System.Console.Haskeline.RunCommand System.Console.Haskeline.Term

1119+ System.Console.Haskeline.Command.Undo System.Console.Haskeline.Vi

1120+ System.Console.Haskeline.Backend.Posix

1121+ System.Console.Haskeline.Backend.Posix.Encoder

1122+ System.Console.Haskeline.Backend.DumbTerm

1123+ System.Console.Haskeline.Backend.Terminfo

1124+import-dirs:

1125+library-dirs:

1126+dynamic-library-dirs:

1127+data-dir:

1128+hs-libraries: HShaskeline-0.8.2

1129+depends:

1130+ base-4.16.0.0 bytestring-0.11.1.0 containers-0.6.5.1

1131+ directory-1.3.6.2 exceptions-0.10.4 filepath-1.4.2.1

1132+ process-1.6.13.2 stm-2.5.0.0 terminfo-0.4.1.5 transformers-0.5.6.2

1133+ unix-2.7.2.2

1134+haddock-interfaces:

1135+haddock-html:

1136+---

1137+name: hpc

1138+version: 0.6.1.0

1139+visibility: public

1140+id: hpc-0.6.1.0

1141+key: hpc-0.6.1.0

1142+license: BSD-3-Clause

1143+maintainer: ghc-devs@haskell.org

1144+author: Andy Gill

1145+synopsis: Code Coverage Library for Haskell

1146+description:

1147+ This package provides the code coverage library for Haskell.

1148+ See <http://www.haskell.org/haskellwiki/Haskell_program_coverage> for more

1149+ information.

1150+category: Control

1151+exposed: True

1152+exposed-modules:

1153+ Trace.Hpc.Mix Trace.Hpc.Reflect Trace.Hpc.Tix Trace.Hpc.Util

1154+import-dirs:

1155+library-dirs:

1156+dynamic-library-dirs:

1157+data-dir:

1158+hs-libraries: HShpc-0.6.1.0

1159+depends:

1160+ base-4.16.0.0 containers-0.6.5.1 deepseq-1.4.6.0 directory-1.3.6.2

1161+ filepath-1.4.2.1 time-1.11.1.1

1162+haddock-interfaces:

1163+haddock-html:

1164+---

1165+name: integer-gmp

1166+version: 1.1

1167+visibility: public

1168+id: integer-gmp-1.1

1169+key: integer-gmp-1.1

1170+license: BSD-3-Clause

1171+maintainer: hvr@gnu.org

1172+author: Herbert Valerio Riedel

1173+synopsis: Integer library based on GMP

1174+description:

1175+ This package used to provide an implementation of the standard 'Integer'

1176+ type based on the

1177+ <http://gmplib.org/ GNU Multiple Precision Arithmetic Library (GMP)>.

1178+ It is now deprecated in favor of the 'ghc-bignum' package.

1179+ Its purpose is to provide backward compatibility for codes directly

1180+ depending on the `integer-gmp` package.

1181+category: Numeric, Algebra

1182+exposed: True

1183+exposed-modules: GHC.Integer.GMP.Internals

1184+import-dirs:

1185+library-dirs:

1186+dynamic-library-dirs:

1187+data-dir:

1188+hs-libraries: HSinteger-gmp-1.1

1189+depends: base-4.16.0.0 ghc-bignum-1.2 ghc-prim-0.8.0

1190+haddock-interfaces:

1191+haddock-html:

1192+---

1193+name: libiserv

1194+version: 9.2.1

1195+visibility: public

1196+id: libiserv-9.2.1

1197+key: libiserv-9.2.1

1198+license: BSD-3-Clause

1199+copyright: XXX

1200+maintainer: XXX

1201+author: XXX

1202+synopsis:

1203+ Provides shared functionality between iserv and iserv-proxy.

1204+description:

1205+ Provides shared functionality between iserv and iserv-proxy.

1206+category: Development

1207+exposed: True

1208+exposed-modules: GHCi.Utils Lib

1209+import-dirs:

1210+library-dirs:

1211+dynamic-library-dirs:

1212+data-dir:

1213+hs-libraries: HSlibiserv-9.2.1

1214+depends:

1215+ base-4.16.0.0 binary-0.8.9.0 bytestring-0.11.1.0 containers-0.6.5.1

1216+ deepseq-1.4.6.0 ghci-9.2.1 unix-2.7.2.2

1217+haddock-interfaces:

1218+haddock-html:

1219+---

1220+name: mtl

1221+version: 2.2.2

1222+visibility: public

1223+id: mtl-2.2.2

1224+key: mtl-2.2.2

1225+license: BSD-3-Clause

1226+maintainer: Edward Kmett <ekmett@gmail.com>

1227+author: Andy Gill

1228+homepage: http://github.com/haskell/mtl

1229+synopsis: Monad classes, using functional dependencies

1230+description:

1231+ Monad classes using functional dependencies, with instances

1232+ for various monad transformers, inspired by the paper

1233+ /Functional Programming with Overloading and Higher-Order Polymorphism/,

1234+ by Mark P Jones, in /Advanced School of Functional Programming/, 1995

1235+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1236+category: Control

1237+exposed: True

1238+exposed-modules:

1239+ Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error

1240+ Control.Monad.Error.Class Control.Monad.Except

1241+ Control.Monad.Identity Control.Monad.List Control.Monad.RWS

1242+ Control.Monad.RWS.Class Control.Monad.RWS.Lazy

1243+ Control.Monad.RWS.Strict Control.Monad.Reader

1244+ Control.Monad.Reader.Class Control.Monad.State

1245+ Control.Monad.State.Class Control.Monad.State.Lazy

1246+ Control.Monad.State.Strict Control.Monad.Trans Control.Monad.Writer

1247+ Control.Monad.Writer.Class Control.Monad.Writer.Lazy

1248+ Control.Monad.Writer.Strict

1249+import-dirs:

1250+library-dirs:

1251+dynamic-library-dirs:

1252+data-dir:

1253+hs-libraries: HSmtl-2.2.2

1254+depends: base-4.16.0.0 transformers-0.5.6.2

1255+haddock-interfaces:

1256+haddock-html:

1257+---

1258+name: parsec

1259+version: 3.1.14.0

1260+visibility: public

1261+id: parsec-3.1.14.0

1262+key: parsec-3.1.14.0

1263+license: BSD-3-Clause

1264+maintainer: Herbert Valerio Riedel <hvr@gnu.org>

1265+author:

1266+ Daan Leijen <daan@microsoft.com>, Paolo Martini <paolo@nemail.it>, Antoine Latter <aslatter@gmail.com>

1267+homepage: https://github.com/haskell/parsec

1268+synopsis: Monadic parser combinators

1269+description:

1270+ Parsec is designed from scratch as an industrial-strength parser

1271+ library. It is simple, safe, well documented (on the package

1272+ homepage), has extensive libraries, good error messages,

1273+ and is fast. It is defined as a monad transformer that can be

1274+ stacked on arbitrary monads, and it is also parametric in the

1275+ input stream type.

1276+ The main entry point is the "Text.Parsec" module which provides

1277+ defaults for parsing 'Char'acter data.

1278+ The "Text.ParserCombinators.Parsec" module hierarchy contains

1279+ the legacy @parsec-2@ API and may be removed at some point in

1280+ the future.

1281+category: Parsing

1282+exposed: True

1283+exposed-modules:

1284+ Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy

1285+ Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error

1286+ Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm

1287+ Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String

1288+ Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token

1289+ Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char

1290+ Text.ParserCombinators.Parsec.Combinator

1291+ Text.ParserCombinators.Parsec.Error

1292+ Text.ParserCombinators.Parsec.Expr

1293+ Text.ParserCombinators.Parsec.Language

1294+ Text.ParserCombinators.Parsec.Perm

1295+ Text.ParserCombinators.Parsec.Pos

1296+ Text.ParserCombinators.Parsec.Prim

1297+ Text.ParserCombinators.Parsec.Token

1298+import-dirs:

1299+library-dirs:

1300+dynamic-library-dirs:

1301+data-dir:

1302+hs-libraries: HSparsec-3.1.14.0

1303+depends:

1304+ base-4.16.0.0 bytestring-0.11.1.0 mtl-2.2.2 text-1.2.5.0

1305+haddock-interfaces:

1306+haddock-html:

1307+---

1308+name: pretty

1309+version: 1.1.3.6

1310+visibility: public

1311+id: pretty-1.1.3.6

1312+key: pretty-1.1.3.6

1313+license: BSD-3-Clause

1314+maintainer: David Terei <code@davidterei.com>

1315+stability: Stable

1316+homepage: http://github.com/haskell/pretty

1317+synopsis: Pretty-printing library

1318+description:

1319+ This package contains a pretty-printing library, a set of API's

1320+ that provides a way to easily print out text in a consistent

1321+ format of your choosing. This is useful for compilers and related

1322+ tools.

1323+ This library was originally designed by John Hughes's and has since

1324+ been heavily modified by Simon Peyton Jones.

1325+category: Text

1326+exposed: True

1327+exposed-modules:

1328+ Text.PrettyPrint Text.PrettyPrint.Annotated

1329+ Text.PrettyPrint.Annotated.HughesPJ

1330+ Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ

1331+ Text.PrettyPrint.HughesPJClass

1332+import-dirs:

1333+library-dirs:

1334+dynamic-library-dirs:

1335+data-dir:

1336+hs-libraries: HSpretty-1.1.3.6

1337+depends: base-4.16.0.0 deepseq-1.4.6.0 ghc-prim-0.8.0

1338+haddock-interfaces:

1339+haddock-html:

1340+---

1341+name: process

1342+version: 1.6.13.2

1343+visibility: public

1344+id: process-1.6.13.2

1345+key: process-1.6.13.2

1346+license: BSD-3-Clause

1347+maintainer: libraries@haskell.org

1348+synopsis: Process libraries

1349+description:

1350+ This package contains libraries for dealing with system processes.

1351+ The typed-process package is a more recent take on a process API,

1352+ which uses this package internally. It features better binary

1353+ support, easier concurrency, and a more composable API. You can

1354+ read more about it at

1355+ <https://github.com/fpco/typed-process/#readme>.

1356+category: System

1357+exposed: True

1358+exposed-modules: System.Cmd System.Process System.Process.Internals

1359+hidden-modules: System.Process.Common System.Process.Posix

1360+import-dirs:

1361+library-dirs:

1362+dynamic-library-dirs:

1363+data-dir:

1364+hs-libraries: HSprocess-1.6.13.2

1365+include-dirs:

1366+includes: runProcess.h

1367+depends:

1368+ base-4.16.0.0 deepseq-1.4.6.0 directory-1.3.6.2 filepath-1.4.2.1

1369+ unix-2.7.2.2

1370+haddock-interfaces:

1371+haddock-html:

1372+---

1373+name: stm

1374+version: 2.5.0.0

1375+visibility: public

1376+id: stm-2.5.0.0

1377+key: stm-2.5.0.0

1378+license: BSD-3-Clause

1379+maintainer: libraries@haskell.org

1380+homepage: https://wiki.haskell.org/Software_transactional_memory

1381+synopsis: Software Transactional Memory

1382+description:

1383+ Software Transactional Memory, or STM, is an abstraction for

1384+ concurrent communication. The main benefits of STM are

1385+ /composability/ and /modularity/. That is, using STM you can write

1386+ concurrent abstractions that can be easily composed with any other

1387+ abstraction built using STM, without exposing the details of how

1388+ your abstraction ensures safety. This is typically not the case

1389+ with other forms of concurrent communication, such as locks or

1390+ 'MVar's.

1391+category: Concurrency

1392+exposed: True

1393+exposed-modules:

1394+ Control.Concurrent.STM Control.Concurrent.STM.TArray

1395+ Control.Concurrent.STM.TBQueue Control.Concurrent.STM.TChan

1396+ Control.Concurrent.STM.TMVar Control.Concurrent.STM.TQueue

1397+ Control.Concurrent.STM.TSem Control.Concurrent.STM.TVar

1398+ Control.Monad.STM

1399+hidden-modules: Control.Sequential.STM

1400+import-dirs:

1401+library-dirs:

1402+dynamic-library-dirs:

1403+data-dir:

1404+hs-libraries: HSstm-2.5.0.0

1405+depends: array-0.5.4.0 base-4.16.0.0

1406+haddock-interfaces:

1407+haddock-html:

1408+---

1409+name: template-haskell

1410+version: 2.18.0.0

1411+visibility: public

1412+id: template-haskell-2.18.0.0

1413+key: template-haskell-2.18.0.0

1414+license: BSD-3-Clause

1415+maintainer: libraries@haskell.org

1416+synopsis: Support library for Template Haskell

1417+description:

1418+ This package provides modules containing facilities for manipulating

1419+ Haskell source code using Template Haskell.

1420+ See <http://www.haskell.org/haskellwiki/Template_Haskell> for more

1421+ information.

1422+category: Template Haskell

1423+exposed: True

1424+exposed-modules:

1425+ Language.Haskell.TH Language.Haskell.TH.CodeDo

1426+ Language.Haskell.TH.LanguageExtensions Language.Haskell.TH.Lib

1427+ Language.Haskell.TH.Lib.Internal Language.Haskell.TH.Ppr

1428+ Language.Haskell.TH.PprLib Language.Haskell.TH.Quote

1429+ Language.Haskell.TH.Syntax

1430+hidden-modules: Language.Haskell.TH.Lib.Map

1431+import-dirs:

1432+library-dirs:

1433+dynamic-library-dirs:

1434+data-dir:

1435+hs-libraries: HStemplate-haskell-2.18.0.0

1436+depends:

1437+ base-4.16.0.0 ghc-boot-th-9.2.1 ghc-prim-0.8.0 pretty-1.1.3.6

1438+haddock-interfaces:

1439+haddock-html:

1440+---

1441+name: terminfo

1442+version: 0.4.1.5

1443+visibility: public

1444+id: terminfo-0.4.1.5

1445+key: terminfo-0.4.1.5

1446+license: BSD-3-Clause

1447+copyright: (c) Judah Jacobson

1448+maintainer: Judah Jacobson <judah.jacobson@gmail.com>

1449+author: Judah Jacobson

1450+stability: Stable

1451+homepage: https://github.com/judah/terminfo

1452+synopsis: Haskell bindings to the terminfo library.

1453+description:

1454+ This library provides an interface to the terminfo database (via bindings to the

1455+ curses library). <http://en.wikipedia.org/wiki/Terminfo Terminfo> allows POSIX

1456+ systems to interact with a variety of terminals using a standard set of capabilities.

1457+category: User Interfaces

1458+exposed: True

1459+exposed-modules:

1460+ System.Console.Terminfo System.Console.Terminfo.Base

1461+ System.Console.Terminfo.Color System.Console.Terminfo.Cursor

1462+ System.Console.Terminfo.Edit System.Console.Terminfo.Effects

1463+ System.Console.Terminfo.Keys

1464+import-dirs:

1465+library-dirs:

1466+dynamic-library-dirs:

1467+data-dir:

1468+hs-libraries: HSterminfo-0.4.1.5

1469+extra-libraries: tinfo

1470+depends: base-4.16.0.0

1471+haddock-interfaces:

1472+haddock-html:

1473+---

1474+name: text

1475+version: 1.2.5.0

1476+visibility: public

1477+id: text-1.2.5.0

1478+key: text-1.2.5.0

1479+license: BSD-2-Clause

1480+copyright: 2009-2011 Bryan O'Sullivan, 2008-2009 Tom Harper

1481+maintainer:

1482+ Haskell Text Team <andrew.lelechenko@gmail.com>, Core Libraries Committee

1483+author: Bryan O'Sullivan <bos@serpentine.com>

1484+homepage: https://github.com/haskell/text

1485+synopsis: An efficient packed Unicode text type.

1486+description:

1487+ An efficient packed, immutable Unicode text type (both strict and

1488+ lazy), with a powerful loop fusion optimization framework.

1489+ The 'Text' type represents Unicode character strings, in a time and

1490+ space-efficient manner. This package provides text processing

1491+ capabilities that are optimized for performance critical use, both

1492+ in terms of large data quantities and high speed.

1493+ The 'Text' type provides character-encoding, type-safe case

1494+ conversion via whole-string case conversion functions (see "Data.Text").

1495+ It also provides a range of functions for converting 'Text' values to

1496+ and from 'ByteStrings', using several standard encodings

1497+ (see "Data.Text.Encoding").

1498+ Efficient locale-sensitive support for text IO is also supported

1499+ (see "Data.Text.IO").

1500+ These modules are intended to be imported qualified, to avoid name

1501+ clashes with Prelude functions, e.g.

1502+ > import qualified Data.Text as T

1503+ == ICU Support

1504+ To use an extended and very rich family of functions for working

1505+ with Unicode text (including normalization, regular expressions,

1506+ non-standard encodings, text breaking, and locales), see

1507+ the [text-icu package](https://hackage.haskell.org/package/text-icu)

1508+ based on the well-respected and liberally

1509+ licensed [ICU library](http://site.icu-project.org/).

1510+ == Internal Representation: UTF-16 vs. UTF-8

1511+ Currently the @text@ library uses UTF-16 as its internal representation

1512+ which is [neither a fixed-width nor always the most dense representation](http://utf8everywhere.org/)

1513+ for Unicode text. We're currently investigating the feasibility

1514+ of [changing Text's internal representation to UTF-8](https://github.com/text-utf8)

1515+ and if you need such a 'Text' type right now you might be interested in using the spin-off

1516+ packages <https://hackage.haskell.org/package/text-utf8 text-utf8> and

1517+ <https://hackage.haskell.org/package/text-short text-short>.

1518+category: Data, Text

1519+exposed: True

1520+exposed-modules:

1521+ Data.Text Data.Text.Array Data.Text.Encoding

1522+ Data.Text.Encoding.Error Data.Text.Foreign Data.Text.IO

1523+ Data.Text.Internal Data.Text.Internal.Builder

1524+ Data.Text.Internal.Builder.Functions

1525+ Data.Text.Internal.Builder.Int.Digits

1526+ Data.Text.Internal.Builder.RealFloat.Functions

1527+ Data.Text.Internal.ByteStringCompat

1528+ Data.Text.Internal.Encoding.Fusion

1529+ Data.Text.Internal.Encoding.Fusion.Common

1530+ Data.Text.Internal.Encoding.Utf16 Data.Text.Internal.Encoding.Utf32

1531+ Data.Text.Internal.Encoding.Utf8 Data.Text.Internal.Functions

1532+ Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping

1533+ Data.Text.Internal.Fusion.Common Data.Text.Internal.Fusion.Size

1534+ Data.Text.Internal.Fusion.Types Data.Text.Internal.IO

1535+ Data.Text.Internal.Lazy Data.Text.Internal.Lazy.Encoding.Fusion

1536+ Data.Text.Internal.Lazy.Fusion Data.Text.Internal.Lazy.Search

1537+ Data.Text.Internal.PrimCompat Data.Text.Internal.Private

1538+ Data.Text.Internal.Read Data.Text.Internal.Search

1539+ Data.Text.Internal.Unsafe Data.Text.Internal.Unsafe.Char

1540+ Data.Text.Internal.Unsafe.Shift Data.Text.Lazy

1541+ Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int

1542+ Data.Text.Lazy.Builder.RealFloat Data.Text.Lazy.Encoding

1543+ Data.Text.Lazy.IO Data.Text.Lazy.Internal Data.Text.Lazy.Read

1544+ Data.Text.Read Data.Text.Unsafe

1545+hidden-modules: Data.Text.Show

1546+import-dirs:

1547+library-dirs:

1548+dynamic-library-dirs:

1549+data-dir:

1550+hs-libraries: HStext-1.2.5.0

1551+depends:

1552+ array-0.5.4.0 base-4.16.0.0 binary-0.8.9.0 bytestring-0.11.1.0

1553+ deepseq-1.4.6.0 ghc-prim-0.8.0 template-haskell-2.18.0.0

1554+haddock-interfaces:

1555+haddock-html:

1556+---

1557+name: time

1558+version: 1.11.1.1

1559+visibility: public

1560+id: time-1.11.1.1

1561+key: time-1.11.1.1

1562+license: BSD-3-Clause

1563+maintainer: <ashley@semantic.org>

1564+author: Ashley Yakeley

1565+stability: stable

1566+homepage: https://github.com/haskell/time

1567+synopsis: A time library

1568+description: Time, clocks and calendars

1569+category: Time

1570+exposed: True

1571+exposed-modules:

1572+ Data.Time Data.Time.Calendar Data.Time.Calendar.Easter

1573+ Data.Time.Calendar.Julian Data.Time.Calendar.Month

1574+ Data.Time.Calendar.MonthDay Data.Time.Calendar.OrdinalDate

1575+ Data.Time.Calendar.Quarter Data.Time.Calendar.WeekDate

1576+ Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System

1577+ Data.Time.Clock.TAI Data.Time.Format Data.Time.Format.ISO8601

1578+ Data.Time.Format.Internal Data.Time.LocalTime

1579+hidden-modules:

1580+ Data.Format Data.Time.Calendar.Types Data.Time.Calendar.Private

1581+ Data.Time.Calendar.Days Data.Time.Calendar.Gregorian

1582+ Data.Time.Calendar.CalendarDiffDays Data.Time.Calendar.Week

1583+ Data.Time.Calendar.JulianYearDay Data.Time.Clock.Internal.DiffTime

1584+ Data.Time.Clock.Internal.AbsoluteTime

1585+ Data.Time.Clock.Internal.NominalDiffTime

1586+ Data.Time.Clock.Internal.POSIXTime

1587+ Data.Time.Clock.Internal.UniversalTime

1588+ Data.Time.Clock.Internal.SystemTime

1589+ Data.Time.Clock.Internal.UTCTime Data.Time.Clock.Internal.CTimeval

1590+ Data.Time.Clock.Internal.CTimespec Data.Time.Clock.Internal.UTCDiff

1591+ Data.Time.LocalTime.Internal.TimeZone

1592+ Data.Time.LocalTime.Internal.TimeOfDay

1593+ Data.Time.LocalTime.Internal.CalendarDiffTime

1594+ Data.Time.LocalTime.Internal.LocalTime

1595+ Data.Time.LocalTime.Internal.ZonedTime Data.Time.Format.Parse

1596+ Data.Time.Format.Locale Data.Time.Format.Format.Class

1597+ Data.Time.Format.Format.Instances Data.Time.Format.Parse.Class

1598+ Data.Time.Format.Parse.Instances

1599+import-dirs:

1600+library-dirs:

1601+dynamic-library-dirs:

1602+data-dir:

1603+hs-libraries: HStime-1.11.1.1

1604+include-dirs:

1605+depends: base-4.16.0.0 deepseq-1.4.6.0

1606+haddock-interfaces:

1607+haddock-html:

1608+---

1609+name: transformers

1610+version: 0.5.6.2

1611+visibility: public

1612+id: transformers-0.5.6.2

1613+key: transformers-0.5.6.2

1614+license: BSD-3-Clause

1615+maintainer: Ross Paterson <R.Paterson@city.ac.uk>

1616+author: Andy Gill, Ross Paterson

1617+synopsis: Concrete functor and monad transformers

1618+description:

1619+ A portable library of functor and monad transformers, inspired by

1620+ the paper

1621+ * \"Functional Programming with Overloading and Higher-Order

1622+ Polymorphism\", by Mark P Jones,

1623+ in /Advanced School of Functional Programming/, 1995

1624+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1625+ This package contains:

1626+ * the monad transformer class (in "Control.Monad.Trans.Class")

1627+ * concrete functor and monad transformers, each with associated

1628+ operations and functions to lift operations associated with other

1629+ transformers.

1630+ The package can be used on its own in portable Haskell code, in

1631+ which case operations need to be manually lifted through transformer

1632+ stacks (see "Control.Monad.Trans.Class" for some examples).

1633+ Alternatively, it can be used with the non-portable monad classes in

1634+ the @mtl@ or @monads-tf@ packages, which automatically lift operations

1635+ introduced by monad transformers through other transformers.

1636+category: Control

1637+exposed: True

1638+exposed-modules:

1639+ Control.Applicative.Backwards Control.Applicative.Lift

1640+ Control.Monad.Signatures Control.Monad.Trans.Accum

1641+ Control.Monad.Trans.Class Control.Monad.Trans.Cont

1642+ Control.Monad.Trans.Error Control.Monad.Trans.Except

1643+ Control.Monad.Trans.Identity Control.Monad.Trans.List

1644+ Control.Monad.Trans.Maybe Control.Monad.Trans.RWS

1645+ Control.Monad.Trans.RWS.CPS Control.Monad.Trans.RWS.Lazy

1646+ Control.Monad.Trans.RWS.Strict Control.Monad.Trans.Reader

1647+ Control.Monad.Trans.Select Control.Monad.Trans.State

1648+ Control.Monad.Trans.State.Lazy Control.Monad.Trans.State.Strict

1649+ Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS

1650+ Control.Monad.Trans.Writer.Lazy Control.Monad.Trans.Writer.Strict

1651+ Data.Functor.Constant Data.Functor.Reverse

1652+import-dirs:

1653+library-dirs:

1654+dynamic-library-dirs:

1655+data-dir:

1656+hs-libraries: HStransformers-0.5.6.2

1657+depends: base-4.16.0.0

1658+haddock-interfaces:

1659+haddock-html:

1660+---

1661+name: unix

1662+version: 2.7.2.2

1663+visibility: public

1664+id: unix-2.7.2.2

1665+key: unix-2.7.2.2

1666+license: BSD-3-Clause

1667+maintainer: libraries@haskell.org

1668+homepage: https://github.com/haskell/unix

1669+synopsis: POSIX functionality

1670+description:

1671+ This package gives you access to the set of operating system

1672+ services standardised by

1673+ <http://pubs.opengroup.org/onlinepubs/9699919799/ POSIX.1-2008>

1674+ (or the IEEE Portable Operating System Interface for Computing

1675+ Environments - IEEE Std. 1003.1).

1676+ The package is not supported under Windows.

1677+category: System

1678+exposed: True

1679+exposed-modules:

1680+ System.Posix System.Posix.ByteString

1681+ System.Posix.ByteString.FilePath System.Posix.Directory

1682+ System.Posix.Directory.ByteString System.Posix.DynamicLinker

1683+ System.Posix.DynamicLinker.ByteString

1684+ System.Posix.DynamicLinker.Module

1685+ System.Posix.DynamicLinker.Module.ByteString

1686+ System.Posix.DynamicLinker.Prim System.Posix.Env

1687+ System.Posix.Env.ByteString System.Posix.Error System.Posix.Fcntl

1688+ System.Posix.Files System.Posix.Files.ByteString System.Posix.IO

1689+ System.Posix.IO.ByteString System.Posix.Process

1690+ System.Posix.Process.ByteString System.Posix.Process.Internals

1691+ System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem

1692+ System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp

1693+ System.Posix.Temp.ByteString System.Posix.Terminal

1694+ System.Posix.Terminal.ByteString System.Posix.Time

1695+ System.Posix.Unistd System.Posix.User

1696+hidden-modules:

1697+ System.Posix.Directory.Common System.Posix.DynamicLinker.Common

1698+ System.Posix.Files.Common System.Posix.IO.Common

1699+ System.Posix.Process.Common System.Posix.Terminal.Common

1700+import-dirs:

1701+library-dirs:

1702+dynamic-library-dirs:

1703+data-dir:

1704+hs-libraries: HSunix-2.7.2.2

1705+extra-libraries: rt util dl pthread

1706+include-dirs:

1707+includes: HsUnix.h execvpe.h

1708+depends: base-4.16.0.0 bytestring-0.11.1.0 time-1.11.1.1

1709+haddock-interfaces:

1710+haddock-html:

1711+---

1712+name: xhtml

1713+version: 3000.2.2.1

1714+visibility: public

1715+id: xhtml-3000.2.2.1

1716+key: xhtml-3000.2.2.1

1717+license: BSD-3-Clause

1718+copyright:

1719+ Bjorn Bringert 2004-2006, Andy Gill and the Oregon

1720+ Graduate Institute of Science and Technology, 1999-2001

1721+maintainer: Chris Dornan <chris@chrisdornan.com>

1722+author: Bjorn Bringert

1723+stability: Stable

1724+homepage: https://github.com/haskell/xhtml

1725+synopsis: An XHTML combinator library

1726+description:

1727+ This package provides combinators for producing

1728+ XHTML 1.0, including the Strict, Transitional and

1729+ Frameset variants.

1730+category: Web, XML, Pretty Printer

1731+exposed: True

1732+exposed-modules:

1733+ Text.XHtml Text.XHtml.Debug Text.XHtml.Frameset Text.XHtml.Strict

1734+ Text.XHtml.Table Text.XHtml.Transitional

1735+hidden-modules:

1736+ Text.XHtml.Strict.Attributes Text.XHtml.Strict.Elements

1737+ Text.XHtml.Frameset.Attributes Text.XHtml.Frameset.Elements

1738+ Text.XHtml.Transitional.Attributes Text.XHtml.Transitional.Elements

1739+ Text.XHtml.BlockTable Text.XHtml.Extras Text.XHtml.Internals

1740+import-dirs:

1741+library-dirs:

1742+dynamic-library-dirs:

1743+data-dir:

1744+hs-libraries: HSxhtml-3000.2.2.1

1745+depends: base-4.16.0.0

1746+haddock-interfaces:

1747+haddock-html:

1748+---

1749+name: rts

1750+version: 1.0.2

1751+visibility: public

1752+id: rts

1753+key: rts

1754+license: BSD-3-Clause

1755+maintainer: glasgow-haskell-users@haskell.org

1756+exposed: True

1757+library-dirs:

1758+hs-libraries: HSrts

1759+extra-libraries: m rt dl ffi numa pthread

1760+include-dirs:

1761+includes: Stg.h

1762+ld-options:

1763+ "-Wl,-u,base_GHCziTopHandler_runIO_closure"

1764+ "-Wl,-u,base_GHCziTopHandler_runNonIO_closure"

1765+ "-Wl,-u,ghczmprim_GHCziTuple_Z0T_closure"

1766+ "-Wl,-u,ghczmprim_GHCziTypes_True_closure"

1767+ "-Wl,-u,ghczmprim_GHCziTypes_False_closure"

1768+ "-Wl,-u,base_GHCziPack_unpackCString_closure"

1769+ "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure"

1770+ "-Wl,-u,base_GHCziIOziException_stackOverflow_closure"

1771+ "-Wl,-u,base_GHCziIOziException_heapOverflow_closure"

1772+ "-Wl,-u,base_GHCziIOziException_allocationLimitExceeded_closure"

1773+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"

1774+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"

1775+ "-Wl,-u,base_GHCziIOziException_cannotCompactFunction_closure"

1776+ "-Wl,-u,base_GHCziIOziException_cannotCompactPinned_closure"

1777+ "-Wl,-u,base_GHCziIOziException_cannotCompactMutable_closure"

1778+ "-Wl,-u,base_GHCziIOPort_doubleReadException_closure"

1779+ "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure"

1780+ "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure"

1781+ "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure"

1782+ "-Wl,-u,base_GHCziExceptionziType_divZZeroException_closure"

1783+ "-Wl,-u,base_GHCziExceptionziType_underflowException_closure"

1784+ "-Wl,-u,base_GHCziExceptionziType_overflowException_closure"

1785+ "-Wl,-u,base_GHCziConcziSync_runSparks_closure"

1786+ "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure"

1787+ "-Wl,-u,base_GHCziConcziIO_interruptIOManager_closure"

1788+ "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"

1789+ "-Wl,-u,base_GHCziConcziSignal_runHandlersPtr_closure"

1790+ "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure"

1791+ "-Wl,-u,base_GHCziTopHandler_runMainIO_closure"

1792+ "-Wl,-u,ghczmprim_GHCziTypes_Czh_con_info"

1793+ "-Wl,-u,ghczmprim_GHCziTypes_Izh_con_info"

1794+ "-Wl,-u,ghczmprim_GHCziTypes_Fzh_con_info"

1795+ "-Wl,-u,ghczmprim_GHCziTypes_Dzh_con_info"

1796+ "-Wl,-u,ghczmprim_GHCziTypes_Wzh_con_info"

1797+ "-Wl,-u,base_GHCziPtr_Ptr_con_info"

1798+ "-Wl,-u,base_GHCziPtr_FunPtr_con_info"

1799+ "-Wl,-u,base_GHCziInt_I8zh_con_info"

1800+ "-Wl,-u,base_GHCziInt_I16zh_con_info"

1801+ "-Wl,-u,base_GHCziInt_I32zh_con_info"

1802+ "-Wl,-u,base_GHCziInt_I64zh_con_info"

1803+ "-Wl,-u,base_GHCziWord_W8zh_con_info"

1804+ "-Wl,-u,base_GHCziWord_W16zh_con_info"

1805+ "-Wl,-u,base_GHCziWord_W32zh_con_info"

1806+ "-Wl,-u,base_GHCziWord_W64zh_con_info"

1807+ "-Wl,-u,base_GHCziStable_StablePtr_con_info"

1808+ "-Wl,-u,hs_atomic_add8" "-Wl,-u,hs_atomic_add16"

1809+ "-Wl,-u,hs_atomic_add32" "-Wl,-u,hs_atomic_add64"

1810+ "-Wl,-u,hs_atomic_sub8" "-Wl,-u,hs_atomic_sub16"

1811+ "-Wl,-u,hs_atomic_sub32" "-Wl,-u,hs_atomic_sub64"

1812+ "-Wl,-u,hs_atomic_and8" "-Wl,-u,hs_atomic_and16"

1813+ "-Wl,-u,hs_atomic_and32" "-Wl,-u,hs_atomic_and64"

1814+ "-Wl,-u,hs_atomic_nand8" "-Wl,-u,hs_atomic_nand16"

1815+ "-Wl,-u,hs_atomic_nand32" "-Wl,-u,hs_atomic_nand64"

1816+ "-Wl,-u,hs_atomic_or8" "-Wl,-u,hs_atomic_or16"

1817+ "-Wl,-u,hs_atomic_or32" "-Wl,-u,hs_atomic_or64"

1818+ "-Wl,-u,hs_atomic_xor8" "-Wl,-u,hs_atomic_xor16"

1819+ "-Wl,-u,hs_atomic_xor32" "-Wl,-u,hs_atomic_xor64"

1820+ "-Wl,-u,hs_cmpxchg8" "-Wl,-u,hs_cmpxchg16" "-Wl,-u,hs_cmpxchg32"

1821+ "-Wl,-u,hs_cmpxchg64" "-Wl,-u,hs_xchg8" "-Wl,-u,hs_xchg16"

1822+ "-Wl,-u,hs_xchg32" "-Wl,-u,hs_xchg64" "-Wl,-u,hs_atomicread8"

1823+ "-Wl,-u,hs_atomicread16" "-Wl,-u,hs_atomicread32"

1824+ "-Wl,-u,hs_atomicread64" "-Wl,-u,hs_atomicwrite8"

1825+ "-Wl,-u,hs_atomicwrite16" "-Wl,-u,hs_atomicwrite32"

1826+ "-Wl,-u,hs_atomicwrite64"

materialized/dummy-ghc/ghc-9.2.1-aarch64-linux/ghc-pkg/versionnew file+1

@@ -0,0 +1 @@

1+GHC package manager version 9.2.1

materialized/dummy-ghc/ghc-9.2.1-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","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 llc command","llc")

41+ ,("LLVM opt command","opt")

42+ ,("LLVM clang command","clang")

43+ ,("bignum backend","gmp")

44+ ,("Use interpreter","YES")

45+ ,("Support SMP","YES")

46+ ,("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")

47+ ,("Tables next to code","YES")

48+ ,("Leading underscore","NO")

49+ ,("Use LibFFI","YES")

50+ ,("RTS expects libdw","NO")

51+ ,("Project version","9.2.1")

52+ ,("Project Git commit id","82e6bf12786908ccda643dd1dceb42abcc97290c")

53+ ,("Booter version","8.10.7")

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","YES")

61+ ,("Target default backend","NCG")

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+ ,("GHC Dynamic","YES")

71+ ,("GHC Profiled","NO")

72+ ,("Debug on","NO")

73+ ]

materialized/dummy-ghc/ghc-9.2.1-aarch64-linux/ghc/numeric-versionnew file+1

@@ -0,0 +1 @@

1+9.2.1

materialized/dummy-ghc/ghc-9.2.1-aarch64-linux/ghc/supported-languagesnew file+266

@@ -0,0 +1,266 @@

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+MonomorphismRestriction

136+NoMonomorphismRestriction

137+MultiParamTypeClasses

138+NoMultiParamTypeClasses

139+MultiWayIf

140+NoMultiWayIf

141+NumericUnderscores

142+NoNumericUnderscores

143+NPlusKPatterns

144+NoNPlusKPatterns

145+NamedFieldPuns

146+NoNamedFieldPuns

147+NamedWildCards

148+NoNamedWildCards

149+NegativeLiterals

150+NoNegativeLiterals

151+HexFloatLiterals

152+NoHexFloatLiterals

153+NondecreasingIndentation

154+NoNondecreasingIndentation

155+NullaryTypeClasses

156+NoNullaryTypeClasses

157+NumDecimals

158+NoNumDecimals

159+OverlappingInstances

160+NoOverlappingInstances

161+OverloadedLabels

162+NoOverloadedLabels

163+OverloadedLists

164+NoOverloadedLists

165+OverloadedStrings

166+NoOverloadedStrings

167+PackageImports

168+NoPackageImports

169+ParallelArrays

170+NoParallelArrays

171+ParallelListComp

172+NoParallelListComp

173+PartialTypeSignatures

174+NoPartialTypeSignatures

175+PatternGuards

176+NoPatternGuards

177+PatternSignatures

178+NoPatternSignatures

179+PatternSynonyms

180+NoPatternSynonyms

181+PolyKinds

182+NoPolyKinds

183+PolymorphicComponents

184+NoPolymorphicComponents

185+QuantifiedConstraints

186+NoQuantifiedConstraints

187+PostfixOperators

188+NoPostfixOperators

189+QuasiQuotes

190+NoQuasiQuotes

191+QualifiedDo

192+NoQualifiedDo

193+Rank2Types

194+NoRank2Types

195+RankNTypes

196+NoRankNTypes

197+RebindableSyntax

198+NoRebindableSyntax

199+OverloadedRecordDot

200+NoOverloadedRecordDot

201+OverloadedRecordUpdate

202+NoOverloadedRecordUpdate

203+RecordPuns

204+NoRecordPuns

205+RecordWildCards

206+NoRecordWildCards

207+RecursiveDo

208+NoRecursiveDo

209+RelaxedLayout

210+NoRelaxedLayout

211+RelaxedPolyRec

212+NoRelaxedPolyRec

213+RoleAnnotations

214+NoRoleAnnotations

215+ScopedTypeVariables

216+NoScopedTypeVariables

217+StandaloneDeriving

218+NoStandaloneDeriving

219+StarIsType

220+NoStarIsType

221+StaticPointers

222+NoStaticPointers

223+Strict

224+NoStrict

225+StrictData

226+NoStrictData

227+TemplateHaskell

228+NoTemplateHaskell

229+TemplateHaskellQuotes

230+NoTemplateHaskellQuotes

231+StandaloneKindSignatures

232+NoStandaloneKindSignatures

233+TraditionalRecordSyntax

234+NoTraditionalRecordSyntax

235+TransformListComp

236+NoTransformListComp

237+TupleSections

238+NoTupleSections

239+TypeApplications

240+NoTypeApplications

241+TypeInType

242+NoTypeInType

243+TypeFamilies

244+NoTypeFamilies

245+TypeOperators

246+NoTypeOperators

247+TypeSynonymInstances

248+NoTypeSynonymInstances

249+UnboxedTuples

250+NoUnboxedTuples

251+UnboxedSums

252+NoUnboxedSums

253+UndecidableInstances

254+NoUndecidableInstances

255+UndecidableSuperClasses

256+NoUndecidableSuperClasses

257+UnicodeSyntax

258+NoUnicodeSyntax

259+UnliftedDatatypes

260+NoUnliftedDatatypes

261+UnliftedFFITypes

262+NoUnliftedFFITypes

263+UnliftedNewtypes

264+NoUnliftedNewtypes

265+ViewPatterns

266+NoViewPatterns

materialized/dummy-ghc/ghc-9.2.1-aarch64-linux/ghc/versionnew file+1

@@ -0,0 +1 @@

1+The Glorious Glasgow Haskell Compilation System, version 9.2.1

materialized/dummy-ghc/ghc-9.2.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","--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.2.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.2.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.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/info+6

This diff is too big to show here.

materialized/dummy-ghc/ghc-9.2.2-x86_64-linux/ghc/info+6

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-global+37−2

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/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/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/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/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/ghc882/ghc.nix−4

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/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/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/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/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/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/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/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/ghc865/.plan.nix/ghc.nix−4

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc865/default.nix+2−9

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/default.nix−8

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/default.nix−8

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/default.nix−8

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc902/default.nix+1

This diff is too big to show here.

materialized/ghc-extra-projects/cross/ghc922/default.nix+1

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/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/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/default.nix−8

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/default.nix−8

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/default.nix−8

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/default.nix−8

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/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/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/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/default.nix−8

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/default.nix−8

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/default.nix−8

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/default.nix−8

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/default.nix+32−32

This diff is too big to show here.

materialized/ghc8103/nix-tools/default.nix+32−32

This diff is too big to show here.

materialized/ghc8104/nix-tools/default.nix+32−32

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/default.nix+32−32

This diff is too big to show here.

materialized/ghc8105/nix-tools/default.nix+32−32

This diff is too big to show here.

materialized/ghc8106/nix-tools/default.nix+32−32

This diff is too big to show here.

materialized/ghc8107/nix-tools/default.nix+32−32

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/ghc863/nix-tools/.plan.nix/hackage-db.nixnew file+110

This diff is too big to show here.

materialized/ghc863/nix-tools/.plan.nix/nix-tools.nixnew file+234

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/ghc864/nix-tools/.plan.nix/hackage-db.nixnew file+110

This diff is too big to show here.

materialized/ghc864/nix-tools/.plan.nix/nix-tools.nixnew file+234

This diff is too big to show here.

materialized/ghc864/nix-tools/default.nixnew file+509

This diff is too big to show here.

materialized/ghc865/nix-tools/default.nix+31−31

This diff is too big to show here.

materialized/ghc882/nix-tools/default.nix+32−32

This diff is too big to show here.

materialized/ghc883/nix-tools/default.nix+32−32

This diff is too big to show here.

materialized/ghc884/nix-tools/default.nix+32−32

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/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.jsonnew file+6155

This diff is too big to show here.

mk-local-hackage-repo/default.nix+1−1

This diff is too big to show here.

modules/cabal-project.nix−5

This diff is too big to show here.

modules/component-driver.nix+4−4

This diff is too big to show here.

modules/configuration-nix.nix+44−1

This diff is too big to show here.

modules/hackage-project.nixnew file+60

This diff is too big to show here.

modules/hackage-quirks.nixnew file+88

This diff is too big to show here.

modules/package.nix+2−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−7

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+123−37

This diff is too big to show here.

overlays/default.nix−4

This diff is too big to show here.

overlays/eval-packages.nixdeleted−14

This diff is too big to show here.

overlays/ghc-packages.nix+31−21

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.nixdeleted−71

This diff is too big to show here.

overlays/haskell.nix+70−90

This diff is too big to show here.

overlays/hix.nix+3−3

This diff is too big to show here.

overlays/mingw_w64.nix+4−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.patchnew file+20

This diff is too big to show here.

overlays/patches/ghc/3434.patch → overlays/patches/ghc/ghc-8.10-3434.patchrenamed

The content is the same.

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.2-3434.patchnew file+68

This diff is too big to show here.

overlays/patches/ghc/ghc-9.2-Cabal-3886.patchnew file+170

This diff is too big to show here.

overlays/patches/ghc/ghc-9.2-cabal-host.patchnew file+13

This diff is too big to show here.

overlays/patches/ghc/ghc-9.2-global-unique-counters-in-rts.patchnew file+83

This diff is too big to show here.

overlays/tools.nix+28−42

This diff is too big to show here.

overlays/windows.nix+10−28

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/js-ghc8107/buffer-builder.patchnew file+79

This diff is too big to show here.

patches/js-ghc8107/conduit-extra.patchnew file+48

This diff is too big to show here.

patches/js-ghc8107/default.nixnew file+7

This diff is too big to show here.

patches/js-ghc8107/double-conversion.patchnew file+64

This diff is too big to show here.

patches/js-ghc8107/network.patchnew file+16

This diff is too big to show here.

patches/js-ghc8107/say.patchnew file+22

This diff is too big to show here.

patches/languge-c-int128.patchnew file+146

This diff is too big to show here.

patches/update-patches.sh+6−2

This diff is too big to show here.

scripts/check-compiler-materialization/default.nix+31−22

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

This diff is too big to show here.

test/ca-derivations/default.nixnew file+59

This diff is too big to show here.

test/cabal-22/default.nix+3−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−49

This diff is too big to show here.

test/exe-dlls/default.nixnew file+25

This diff is too big to show here.

test/exe-dlls/exe-dlls.cabalnew file+18

This diff is too big to show here.

test/exe-dlls/src/Main.hsnew file+14

This diff is too big to show here.

test/exe-lib-dlls/default.nixnew file+25

This diff is too big to show here.

test/exe-lib-dlls/exe-lib-dlls.cabalnew file+24

This diff is too big to show here.

test/exe-lib-dlls/exes/Main.hsnew file+6

This diff is too big to show here.

test/exe-lib-dlls/src/Lib.hsnew file+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/default.nix+2−2

This diff is too big to show here.

test/extra-hackage/default.nix+3−3

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/cabal.project−7

This diff is too big to show here.

test/ghcjs-overlay/default.nix+11−3

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+4−5

This diff is too big to show here.

test/sha256map/default.nix+2−2

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.hsnew file+9

This diff is too big to show here.

test/th-dlls/default.nix+3−2

This diff is too big to show here.

test/th-dlls/th-dlls.cabal+6

This diff is too big to show here.

test/unit.nix+4−4

This diff is too big to show here.

test/with-packages/default.nix+3−1

This diff is too big to show here.