7078b14 · haskell.nix · git.iko.soy

git.iko.soy/haskell.nix

on iko/ghcjs-patch-master help sign in

Add support for ghcjs 8.8 and making ghcjs bundles (#828)

Fixes ghcjs 8.6.5 and 8.8.4. Uses emscripten for ghcjs 8.8 and adds scripts for building ghcjs 8.8. Many fixes for ghcjs test failures. Includes relocatableConfigFiles for making relocatable ghcjs bundles.

commit7078b145e981e8b14fc7ea62126fab3378090ef4 authorHamish Mackenzie <Hamish.Mackenzie@iohk.io> dateTue 17 Nov 2020, 22:22 (6 years ago) parent028eeb1

92 files changed+12836−136

compare with iko/ghcjs-patch-master

unifiedsplit

builder/comp-builder.nix+3−2

@@ -163,7 +163,7 @@ let

163163 ]

164164 );

165165

166− setupGhcOptions = lib.optional (package.ghcOptions != null) '' --ghc-options="${package.ghcOptions}"'';

166+ setupGhcOptions = lib.optional (package.ghcOptions != null) '' --ghc${lib.optionalString (stdenv.hostPlatform.isGhcjs) "js"}-options="${package.ghcOptions}"'';

167167

168168 executableToolDepends =

169169 (lib.concatMap (c: if c.isHaskell or false

@@ -184,7 +184,7 @@ let

184184 else abort "shellHook should be a string or a function";

185185

186186 exeExt = if stdenv.hostPlatform.isGhcjs then ".jsexe/all.js" else

187− if stdenv.hostPlatform.isWindows then ".exe" else "";

187+ stdenv.hostPlatform.extensions.executable;

188188 exeName = componentId.cname + exeExt;

189189 testExecutable = "dist/build/${componentId.cname}/${exeName}";

190190

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

246246 inherit (package) identifier;

247247 config = component;

248248 inherit configFiles executableToolDepends cleanSrc exeName;

249+ exePath = drv + "/bin/${exeName}";

249250 env = shellWrappers;

250251 profiled = self (drvArgs // { enableLibraryProfiling = true; });

251252 } // lib.optionalAttrs (haskellLib.isLibrary componentId) ({

builder/default.nix+1−1

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

7878 inherit haskellLib ghc comp-builder setup-builder;

7979 };

8080

81− inherit shellFor;

81+ inherit shellFor makeConfigFiles;

8282

8383 ghcWithPackages = withPackages { withHoogle = false; };

8484 ghcWithHoogle = withPackages { withHoogle = true; };

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

@@ -56,13 +56,21 @@ let

5656 (p: "${p.configFiles}")

5757 libDeps;

5858 in lib.concatStringsSep "\" \"" xs;

59− libs = lib.concatMapStringsSep "\" \"" (p: "${p}") libDeps;

60−in

61− runCommand "${ghc.targetPrefix}${fullName}-config" {

59+ libs = lib.concatMapStringsSep "\" \"" (p: "${p}") libDeps;

60+ drv = runCommand "${ghc.targetPrefix}${fullName}-config" {

6261 nativeBuildInputs = [ghc];

6362 passthru = {

6463 inherit (ghc) targetPrefix;

65− inherit ghcCommand ghcCommandCaps libDir packageCfgDir;

64+ inherit ghcCommand ghcCommandCaps libDir packageCfgDir component;

65+ # Use ''${pkgroot} relative paths so that we can relocate the package database

66+ # along with referenced packages and still have it work on systems with

67+ # or without nix installed.

68+ relocatableConfigFiles = runCommand "${ghc.targetPrefix}${fullName}-relocatable-config" ''

69+ cp -r ${drv} $out

70+ chmod -R +w $out

71+ sed -i 's|/nix/store/|''${pkgroot}/../../../|' $out/${packageCfgDir}/*.conf

72+ ${target-pkg} -v0 --package-db $out/${packageCfgDir} recache

73+ '';

6674 };

6775 } (''

6876 mkdir -p $out

@@ -186,4 +194,5 @@ in

186194 done

187195 '' + ''

188196 ${target-pkg} -v0 --package-db $out/${packageCfgDir} recache

189− '')

197+ '');

198+in drv

ci.nix+5−2

@@ -43,7 +43,9 @@

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

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

4545 let lib = nixpkgs.lib;

46− in lib.optionalAttrs (system == "x86_64-linux" && (nixpkgsName == "R2009" || (compiler-nix-name != "ghc8101" && compiler-nix-name != "ghc8102" && compiler-nix-name != "ghc8102-experimental"))) {

46+ in lib.optionalAttrs (nixpkgsName == "R2003" && (__elem compiler-nix-name ["ghc865" "ghc884"])) {

47+ inherit (lib.systems.examples) ghcjs;

48+ } // lib.optionalAttrs (system == "x86_64-linux" && (nixpkgsName == "R2009" || (!(__elem compiler-nix-name ["ghc8101" "ghc8102" "ghc8102-experimental"])))) {

4749 # Windows cross compilation is currently broken on macOS

4850 inherit (lib.systems.examples) mingwW64;

4951 } // lib.optionalAttrs (system == "x86_64-linux") {

@@ -90,7 +92,8 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:

9092 } // pkgs.lib.optionalAttrs (runTests && crossSystemName != "aarch64-multiplatform") {

9193 # Tests are broken on aarch64 cross https://github.com/input-output-hk/haskell.nix/issues/513

9294 inherit (build) tests;

93− }) // pkgs.lib.optionalAttrs (ifdLevel >= 2) {

95+ }) // pkgs.lib.optionalAttrs (ifdLevel >= 2 && crossSystemName != "ghcjs") {

96+ # GHCJS builds its own template haskell runner.

9497 remote-iserv = pkgs.ghc-extra-packages."${compiler-nix-name}".remote-iserv.components.exes.remote-iserv;

9598 iserv-proxy = pkgs.ghc-extra-packages."${compiler-nix-name}".iserv-proxy.components.exes.iserv-proxy;

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

compiler/ghcjs/ghcjs-src.json+2−2

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

11{

22 "url": "https://github.com/ghcjs/ghcjs",

3− "rev": "e87195eaa2bc7e320e18cf10386802bc90b7c874",

4− "sha256": "02mwkf7aagxqi142gcmq048244apslrr72p568akcab9s0fn2gvy",

3+ "rev": "31a54f7320b1f9700eb6389c2eb2d50c712e8371",

4+ "sha256": "1cj1gfqcj0ygc23xj5gbm0ym9wmh8ini57zlgd6s25avgjbrwga6",

55 "fetchSubmodules": true

66}

compiler/ghcjs/ghcjs.nix+234−22

@@ -3,16 +3,18 @@

33, ghcjsSrc ? pkgs.buildPackages.fetchgit (builtins.fromJSON (builtins.readFile ghcjsSrcJson))

44, ghcjsVersion ? "8.6.0.1"

55, ghcVersion ? "8.6.5"

6+, compiler-nix-name ? if builtins.compareVersions ghcjsVersion "8.8.0.0" > 0

7+ then "ghc884"

8+ else "ghc865"

69, ghc ? pkgs.buildPackages.ghc

7−, happy ? pkgs.buildPackages.haskellPackages.happy

8−, alex ? pkgs.buildPackages.haskellPackages.alex

9−, cabal-install ? pkgs.buildPackages.cabal-install

1010}:

1111let

12+ isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" > 0;

13+

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

1315 src = ghcjsSrc;

14− inherit ghc ghcjsVersion ghcVersion happy alex cabal-install;

15− index-state = "2019-12-10T00:00:00Z";

16+ inherit ghcjsVersion compiler-nix-name;

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

1618# plan-sha256 = "1wy2lr08maxyi7r8jiwf2gj6pdayk5vxxwh42bj4s2gg4035z0yc";

1719# materialized = ../../materialized/ghcjs;

1820 };

@@ -24,21 +26,30 @@ let

2426 paths = [

2527 ghcjs.components.exes.ghcjs

2628 ghcjs.components.exes.ghcjs-pkg

29+ ghcjs.components.exes.ghcjs-boot

30+ ghcjs.components.exes.ghcjs-dumparchive

31+ ] ++ (if isGhcjs88

32+ then [

33+ ghcjs.components.exes.haddock

34+ ghcjs.components.exes.private-ghcjs-run

35+ ghcjs.components.exes.private-ghcjs-unlit

36+ ghcjs.components.exes.private-ghcjs-hsc2hs

37+ ]

38+ else [

2739 ghcjs.components.exes.haddock-ghcjs

2840 ghcjs.components.exes.hsc2hs-ghcjs

29− ghcjs.components.exes.ghcjs-boot

3041 ghcjs.components.exes.ghcjs-run

31− ghcjs.components.exes.ghcjs-dumparchive

32− ];

42+ ]);

3343 };

3444 libexec = "libexec/${builtins.replaceStrings ["darwin" "i686"] ["osx" "i386"] pkgs.stdenv.buildPlatform.system}-${ghc.name}/ghcjs-${ghcVersion}";

3545 booted-ghcjs = pkgs.stdenv.mkDerivation {

3646 name = "ghcjs-${ghcVersion}";

3747 src = project.configured-src;

3848

39− nativeBuildInputs = project.bootInputs;

49+ nativeBuildInputs = project.bootInputs

50+ ++ pkgs.lib.optional isGhcjs88 pkgs.buildPackages.procps;

4051 passthru = {

41− inherit all-ghcjs;

52+ inherit all-ghcjs bundled-ghcjs project;

4253 inherit (project) configured-src;

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

4455 isHaskellNixCompiler = true;

@@ -46,23 +57,224 @@ let

4657 dontConfigure = true;

4758 dontInstall = true;

4859 buildPhase = ''

49− export HOME=$TMP

50− mkdir $HOME/.cabal

51− touch $HOME/.cabal/config

52− cd lib/boot

53−

54− mkdir -p $out/bin

55− mkdir -p $out/lib/ghcjs-${ghcVersion}

56− lndir ${all-ghcjs}/${libexec} $out/bin

60+ export HOME=$TMP

61+ mkdir $HOME/.cabal

62+ touch $HOME/.cabal/config

63+ cd lib/boot

64+ ${if isGhcjs88

65+ then ''

66+ mkdir -p $out/bin

67+ mkdir -p $out/lib

68+ lndir ${all-ghcjs}/bin $out/bin

69+ chmod -R +w $out/bin

70+ rm $out/bin/ghcjs-boot

71+ cp ${ghcjs.components.exes.ghcjs-boot}/bin/ghcjs-boot $out/bin

72+ rm $out/bin/haddock

73+ cp ${ghcjs.components.exes.haddock}/bin/haddock $out/bin

5774

58− wrapProgram $out/bin/ghcjs --add-flags "-B$out/lib/ghcjs-${ghcVersion}"

59− wrapProgram $out/bin/haddock-ghcjs --add-flags "-B$out/lib/ghcjs-${ghcVersion}"

60− wrapProgram $out/bin/ghcjs-pkg --add-flags "--global-package-db=$out/lib/ghcjs-${ghcVersion}/package.conf.d"

75+ wrapProgram $out/bin/ghcjs --add-flags "-B$out/lib"

76+ wrapProgram $out/bin/haddock --add-flags "-B$out/lib"

77+ wrapProgram $out/bin/ghcjs-pkg --add-flags "--global-package-db=$out/lib/package.conf.d"

78+ ''

79+ else ''

80+ mkdir -p $out/bin

81+ mkdir -p $out/lib/ghcjs-${ghcVersion}

82+ lndir ${all-ghcjs}/${libexec} $out/bin

6183

62− env PATH=$out/bin:$PATH $out/bin/ghcjs-boot -j1 --with-ghcjs-bin $out/bin

84+ wrapProgram $out/bin/ghcjs --add-flags "-B$out/lib/ghcjs-${ghcVersion}"

85+ wrapProgram $out/bin/haddock-ghcjs --add-flags "-B$out/lib/ghcjs-${ghcVersion}"

86+ wrapProgram $out/bin/ghcjs-pkg --add-flags "--global-package-db=$out/lib/ghcjs-${ghcVersion}/package.conf.d"

87+ ''

88+ }

89+ # Avoid timeouts while unix package runs hsc2hs (it does not print anything

90+ # for more than 900 seconds).

91+ {

92+ for n in {1..50}; do

93+ if [ ! -f $TMP/done ]; then

94+ sleep 300

95+ echo Keep alive $n

96+ fi

97+ done

98+ } &

99+ ${ if isGhcjs88

100+ then

101+ # Unsets NIX_CFLAGS_COMPILE so the osx version of iconv.h is not used by mistake

102+ ''

103+ env -u NIX_CFLAGS_COMPILE PATH=$out/bin:$PATH \

104+ PYTHON=${pkgs.buildPackages.python3}/bin/python3 \

105+ $out/bin/ghcjs-boot -j1 --with-emsdk=${project.emsdk} --no-prof --no-haddock \

106+ || (echo failed > $TMP/done; false)

107+ ''

108+ else ''

109+ env PATH=$out/bin:$PATH $out/bin/ghcjs-boot -j1 --with-ghcjs-bin $out/bin \

110+ || (echo failed > $TMP/done; false)

111+ ''

112+ }

113+ echo ok > $TMP/done

63114 '';

64115 # We hard code -j1 as a temporary workaround for

65116 # https://github.com/ghcjs/ghcjs/issues/654

66117 # enableParallelBuilding = true;

67118 };

119+ ghcjs-relocatable-bin = pkgs.stdenv.mkDerivation {

120+ name = "ghcjs-relocatable-bin-${ghcVersion}";

121+ src = all-ghcjs;

122+ dontConfigure = true;

123+ dontInstall = true;

124+ dontPatchShebangs = true;

125+ dontPatchELF = true;

126+ buildPhase = ''

127+ # Copy the ghcjs exectuables

128+ mkdir -p $out/bin

129+ cp $src/${libexec}/* $out/bin

130+

131+ # Add readlink (needed by bundleRootDir)

132+ cp ${pkgs.coreutils}/bin/readlink $out/bin

133+

134+ '' + (pkgs.lib.optionalString pkgs.stdenv.isDarwin ''

135+ # Make the executables location independent using install_name_tool and @executable_path

136+

137+ # Copy the libraries needed into place

138+ cp ${pkgs.gmp}/lib/libgmp.10.dylib $out/bin

139+ cp ${pkgs.ncurses}/lib/libncursesw.6.dylib $out/bin

140+ cp ${pkgs.libffi}/lib/libffi.6.dylib $out/bin

141+

142+ # Set the ID of the libraries

143+ chmod -R +w $out/bin

144+ install_name_tool -id "@executable_path/libgmp.10.dylib" "$out/bin/libgmp.10.dylib"

145+ install_name_tool -id "@executable_path/libncursesw.6.dylib" "$out/bin/libncursesw.6.dylib"

146+ install_name_tool -id "@executable_path/libffi.6.dylib" "$out/bin/libffi.6.dylib"

147+

148+ # Modify all the references so we look for the libraries in the system location or

149+ # @executable_path (the directory containin the exetubable itself).

150+ for fn in $out/bin/*; do

151+ install_name_tool -change "${pkgs.libiconv}/lib/libiconv.dylib" /usr/lib/libiconv.dylib "$fn"

152+ install_name_tool -change "${pkgs.stdenv.libc}/lib/libSystem.B.dylib" /usr/lib/libSystem.B.dylib "$fn"

153+ install_name_tool -change "${pkgs.gmp}/lib/libgmp.10.dylib" "@executable_path/libgmp.10.dylib" "$fn"

154+ install_name_tool -change "${pkgs.ncurses}/lib/libncursesw.6.dylib" "@executable_path/libncursesw.6.dylib" "$fn"

155+ install_name_tool -change "${pkgs.libffi}/lib/libffi.6.dylib" "@executable_path/libffi.6.dylib" "$fn"

156+ done

157+ '')

158+

159+ + (pkgs.lib.optionalString pkgs.stdenv.isLinux ''

160+ # Make the executables location independent using patchelf and $ORIGIN.

161+ chmod -R +w $out/bin

162+ # This interpreter setting will not work on nixOS, but this bundle is

163+ # not really needed on nixOS systems.

164+ patchelf --set-interpreter /lib64/ld-linux-x86-64.so.2 $out/bin/*

165+ patchelf --set-rpath '$ORIGIN' $out/bin/*

166+ # Link the libraries needed into place

167+ ln -s ${pkgs.gmp}/lib/libgmp.so.* $out/bin

168+ ln -s ${pkgs.ncurses}/lib/libncursesw.so.* $out/bin

169+ ln -s ${pkgs.libffi}/lib/libffi.so.* $out/bin

170+ '');

171+ };

172+ # This is a way to find the location of the root directory of this bundle

173+ # when one of the wrapper scripts runs. By using readlink (to avoid

174+ # issues with symlinks that might be made to the script) and dirname

175+ # we can find the directory even when it may have been moved.

176+ bundleRootDir = ''"$(dirname "$(dirname "$(readlink -f "$0")")")"'';

177+ bundled-ghcjs = {

178+ compilerName ? "ghcjs", # Name for the compiler wrapper

179+ db ? null, # A ghcjs package database this argument should can

180+ # be `project.(shellFor { ... }).configFiles` or

181+ # the result of a `makeConfigFiles` call.

182+ hostDb ? null # Like db, but this will be passed as the `-host-package-db`.

183+ }:

184+ let

185+ libDeps = pkgs.lib.concatMapStrings (lib: "${lib} ") (pkgs.lib.unique (

186+ [booted-ghcjs ghc db hostDb pkgs.ncurses pkgs.gmp pkgs.libffi]

187+ ++ (pkgs.haskell-nix.haskellLib.flatLibDepends db.component)

188+ ++ (pkgs.haskell-nix.haskellLib.flatLibDepends hostDb.component)

189+ ));

190+ in pkgs.stdenv.mkDerivation {

191+ name = "${compilerName}-${ghcVersion}-bundle";

192+ src = booted-ghcjs;

193+ nativeBuildInputs = [ pkgs.makeWrapper pkgs.xorg.lndir ];

194+ dontConfigure = true;

195+ dontInstall = true;

196+ dontPatchShebangs = true;

197+ dontPatchELF = true;

198+ buildPhase = ''

199+ # Copy the ghcjs exectuables

200+ mkdir -p $out/bin

201+ lndir ${ghcjs-relocatable-bin}/bin $out/bin

202+

203+ # Make the executables writeable for patchelf and install_name_tool

204+ chmod -R +w $out/bin

205+

206+ # And links for the /lib directory of all the dependencies

207+ # including the booted ghcjs

208+ for lib in ${ libDeps }; do

209+ if [ -d $lib/lib ]; then

210+ mkdir -p $out/$(basename $lib)

211+ lndir -silent $lib $out/$(basename $lib)

212+ fi

213+ done

214+

215+ '' + (pkgs.lib.optionalString pkgs.stdenv.isDarwin ''

216+ rm -rf $out/$(basename ${hostDb})/lib/links

217+ cp -rL ${hostDb}/lib/links $out/$(basename ${hostDb})/lib

218+ chmod -R +w $out/$(basename ${hostDb})/lib/links

219+

220+ # Modify all the references so we look for the libraries in the system location or

221+ # @executable_path (the directory containin the exetubable itself).

222+ for fn in $out/$(basename ${hostDb})/lib/links/*; do

223+ install_name_tool -change "${pkgs.libiconv}/lib/libiconv.dylib" /usr/lib/libiconv.dylib "$fn"

224+ install_name_tool -change "${pkgs.stdenv.libc}/lib/libSystem.B.dylib" /usr/lib/libSystem.B.dylib "$fn"

225+ install_name_tool -change "${pkgs.gmp}/lib/libgmp.10.dylib" "@executable_path/libgmp.10.dylib" "$fn"

226+ install_name_tool -change "${pkgs.ncurses}/lib/libncursesw.6.dylib" "@executable_path/libncursesw.6.dylib" "$fn"

227+ install_name_tool -change "${pkgs.libffi}/lib/libffi.6.dylib" "@executable_path/libffi.6.dylib" "$fn"

228+ done

229+ '') + ''

230+

231+ # Wrap the programs to add the ghcjs library dir and package DB directories

232+ wrapProgram $out/bin/ghcjs \

233+ --add-flags '"-B${bundleRootDir}/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}"' \

234+ --add-flags '"-package-db ${db}/${db.packageCfgDir}"' ${

235+ pkgs.lib.optionalString (hostDb != null)

236+ " --add-flags '-host-package-db=${hostDb}/${hostDb.packageCfgDir}'"

237+ }

238+ wrapProgram $out/bin/ghcjs-pkg --add-flags '"--global-package-db=${db}/${db.packageCfgDir}"'

239+ wrapProgram $out/bin/haddock-ghcjs --add-flags '"-B${bundleRootDir}/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}"'

240+

241+ # Fix the bang pattern to use the systems bash.

242+ # Replace the absolute output path ($out) with bundleRootDir

243+ # (this will fix the references to the unwarpped executables).

244+ # Replace the `/nix/store` refs (in the package DB paths) with

245+ # bundleRootDir.

246+ sed -i \

247+ -e 's|${pkgs.stdenv.shell}|/usr/bin/env -S bash|' \

248+ -e "s|$out/|"'${bundleRootDir}/|g' \

249+ -e 's|/nix/store/|${bundleRootDir}/|g' \

250+ $out/bin/ghcjs $out/bin/haddock-ghcjs $out/bin/ghcjs-pkg

251+

252+ # Update the ghcjs and ghc settings files so that `cc` looked up in the PATH.

253+ rm $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/settings

254+ sed -e 's|/nix/store/.*/bin/cc|cc|' \

255+ < ${booted-ghcjs}/lib/ghcjs-${ghcVersion}/settings \

256+ > $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/settings

257+ rm $out/$(basename ${ghc})/lib/ghc-${ghcVersion}/settings

258+ sed -e 's|/nix/store/.*/bin/cc|cc|' \

259+ < ${ghc}/lib/ghc-${ghcVersion}/settings \

260+ > $out/$(basename ${ghc})/lib/ghc-${ghcVersion}/settings

261+

262+ # Update the ghcjs settings files so that `node` looked up in the PATH.

263+ rm $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/nodeSettings.json

264+ sed -e 's|/nix/store/.*/bin/node|node|' \

265+ < ${booted-ghcjs}/lib/ghcjs-${ghcVersion}/nodeSettings.json \

266+ > $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/nodeSettings.json

267+

268+ # Update the ghcjs settings files so that `node` looked up in the PATH.

269+ rm $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/ghc_libdir

270+ sed -e 's|/nix/store/|../../../|' \

271+ < ${booted-ghcjs}/lib/ghcjs-${ghcVersion}/ghc_libdir \

272+ > $out/$(basename ${booted-ghcjs})/lib/ghcjs-${ghcVersion}/ghc_libdir

273+ '' + (pkgs.lib.optionalString (compilerName != "ghcjs") ''

274+ # Rename the wrappers based on the `compilerName` arg

275+ mv $out/bin/ghcjs $out/bin/${compilerName}

276+ mv $out/bin/ghcjs-pkg $out/bin/${compilerName}-pkg

277+ mv $out/bin/haddock-ghcjs $out/bin/haddock-${compilerName}

278+ '');

279+ };

68280in booted-ghcjs

compiler/ghcjs/ghcjs88-src.jsonnew file+6

@@ -0,0 +1,6 @@

1+{

2+ "url": "https://github.com/ghcjs/ghcjs",

3+ "rev": "1193ead2c760bab1e2ab461458ec771237ccf9b5",

4+ "sha256": "1h7gaq1lhf61b5x693phgpm2z0w393b1sbkxrd9mxzz9xxlyrhkl",

5+ "fetchSubmodules": true

6+}

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

@@ -267,6 +267,11 @@ let

267267 ${ghc.targetPrefix}ghc --info | grep -v /nix/store > $out/ghc/info

268268 ${ghc.targetPrefix}ghc --supported-languages > $out/ghc/supported-languages

269269 ${ghc.targetPrefix}ghc-pkg --version > $out/ghc-pkg/version

270+ ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-") ''

271+ ${ghc.targetPrefix}ghc --numeric-ghc-version > $out/ghc/numeric-ghc-version

272+ ${ghc.targetPrefix}ghc --numeric-ghcjs-version > $out/ghc/numeric-ghcjs-version

273+ ${ghc.targetPrefix}ghc-pkg --numeric-ghcjs-version > $out/ghc-pkg/numeric-ghcjs-version

274+ ''}

270275 # The order of the `ghc-pkg dump` output seems to be non

271276 # deterministic so we need to sort it so that it is always

272277 # the same.

@@ -301,6 +306,14 @@ let

301306 --numeric-version*)

302307 cat ${dummy-ghc-data}/ghc/numeric-version

303308 ;;

309+ ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-") ''

310+ --numeric-ghc-version*)

311+ cat ${dummy-ghc-data}/ghc/numeric-ghc-version

312+ ;;

313+ --numeric-ghcjs-version*)

314+ cat ${dummy-ghc-data}/ghc/numeric-ghcjs-version

315+ ;;

316+ ''}

304317 --supported-languages*)

305318 cat ${dummy-ghc-data}/ghc/supported-languages

306319 ;;

@@ -333,6 +346,11 @@ let

333346 --version)

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

335348 ;;

349+ ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-") ''

350+ --numeric-ghcjs-version)

351+ cat ${dummy-ghc-data}/ghc-pkg/numeric-ghcjs-version

352+ ;;

353+ ''}

336354 'dump --global -v0')

337355 cat ${dummy-ghc-data}/ghc-pkg/dump-global

338356 ;;

@@ -427,6 +445,8 @@ let

427445 --with-ghc-pkg=${ghc.targetPrefix}ghc-pkg \

428446 --enable-tests \

429447 --enable-benchmarks \

448+ ${pkgs.lib.optionalString (ghc.targetPrefix == "js-unknown-ghcjs-")

449+ "--ghcjs --with-ghcjs=js-unknown-ghcjs-ghc --with-ghcjs-pkg=js-unknown-ghcjs-ghc-pkg"} \

430450 ${configureArgs}

431451

432452 mkdir -p $out

lib/ghcjs-project.nix+70−25

@@ -1,3 +1,7 @@

1+# IMPORTANT: This is for building ghcjs, not for building with

2+# ghcjs. To build with ghcjs then just replace `haskell-nix`

3+# with `pkgsCross.ghcjs.haskell-nix`.

4+#

15# For the time being we can't really treat ghcjs like a

26# regular ghc (with different target). We need this as a

37# stop-gap measure until ghcjs can be treated like a regular

@@ -17,15 +21,26 @@

1721# of the project.

1822{ pkgs }:

1923{ src

20−, ghc ? pkgs.ghc

21−, ghcjsVersion ? "8.6.0.1" # TODO get this from the source?

22−, ghcVersion ? "8.6.5" # TODO get this from the ghc arg?

23−, happy ? pkgs.haskellPackages.happy

24−, alex ? pkgs.haskellPackages.alex

25−, cabal-install ? pkgs.cabal-install

24+, compiler-nix-name

25+, ghc ? pkgs.buildPackages.haskell-nix.compiler.${compiler-nix-name}

26+, ghcjsVersion

27+, ghcVersion ? ghc.version

28+, happy ? pkgs.haskell-nix.tool compiler-nix-name "happy" {

29+ index-state = pkgs.haskell-nix.internalHackageIndexState;

30+ version = "1.19.12";

31+ materialized = ../materialized/ghcjs/happy + "/${compiler-nix-name}";

32+ }

33+, alex ? pkgs.haskell-nix.tool compiler-nix-name "alex" {

34+ index-state = pkgs.haskell-nix.internalHackageIndexState;

35+ version = "3.2.5";

36+ materialized = ../materialized/ghcjs/alex + "/${compiler-nix-name}";

37+ }

38+, cabal-install ? pkgs.haskell-nix.cabal-install.${compiler-nix-name}

2639, ...

2740}@args:

2841let

42+ isGhcjs88 = builtins.compareVersions ghcjsVersion "8.8.0.0" > 0;

43+

2944 # Inputs needed to configure the GHCJS source tree

3045 configureInputs = with pkgs; [

3146 perl

@@ -38,8 +53,19 @@ let

3853 alex

3954 cabal-install

4055 ];

56+ # nixpkgs does not have an emsdk, this derivation uses symlinks to make something

57+ # that matches enought for `ghcjs-boot` to work

58+ emscriptenupstream = pkgs.buildPackages.emscriptenupstream;

59+ emscripten = pkgs.buildPackages.emscripten.override {

60+ emscriptenBackend = emscriptenupstream;

61+ };

62+ emsdk = pkgs.linkFarm "emsdk" [

63+ { name = "upstream/bin"; path = emscriptenupstream + "/bin"; }

64+ { name = "upstream/emscripten"; path = emscripten + "/bin"; }

65+ { name = "share"; path = emscripten + "/share"; }

66+ ];

4167 # Inputs needed to boot the GHCJS compiler

42− bootInputs = with pkgs; [

68+ bootInputs = with pkgs.buildPackages; [

4369 nodejs

4470 makeWrapper

4571 xorg.lndir

@@ -49,7 +75,8 @@ let

4975 ++ [ ghc cabal-install ]

5076 ++ lib.optionals stdenv.isDarwin [

5177 pkgs.buildPackages.gcc # https://github.com/ghcjs/ghcjs/issues/663

52− ];

78+ ]

79+ ++ lib.optional isGhcjs88 [ emsdk ];

5380 # Configured the GHCJS source

5481 configured-src = pkgs.runCommand "configured-ghcjs-src" {

5582 buildInputs = configureInputs;

@@ -66,31 +93,45 @@ let

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

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

6895

69− # TODO: How to actually fix this?

70− # Seems to work fine and produce the right files.

71− touch ghc/includes/ghcautoconf.h

72− mkdir -p ghc/compiler/vectorise

73− mkdir -p ghc/utils/haddock/haddock-library/vendor

96+ ${

97+ # TODO: How to actually fix this?

98+ # Seems to work fine and produce the right files.

99+ pkgs.lib.optionalString (!isGhcjs88) ''

100+ touch ghc/includes/ghcautoconf.h

101+ mkdir -p ghc/compiler/vectorise

102+ mkdir -p ghc/utils/haddock/haddock-library/vendor

103+ ''

104+ }

105+

106+ rm -rf utils/pkg-cache/ghc

107+ cp -r ${ghc.generated} utils/pkg-cache/ghc

108+

109+ cp ${../overlays/patches/config.sub} ghc/libraries/integer-gmp/config.sub

110+ cp ${../overlays/patches/config.sub} ghc/libraries/base/config.sub

111+ cp ${../overlays/patches/config.sub} ghc/libraries/unix/config.sub

74112

75113 patchShebangs .

76114 sed -i 's/gcc /cc /g' utils/makePackages.sh

77− cat utils/makePackages.sh

78115 ./utils/makePackages.sh copy

79116

80− echo " build-tool-depends: alex:alex, happy:happy <= 1.19.9" >> lib/ghc-api-ghcjs/ghc-api-ghcjs.cabal

81−

82− # nuke the HsBaseConfig.h from base.buildinfo.in; this will

83− # prevent it from being installed and provide incorrect values.

84− sed -i 's/HsBaseConfig.h//g' lib/boot/pkg/base/base.buildinfo.in

85− cat lib/boot/pkg/base/base.buildinfo.in

86− '';

117+ ${

118+ # nuke the HsBaseConfig.h from base.buildinfo.in; this will

119+ # prevent it from being installed and provide incorrect values.

120+ pkgs.lib.optionalString (!isGhcjs88) ''

121+ echo " build-tool-depends: alex:alex, happy:happy <= 1.19.9" >> lib/ghc-api-ghcjs/ghc-api-ghcjs.cabal

122+ sed -i 's/HsBaseConfig.h//g' lib/boot/pkg/base/base.buildinfo.in

123+ ''

124+ }'';

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

88126

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

90128 (pkgs.lib.filterAttrs

91− (n: _: builtins.any (x: x == n)

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

129+ (n: _: !(builtins.any (x: x == n)

130+ ["src" "ghcjsVersion" "ghcVersion" "happy" "alex" "cabal-install"])) args) // {

93131 src = configured-src;

132+ compiler-nix-name = if isGhcjs88 then "ghc884" else "ghc865";

133+ configureArgs = pkgs.lib.optionalString isGhcjs88 "--constraint='Cabal >=3.0.2.0 && <3.1'";

134+ materialized = ../materialized + (if isGhcjs88 then "/ghcjs884" else "/ghcjs865");

94135 modules = [

95136 {

96137 # we need ghc-boot in here for ghcjs.

@@ -99,8 +140,10 @@ let

99140 "ghc-boot" "binary" "bytestring" "filepath" "directory" "containers"

100141 "time" "unix" "Win32" ];

101142 }

102− {

143+ (pkgs.lib.optionalAttrs (!isGhcjs88) {

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

145+ })

146+ {

104147 packages.ghcjs.doHaddock = false;

105148 packages.haddock-ghcjs.doHaddock = false;

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

@@ -114,6 +157,7 @@ let

114157 packages.ghc.flags.ghci = true;

115158 packages.ghci.flags.ghci = true;

116159 # packages.ghcjs.components.library.configureFlags = [ "-fno-wrapper-install" ];

160+ packages.ghcjs.components.library.build-tools = [ alex ];

117161 }

118162 ];

119163 });

@@ -124,8 +168,9 @@ in ghcjsProject // {

124168 shellFor = args: (ghcjsProject.hsPkgs.shellFor args).overrideAttrs (drv: {

125169 buildInputs = (drv.buildInputs or []) ++ configureInputs;

126170 nativeBuildInputs = (drv.nativeBuildInputs or []) ++ bootInputs;

171+ EMSDK = emsdk;

127172 });

128173 };

129− inherit configureInputs bootInputs configured-src;

174+ inherit configureInputs bootInputs configured-src emscriptenupstream emscripten emsdk;

130175}

131176

lib/system-nixpkgs-map.nix+2−2

@@ -2,10 +2,10 @@

22# cabal file to nixpkgs pkgs.

33# See ../docs/dev/pkg-map.md

44pkgs:

5−# fetchgit should always come from the buildPackages

5+# fetchgit should always come from the evalPackages

66# if it comes from the targetPackages we won't even

77# be able to execute it.

8− { fetchgit = pkgs.buildPackages.fetchgit; }

8+ { fetchgit = pkgs.evalPackages.fetchgit; }

99# haskell lib -> nix lib mapping

1010# -- linux

1111// { crypto = pkgs.openssl;

materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc-pkg/dump-globalnew file+1183

@@ -0,0 +1,1183 @@

1+name: Cabal

2+version: 2.4.0.1

3+id: Cabal-2.4.0.1-B0dCMLaAC7v7z5Xn21aFCg

4+key: Cabal-2.4.0.1-B0dCMLaAC7v7z5Xn21aFCg

5+license: BSD3

6+copyright: 2003-2018, Cabal Development Team (see AUTHORS file)

7+maintainer: cabal-devel@haskell.org

8+author: Cabal Development Team <cabal-devel@haskell.org>

9+homepage: http://www.haskell.org/cabal/

10+synopsis: A framework for packaging Haskell software

11+description:

12+ The Haskell Common Architecture for Building Applications and

13+ Libraries: a framework defining a common interface for authors to more

14+ easily build their Haskell applications in a portable way.

15+ The Haskell Cabal is part of a larger infrastructure for distributing,

16+ organizing, and cataloging Haskell libraries and tools.

17+category: Distribution

18+exposed: True

19+exposed-modules:

20+ Distribution.Backpack Distribution.Backpack.ComponentsGraph

21+ Distribution.Backpack.Configure

22+ Distribution.Backpack.ConfiguredComponent

23+ Distribution.Backpack.DescribeUnitId

24+ Distribution.Backpack.FullUnitId

25+ Distribution.Backpack.LinkedComponent

26+ Distribution.Backpack.ModSubst Distribution.Backpack.ModuleShape

27+ Distribution.Backpack.PreModuleShape Distribution.CabalSpecVersion

28+ Distribution.Compat.Binary Distribution.Compat.CharParsing

29+ Distribution.Compat.CreatePipe Distribution.Compat.DList

30+ Distribution.Compat.Directory Distribution.Compat.Environment

31+ Distribution.Compat.Exception Distribution.Compat.Graph

32+ Distribution.Compat.Internal.TempFile Distribution.Compat.Lens

33+ Distribution.Compat.Newtype Distribution.Compat.Parsing

34+ Distribution.Compat.Prelude.Internal Distribution.Compat.ReadP

35+ Distribution.Compat.Semigroup Distribution.Compat.Stack

36+ Distribution.Compat.Time Distribution.Compiler

37+ Distribution.FieldGrammar Distribution.FieldGrammar.Class

38+ Distribution.FieldGrammar.FieldDescrs

39+ Distribution.FieldGrammar.Parsec Distribution.FieldGrammar.Pretty

40+ Distribution.InstalledPackageInfo Distribution.License

41+ Distribution.Make Distribution.ModuleName Distribution.Package

42+ Distribution.PackageDescription

43+ Distribution.PackageDescription.Check

44+ Distribution.PackageDescription.Configuration

45+ Distribution.PackageDescription.FieldGrammar

46+ Distribution.PackageDescription.Parsec

47+ Distribution.PackageDescription.PrettyPrint

48+ Distribution.PackageDescription.Quirks

49+ Distribution.PackageDescription.Utils Distribution.ParseUtils

50+ Distribution.Parsec.Class Distribution.Parsec.Common

51+ Distribution.Parsec.ConfVar Distribution.Parsec.Field

52+ Distribution.Parsec.FieldLineStream Distribution.Parsec.Lexer

53+ Distribution.Parsec.LexerMonad Distribution.Parsec.Newtypes

54+ Distribution.Parsec.ParseResult Distribution.Parsec.Parser

55+ Distribution.Pretty Distribution.PrettyUtils Distribution.ReadE

56+ Distribution.SPDX Distribution.SPDX.License

57+ Distribution.SPDX.LicenseExceptionId

58+ Distribution.SPDX.LicenseExpression Distribution.SPDX.LicenseId

59+ Distribution.SPDX.LicenseListVersion

60+ Distribution.SPDX.LicenseReference Distribution.Simple

61+ Distribution.Simple.Bench Distribution.Simple.Build

62+ Distribution.Simple.Build.Macros

63+ Distribution.Simple.Build.PathsModule

64+ Distribution.Simple.BuildPaths Distribution.Simple.BuildTarget

65+ Distribution.Simple.BuildToolDepends Distribution.Simple.CCompiler

66+ Distribution.Simple.Command Distribution.Simple.Compiler

67+ Distribution.Simple.Configure Distribution.Simple.Doctest

68+ Distribution.Simple.Flag Distribution.Simple.GHC

69+ Distribution.Simple.GHCJS Distribution.Simple.Glob

70+ Distribution.Simple.Haddock Distribution.Simple.HaskellSuite

71+ Distribution.Simple.Hpc Distribution.Simple.Install

72+ Distribution.Simple.InstallDirs Distribution.Simple.LocalBuildInfo

73+ Distribution.Simple.PackageIndex Distribution.Simple.PreProcess

74+ Distribution.Simple.PreProcess.Unlit Distribution.Simple.Program

75+ Distribution.Simple.Program.Ar Distribution.Simple.Program.Builtin

76+ Distribution.Simple.Program.Db Distribution.Simple.Program.Find

77+ Distribution.Simple.Program.GHC Distribution.Simple.Program.HcPkg

78+ Distribution.Simple.Program.Hpc

79+ Distribution.Simple.Program.Internal Distribution.Simple.Program.Ld

80+ Distribution.Simple.Program.ResponseFile

81+ Distribution.Simple.Program.Run Distribution.Simple.Program.Script

82+ Distribution.Simple.Program.Strip Distribution.Simple.Program.Types

83+ Distribution.Simple.Register Distribution.Simple.Setup

84+ Distribution.Simple.SrcDist Distribution.Simple.Test

85+ Distribution.Simple.Test.ExeV10 Distribution.Simple.Test.LibV09

86+ Distribution.Simple.Test.Log Distribution.Simple.UHC

87+ Distribution.Simple.UserHooks Distribution.Simple.Utils

88+ Distribution.System Distribution.TestSuite Distribution.Text

89+ Distribution.Types.AbiDependency Distribution.Types.AbiHash

90+ Distribution.Types.AnnotatedId Distribution.Types.Benchmark

91+ Distribution.Types.Benchmark.Lens

92+ Distribution.Types.BenchmarkInterface

93+ Distribution.Types.BenchmarkType Distribution.Types.BuildInfo

94+ Distribution.Types.BuildInfo.Lens Distribution.Types.BuildType

95+ Distribution.Types.Component Distribution.Types.ComponentId

96+ Distribution.Types.ComponentInclude

97+ Distribution.Types.ComponentLocalBuildInfo

98+ Distribution.Types.ComponentName

99+ Distribution.Types.ComponentRequestedSpec

100+ Distribution.Types.CondTree Distribution.Types.Condition

101+ Distribution.Types.Dependency Distribution.Types.DependencyMap

102+ Distribution.Types.ExeDependency Distribution.Types.Executable

103+ Distribution.Types.Executable.Lens

104+ Distribution.Types.ExecutableScope Distribution.Types.ExposedModule

105+ Distribution.Types.ForeignLib Distribution.Types.ForeignLib.Lens

106+ Distribution.Types.ForeignLibOption

107+ Distribution.Types.ForeignLibType

108+ Distribution.Types.GenericPackageDescription

109+ Distribution.Types.GenericPackageDescription.Lens

110+ Distribution.Types.HookedBuildInfo

111+ Distribution.Types.IncludeRenaming

112+ Distribution.Types.InstalledPackageInfo

113+ Distribution.Types.InstalledPackageInfo.FieldGrammar

114+ Distribution.Types.InstalledPackageInfo.Lens

115+ Distribution.Types.LegacyExeDependency Distribution.Types.Lens

116+ Distribution.Types.Library Distribution.Types.Library.Lens

117+ Distribution.Types.LocalBuildInfo Distribution.Types.Mixin

118+ Distribution.Types.Module Distribution.Types.ModuleReexport

119+ Distribution.Types.ModuleRenaming

120+ Distribution.Types.MungedPackageId

121+ Distribution.Types.MungedPackageName

122+ Distribution.Types.PackageDescription

123+ Distribution.Types.PackageDescription.Lens

124+ Distribution.Types.PackageId Distribution.Types.PackageId.Lens

125+ Distribution.Types.PackageName

126+ Distribution.Types.PkgconfigDependency

127+ Distribution.Types.PkgconfigName Distribution.Types.SetupBuildInfo

128+ Distribution.Types.SetupBuildInfo.Lens

129+ Distribution.Types.SourceRepo Distribution.Types.SourceRepo.Lens

130+ Distribution.Types.TargetInfo Distribution.Types.TestSuite

131+ Distribution.Types.TestSuite.Lens

132+ Distribution.Types.TestSuiteInterface Distribution.Types.TestType

133+ Distribution.Types.UnitId Distribution.Types.UnqualComponentName

134+ Distribution.Types.Version Distribution.Types.VersionInterval

135+ Distribution.Types.VersionRange Distribution.Utils.Generic

136+ Distribution.Utils.IOData Distribution.Utils.LogProgress

137+ Distribution.Utils.MapAccum Distribution.Utils.NubList

138+ Distribution.Utils.Progress Distribution.Utils.ShortText

139+ Distribution.Verbosity Distribution.Version

140+ Language.Haskell.Extension

141+hidden-modules: Distribution.Backpack.PreExistingComponent

142+ Distribution.Backpack.ReadyComponent Distribution.Backpack.MixLink

143+ Distribution.Backpack.ModuleScope Distribution.Backpack.UnifyM

144+ Distribution.Backpack.Id Distribution.Utils.UnionFind

145+ Distribution.Utils.Base62 Distribution.Compat.CopyFile

146+ Distribution.Compat.GetShortPathName Distribution.Compat.MonadFail

147+ Distribution.Compat.Prelude Distribution.Compat.SnocList

148+ Distribution.GetOpt Distribution.Lex Distribution.Utils.String

149+ Distribution.Simple.GHC.EnvironmentParser

150+ Distribution.Simple.GHC.Internal Distribution.Simple.GHC.ImplInfo

151+ Paths_Cabal

152+hs-libraries: HSCabal-2.4.0.1-B0dCMLaAC7v7z5Xn21aFCg

153+depends:

154+ array-0.5.3.0-164UCDdQjfT6fdtNV9FrwT

155+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

156+ binary-0.8.6.0-H5jYuYqJeOLDt7eFZnyaWc

157+ bytestring-0.10.8.2-FBklFuapa1a7kq4yflY7Bt

158+ containers-0.6.0.1-BAqcfV1UBBeCIRjPbUYeSG

159+ deepseq-1.4.4.0-IftsS9ityeGZTtUqULJH7

160+ directory-1.3.3.0-5pg72mHzHk4Dhxxy4wYd2z

161+ filepath-1.4.2.1-DG92Jon7uT21h5exmtoJCU

162+ mtl-2.2.2-ApFELyUjwv93Vj2GS8sioS

163+ parsec-3.1.13.0-B5rilSKpqzU4t8cguYXeJQ

164+ pretty-1.1.3.6-HCbdzOHqNpW5RoNxlHyeg5

165+ process-1.6.5.0-Wgw4Qh9nsHBTY0LWykUqv

166+ text-1.2.3.1-2mMWCa8HNEL4R4p8nnvwO2

167+ time-1.8.0.2-3d3i5aGvKEfEHwUSNgliL4

168+ transformers-0.5.6.2-KaPP0fdMTwBF02jPgfEE5s

169+ unix-2.7.2.2-JxmyTgtpFqj7lvsQuv62w2

170+---

171+name: array

172+version: 0.5.3.0

173+id: array-0.5.3.0-164UCDdQjfT6fdtNV9FrwT

174+key: array-0.5.3.0-164UCDdQjfT6fdtNV9FrwT

175+license: BSD3

176+maintainer: libraries@haskell.org

177+synopsis: Mutable and immutable arrays

178+description:

179+ In addition to providing the "Data.Array" module

180+ <http://www.haskell.org/onlinereport/haskell2010/haskellch14.html as specified in the Haskell 2010 Language Report>,

181+ this package also defines the classes 'IArray' of

182+ immutable arrays and 'MArray' of arrays mutable within appropriate

183+ monads, as well as some instances of these classes.

184+category: Data Structures

185+exposed: True

186+exposed-modules:

187+ Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO

188+ Data.Array.IO.Internals Data.Array.IO.Safe Data.Array.MArray

189+ Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe

190+ Data.Array.Storable Data.Array.Storable.Internals

191+ Data.Array.Storable.Safe Data.Array.Unboxed Data.Array.Unsafe

192+hs-libraries: HSarray-0.5.3.0-164UCDdQjfT6fdtNV9FrwT

193+depends:

194+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

195+---

196+name: base

197+version: 4.12.0.0

198+id: base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

199+key: base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

200+license: BSD3

201+maintainer: libraries@haskell.org

202+synopsis: Basic libraries

203+description:

204+ This package contains the Standard Haskell "Prelude" and its support libraries,

205+ and a large collection of useful libraries ranging from data

206+ structures to parsing combinators and debugging utilities.

207+category: Prelude

208+exposed: True

209+exposed-modules:

210+ Control.Applicative Control.Arrow Control.Category

211+ Control.Concurrent Control.Concurrent.Chan Control.Concurrent.MVar

212+ Control.Concurrent.QSem Control.Concurrent.QSemN Control.Exception

213+ Control.Exception.Base Control.Monad Control.Monad.Fail

214+ Control.Monad.Fix Control.Monad.IO.Class Control.Monad.Instances

215+ Control.Monad.ST Control.Monad.ST.Lazy Control.Monad.ST.Lazy.Safe

216+ Control.Monad.ST.Lazy.Unsafe Control.Monad.ST.Safe

217+ Control.Monad.ST.Strict Control.Monad.ST.Unsafe Control.Monad.Zip

218+ Data.Bifoldable Data.Bifunctor Data.Bitraversable Data.Bits

219+ Data.Bool Data.Char Data.Coerce Data.Complex Data.Data Data.Dynamic

220+ Data.Either Data.Eq Data.Fixed Data.Foldable Data.Function

221+ Data.Functor Data.Functor.Classes Data.Functor.Compose

222+ Data.Functor.Const Data.Functor.Contravariant Data.Functor.Identity

223+ Data.Functor.Product Data.Functor.Sum Data.IORef Data.Int Data.Ix

224+ Data.Kind Data.List Data.List.NonEmpty Data.Maybe Data.Monoid

225+ Data.Ord Data.Proxy Data.Ratio Data.STRef Data.STRef.Lazy

226+ Data.STRef.Strict Data.Semigroup Data.String Data.Traversable

227+ Data.Tuple Data.Type.Bool Data.Type.Coercion Data.Type.Equality

228+ Data.Typeable Data.Unique Data.Version Data.Void Data.Word

229+ Debug.Trace Foreign Foreign.C Foreign.C.Error Foreign.C.String

230+ Foreign.C.Types Foreign.Concurrent Foreign.ForeignPtr

231+ Foreign.ForeignPtr.Safe Foreign.ForeignPtr.Unsafe Foreign.Marshal

232+ Foreign.Marshal.Alloc Foreign.Marshal.Array Foreign.Marshal.Error

233+ Foreign.Marshal.Pool Foreign.Marshal.Safe Foreign.Marshal.Unsafe

234+ Foreign.Marshal.Utils Foreign.Ptr Foreign.Safe Foreign.StablePtr

235+ Foreign.Storable GHC.Arr GHC.Base GHC.ByteOrder GHC.Char GHC.Clock

236+ GHC.Conc GHC.Conc.IO GHC.Conc.Signal GHC.Conc.Sync

237+ GHC.ConsoleHandler GHC.Constants GHC.Desugar GHC.Enum

238+ GHC.Environment GHC.Err GHC.Exception GHC.Exception.Type

239+ GHC.ExecutionStack GHC.ExecutionStack.Internal GHC.Exts

240+ GHC.Fingerprint GHC.Fingerprint.Type GHC.Float

241+ GHC.Float.ConversionUtils GHC.Float.RealFracMethods GHC.Foreign

242+ GHC.ForeignPtr GHC.GHCi GHC.Generics GHC.IO GHC.IO.Buffer

243+ GHC.IO.BufferedIO GHC.IO.Device GHC.IO.Encoding

244+ GHC.IO.Encoding.CodePage GHC.IO.Encoding.Failure

245+ GHC.IO.Encoding.Iconv GHC.IO.Encoding.Latin1 GHC.IO.Encoding.Types

246+ GHC.IO.Encoding.UTF16 GHC.IO.Encoding.UTF32 GHC.IO.Encoding.UTF8

247+ GHC.IO.Exception GHC.IO.FD GHC.IO.Handle GHC.IO.Handle.FD

248+ GHC.IO.Handle.Internals GHC.IO.Handle.Lock GHC.IO.Handle.Text

249+ GHC.IO.Handle.Types GHC.IO.IOMode GHC.IO.Unsafe GHC.IOArray

250+ GHC.IORef GHC.Int GHC.List GHC.MVar GHC.Maybe GHC.Natural GHC.Num

251+ GHC.OldList GHC.OverloadedLabels GHC.Pack GHC.Profiling GHC.Ptr

252+ GHC.RTS.Flags GHC.Read GHC.Real GHC.Records GHC.ResponseFile GHC.ST

253+ GHC.STRef GHC.Show GHC.Stable GHC.StableName GHC.Stack

254+ GHC.Stack.CCS GHC.Stack.Types GHC.StaticPtr GHC.Stats GHC.Storable

255+ GHC.TopHandler GHC.TypeLits GHC.TypeNats GHC.Unicode GHC.Weak

256+ GHC.Word Numeric Numeric.Natural Prelude System.CPUTime

257+ System.Console.GetOpt System.Environment System.Environment.Blank

258+ System.Exit System.IO System.IO.Error System.IO.Unsafe System.Info

259+ System.Mem System.Mem.StableName System.Mem.Weak

260+ System.Posix.Internals System.Posix.Types System.Timeout

261+ Text.ParserCombinators.ReadP Text.ParserCombinators.ReadPrec

262+ Text.Printf Text.Read Text.Read.Lex Text.Show Text.Show.Functions

263+ Type.Reflection Type.Reflection.Unsafe Unsafe.Coerce

264+hidden-modules: Control.Monad.ST.Imp Control.Monad.ST.Lazy.Imp

265+ Data.Functor.Utils Data.OldList Data.Semigroup.Internal

266+ Data.Typeable.Internal Foreign.ForeignPtr.Imp

267+ GHC.StaticPtr.Internal System.Environment.ExecutablePath

268+ System.CPUTime.Utils System.CPUTime.Unsupported

269+hs-libraries: HSbase-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

270+includes:

271+ HsBase.h

272+depends:

273+ ghc-prim-0.5.3-D5yTV0DK5iW2rkul1Hko6R

274+ integer-gmp-1.0.2.0-6GHJbRN6krEDXGMaCSGBVX rts

275+---

276+name: binary

277+version: 0.8.6.0

278+id: binary-0.8.6.0-H5jYuYqJeOLDt7eFZnyaWc

279+key: binary-0.8.6.0-H5jYuYqJeOLDt7eFZnyaWc

280+license: BSD3

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

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

283+stability: provisional

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

285+synopsis: Binary serialisation for Haskell values using lazy ByteStrings

286+description:

287+ Efficient, pure binary serialisation using lazy ByteStrings.

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

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

290+ The format used can be automatically generated, or

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

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

293+ so this library should be suitable for high performance

294+ scenarios.

295+category: Data, Parsing

296+exposed: True

297+exposed-modules:

298+ Data.Binary Data.Binary.Builder Data.Binary.Get

299+ Data.Binary.Get.Internal Data.Binary.Put

300+hidden-modules: Data.Binary.Class Data.Binary.Internal

301+ Data.Binary.Generic Data.Binary.FloatCast

302+hs-libraries: HSbinary-0.8.6.0-H5jYuYqJeOLDt7eFZnyaWc

303+depends:

304+ array-0.5.3.0-164UCDdQjfT6fdtNV9FrwT

305+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

306+ bytestring-0.10.8.2-FBklFuapa1a7kq4yflY7Bt

307+ containers-0.6.0.1-BAqcfV1UBBeCIRjPbUYeSG

308+---

309+name: bytestring

310+version: 0.10.8.2

311+id: bytestring-0.10.8.2-FBklFuapa1a7kq4yflY7Bt

312+key: bytestring-0.10.8.2-FBklFuapa1a7kq4yflY7Bt

313+license: BSD3

314+copyright: Copyright (c) Don Stewart 2005-2009,

315+ (c) Duncan Coutts 2006-2015,

316+ (c) David Roundy 2003-2005,

317+ (c) Jasper Van der Jeugt 2010,

318+ (c) Simon Meier 2010-2013.

319+maintainer: Duncan Coutts <duncan@community.haskell.org>

320+author: Don Stewart,

321+ Duncan Coutts

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

323+synopsis: Fast, compact, strict and lazy byte strings with a list interface

324+description:

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

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

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

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

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

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

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

332+ Two 'ByteString' variants are provided:

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

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

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

336+ suitable for I\/O streaming tasks.

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

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

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

340+ and network protocols).

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

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

343+ serialisation or pretty printing.

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

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

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

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

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

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

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

351+ > import qualified Data.ByteString as BS

352+category: Data

353+exposed: True

354+exposed-modules:

355+ Data.ByteString Data.ByteString.Builder

356+ Data.ByteString.Builder.Extra Data.ByteString.Builder.Internal

357+ Data.ByteString.Builder.Prim Data.ByteString.Builder.Prim.Internal

358+ Data.ByteString.Char8 Data.ByteString.Internal Data.ByteString.Lazy

359+ Data.ByteString.Lazy.Builder Data.ByteString.Lazy.Builder.ASCII

360+ Data.ByteString.Lazy.Builder.Extras Data.ByteString.Lazy.Char8

361+ Data.ByteString.Lazy.Internal Data.ByteString.Short

362+ Data.ByteString.Short.Internal Data.ByteString.Unsafe

363+hidden-modules: Data.ByteString.Builder.ASCII

364+ Data.ByteString.Builder.Prim.Binary

365+ Data.ByteString.Builder.Prim.ASCII

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

367+ Data.ByteString.Builder.Prim.Internal.UncheckedShifts

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

369+hs-libraries: HSbytestring-0.10.8.2-FBklFuapa1a7kq4yflY7Bt

370+includes:

371+ fpstring.h

372+depends:

373+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

374+ deepseq-1.4.4.0-IftsS9ityeGZTtUqULJH7

375+ ghc-prim-0.5.3-D5yTV0DK5iW2rkul1Hko6R

376+ integer-gmp-1.0.2.0-6GHJbRN6krEDXGMaCSGBVX

377+---

378+name: containers

379+version: 0.6.0.1

380+id: containers-0.6.0.1-BAqcfV1UBBeCIRjPbUYeSG

381+key: containers-0.6.0.1-BAqcfV1UBBeCIRjPbUYeSG

382+license: BSD3

383+maintainer: libraries@haskell.org

384+synopsis: Assorted concrete container types

385+description:

386+ This package contains efficient general-purpose implementations

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

388+ trees, and graphs.

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

390+ operations see the [containers

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

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

393+ remains valid even if structures are shared.

394+category: Data Structures

395+exposed: True

396+exposed-modules:

397+ Data.Containers.ListUtils Data.Graph Data.IntMap

398+ Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy

399+ Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict

400+ Data.IntSet Data.IntSet.Internal Data.Map Data.Map.Internal

401+ Data.Map.Internal.Debug Data.Map.Lazy Data.Map.Merge.Lazy

402+ Data.Map.Merge.Strict Data.Map.Strict Data.Map.Strict.Internal

403+ Data.Sequence Data.Sequence.Internal Data.Sequence.Internal.Sorting

404+ Data.Set Data.Set.Internal Data.Tree

405+ Utils.Containers.Internal.BitQueue

406+ Utils.Containers.Internal.BitUtil

407+ Utils.Containers.Internal.StrictPair

408+hidden-modules: Utils.Containers.Internal.State

409+ Utils.Containers.Internal.StrictMaybe

410+ Utils.Containers.Internal.PtrEquality

411+ Utils.Containers.Internal.Coercions

412+ Utils.Containers.Internal.TypeError

413+ Data.Map.Internal.DeprecatedShowTree

414+ Data.IntMap.Internal.DeprecatedDebug

415+hs-libraries: HScontainers-0.6.0.1-BAqcfV1UBBeCIRjPbUYeSG

416+depends:

417+ array-0.5.3.0-164UCDdQjfT6fdtNV9FrwT

418+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

419+ deepseq-1.4.4.0-IftsS9ityeGZTtUqULJH7

420+ ghc-prim-0.5.3-D5yTV0DK5iW2rkul1Hko6R

421+---

422+name: deepseq

423+version: 1.4.4.0

424+id: deepseq-1.4.4.0-IftsS9ityeGZTtUqULJH7

425+key: deepseq-1.4.4.0-IftsS9ityeGZTtUqULJH7

426+license: BSD3

427+maintainer: libraries@haskell.org

428+synopsis: Deep evaluation of data structures

429+description:

430+ This package provides methods for fully evaluating data structures

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

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

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

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

435+ wrong thread.

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

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

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

439+ components) which defines strategies for fully evaluating different

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

441+ details.

442+category: Control

443+exposed: True

444+exposed-modules:

445+ Control.DeepSeq

446+hidden-modules: Control.DeepSeq.BackDoor

447+hs-libraries: HSdeepseq-1.4.4.0-IftsS9ityeGZTtUqULJH7

448+depends:

449+ array-0.5.3.0-164UCDdQjfT6fdtNV9FrwT

450+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

451+---

452+name: directory

453+version: 1.3.3.0

454+id: directory-1.3.3.0-5pg72mHzHk4Dhxxy4wYd2z

455+key: directory-1.3.3.0-5pg72mHzHk4Dhxxy4wYd2z

456+license: BSD3

457+maintainer: libraries@haskell.org

458+synopsis: Platform-agnostic library for filesystem operations

459+description:

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

461+ directories in a portable way.

462+category: System

463+exposed: True

464+exposed-modules:

465+ System.Directory System.Directory.Internal

466+ System.Directory.Internal.Prelude

467+hidden-modules: System.Directory.Internal.C_utimensat

468+ System.Directory.Internal.Common System.Directory.Internal.Config

469+ System.Directory.Internal.Posix System.Directory.Internal.Windows

470+ System.Directory.Internal.GHCJS

471+hs-libraries: HSdirectory-1.3.3.0-5pg72mHzHk4Dhxxy4wYd2z

472+depends:

473+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

474+ filepath-1.4.2.1-DG92Jon7uT21h5exmtoJCU

475+ ghcjs-prim-0.1.1.0-EXzjGVHQlAS2XAXcu0iCbS

476+ time-1.8.0.2-3d3i5aGvKEfEHwUSNgliL4

477+ unix-2.7.2.2-JxmyTgtpFqj7lvsQuv62w2

478+---

479+name: filepath

480+version: 1.4.2.1

481+id: filepath-1.4.2.1-DG92Jon7uT21h5exmtoJCU

482+key: filepath-1.4.2.1-DG92Jon7uT21h5exmtoJCU

483+license: BSD3

484+copyright: Neil Mitchell 2005-2018

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

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

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

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

489+description:

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

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

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

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

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

495+category: System

496+exposed: True

497+exposed-modules:

498+ System.FilePath System.FilePath.Current System.FilePath.Posix

499+ System.FilePath.Windows

500+hs-libraries: HSfilepath-1.4.2.1-DG92Jon7uT21h5exmtoJCU

501+depends:

502+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

503+---

504+name: ghc

505+version: 8.6.5

506+id: ghc-8.6.5-5kR8eDcAQgs235a2XOhrTu

507+key: ghc-8.6.5-5kR8eDcAQgs235a2XOhrTu

508+license: BSD3

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

510+author: The GHC Team

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

512+synopsis: The GHC API

513+description:

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

515+ compiling Haskell programs. Important use cases are programs

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

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

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

519+ through this package.

520+category: Development

521+exposed-modules:

522+ Plugins,

523+ Serialized from ghc-boot-8.6.5-5ESTVpsVXiHLUeDFqBph3M:GHC.Serialized

524+hs-libraries: HSghc-8.6.5-5kR8eDcAQgs235a2XOhrTu

525+depends:

526+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

527+ ghc-boot-8.6.5-5ESTVpsVXiHLUeDFqBph3M

528+---

529+name: ghc-boot

530+version: 8.6.5

531+id: ghc-boot-8.6.5-5ESTVpsVXiHLUeDFqBph3M

532+key: ghc-boot-8.6.5-5ESTVpsVXiHLUeDFqBph3M

533+license: BSD3

534+maintainer: ghc-devs@haskell.org

535+synopsis: Shared functionality between GHC and its boot libraries

536+description:

537+ This library is shared between GHC, ghc-pkg, and other boot

538+ libraries.

539+ A note about "GHC.PackageDb": it only deals with the subset of

540+ the package database that the compiler cares about: modules

541+ paths etc and not package metadata like description, authors

542+ etc. It is thus not a library interface to ghc-pkg and is *not*

543+ suitable for modifying GHC package databases.

544+ The package database format and this library are constructed in

545+ such a way that while ghc-pkg depends on Cabal, the GHC library

546+ and program do not have to depend on Cabal.

547+category: GHC

548+exposed: True

549+exposed-modules:

550+ GHC.ForeignSrcLang GHC.HandleEncoding GHC.LanguageExtensions

551+ GHC.PackageDb GHC.Serialized

552+hs-libraries: HSghc-boot-8.6.5-5ESTVpsVXiHLUeDFqBph3M

553+depends:

554+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

555+ binary-0.8.6.0-H5jYuYqJeOLDt7eFZnyaWc

556+ bytestring-0.10.8.2-FBklFuapa1a7kq4yflY7Bt

557+ directory-1.3.3.0-5pg72mHzHk4Dhxxy4wYd2z

558+ filepath-1.4.2.1-DG92Jon7uT21h5exmtoJCU

559+ ghc-boot-th-8.6.5-8EgBuWnIPyA5myTiWPrjgj

560+---

561+name: ghc-boot-th

562+version: 8.6.5

563+id: ghc-boot-th-8.6.5-8EgBuWnIPyA5myTiWPrjgj

564+key: ghc-boot-th-8.6.5-8EgBuWnIPyA5myTiWPrjgj

565+license: BSD3

566+maintainer: ghc-devs@haskell.org

567+synopsis: Shared functionality between GHC and the @template-haskell@

568+ library

569+description:

570+ This library contains various bits shared between the @ghc@ and

571+ @template-haskell@ libraries.

572+ This package exists to ensure that @template-haskell@ has a

573+ minimal set of transitive dependencies, since it is intended to

574+ be depended upon by user code.

575+category: GHC

576+exposed: True

577+exposed-modules:

578+ GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme

579+hs-libraries: HSghc-boot-th-8.6.5-8EgBuWnIPyA5myTiWPrjgj

580+depends:

581+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

582+---

583+name: ghc-compact

584+version: 0.1.0.0

585+id: ghc-compact-0.1.0.0-9v5dp4iVlu4IJ1Sf6JqvIW

586+key: ghc-compact-0.1.0.0-9v5dp4iVlu4IJ1Sf6JqvIW

587+license: BSD3

588+maintainer: libraries@haskell.org

589+synopsis: In memory storage of deeply evaluated data structure

590+description:

591+ This package provides minimal functionality for working with

592+ "compact regions", which hold a fully evaluated Haskell object graph.

593+ These regions maintain the invariant that no pointers live inside the struct

594+ that point outside it, which ensures efficient garbage collection without

595+ ever reading the structure contents (effectively, it works as a manually

596+ managed "oldest generation" which is never freed until the whole is

597+ released).

598+ Internally, the struct is stored a single contiguous block of memory,

599+ which allows efficient serialization and deserialization of structs

600+ for distributed computing.

601+category: Data

602+exposed: True

603+exposed-modules:

604+ GHC.Compact GHC.Compact.Serialized

605+hs-libraries: HSghc-compact-0.1.0.0-9v5dp4iVlu4IJ1Sf6JqvIW

606+depends:

607+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

608+ bytestring-0.10.8.2-FBklFuapa1a7kq4yflY7Bt

609+ ghc-prim-0.5.3-D5yTV0DK5iW2rkul1Hko6R

610+---

611+name: ghc-heap

612+version: 8.6.5

613+id: ghc-heap-8.6.5-EF2BPSQD7bDCq4zFDLcCIj

614+key: ghc-heap-8.6.5-EF2BPSQD7bDCq4zFDLcCIj

615+license: BSD3

616+maintainer: libraries@haskell.org

617+synopsis: Functions for walking GHC's heap

618+description:

619+ This package provides functions for walking the GHC heap data structures

620+ and retrieving information about those data structures.

621+category: GHC

622+exposed: True

623+exposed-modules:

624+ GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures

625+ GHC.Exts.Heap.Constants GHC.Exts.Heap.InfoTable

626+ GHC.Exts.Heap.InfoTable.Types GHC.Exts.Heap.InfoTableProf

627+ GHC.Exts.Heap.Utils

628+hs-libraries: HSghc-heap-8.6.5-EF2BPSQD7bDCq4zFDLcCIj

629+depends:

630+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

631+ ghc-prim-0.5.3-D5yTV0DK5iW2rkul1Hko6R rts

632+---

633+name: ghc-prim

634+version: 0.5.3

635+id: ghc-prim-0.5.3-D5yTV0DK5iW2rkul1Hko6R

636+key: ghc-prim-0.5.3-D5yTV0DK5iW2rkul1Hko6R

637+license: BSD3

638+maintainer: libraries@haskell.org

639+synopsis: GHC primitives

640+description:

641+ This package contains the primitive types and operations supplied by GHC.

642+category: GHC

643+exposed: True

644+exposed-modules:

645+ GHC.CString GHC.Classes GHC.Debug GHC.IntWord64 GHC.Magic

646+ GHC.PrimopWrappers GHC.Tuple GHC.Types GHC.Prim

647+hs-libraries: HSghc-prim-0.5.3-D5yTV0DK5iW2rkul1Hko6R

648+depends:

649+ rts

650+---

651+name: ghci

652+version: 8.6.5

653+id: ghci-8.6.5-P1uAC7fKP5AtexQsPxPeS

654+key: ghci-8.6.5-P1uAC7fKP5AtexQsPxPeS

655+license: BSD3

656+maintainer: ghc-devs@haskell.org

657+synopsis: The library supporting GHC's interactive interpreter

658+description:

659+ This library offers interfaces which mediate interactions between the

660+ @ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter

661+ backend.

662+category: GHC

663+exposed: True

664+exposed-modules:

665+ GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI

666+ GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes

667+ GHCi.ResolvedBCO GHCi.Run GHCi.Signals GHCi.StaticPtrTable GHCi.TH

668+ GHCi.TH.Binary SizedSeq

669+hs-libraries: HSghci-8.6.5-P1uAC7fKP5AtexQsPxPeS

670+depends:

671+ array-0.5.3.0-164UCDdQjfT6fdtNV9FrwT

672+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

673+ binary-0.8.6.0-H5jYuYqJeOLDt7eFZnyaWc

674+ bytestring-0.10.8.2-FBklFuapa1a7kq4yflY7Bt

675+ containers-0.6.0.1-BAqcfV1UBBeCIRjPbUYeSG

676+ deepseq-1.4.4.0-IftsS9ityeGZTtUqULJH7

677+ filepath-1.4.2.1-DG92Jon7uT21h5exmtoJCU

678+ ghc-boot-8.6.5-5ESTVpsVXiHLUeDFqBph3M

679+ ghc-boot-th-8.6.5-8EgBuWnIPyA5myTiWPrjgj

680+ ghc-heap-8.6.5-EF2BPSQD7bDCq4zFDLcCIj

681+ template-haskell-2.14.0.0-IL8m17bycJ4COnAZFzmrvL

682+ transformers-0.5.6.2-KaPP0fdMTwBF02jPgfEE5s

683+ unix-2.7.2.2-JxmyTgtpFqj7lvsQuv62w2

684+---

685+name: ghcjs-prim

686+version: 0.1.1.0

687+id: ghcjs-prim-0.1.1.0-EXzjGVHQlAS2XAXcu0iCbS

688+key: ghcjs-prim-0.1.1.0-EXzjGVHQlAS2XAXcu0iCbS

689+license: MIT

690+maintainer: stegeman@gmail.com

691+author: Luite Stegeman

692+homepage: http://github.com/ghcjs

693+exposed: True

694+exposed-modules:

695+ GHCJS.Prim GHCJS.Prim.Internal GHCJS.Prim.Internal.Build

696+hs-libraries: HSghcjs-prim-0.1.1.0-EXzjGVHQlAS2XAXcu0iCbS

697+depends:

698+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

699+ ghc-prim-0.5.3-D5yTV0DK5iW2rkul1Hko6R

700+---

701+name: ghcjs-th

702+version: 0.1.0.0

703+id: ghcjs-th-0.1.0.0-LTlytbLRHn01Zf4MT4Tapl

704+key: ghcjs-th-0.1.0.0-LTlytbLRHn01Zf4MT4Tapl

705+license: MIT

706+maintainer: stegeman@gmail.com

707+author: Luite Stegeman

708+homepage: http://github.com/ghcjs

709+exposed: True

710+exposed-modules:

711+ GHCJS.Prim.TH.Eval GHCJS.Prim.TH.Serialized GHCJS.Prim.TH.Types

712+hs-libraries: HSghcjs-th-0.1.0.0-LTlytbLRHn01Zf4MT4Tapl

713+depends:

714+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

715+ binary-0.8.6.0-H5jYuYqJeOLDt7eFZnyaWc

716+ bytestring-0.10.8.2-FBklFuapa1a7kq4yflY7Bt

717+ containers-0.6.0.1-BAqcfV1UBBeCIRjPbUYeSG

718+ ghc-prim-0.5.3-D5yTV0DK5iW2rkul1Hko6R

719+ ghci-8.6.5-P1uAC7fKP5AtexQsPxPeS

720+ template-haskell-2.14.0.0-IL8m17bycJ4COnAZFzmrvL

721+---

722+name: integer-gmp

723+version: 1.0.2.0

724+id: integer-gmp-1.0.2.0-6GHJbRN6krEDXGMaCSGBVX

725+key: integer-gmp-1.0.2.0-6GHJbRN6krEDXGMaCSGBVX

726+license: BSD3

727+maintainer: hvr@gnu.org

728+author: Herbert Valerio Riedel

729+synopsis: Integer library based on GMP

730+description:

731+ This package provides the low-level implementation of the standard

732+ 'Integer' type based on the

733+ <http://gmplib.org/ GNU Multiple Precision Arithmetic Library (GMP)>.

734+ This package provides access to the internal representation of

735+ 'Integer' as well as primitive operations with no proper error

736+ handling, and should only be used directly with the utmost care.

737+category: Numeric, Algebra

738+exposed: True

739+exposed-modules:

740+ GHC.Integer GHC.Integer.GMP.Internals GHC.Integer.Logarithms

741+ GHC.Integer.Logarithms.Internals

742+hidden-modules: GHC.Integer.Type

743+hs-libraries: HSinteger-gmp-1.0.2.0-6GHJbRN6krEDXGMaCSGBVX

744+extra-libraries:

745+ gmp

746+depends:

747+ ghc-prim-0.5.3-D5yTV0DK5iW2rkul1Hko6R

748+---

749+name: mtl

750+version: 2.2.2

751+id: mtl-2.2.2-ApFELyUjwv93Vj2GS8sioS

752+key: mtl-2.2.2-ApFELyUjwv93Vj2GS8sioS

753+license: BSD3

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

755+author: Andy Gill

756+homepage: http://github.com/haskell/mtl

757+synopsis: Monad classes, using functional dependencies

758+description:

759+ Monad classes using functional dependencies, with instances

760+ for various monad transformers, inspired by the paper

761+ /Functional Programming with Overloading and Higher-Order Polymorphism/,

762+ by Mark P Jones, in /Advanced School of Functional Programming/, 1995

763+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

764+category: Control

765+exposed: True

766+exposed-modules:

767+ Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error

768+ Control.Monad.Error.Class Control.Monad.Except

769+ Control.Monad.Identity Control.Monad.List Control.Monad.RWS

770+ Control.Monad.RWS.Class Control.Monad.RWS.Lazy

771+ Control.Monad.RWS.Strict Control.Monad.Reader

772+ Control.Monad.Reader.Class Control.Monad.State

773+ Control.Monad.State.Class Control.Monad.State.Lazy

774+ Control.Monad.State.Strict Control.Monad.Trans Control.Monad.Writer

775+ Control.Monad.Writer.Class Control.Monad.Writer.Lazy

776+ Control.Monad.Writer.Strict

777+hs-libraries: HSmtl-2.2.2-ApFELyUjwv93Vj2GS8sioS

778+depends:

779+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

780+ transformers-0.5.6.2-KaPP0fdMTwBF02jPgfEE5s

781+---

782+name: parsec

783+version: 3.1.13.0

784+id: parsec-3.1.13.0-B5rilSKpqzU4t8cguYXeJQ

785+key: parsec-3.1.13.0-B5rilSKpqzU4t8cguYXeJQ

786+license: BSD3

787+maintainer: Herbert Valerio Riedel <hvr@gnu.org>

788+author: Daan Leijen <daan@microsoft.com>, Paolo Martini <paolo@nemail.it>, Antoine Latter <aslatter@gmail.com>

789+homepage: https://github.com/haskell/parsec

790+synopsis: Monadic parser combinators

791+description:

792+ Parsec is designed from scratch as an industrial-strength parser

793+ library. It is simple, safe, well documented (on the package

794+ homepage), has extensive libraries, good error messages,

795+ and is fast. It is defined as a monad transformer that can be

796+ stacked on arbitrary monads, and it is also parametric in the

797+ input stream type.

798+ The main entry point is the "Text.Parsec" module which provides

799+ defaults for parsing 'Char'acter data.

800+ The "Text.ParserCombinators.Parsec" module hierarchy contains

801+ the legacy @parsec-2@ API and may be removed at some point in

802+ the future.

803+category: Parsing

804+exposed: True

805+exposed-modules:

806+ Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy

807+ Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error

808+ Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm

809+ Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String

810+ Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token

811+ Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char

812+ Text.ParserCombinators.Parsec.Combinator

813+ Text.ParserCombinators.Parsec.Error

814+ Text.ParserCombinators.Parsec.Expr

815+ Text.ParserCombinators.Parsec.Language

816+ Text.ParserCombinators.Parsec.Perm

817+ Text.ParserCombinators.Parsec.Pos

818+ Text.ParserCombinators.Parsec.Prim

819+ Text.ParserCombinators.Parsec.Token

820+hs-libraries: HSparsec-3.1.13.0-B5rilSKpqzU4t8cguYXeJQ

821+depends:

822+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

823+ bytestring-0.10.8.2-FBklFuapa1a7kq4yflY7Bt

824+ mtl-2.2.2-ApFELyUjwv93Vj2GS8sioS

825+ text-1.2.3.1-2mMWCa8HNEL4R4p8nnvwO2

826+---

827+name: pretty

828+version: 1.1.3.6

829+id: pretty-1.1.3.6-HCbdzOHqNpW5RoNxlHyeg5

830+key: pretty-1.1.3.6-HCbdzOHqNpW5RoNxlHyeg5

831+license: BSD3

832+maintainer: David Terei <code@davidterei.com>

833+stability: Stable

834+homepage: http://github.com/haskell/pretty

835+synopsis: Pretty-printing library

836+description:

837+ This package contains a pretty-printing library, a set of API's

838+ that provides a way to easily print out text in a consistent

839+ format of your choosing. This is useful for compilers and related

840+ tools.

841+ This library was originally designed by John Hughes's and has since

842+ been heavily modified by Simon Peyton Jones.

843+category: Text

844+exposed: True

845+exposed-modules:

846+ Text.PrettyPrint Text.PrettyPrint.Annotated

847+ Text.PrettyPrint.Annotated.HughesPJ

848+ Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ

849+ Text.PrettyPrint.HughesPJClass

850+hs-libraries: HSpretty-1.1.3.6-HCbdzOHqNpW5RoNxlHyeg5

851+depends:

852+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

853+ deepseq-1.4.4.0-IftsS9ityeGZTtUqULJH7

854+ ghc-prim-0.5.3-D5yTV0DK5iW2rkul1Hko6R

855+---

856+name: process

857+version: 1.6.5.0

858+id: process-1.6.5.0-Wgw4Qh9nsHBTY0LWykUqv

859+key: process-1.6.5.0-Wgw4Qh9nsHBTY0LWykUqv

860+license: BSD3

861+maintainer: libraries@haskell.org

862+synopsis: Process libraries

863+description:

864+ This package contains libraries for dealing with system processes.

865+ The typed-process package is a more recent take on a process API,

866+ which uses this package internally. It features better binary

867+ support, easier concurrency, and a more composable API. You can

868+ read more about it at

869+ <https://haskell-lang.org/library/typed-process>.

870+category: System

871+exposed: True

872+exposed-modules:

873+ System.Cmd System.Process System.Process.Internals

874+hidden-modules: System.Process.Common System.Process.Posix

875+hs-libraries: HSprocess-1.6.5.0-Wgw4Qh9nsHBTY0LWykUqv

876+includes:

877+ runProcess.h

878+depends:

879+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

880+ deepseq-1.4.4.0-IftsS9ityeGZTtUqULJH7

881+ directory-1.3.3.0-5pg72mHzHk4Dhxxy4wYd2z

882+ filepath-1.4.2.1-DG92Jon7uT21h5exmtoJCU

883+ ghcjs-prim-0.1.1.0-EXzjGVHQlAS2XAXcu0iCbS

884+ unix-2.7.2.2-JxmyTgtpFqj7lvsQuv62w2

885+---

886+name: rts

887+version: 1.0

888+id: rts

889+key: rts

890+license: BSD-3-Clause

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

892+exposed: True

893+hs-libraries: HSrts

894+extra-libraries:

895+ m dl ffi

896+includes:

897+ Stg.h

898+ld-options: "-Wl,-u,_base_GHCziTopHandler_runIO_closure"

899+ "-Wl,-u,_base_GHCziTopHandler_runNonIO_closure"

900+ "-Wl,-u,_ghczmprim_GHCziTuple_Z0T_closure"

901+ "-Wl,-u,_ghczmprim_GHCziTypes_True_closure"

902+ "-Wl,-u,_ghczmprim_GHCziTypes_False_closure"

903+ "-Wl,-u,_base_GHCziPack_unpackCString_closure"

904+ "-Wl,-u,_base_GHCziWeak_runFinalizzerBatch_closure"

905+ "-Wl,-u,_base_GHCziIOziException_stackOverflow_closure"

906+ "-Wl,-u,_base_GHCziIOziException_heapOverflow_closure"

907+ "-Wl,-u,_base_GHCziIOziException_allocationLimitExceeded_closure"

908+ "-Wl,-u,_base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"

909+ "-Wl,-u,_base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"

910+ "-Wl,-u,_base_GHCziIOziException_cannotCompactFunction_closure"

911+ "-Wl,-u,_base_GHCziIOziException_cannotCompactPinned_closure"

912+ "-Wl,-u,_base_GHCziIOziException_cannotCompactMutable_closure"

913+ "-Wl,-u,_base_ControlziExceptionziBase_absentSumFieldError_closure"

914+ "-Wl,-u,_base_ControlziExceptionziBase_nonTermination_closure"

915+ "-Wl,-u,_base_ControlziExceptionziBase_nestedAtomically_closure"

916+ "-Wl,-u,_base_GHCziEventziThread_blockedOnBadFD_closure"

917+ "-Wl,-u,_base_GHCziConcziSync_runSparks_closure"

918+ "-Wl,-u,_base_GHCziConcziIO_ensureIOManagerIsRunning_closure"

919+ "-Wl,-u,_base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"

920+ "-Wl,-u,_base_GHCziConcziSignal_runHandlersPtr_closure"

921+ "-Wl,-u,_base_GHCziTopHandler_flushStdHandles_closure"

922+ "-Wl,-u,_base_GHCziTopHandler_runMainIO_closure"

923+ "-Wl,-u,_ghczmprim_GHCziTypes_Czh_con_info"

924+ "-Wl,-u,_ghczmprim_GHCziTypes_Izh_con_info"

925+ "-Wl,-u,_ghczmprim_GHCziTypes_Fzh_con_info"

926+ "-Wl,-u,_ghczmprim_GHCziTypes_Dzh_con_info"

927+ "-Wl,-u,_ghczmprim_GHCziTypes_Wzh_con_info"

928+ "-Wl,-u,_base_GHCziPtr_Ptr_con_info"

929+ "-Wl,-u,_base_GHCziPtr_FunPtr_con_info"

930+ "-Wl,-u,_base_GHCziInt_I8zh_con_info"

931+ "-Wl,-u,_base_GHCziInt_I16zh_con_info"

932+ "-Wl,-u,_base_GHCziInt_I32zh_con_info"

933+ "-Wl,-u,_base_GHCziInt_I64zh_con_info"

934+ "-Wl,-u,_base_GHCziWord_W8zh_con_info"

935+ "-Wl,-u,_base_GHCziWord_W16zh_con_info"

936+ "-Wl,-u,_base_GHCziWord_W32zh_con_info"

937+ "-Wl,-u,_base_GHCziWord_W64zh_con_info"

938+ "-Wl,-u,_base_GHCziStable_StablePtr_con_info"

939+ "-Wl,-u,_hs_atomic_add8" "-Wl,-u,_hs_atomic_add16"

940+ "-Wl,-u,_hs_atomic_add32" "-Wl,-u,_hs_atomic_add64"

941+ "-Wl,-u,_hs_atomic_sub8" "-Wl,-u,_hs_atomic_sub16"

942+ "-Wl,-u,_hs_atomic_sub32" "-Wl,-u,_hs_atomic_sub64"

943+ "-Wl,-u,_hs_atomic_and8" "-Wl,-u,_hs_atomic_and16"

944+ "-Wl,-u,_hs_atomic_and32" "-Wl,-u,_hs_atomic_and64"

945+ "-Wl,-u,_hs_atomic_nand8" "-Wl,-u,_hs_atomic_nand16"

946+ "-Wl,-u,_hs_atomic_nand32" "-Wl,-u,_hs_atomic_nand64"

947+ "-Wl,-u,_hs_atomic_or8" "-Wl,-u,_hs_atomic_or16"

948+ "-Wl,-u,_hs_atomic_or32" "-Wl,-u,_hs_atomic_or64"

949+ "-Wl,-u,_hs_atomic_xor8" "-Wl,-u,_hs_atomic_xor16"

950+ "-Wl,-u,_hs_atomic_xor32" "-Wl,-u,_hs_atomic_xor64"

951+ "-Wl,-u,_hs_cmpxchg8" "-Wl,-u,_hs_cmpxchg16" "-Wl,-u,_hs_cmpxchg32"

952+ "-Wl,-u,_hs_cmpxchg64" "-Wl,-u,_hs_atomicread8"

953+ "-Wl,-u,_hs_atomicread16" "-Wl,-u,_hs_atomicread32"

954+ "-Wl,-u,_hs_atomicread64" "-Wl,-u,_hs_atomicwrite8"

955+ "-Wl,-u,_hs_atomicwrite16" "-Wl,-u,_hs_atomicwrite32"

956+ "-Wl,-u,_hs_atomicwrite64" "-Wl,-search_paths_first"

957+---

958+name: template-haskell

959+version: 2.14.0.0

960+id: template-haskell-2.14.0.0-IL8m17bycJ4COnAZFzmrvL

961+key: template-haskell-2.14.0.0-IL8m17bycJ4COnAZFzmrvL

962+license: BSD3

963+maintainer: libraries@haskell.org

964+synopsis: Support library for Template Haskell

965+description:

966+ This package provides modules containing facilities for manipulating

967+ Haskell source code using Template Haskell.

968+ See <http://www.haskell.org/haskellwiki/Template_Haskell> for more

969+ information.

970+category: Template Haskell

971+exposed: True

972+exposed-modules:

973+ Language.Haskell.TH Language.Haskell.TH.LanguageExtensions

974+ Language.Haskell.TH.Lib Language.Haskell.TH.Lib.Internal

975+ Language.Haskell.TH.Ppr Language.Haskell.TH.PprLib

976+ Language.Haskell.TH.Quote Language.Haskell.TH.Syntax

977+hidden-modules: Language.Haskell.TH.Lib.Map

978+hs-libraries: HStemplate-haskell-2.14.0.0-IL8m17bycJ4COnAZFzmrvL

979+depends:

980+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

981+ ghc-boot-th-8.6.5-8EgBuWnIPyA5myTiWPrjgj

982+ pretty-1.1.3.6-HCbdzOHqNpW5RoNxlHyeg5

983+---

984+name: text

985+version: 1.2.3.1

986+id: text-1.2.3.1-2mMWCa8HNEL4R4p8nnvwO2

987+key: text-1.2.3.1-2mMWCa8HNEL4R4p8nnvwO2

988+license: BSD2

989+copyright: 2009-2011 Bryan O'Sullivan, 2008-2009 Tom Harper

990+maintainer: Bryan O'Sullivan <bos@serpentine.com>, Herbert Valerio Riedel <hvr@gnu.org>

991+author: Bryan O'Sullivan <bos@serpentine.com>

992+homepage: https://github.com/haskell/text

993+synopsis: An efficient packed Unicode text type.

994+description:

995+ An efficient packed, immutable Unicode text type (both strict and

996+ lazy), with a powerful loop fusion optimization framework.

997+ The 'Text' type represents Unicode character strings, in a time and

998+ space-efficient manner. This package provides text processing

999+ capabilities that are optimized for performance critical use, both

1000+ in terms of large data quantities and high speed.

1001+ The 'Text' type provides character-encoding, type-safe case

1002+ conversion via whole-string case conversion functions (see "Data.Text").

1003+ It also provides a range of functions for converting 'Text' values to

1004+ and from 'ByteStrings', using several standard encodings

1005+ (see "Data.Text.Encoding").

1006+ Efficient locale-sensitive support for text IO is also supported

1007+ (see "Data.Text.IO").

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

1009+ clashes with Prelude functions, e.g.

1010+ > import qualified Data.Text as T

1011+ To use an extended and very rich family of functions for working

1012+ with Unicode text (including normalization, regular expressions,

1013+ non-standard encodings, text breaking, and locales), see

1014+ the [text-icu package](https://hackage.haskell.org/package/text-icu)

1015+ based on the well-respected and liberally

1016+ licensed [ICU library](http://site.icu-project.org/).

1017+category: Data, Text

1018+exposed: True

1019+exposed-modules:

1020+ Data.Text Data.Text.Array Data.Text.Encoding

1021+ Data.Text.Encoding.Error Data.Text.Foreign Data.Text.IO

1022+ Data.Text.Internal Data.Text.Internal.Builder

1023+ Data.Text.Internal.Builder.Functions

1024+ Data.Text.Internal.Builder.Int.Digits

1025+ Data.Text.Internal.Builder.RealFloat.Functions

1026+ Data.Text.Internal.Encoding.Fusion

1027+ Data.Text.Internal.Encoding.Fusion.Common

1028+ Data.Text.Internal.Encoding.Utf16 Data.Text.Internal.Encoding.Utf32

1029+ Data.Text.Internal.Encoding.Utf8 Data.Text.Internal.Functions

1030+ Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping

1031+ Data.Text.Internal.Fusion.Common Data.Text.Internal.Fusion.Size

1032+ Data.Text.Internal.Fusion.Types Data.Text.Internal.IO

1033+ Data.Text.Internal.Lazy Data.Text.Internal.Lazy.Encoding.Fusion

1034+ Data.Text.Internal.Lazy.Fusion Data.Text.Internal.Lazy.Search

1035+ Data.Text.Internal.Private Data.Text.Internal.Read

1036+ Data.Text.Internal.Search Data.Text.Internal.Unsafe

1037+ Data.Text.Internal.Unsafe.Char Data.Text.Internal.Unsafe.Shift

1038+ Data.Text.Lazy Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int

1039+ Data.Text.Lazy.Builder.RealFloat Data.Text.Lazy.Encoding

1040+ Data.Text.Lazy.IO Data.Text.Lazy.Internal Data.Text.Lazy.Read

1041+ Data.Text.Read Data.Text.Unsafe

1042+hidden-modules: Data.Text.Show

1043+hs-libraries: HStext-1.2.3.1-2mMWCa8HNEL4R4p8nnvwO2

1044+depends:

1045+ array-0.5.3.0-164UCDdQjfT6fdtNV9FrwT

1046+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

1047+ binary-0.8.6.0-H5jYuYqJeOLDt7eFZnyaWc

1048+ bytestring-0.10.8.2-FBklFuapa1a7kq4yflY7Bt

1049+ deepseq-1.4.4.0-IftsS9ityeGZTtUqULJH7

1050+ ghc-prim-0.5.3-D5yTV0DK5iW2rkul1Hko6R

1051+ integer-gmp-1.0.2.0-6GHJbRN6krEDXGMaCSGBVX

1052+---

1053+name: time

1054+version: 1.8.0.2

1055+id: time-1.8.0.2-3d3i5aGvKEfEHwUSNgliL4

1056+key: time-1.8.0.2-3d3i5aGvKEfEHwUSNgliL4

1057+license: BSD3

1058+maintainer: <ashley@semantic.org>

1059+author: Ashley Yakeley

1060+stability: stable

1061+homepage: https://github.com/haskell/time

1062+synopsis: A time library

1063+description:

1064+ A time library

1065+category: Time

1066+exposed: True

1067+exposed-modules:

1068+ Data.Time Data.Time.Calendar Data.Time.Calendar.Easter

1069+ Data.Time.Calendar.Julian Data.Time.Calendar.MonthDay

1070+ Data.Time.Calendar.OrdinalDate Data.Time.Calendar.WeekDate

1071+ Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System

1072+ Data.Time.Clock.TAI Data.Time.Format Data.Time.LocalTime

1073+hidden-modules: Data.Time.Calendar.Private Data.Time.Calendar.Days

1074+ Data.Time.Calendar.Gregorian Data.Time.Calendar.JulianYearDay

1075+ Data.Time.Clock.Internal.DiffTime

1076+ Data.Time.Clock.Internal.AbsoluteTime

1077+ Data.Time.Clock.Internal.NominalDiffTime

1078+ Data.Time.Clock.Internal.POSIXTime

1079+ Data.Time.Clock.Internal.UniversalTime

1080+ Data.Time.Clock.Internal.SystemTime

1081+ Data.Time.Clock.Internal.UTCTime Data.Time.Clock.Internal.CTimeval

1082+ Data.Time.Clock.Internal.CTimespec Data.Time.Clock.Internal.UTCDiff

1083+ Data.Time.LocalTime.Internal.TimeZone

1084+ Data.Time.LocalTime.Internal.TimeOfDay

1085+ Data.Time.LocalTime.Internal.LocalTime

1086+ Data.Time.LocalTime.Internal.ZonedTime Data.Time.Format.Parse

1087+ Data.Time.Format.Locale

1088+hs-libraries: HStime-1.8.0.2-3d3i5aGvKEfEHwUSNgliL4

1089+depends:

1090+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

1091+ deepseq-1.4.4.0-IftsS9ityeGZTtUqULJH7

1092+---

1093+name: transformers

1094+version: 0.5.6.2

1095+id: transformers-0.5.6.2-KaPP0fdMTwBF02jPgfEE5s

1096+key: transformers-0.5.6.2-KaPP0fdMTwBF02jPgfEE5s

1097+license: BSD3

1098+maintainer: Ross Paterson <R.Paterson@city.ac.uk>

1099+author: Andy Gill, Ross Paterson

1100+synopsis: Concrete functor and monad transformers

1101+description:

1102+ A portable library of functor and monad transformers, inspired by

1103+ the paper

1104+ * \"Functional Programming with Overloading and Higher-Order

1105+ Polymorphism\", by Mark P Jones,

1106+ in /Advanced School of Functional Programming/, 1995

1107+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).

1108+ This package contains:

1109+ * the monad transformer class (in "Control.Monad.Trans.Class")

1110+ * concrete functor and monad transformers, each with associated

1111+ operations and functions to lift operations associated with other

1112+ transformers.

1113+ The package can be used on its own in portable Haskell code, in

1114+ which case operations need to be manually lifted through transformer

1115+ stacks (see "Control.Monad.Trans.Class" for some examples).

1116+ Alternatively, it can be used with the non-portable monad classes in

1117+ the @mtl@ or @monads-tf@ packages, which automatically lift operations

1118+ introduced by monad transformers through other transformers.

1119+category: Control

1120+exposed: True

1121+exposed-modules:

1122+ Control.Applicative.Backwards Control.Applicative.Lift

1123+ Control.Monad.Signatures Control.Monad.Trans.Accum

1124+ Control.Monad.Trans.Class Control.Monad.Trans.Cont

1125+ Control.Monad.Trans.Error Control.Monad.Trans.Except

1126+ Control.Monad.Trans.Identity Control.Monad.Trans.List

1127+ Control.Monad.Trans.Maybe Control.Monad.Trans.RWS

1128+ Control.Monad.Trans.RWS.CPS Control.Monad.Trans.RWS.Lazy

1129+ Control.Monad.Trans.RWS.Strict Control.Monad.Trans.Reader

1130+ Control.Monad.Trans.Select Control.Monad.Trans.State

1131+ Control.Monad.Trans.State.Lazy Control.Monad.Trans.State.Strict

1132+ Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS

1133+ Control.Monad.Trans.Writer.Lazy Control.Monad.Trans.Writer.Strict

1134+ Data.Functor.Constant Data.Functor.Reverse

1135+hs-libraries: HStransformers-0.5.6.2-KaPP0fdMTwBF02jPgfEE5s

1136+depends:

1137+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

1138+---

1139+name: unix

1140+version: 2.7.2.2

1141+id: unix-2.7.2.2-JxmyTgtpFqj7lvsQuv62w2

1142+key: unix-2.7.2.2-JxmyTgtpFqj7lvsQuv62w2

1143+license: BSD3

1144+maintainer: libraries@haskell.org

1145+homepage: https://github.com/haskell/unix

1146+synopsis: POSIX functionality

1147+description:

1148+ This package gives you access to the set of operating system

1149+ services standardised by

1150+ <http://pubs.opengroup.org/onlinepubs/9699919799/ POSIX.1-2008>

1151+ (or the IEEE Portable Operating System Interface for Computing

1152+ Environments - IEEE Std. 1003.1).

1153+ The package is not supported under Windows.

1154+category: System

1155+exposed: True

1156+exposed-modules:

1157+ System.Posix System.Posix.ByteString

1158+ System.Posix.ByteString.FilePath System.Posix.Directory

1159+ System.Posix.Directory.ByteString System.Posix.DynamicLinker

1160+ System.Posix.DynamicLinker.ByteString

1161+ System.Posix.DynamicLinker.Module

1162+ System.Posix.DynamicLinker.Module.ByteString

1163+ System.Posix.DynamicLinker.Prim System.Posix.Env

1164+ System.Posix.Env.ByteString System.Posix.Error System.Posix.Fcntl

1165+ System.Posix.Files System.Posix.Files.ByteString System.Posix.IO

1166+ System.Posix.IO.ByteString System.Posix.Process

1167+ System.Posix.Process.ByteString System.Posix.Process.Internals

1168+ System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem

1169+ System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp

1170+ System.Posix.Temp.ByteString System.Posix.Terminal

1171+ System.Posix.Terminal.ByteString System.Posix.Time

1172+ System.Posix.Unistd System.Posix.User

1173+hidden-modules: System.Posix.Directory.Common

1174+ System.Posix.DynamicLinker.Common System.Posix.Files.Common

1175+ System.Posix.IO.Common System.Posix.Process.Common

1176+ System.Posix.Terminal.Common

1177+hs-libraries: HSunix-2.7.2.2-JxmyTgtpFqj7lvsQuv62w2

1178+includes:

1179+ HsUnix.h execvpe.h

1180+depends:

1181+ base-4.12.0.0-BGkpKxWDclNH5NZN2wRc8Q

1182+ bytestring-0.10.8.2-FBklFuapa1a7kq4yflY7Bt

1183+ time-1.8.0.2-3d3i5aGvKEfEHwUSNgliL4

materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc-pkg/numeric-ghcjs-versionnew file+1

@@ -0,0 +1 @@

1+8.6.5

materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc-pkg/versionnew file+1

@@ -0,0 +1 @@

1+GHCJS package manager version 8.6.5

materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/infonew file+58

@@ -0,0 +1,58 @@

1+ [("Project name","The Glorious Glasgow Haskell Compilation System for JavaScript")

2+ ,("Project version","8.6.5")

3+ ,("Native Too","NO")

4+ ,("GCC extra via C opts"," -fwrapv -fno-builtin")

5+ ,("C compiler flags"," -fno-stack-protector")

6+ ,("C compiler link flags"," ")

7+ ,("C compiler supports -no-pie","NO")

8+ ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

9+ ,("ld flags","")

10+ ,("ld supports compact unwind","YES")

11+ ,("ld supports build-id","NO")

12+ ,("ld supports filelist","YES")

13+ ,("ld is GNU ld","NO")

14+ ,("ar flags","qcls")

15+ ,("ar supports at file","NO")

16+ ,("touch command","touch")

17+ ,("dllwrap command","/bin/false")

18+ ,("windres command","/bin/false")

19+ ,("libtool command","libtool")

20+ ,("cross compiling","NO")

21+ ,("target os","OSDarwin")

22+ ,("target arch","ArchX86_64")

23+ ,("target word size","8")

24+ ,("target has GNU nonexec stack","False")

25+ ,("target has .ident directive","True")

26+ ,("target has subsections via symbols","True")

27+ ,("target has RTS linker","YES")

28+ ,("Unregisterised","NO")

29+ ,("LLVM llc command","llc")

30+ ,("LLVM opt command","opt")

31+ ,("LLVM clang command","clang")

32+ ,("Project Git commit id","9dd298d09697d625bc648c7ff5f5f4241fb56ade")

33+ ,("Booter version","8.6.1")

34+ ,("Stage","2")

35+ ,("Build platform","x86_64-unknown-linux")

36+ ,("Host platform","x86_64-unknown-linux")

37+ ,("Target platform","x86_64-unknown-linux")

38+ ,("Have interpreter","YES")

39+ ,("Object splitting supported","YES")

40+ ,("Have native code generator","YES")

41+ ,("Support SMP","YES")

42+ ,("Tables next to code","YES")

43+ ,("RTS ways","l debug thr thr_debug thr_l thr_p dyn debug_dyn thr_dyn thr_debug_dyn l_dyn thr_l_dyn")

44+ ,("RTS expects libdw","NO")

45+ ,("Support dynamic-too","YES")

46+ ,("Support parallel --make","YES")

47+ ,("Support reexported-modules","YES")

48+ ,("Support thinning and renaming package flags","YES")

49+ ,("Support Backpack","YES")

50+ ,("Requires unified installed package IDs","YES")

51+ ,("Uses package keys","YES")

52+ ,("Uses unit IDs","YES")

53+ ,("Dynamic by default","NO")

54+ ,("GHC Dynamic","NO")

55+ ,("GHC Profiled","NO")

56+ ,("Leading underscore","NO")

57+ ,("Debug on","False")

58+ ]

materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/numeric-ghc-versionnew file+1

@@ -0,0 +1 @@

1+8.6.5

materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/numeric-ghcjs-versionnew file+1

@@ -0,0 +1 @@

1+8.6.5

materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/ghc/numeric-versionnew file+1

@@ -0,0 +1 @@

1+8.6.5

materialized/dummy-ghc/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-darwin/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/js-unknown-ghcjs-js-unknown-ghcjs-ghc-8.6.5-x86_64-linux/ghc-pkg/dump-globalnew file+1185

@@ -0,0 +1,1185 @@