15fc6b3 · haskell.nix · git.iko.soy

git.iko.soy/haskell.nix

on iko/ghcjs-patch-master help sign in

Add ghc 8.10.1 (#541)

* ghc 8.10 * Adds/Updates/Removes materialization files * Disable one-shot-kqueue-on-macos patch on ghc-8.10 * Test ghc883 and ghc8101 but only with nix 20.03 * Various smaller fixes. This should fix the infinite recursion issue with #654 Co-authored-by: Lennart Spitzner <hexagoxel@hexagoxel.de>

commit15fc6b3774774d3b457dfe03006c0c0bdae6d7ad authorHamish Mackenzie <Hamish.Mackenzie@iohk.io> dateSun 7 Jun 2020, 15:05 (6 years ago) parent2f81e72

103 files changed+15764−135

compare with iko/ghcjs-patch-master

unifiedsplit

ci.nix+20−14

@@ -12,21 +12,23 @@

1212 "R1909" = "nixpkgs-1909";

1313 "R2003" = "nixpkgs-2003";

1414 };

15− compilerNixNames = builtins.mapAttrs (defaultCompilerNixName: _:

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

15+ compilerNixNames = nixpkgsName: nixpkgs: builtins.mapAttrs (defaultCompilerNixName: _:

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

1717 ghc865 = {};

18+ } // nixpkgs.lib.optionalAttrs (nixpkgsName == "R2003") {

1819 ghc883 = {};

19− };

20+ ghc8101 = {};

21+ });

2022 systems = nixpkgs: nixpkgs.lib.filterAttrs (_: v: builtins.elem v supportedSystems) {

2123 # I wanted to take these from 'lib.systems.examples', but apparently there isn't one for linux!

2224 linux = "x86_64-linux";

2325 darwin = "x86_64-darwin";

2426 };

25− crossSystems = nixpkgsName: nixpkgs: system:

27+ crossSystems = nixpkgsName: nixpkgs: compilerNixName: system:

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

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

2830 let lib = nixpkgs.lib;

29− in lib.optionalAttrs (system == "x86_64-linux") {

31+ in lib.optionalAttrs (system == "x86_64-linux" && compilerNixName != "ghc8101") {

3032 # Windows cross compilation is currently broken on macOS

3133 inherit (lib.systems.examples) mingwW64;

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

@@ -39,7 +41,7 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:

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

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

4143 genericPkgs = import pinnedNixpkgsSrc {};

42− in dimension "GHC version" compilerNixNames (compilerNixName: nixpkgsArgs:

44+ in dimension "GHC version" (compilerNixNames nixpkgsName genericPkgs) (compilerNixName: nixpkgsArgs:

4345 dimension "System" (systems genericPkgs) (systemName: system:

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

4547 build = import ./build.nix { inherit pkgs ifdLevel; };

@@ -49,33 +51,37 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:

4951 # TODO: can we merge this into the general case by picking an appropriate "cross system" to mean native?

5052 native = pkgs.recurseIntoAttrs ({

5153 inherit (build) tests tools maintainer-scripts maintainer-script-cache;

52− ghc = pkgs.haskell-nix.compiler."${compilerNixName}";

54+ ghc = pkgs.buildPackages.haskell-nix.compiler."${compilerNixName}";

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

5456 iserv-proxy = pkgs.ghc-extra-packages."${compilerNixName}".iserv-proxy.components.exes.iserv-proxy;

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

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

5658 hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;

5759 });

5860 }

5961 //

60− dimension "Cross system" (crossSystems nixpkgsName genericPkgs system) (crossSystemName: crossSystem:

62+ dimension "Cross system" (crossSystems nixpkgsName genericPkgs compilerNixName system) (crossSystemName: crossSystem:

6163 # Cross builds

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

6365 build = import ./build.nix { inherit pkgs ifdLevel; };

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

67+ ghc = pkgs.buildPackages.haskell-nix.compiler."${compilerNixName}";

6568 # TODO: look into cross compiling ghc itself

6669 # ghc = pkgs.haskell-nix.compiler."${compilerNixName}";

6770 # TODO: look into making tools work when cross compiling

6871 # inherit (build) tools;

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

73+ tests =

74+ if (crossSystemName != "aarch64-multiplatform")

75+ then build.tests

76+ else pkgs.recurseIntoAttrs {

77+ # Even on aarch64 we still want to build the pinned files

78+ inherit (build.tests) haskellNixRoots;

79+ };

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

7081 remote-iserv = pkgs.ghc-extra-packages."${compilerNixName}".remote-iserv.components.exes.remote-iserv;

7182 iserv-proxy = pkgs.ghc-extra-packages."${compilerNixName}".iserv-proxy.components.exes.iserv-proxy;

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

7384 hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;

74− }

75− //

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

77− pkgs.lib.optionalAttrs (crossSystemName != "aarch64-multiplatform") {

78− inherit (build) tests;

7985 })

8086 )

8187 )

lib/call-cabal-project-to-nix.nix+1−1

@@ -147,7 +147,7 @@ let

147147 fetchRepo = repo:

148148 let sha256 = repo."--sha256" or (lookupSha256 repo);

149149 in (if sha256 != null

150− then pkgs.fetchgit {

150+ then pkgs.evalPackages.fetchgit {

151151 url = repo.location;

152152 rev = repo.tag;

153153 inherit sha256;

lib/default.nix+5−4

@@ -4,8 +4,8 @@

44with haskellLib;

66let

7− # Why `final.evalPackages.buildPackages.git`?

8− # Why not just final.evalPackages.git?

7+ # Why `final.evalPackages.buildPackages.gitMinimal`?

8+ # Why not just final.evalPackages.gitMinimal?

99 #

1010 # A problem arises when `evalPackages` is `buildPackages`.i

1111 # As may be the case in a flake.

@@ -24,7 +24,7 @@ let

2424 # * When `gdb` does not exist for `js`, so when cross

2525 # compiling with ghcjs `final.buildPackages.git` fails

2626 # to build at all.

27− inherit (pkgs.evalPackages.buildPackages) git;

27+ inherit (pkgs.evalPackages.buildPackages) gitMinimal;

2828

2929in {

3030 # Within the package components, these are the attribute names of

@@ -204,7 +204,8 @@ in {

204204

205205 # Clean git directory based on `git ls-files --recurse-submodules`

206206 cleanGit = import ./clean-git.nix {

207− inherit lib git cleanSourceWith;

207+ inherit lib cleanSourceWith;

208+ git = gitMinimal;

208209 inherit (pkgs.evalPackages) runCommand;

209210 };

210211

materialized/bootstrap/ghc844/hscolour/default.nix+1−2

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

1−

21{

32 pkgs = hackage:

43 {

@@ -31,4 +30,4 @@

3130 ({ lib, ... }:

3231 { packages = { "hscolour" = { flags = {}; }; }; })

3332 ];

34− }

33+ }

materialized/bootstrap/ghc882/alex/.plan.nix/alex.nixnew file+160

@@ -0,0 +1,160 @@

1+{ system

2+ , compiler

3+ , flags

4+ , pkgs

5+ , hsPkgs

6+ , pkgconfPkgs

7+ , errorHandler

8+ , config

9+ , ... }:

10+ {

11+ flags = { small_base = true; };

12+ package = {

13+ specVersion = "1.8";

14+ identifier = { name = "alex"; version = "3.2.4"; };

15+ license = "BSD-3-Clause";

16+ copyright = "(c) Chis Dornan, Simon Marlow";

17+ maintainer = "Simon Marlow <marlowsd@gmail.com>";

18+ author = "Chris Dornan and Simon Marlow";

19+ homepage = "http://www.haskell.org/alex/";

20+ url = "";

21+ synopsis = "Alex is a tool for generating lexical analysers in Haskell";

22+ description = "Alex is a tool for generating lexical analysers in Haskell.\nIt takes a description of tokens based on regular\nexpressions and generates a Haskell module containing code\nfor scanning text efficiently. It is similar to the tool\nlex or flex for C/C++.";

23+ buildType = "Simple";

24+ isLocal = true;

25+ detailLevel = "FullDetails";

26+ licenseFiles = [ "LICENSE" ];

27+ dataDir = "data/";

28+ dataFiles = [

29+ "AlexTemplate"

30+ "AlexTemplate-ghc"

31+ "AlexTemplate-ghc-nopred"

32+ "AlexTemplate-ghc-debug"

33+ "AlexTemplate-debug"

34+ "AlexWrapper-basic"

35+ "AlexWrapper-basic-bytestring"

36+ "AlexWrapper-strict-bytestring"

37+ "AlexWrapper-posn"

38+ "AlexWrapper-posn-bytestring"

39+ "AlexWrapper-monad"

40+ "AlexWrapper-monad-bytestring"

41+ "AlexWrapper-monadUserState"

42+ "AlexWrapper-monadUserState-bytestring"

43+ "AlexWrapper-gscan"

44+ ];

45+ extraSrcFiles = [

46+ "CHANGELOG.md"

47+ "README.md"

48+ "TODO"

49+ "alex.spec"

50+ "doc/Makefile"

51+ "doc/aclocal.m4"

52+ "doc/alex.1.in"

53+ "doc/alex.xml"

54+ "doc/config.mk.in"

55+ "doc/configure.ac"

56+ "doc/docbook-xml.mk"

57+ "doc/fptools.css"

58+ "examples/Makefile"

59+ "examples/Tokens.x"

60+ "examples/Tokens_gscan.x"

61+ "examples/Tokens_posn.x"

62+ "examples/examples.x"

63+ "examples/haskell.x"

64+ "examples/lit.x"

65+ "examples/pp.x"

66+ "examples/state.x"

67+ "examples/tiny.y"

68+ "examples/words.x"

69+ "examples/words_monad.x"

70+ "examples/words_posn.x"

71+ "src/Parser.y.boot"

72+ "src/Scan.x.boot"

73+ "src/ghc_hooks.c"

74+ "templates/GenericTemplate.hs"

75+ "templates/wrappers.hs"

76+ "tests/Makefile"

77+ "tests/simple.x"

78+ "tests/null.x"

79+ "tests/tokens.x"

80+ "tests/tokens_gscan.x"

81+ "tests/tokens_posn.x"

82+ "tests/tokens_bytestring.x"

83+ "tests/tokens_posn_bytestring.x"

84+ "tests/tokens_scan_user.x"

85+ "tests/tokens_strict_bytestring.x"

86+ "tests/tokens_monad_bytestring.x"

87+ "tests/tokens_monadUserState_bytestring.x"

88+ "tests/tokens_bytestring_unicode.x"

89+ "tests/basic_typeclass.x"

90+ "tests/basic_typeclass_bytestring.x"

91+ "tests/default_typeclass.x"

92+ "tests/gscan_typeclass.x"

93+ "tests/posn_typeclass.x"

94+ "tests/monad_typeclass.x"

95+ "tests/monad_typeclass_bytestring.x"

96+ "tests/monadUserState_typeclass.x"

97+ "tests/monadUserState_typeclass_bytestring.x"

98+ "tests/posn_typeclass_bytestring.x"

99+ "tests/strict_typeclass.x"

100+ "tests/unicode.x"

101+ ];

102+ extraTmpFiles = [];

103+ extraDocFiles = [];

104+ };

105+ components = {

106+ exes = {

107+ "alex" = {

108+ depends = [

109+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

110+ ] ++ (if flags.small_base

111+ then [

112+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

113+ (hsPkgs."array" or (errorHandler.buildDepError "array"))

114+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

115+ (hsPkgs."directory" or (errorHandler.buildDepError "directory"))

116+ ]

117+ else [ (hsPkgs."base" or (errorHandler.buildDepError "base")) ]);

118+ buildable = true;

119+ modules = [

120+ "AbsSyn"

121+ "CharSet"

122+ "DFA"

123+ "DFAMin"

124+ "DFS"

125+ "Info"

126+ "Map"

127+ "NFA"

128+ "Output"

129+ "Paths_alex"

130+ "Parser"

131+ "ParseMonad"

132+ "Scan"

133+ "Set"

134+ "Sort"

135+ "Util"

136+ "UTF8"

137+ "Data/Ranged"

138+ "Data/Ranged/Boundaries"

139+ "Data/Ranged/RangedSet"

140+ "Data/Ranged/Ranges"

141+ ];

142+ hsSourceDirs = [ "src" ];

143+ mainPath = [ "Main.hs" ] ++ [ "" ];

144+ };

145+ };

146+ tests = {

147+ "tests" = {

148+ depends = [

149+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

150+ (hsPkgs."process" or (errorHandler.buildDepError "process"))

151+ ];

152+ build-tools = [

153+ (hsPkgs.buildPackages.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex")))

154+ ];

155+ buildable = true;

156+ mainPath = [ "test.hs" ];

157+ };

158+ };

159+ };

160+ } // rec { src = (pkgs.lib).mkDefault ../.; }

materialized/bootstrap/ghc882/alex/default.nixnew file+49

@@ -0,0 +1,49 @@

1+{

2+ pkgs = hackage:

3+ {

4+ packages = {

5+ "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;

6+ "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

7+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

8+ "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

9+ "directory".revision = (((hackage."directory")."1.3.4.0").revisions).default;

10+ "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;

11+ "bytestring".revision = (((hackage."bytestring")."0.10.10.0").revisions).default;

12+ "base".revision = (((hackage."base")."4.13.0.0").revisions).default;

13+ "time".revision = (((hackage."time")."1.9.3").revisions).default;

14+ "filepath".revision = (((hackage."filepath")."1.4.2.1").revisions).default;

15+ "process".revision = (((hackage."process")."1.6.7.0").revisions).default;

16+ "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

17+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

18+ };

19+ compiler = {

20+ version = "8.8.2";

21+ nix-name = "ghc882";

22+ packages = {

23+ "ghc-prim" = "0.5.3";

24+ "unix" = "2.7.2.2";

25+ "rts" = "1.0";

26+ "deepseq" = "1.4.4.0";

27+ "directory" = "1.3.4.0";

28+ "containers" = "0.6.2.1";

29+ "bytestring" = "0.10.10.0";

30+ "base" = "4.13.0.0";

31+ "time" = "1.9.3";

32+ "filepath" = "1.4.2.1";

33+ "process" = "1.6.7.0";

34+ "array" = "0.5.4.0";

35+ "integer-gmp" = "1.0.2.0";

36+ };

37+ };

38+ };

39+ extras = hackage:

40+ { packages = { alex = ./.plan.nix/alex.nix; }; };

41+ modules = [

42+ ({ lib, ... }:

43+ {

44+ packages = {

45+ "alex" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

46+ };

47+ })

48+ ];

49+ }

materialized/bootstrap/ghc882/happy-1.19.12/.plan.nix/happy.nixnew file+200

@@ -0,0 +1,200 @@

1+{ system

2+ , compiler

3+ , flags

4+ , pkgs

5+ , hsPkgs

6+ , pkgconfPkgs

7+ , errorHandler

8+ , config

9+ , ... }:

10+ {

11+ flags = { small_base = true; };

12+ package = {

13+ specVersion = "1.8";

14+ identifier = { name = "happy"; version = "1.19.12"; };

15+ license = "BSD-2-Clause";

16+ copyright = "(c) Andy Gill, Simon Marlow";

17+ maintainer = "Simon Marlow <marlowsd@gmail.com>";

18+ author = "Andy Gill and Simon Marlow";

19+ homepage = "https://www.haskell.org/happy/";

20+ url = "";

21+ synopsis = "Happy is a parser generator for Haskell";

22+ description = "Happy is a parser generator for Haskell. Given a grammar\nspecification in BNF, Happy generates Haskell code to parse the\ngrammar. Happy works in a similar way to the @yacc@ tool for C.";

23+ buildType = "Simple";

24+ isLocal = true;

25+ detailLevel = "FullDetails";

26+ licenseFiles = [ "LICENSE" ];

27+ dataDir = "data/";

28+ dataFiles = [

29+ "HappyTemplate"

30+ "HappyTemplate-arrays"

31+ "HappyTemplate-arrays-coerce"

32+ "HappyTemplate-arrays-coerce-debug"

33+ "HappyTemplate-arrays-debug"

34+ "HappyTemplate-arrays-ghc"

35+ "HappyTemplate-arrays-ghc-debug"

36+ "HappyTemplate-coerce"

37+ "HappyTemplate-ghc"

38+ "GLR_Base"

39+ "GLR_Lib"

40+ "GLR_Lib-ghc"

41+ "GLR_Lib-ghc-debug"

42+ ];

43+ extraSrcFiles = [

44+ "ANNOUNCE"

45+ "CHANGES"

46+ "Makefile"

47+ "README.md"

48+ "TODO"

49+ "doc/Makefile"

50+ "doc/aclocal.m4"

51+ "doc/config.mk.in"

52+ "doc/configure.ac"

53+ "doc/docbook-xml.mk"

54+ "doc/fptools.css"

55+ "doc/happy.1.in"

56+ "doc/happy.xml"

57+ "examples/glr/nlp/Main.lhs"

58+ "examples/glr/nlp/Makefile"

59+ "examples/glr/nlp/README"

60+ "examples/glr/nlp/English.y"

61+ "examples/glr/nlp/Hugs.lhs"

62+ "examples/glr/Makefile"

63+ "examples/glr/Makefile.defs"

64+ "examples/glr/expr-eval/Main.lhs"

65+ "examples/glr/expr-eval/Makefile"

66+ "examples/glr/expr-eval/Expr.y"

67+ "examples/glr/expr-eval/README"

68+ "examples/glr/expr-eval/Hugs.lhs"

69+ "examples/glr/expr-tree/Main.lhs"

70+ "examples/glr/expr-tree/Makefile"

71+ "examples/glr/expr-tree/Expr.y"

72+ "examples/glr/expr-tree/README"

73+ "examples/glr/expr-tree/Tree.lhs"

74+ "examples/glr/expr-tree/Hugs.lhs"

75+ "examples/glr/highly-ambiguous/Main.lhs"

76+ "examples/glr/highly-ambiguous/Makefile"

77+ "examples/glr/highly-ambiguous/Expr.y"

78+ "examples/glr/highly-ambiguous/README"

79+ "examples/glr/highly-ambiguous/Hugs.lhs"

80+ "examples/glr/hidden-leftrec/Main.lhs"

81+ "examples/glr/hidden-leftrec/Makefile"

82+ "examples/glr/hidden-leftrec/Expr.y"

83+ "examples/glr/hidden-leftrec/README"

84+ "examples/glr/hidden-leftrec/Hugs.lhs"

85+ "examples/glr/expr-monad/Main.lhs"

86+ "examples/glr/expr-monad/Makefile"

87+ "examples/glr/expr-monad/Expr.y"

88+ "examples/glr/expr-monad/README"

89+ "examples/glr/expr-monad/Hugs.lhs"

90+ "examples/glr/bio-eg/Main.lhs"

91+ "examples/glr/bio-eg/Makefile"

92+ "examples/glr/bio-eg/Bio.y"

93+ "examples/glr/bio-eg/README"

94+ "examples/glr/bio-eg/1-1200.dna"

95+ "examples/glr/bio-eg/1-600.dna"

96+ "examples/glr/common/DV_lhs"

97+ "examples/glr/common/DaVinciTypes.hs"

98+ "examples/glr/packing/Main.lhs"

99+ "examples/glr/packing/Makefile"

100+ "examples/glr/packing/Expr.y"

101+ "examples/glr/packing/README"

102+ "examples/glr/packing/Hugs.lhs"

103+ "examples/PgnParser.ly"

104+ "examples/MonadTest.ly"

105+ "examples/igloo/ParserM.hs"

106+ "examples/igloo/Makefile"

107+ "examples/igloo/Parser.y"

108+ "examples/igloo/Foo.hs"

109+ "examples/igloo/README"

110+ "examples/igloo/Lexer.x"

111+ "examples/README"

112+ "examples/Calc.ly"

113+ "examples/DavesExample.ly"

114+ "examples/ErrorTest.ly"

115+ "examples/ErlParser.ly"

116+ "examples/SimonsExample.ly"

117+ "examples/LexerTest.ly"

118+ "happy.spec"

119+ "src/ARRAY-NOTES"

120+ "tests/AttrGrammar001.y"

121+ "tests/AttrGrammar002.y"

122+ "tests/Makefile"

123+ "tests/Partial.ly"

124+ "tests/Test.ly"

125+ "tests/TestMulti.ly"

126+ "tests/TestPrecedence.ly"

127+ "tests/bogus-token.y"

128+ "tests/bug001.ly"

129+ "tests/bug002.y"

130+ "tests/error001.stderr"

131+ "tests/error001.stdout"

132+ "tests/error001.y"

133+ "tests/monad001.y"

134+ "tests/monad002.ly"

135+ "tests/monaderror.y"

136+ "tests/precedence001.ly"

137+ "tests/precedence002.y"

138+ "tests/test_rules.y"

139+ "tests/issue91.y"

140+ "tests/issue93.y"

141+ "tests/issue94.y"

142+ "tests/issue95.y"

143+ "tests/monaderror-explist.y"

144+ "tests/typeclass_monad001.y"

145+ "tests/typeclass_monad002.ly"

146+ "tests/typeclass_monad_lexer.y"

147+ "tests/rank2.y"

148+ ];

149+ extraTmpFiles = [];

150+ extraDocFiles = [];

151+ };

152+ components = {

153+ exes = {

154+ "happy" = {

155+ depends = [

156+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

157+ (hsPkgs."array" or (errorHandler.buildDepError "array"))

158+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

159+ (hsPkgs."mtl" or (errorHandler.buildDepError "mtl"))

160+ ];

161+ buildable = true;

162+ modules = [

163+ "Paths_happy"

164+ "AbsSyn"

165+ "First"

166+ "GenUtils"

167+ "Grammar"

168+ "Info"

169+ "LALR"

170+ "Lexer"

171+ "ParseMonad"

172+ "Parser"

173+ "ProduceCode"

174+ "ProduceGLRCode"

175+ "NameSet"

176+ "Target"

177+ "AttrGrammar"

178+ "AttrGrammarParser"

179+ "ParamRules"

180+ "PrettyGrammar"

181+ ];

182+ hsSourceDirs = [ "src" ];

183+ mainPath = [ "Main.lhs" ];

184+ };

185+ };

186+ tests = {

187+ "tests" = {

188+ depends = [

189+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

190+ (hsPkgs."process" or (errorHandler.buildDepError "process"))

191+ ];

192+ build-tools = [

193+ (hsPkgs.buildPackages.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy")))

194+ ];

195+ buildable = true;

196+ mainPath = [ "test.hs" ];

197+ };

198+ };

199+ };

200+ } // rec { src = (pkgs.lib).mkDefault ../.; }

materialized/bootstrap/ghc882/happy-1.19.12/default.nixnew file+53

@@ -0,0 +1,53 @@

1+{

2+ pkgs = hackage:

3+ {

4+ packages = {

5+ "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;

6+ "unix".revision = (((hackage."unix")."2.7.2.2").revisions).default;

7+ "mtl".revision = (((hackage."mtl")."2.2.2").revisions).default;

8+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

9+ "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

10+ "directory".revision = (((hackage."directory")."1.3.4.0").revisions).default;

11+ "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;

12+ "bytestring".revision = (((hackage."bytestring")."0.10.10.0").revisions).default;

13+ "base".revision = (((hackage."base")."4.13.0.0").revisions).default;

14+ "time".revision = (((hackage."time")."1.9.3").revisions).default;

15+ "transformers".revision = (((hackage."transformers")."0.5.6.2").revisions).default;

16+ "filepath".revision = (((hackage."filepath")."1.4.2.1").revisions).default;

17+ "process".revision = (((hackage."process")."1.6.7.0").revisions).default;

18+ "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

19+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

20+ };

21+ compiler = {

22+ version = "8.8.2";

23+ nix-name = "ghc882";

24+ packages = {

25+ "ghc-prim" = "0.5.3";

26+ "unix" = "2.7.2.2";

27+ "mtl" = "2.2.2";

28+ "rts" = "1.0";

29+ "deepseq" = "1.4.4.0";

30+ "directory" = "1.3.4.0";

31+ "containers" = "0.6.2.1";

32+ "bytestring" = "0.10.10.0";

33+ "base" = "4.13.0.0";

34+ "time" = "1.9.3";

35+ "transformers" = "0.5.6.2";

36+ "filepath" = "1.4.2.1";

37+ "process" = "1.6.7.0";

38+ "array" = "0.5.4.0";

39+ "integer-gmp" = "1.0.2.0";

40+ };

41+ };

42+ };

43+ extras = hackage:

44+ { packages = { happy = ./.plan.nix/happy.nix; }; };

45+ modules = [

46+ ({ lib, ... }:

47+ {

48+ packages = {

49+ "happy" = { flags = { "small_base" = lib.mkOverride 900 true; }; };

50+ };

51+ })

52+ ];

53+ }

materialized/bootstrap/ghc882/hscolour/.plan.nix/hscolour.nixnew file+70

@@ -0,0 +1,70 @@

1+{ system

2+ , compiler

3+ , flags

4+ , pkgs

5+ , hsPkgs

6+ , pkgconfPkgs

7+ , errorHandler

8+ , config

9+ , ... }:

10+ {

11+ flags = {};

12+ package = {

13+ specVersion = "1.6";

14+ identifier = { name = "hscolour"; version = "1.24.4"; };

15+ license = "LicenseRef-LGPL";

16+ copyright = "2003-2017 Malcolm Wallace; 2006 Bjorn Bringert";

17+ maintainer = "Malcolm Wallace";

18+ author = "Malcolm Wallace";

19+ homepage = "http://code.haskell.org/~malcolm/hscolour/";

20+ url = "";

21+ synopsis = "Colourise Haskell code.";

22+ description = "hscolour is a small Haskell script to colourise Haskell code. It currently\nhas six output formats:\nANSI terminal codes (optionally XTerm-256colour codes),\nHTML 3.2 with <font> tags,\nHTML 4.01 with CSS,\nHTML 4.01 with CSS and mouseover annotations,\nXHTML 1.0 with inline CSS styling,\nLaTeX,\nand mIRC chat codes.";

23+ buildType = "Simple";

24+ isLocal = true;

25+ detailLevel = "FullDetails";

26+ licenseFiles = [ "LICENCE-LGPL" ];

27+ dataDir = "";

28+ dataFiles = [ "hscolour.css" "data/rgb24-example-.hscolour" ];

29+ extraSrcFiles = [];

30+ extraTmpFiles = [];

31+ extraDocFiles = [];

32+ };

33+ components = {

34+ "library" = {

35+ depends = [

36+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

37+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

38+ ];

39+ buildable = true;

40+ modules = [

41+ "Language/Haskell/HsColour"

42+ "Language/Haskell/HsColour/ANSI"

43+ "Language/Haskell/HsColour/Anchors"

44+ "Language/Haskell/HsColour/ACSS"

45+ "Language/Haskell/HsColour/CSS"

46+ "Language/Haskell/HsColour/Classify"

47+ "Language/Haskell/HsColour/ColourHighlight"

48+ "Language/Haskell/HsColour/Colourise"

49+ "Language/Haskell/HsColour/General"

50+ "Language/Haskell/HsColour/HTML"

51+ "Language/Haskell/HsColour/InlineCSS"

52+ "Language/Haskell/HsColour/LaTeX"

53+ "Language/Haskell/HsColour/MIRC"

54+ "Language/Haskell/HsColour/Options"

55+ "Language/Haskell/HsColour/Output"

56+ "Language/Haskell/HsColour/TTY"

57+ ];

58+ };

59+ exes = {

60+ "HsColour" = {

61+ depends = [

62+ (hsPkgs."base" or (errorHandler.buildDepError "base"))

63+ (hsPkgs."containers" or (errorHandler.buildDepError "containers"))

64+ ];

65+ buildable = true;

66+ mainPath = [ "HsColour.hs" ];

67+ };

68+ };

69+ };

70+ } // rec { src = (pkgs.lib).mkDefault ../.; }

materialized/bootstrap/ghc882/hscolour/default.nixnew file+33

@@ -0,0 +1,33 @@

1+{

2+ pkgs = hackage:

3+ {

4+ packages = {

5+ "ghc-prim".revision = (((hackage."ghc-prim")."0.5.3").revisions).default;

6+ "rts".revision = (((hackage."rts")."1.0").revisions).default;

7+ "deepseq".revision = (((hackage."deepseq")."1.4.4.0").revisions).default;

8+ "containers".revision = (((hackage."containers")."0.6.2.1").revisions).default;

9+ "base".revision = (((hackage."base")."4.13.0.0").revisions).default;

10+ "array".revision = (((hackage."array")."0.5.4.0").revisions).default;

11+ "integer-gmp".revision = (((hackage."integer-gmp")."1.0.2.0").revisions).default;

12+ };

13+ compiler = {

14+ version = "8.8.2";

15+ nix-name = "ghc882";

16+ packages = {

17+ "ghc-prim" = "0.5.3";

18+ "rts" = "1.0";

19+ "deepseq" = "1.4.4.0";

20+ "containers" = "0.6.2.1";

21+ "base" = "4.13.0.0";

22+ "array" = "0.5.4.0";

23+ "integer-gmp" = "1.0.2.0";

24+ };

25+ };

26+ };

27+ extras = hackage:

28+ { packages = { hscolour = ./.plan.nix/hscolour.nix; }; };

29+ modules = [

30+ ({ lib, ... }:

31+ { packages = { "hscolour" = { flags = {}; }; }; })

32+ ];

33+ }

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.10.1-x86_64-linux/ghc-pkg/dump-globalnew file+1429

@@ -0,0 +1,1429 @@

1+name: Cabal

2+version: 3.2.0.0

3+visibility: public

4+id: Cabal-3.2.0.0

5+key: Cabal-3.2.0.0

6+license: BSD-3-Clause

7+copyright: 2003-2019, Cabal Development Team (see AUTHORS file)

8+maintainer: cabal-devel@haskell.org

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

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

11+synopsis: A framework for packaging Haskell software

12+description:

13+ The Haskell Common Architecture for Building Applications and

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

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

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

17+ organizing, and cataloging Haskell libraries and tools.

18+category: Distribution

19+exposed: True

20+exposed-modules:

21+ Distribution.Backpack Distribution.Backpack.ComponentsGraph

22+ Distribution.Backpack.Configure

23+ Distribution.Backpack.ConfiguredComponent

24+ Distribution.Backpack.DescribeUnitId

25+ Distribution.Backpack.FullUnitId

26+ Distribution.Backpack.LinkedComponent

27+ Distribution.Backpack.ModSubst Distribution.Backpack.ModuleShape

28+ Distribution.Backpack.PreModuleShape Distribution.CabalSpecVersion

29+ Distribution.Compat.Binary Distribution.Compat.CharParsing

30+ Distribution.Compat.CreatePipe Distribution.Compat.DList

31+ Distribution.Compat.Directory Distribution.Compat.Environment

32+ Distribution.Compat.Exception Distribution.Compat.FilePath

33+ Distribution.Compat.Graph Distribution.Compat.Internal.TempFile

34+ Distribution.Compat.Lens Distribution.Compat.Newtype

35+ Distribution.Compat.Parsing Distribution.Compat.Prelude.Internal

36+ Distribution.Compat.ResponseFile Distribution.Compat.Semigroup

37+ Distribution.Compat.Stack Distribution.Compat.Time

38+ Distribution.Compat.Typeable Distribution.Compiler

39+ Distribution.FieldGrammar Distribution.FieldGrammar.Class

40+ Distribution.FieldGrammar.FieldDescrs

41+ Distribution.FieldGrammar.Parsec Distribution.FieldGrammar.Pretty

42+ Distribution.Fields Distribution.Fields.ConfVar

43+ Distribution.Fields.Field Distribution.Fields.Lexer

44+ Distribution.Fields.LexerMonad Distribution.Fields.ParseResult

45+ Distribution.Fields.Parser Distribution.Fields.Pretty

46+ Distribution.InstalledPackageInfo Distribution.License

47+ Distribution.Make Distribution.ModuleName Distribution.Package

48+ Distribution.PackageDescription

49+ Distribution.PackageDescription.Check

50+ Distribution.PackageDescription.Configuration

51+ Distribution.PackageDescription.FieldGrammar

52+ Distribution.PackageDescription.Parsec

53+ Distribution.PackageDescription.PrettyPrint

54+ Distribution.PackageDescription.Quirks

55+ Distribution.PackageDescription.Utils Distribution.Parsec

56+ Distribution.Parsec.Error Distribution.Parsec.FieldLineStream

57+ Distribution.Parsec.Newtypes Distribution.Parsec.Position

58+ Distribution.Parsec.Warning Distribution.Pretty Distribution.ReadE

59+ Distribution.SPDX Distribution.SPDX.License

60+ Distribution.SPDX.LicenseExceptionId

61+ Distribution.SPDX.LicenseExpression Distribution.SPDX.LicenseId

62+ Distribution.SPDX.LicenseListVersion

63+ Distribution.SPDX.LicenseReference Distribution.Simple

64+ Distribution.Simple.Bench Distribution.Simple.Build

65+ Distribution.Simple.Build.Macros

66+ Distribution.Simple.Build.PathsModule

67+ Distribution.Simple.BuildPaths Distribution.Simple.BuildTarget

68+ Distribution.Simple.BuildToolDepends Distribution.Simple.CCompiler

69+ Distribution.Simple.Command Distribution.Simple.Compiler

70+ Distribution.Simple.Configure Distribution.Simple.Doctest

71+ Distribution.Simple.Flag Distribution.Simple.GHC

72+ Distribution.Simple.GHCJS Distribution.Simple.Glob

73+ Distribution.Simple.Haddock Distribution.Simple.HaskellSuite

74+ Distribution.Simple.Hpc Distribution.Simple.Install

75+ Distribution.Simple.InstallDirs

76+ Distribution.Simple.InstallDirs.Internal

77+ Distribution.Simple.LocalBuildInfo Distribution.Simple.PackageIndex

78+ Distribution.Simple.PreProcess Distribution.Simple.PreProcess.Unlit

79+ Distribution.Simple.Program Distribution.Simple.Program.Ar

80+ Distribution.Simple.Program.Builtin Distribution.Simple.Program.Db

81+ Distribution.Simple.Program.Find Distribution.Simple.Program.GHC

82+ Distribution.Simple.Program.HcPkg Distribution.Simple.Program.Hpc

83+ Distribution.Simple.Program.Internal Distribution.Simple.Program.Ld

84+ Distribution.Simple.Program.ResponseFile

85+ Distribution.Simple.Program.Run Distribution.Simple.Program.Script

86+ Distribution.Simple.Program.Strip Distribution.Simple.Program.Types

87+ Distribution.Simple.Register Distribution.Simple.Setup

88+ Distribution.Simple.ShowBuildInfo Distribution.Simple.SrcDist

89+ Distribution.Simple.Test Distribution.Simple.Test.ExeV10

90+ Distribution.Simple.Test.LibV09 Distribution.Simple.Test.Log

91+ Distribution.Simple.UHC Distribution.Simple.UserHooks

92+ Distribution.Simple.Utils Distribution.System

93+ Distribution.TestSuite Distribution.Text

94+ Distribution.Types.AbiDependency Distribution.Types.AbiHash

95+ Distribution.Types.AnnotatedId Distribution.Types.Benchmark

96+ Distribution.Types.Benchmark.Lens

97+ Distribution.Types.BenchmarkInterface

98+ Distribution.Types.BenchmarkType Distribution.Types.BuildInfo

99+ Distribution.Types.BuildInfo.Lens Distribution.Types.BuildType

100+ Distribution.Types.Component Distribution.Types.ComponentId

101+ Distribution.Types.ComponentInclude

102+ Distribution.Types.ComponentLocalBuildInfo

103+ Distribution.Types.ComponentName

104+ Distribution.Types.ComponentRequestedSpec

105+ Distribution.Types.CondTree Distribution.Types.Condition

106+ Distribution.Types.ConfVar Distribution.Types.Dependency

107+ Distribution.Types.DependencyMap Distribution.Types.ExeDependency

108+ Distribution.Types.Executable Distribution.Types.Executable.Lens

109+ Distribution.Types.ExecutableScope Distribution.Types.ExposedModule

110+ Distribution.Types.Flag Distribution.Types.ForeignLib

111+ Distribution.Types.ForeignLib.Lens

112+ Distribution.Types.ForeignLibOption

113+ Distribution.Types.ForeignLibType

114+ Distribution.Types.GenericPackageDescription

115+ Distribution.Types.GenericPackageDescription.Lens

116+ Distribution.Types.GivenComponent

117+ Distribution.Types.HookedBuildInfo

118+ Distribution.Types.IncludeRenaming

119+ Distribution.Types.InstalledPackageInfo

120+ Distribution.Types.InstalledPackageInfo.FieldGrammar

121+ Distribution.Types.InstalledPackageInfo.Lens

122+ Distribution.Types.LegacyExeDependency Distribution.Types.Lens

123+ Distribution.Types.Library Distribution.Types.Library.Lens

124+ Distribution.Types.LibraryName Distribution.Types.LibraryVisibility

125+ Distribution.Types.LocalBuildInfo Distribution.Types.Mixin

126+ Distribution.Types.Module Distribution.Types.ModuleReexport

127+ Distribution.Types.ModuleRenaming

128+ Distribution.Types.MungedPackageId

129+ Distribution.Types.MungedPackageName

130+ Distribution.Types.PackageDescription

131+ Distribution.Types.PackageDescription.Lens

132+ Distribution.Types.PackageId Distribution.Types.PackageId.Lens

133+ Distribution.Types.PackageName Distribution.Types.PackageName.Magic

134+ Distribution.Types.PackageVersionConstraint

135+ Distribution.Types.PkgconfigDependency

136+ Distribution.Types.PkgconfigName

137+ Distribution.Types.PkgconfigVersion

138+ Distribution.Types.PkgconfigVersionRange

139+ Distribution.Types.SetupBuildInfo

140+ Distribution.Types.SetupBuildInfo.Lens

141+ Distribution.Types.SourceRepo Distribution.Types.SourceRepo.Lens

142+ Distribution.Types.TargetInfo Distribution.Types.TestSuite

143+ Distribution.Types.TestSuite.Lens

144+ Distribution.Types.TestSuiteInterface Distribution.Types.TestType

145+ Distribution.Types.UnitId Distribution.Types.UnqualComponentName

146+ Distribution.Types.Version Distribution.Types.VersionInterval

147+ Distribution.Types.VersionRange

148+ Distribution.Types.VersionRange.Internal Distribution.Utils.Generic

149+ Distribution.Utils.IOData Distribution.Utils.LogProgress

150+ Distribution.Utils.MD5 Distribution.Utils.MapAccum

151+ Distribution.Utils.NubList Distribution.Utils.Progress

152+ Distribution.Utils.ShortText Distribution.Utils.Structured

153+ Distribution.Verbosity Distribution.Verbosity.Internal

154+ Distribution.Version Language.Haskell.Extension

155+hidden-modules:

156+ Distribution.Backpack.PreExistingComponent

157+ Distribution.Backpack.ReadyComponent Distribution.Backpack.MixLink

158+ Distribution.Backpack.ModuleScope Distribution.Backpack.UnifyM

159+ Distribution.Backpack.Id Distribution.Utils.UnionFind

160+ Distribution.Utils.Base62 Distribution.Compat.Async

161+ Distribution.Compat.CopyFile Distribution.Compat.GetShortPathName

162+ Distribution.Compat.MonadFail Distribution.Compat.Prelude

163+ Distribution.Compat.SnocList Distribution.GetOpt Distribution.Lex

164+ Distribution.Utils.String Distribution.Simple.GHC.EnvironmentParser

165+ Distribution.Simple.GHC.Internal Distribution.Simple.GHC.ImplInfo

166+ Distribution.Simple.Utils.Json Paths_Cabal

167+import-dirs:

168+library-dirs:

169+dynamic-library-dirs:

170+data-dir:

171+hs-libraries: HSCabal-3.2.0.0

172+depends:

173+ array-0.5.4.0 base-4.14.0.0 binary-0.8.8.0 bytestring-0.10.10.0

174+ containers-0.6.2.1 deepseq-1.4.4.0 directory-1.3.6.0

175+ filepath-1.4.2.1 mtl-2.2.2 parsec-3.1.14.0 pretty-1.1.3.6

176+ process-1.6.8.2 text-1.2.3.2 time-1.9.3 transformers-0.5.6.2

177+ unix-2.7.2.2

178+haddock-interfaces:

179+haddock-html:

180+---

181+name: array

182+version: 0.5.4.0

183+visibility: public

184+id: array-0.5.4.0

185+key: array-0.5.4.0

186+license: BSD-3-Clause

187+maintainer: libraries@haskell.org

188+synopsis: Mutable and immutable arrays

189+description:

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

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

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

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

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

195+category: Data Structures

196+exposed: True

197+exposed-modules:

198+ Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO

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

200+ Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe

201+ Data.Array.Storable Data.Array.Storable.Internals

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

203+import-dirs:

204+library-dirs:

205+dynamic-library-dirs:

206+data-dir:

207+hs-libraries: HSarray-0.5.4.0

208+depends: base-4.14.0.0

209+haddock-interfaces:

210+haddock-html:

211+---

212+name: base

213+version: 4.14.0.0

214+visibility: public

215+id: base-4.14.0.0

216+key: base-4.14.0.0

217+license: BSD-3-Clause

218+maintainer: libraries@haskell.org

219+synopsis: Basic libraries

220+description:

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

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

223+ structures to parsing combinators and debugging utilities.

224+category: Prelude

225+exposed: True

226+exposed-modules:

227+ Control.Applicative Control.Arrow Control.Category

228+ Control.Concurrent Control.Concurrent.Chan Control.Concurrent.MVar

229+ Control.Concurrent.QSem Control.Concurrent.QSemN Control.Exception

230+ Control.Exception.Base Control.Monad Control.Monad.Fail

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

232+ Control.Monad.ST Control.Monad.ST.Lazy Control.Monad.ST.Lazy.Safe

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

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

235+ Data.Bifoldable Data.Bifunctor Data.Bitraversable Data.Bits

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

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

238+ Data.Functor Data.Functor.Classes Data.Functor.Compose

239+ Data.Functor.Const Data.Functor.Contravariant Data.Functor.Identity

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

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

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

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

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

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

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

247+ Foreign.C.Types Foreign.Concurrent Foreign.ForeignPtr

248+ Foreign.ForeignPtr.Safe Foreign.ForeignPtr.Unsafe Foreign.Marshal

249+ Foreign.Marshal.Alloc Foreign.Marshal.Array Foreign.Marshal.Error

250+ Foreign.Marshal.Pool Foreign.Marshal.Safe Foreign.Marshal.Unsafe

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

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

253+ GHC.Conc GHC.Conc.IO GHC.Conc.Signal GHC.Conc.Sync

254+ GHC.ConsoleHandler GHC.Constants GHC.Desugar GHC.Enum

255+ GHC.Environment GHC.Err GHC.Event GHC.Exception GHC.Exception.Type

256+ GHC.ExecutionStack GHC.ExecutionStack.Internal GHC.Exts

257+ GHC.Fingerprint GHC.Fingerprint.Type GHC.Float

258+ GHC.Float.ConversionUtils GHC.Float.RealFracMethods GHC.Foreign

259+ GHC.ForeignPtr GHC.GHCi GHC.GHCi.Helpers GHC.Generics GHC.IO

260+ GHC.IO.Buffer GHC.IO.BufferedIO GHC.IO.Device GHC.IO.Encoding

261+ GHC.IO.Encoding.CodePage GHC.IO.Encoding.Failure

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

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

264+ GHC.IO.Exception GHC.IO.FD GHC.IO.Handle GHC.IO.Handle.FD

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

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

267+ GHC.IORef GHC.Int GHC.Ix GHC.List GHC.MVar GHC.Maybe GHC.Natural

268+ GHC.Num GHC.OldList GHC.OverloadedLabels GHC.Pack GHC.Profiling

269+ GHC.Ptr GHC.RTS.Flags GHC.Read GHC.Real GHC.Records

270+ GHC.ResponseFile GHC.ST GHC.STRef GHC.Show GHC.Stable

271+ GHC.StableName GHC.Stack GHC.Stack.CCS GHC.Stack.Types

272+ GHC.StaticPtr GHC.Stats GHC.Storable GHC.TopHandler GHC.TypeLits

273+ GHC.TypeNats GHC.Unicode GHC.Weak GHC.Word Numeric Numeric.Natural

274+ Prelude System.CPUTime System.Console.GetOpt System.Environment

275+ System.Environment.Blank System.Exit System.IO System.IO.Error

276+ System.IO.Unsafe System.Info System.Mem System.Mem.StableName

277+ System.Mem.Weak System.Posix.Internals System.Posix.Types

278+ System.Timeout Text.ParserCombinators.ReadP

279+ Text.ParserCombinators.ReadPrec Text.Printf Text.Read Text.Read.Lex

280+ Text.Show Text.Show.Functions Type.Reflection

281+ Type.Reflection.Unsafe Unsafe.Coerce

282+hidden-modules:

283+ Control.Monad.ST.Imp Control.Monad.ST.Lazy.Imp Data.Functor.Utils

284+ Data.OldList Data.Semigroup.Internal Data.Typeable.Internal

285+ Foreign.ForeignPtr.Imp GHC.IO.Handle.Lock.Common

286+ GHC.IO.Handle.Lock.Flock GHC.IO.Handle.Lock.LinuxOFD

287+ GHC.IO.Handle.Lock.NoOp GHC.IO.Handle.Lock.Windows

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

289+ System.CPUTime.Utils GHC.Event.Arr GHC.Event.Array

290+ GHC.Event.Control GHC.Event.EPoll GHC.Event.IntTable

291+ GHC.Event.Internal GHC.Event.KQueue GHC.Event.Manager GHC.Event.PSQ

292+ GHC.Event.Poll GHC.Event.Thread GHC.Event.TimerManager

293+ GHC.Event.Unique System.CPUTime.Posix.ClockGetTime

294+ System.CPUTime.Posix.Times System.CPUTime.Posix.RUsage

295+ System.CPUTime.Unsupported

296+import-dirs:

297+library-dirs:

298+dynamic-library-dirs:

299+data-dir:

300+hs-libraries: HSbase-4.14.0.0

301+include-dirs:

302+includes: HsBase.h

303+depends: ghc-prim-0.6.1 integer-gmp-1.0.3.0 rts

304+haddock-interfaces:

305+haddock-html:

306+---

307+name: binary

308+version: 0.8.8.0

309+visibility: public

310+id: binary-0.8.8.0

311+key: binary-0.8.8.0

312+license: BSD-3-Clause

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

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

315+stability: provisional

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

317+synopsis:

318+ Binary serialisation for Haskell values using lazy ByteStrings

319+description:

320+ Efficient, pure binary serialisation using lazy ByteStrings.

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

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

323+ The format used can be automatically generated, or

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

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

326+ so this library should be suitable for high performance

327+ scenarios.

328+category: Data, Parsing

329+exposed: True

330+exposed-modules:

331+ Data.Binary Data.Binary.Builder Data.Binary.Get

332+ Data.Binary.Get.Internal Data.Binary.Put

333+hidden-modules:

334+ Data.Binary.Class Data.Binary.Internal Data.Binary.Generic

335+ Data.Binary.FloatCast

336+import-dirs:

337+library-dirs:

338+dynamic-library-dirs:

339+data-dir:

340+hs-libraries: HSbinary-0.8.8.0

341+depends:

342+ array-0.5.4.0 base-4.14.0.0 bytestring-0.10.10.0 containers-0.6.2.1

343+haddock-interfaces:

344+haddock-html:

345+---

346+name: bytestring

347+version: 0.10.10.0

348+visibility: public

349+id: bytestring-0.10.10.0

350+key: bytestring-0.10.10.0

351+license: BSD-3-Clause

352+copyright:

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

354+ (c) Duncan Coutts 2006-2015,

355+ (c) David Roundy 2003-2005,

356+ (c) Jasper Van der Jeugt 2010,

357+ (c) Simon Meier 2010-2013.

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

359+author:

360+ Don Stewart,

361+ Duncan Coutts

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

363+synopsis:

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

365+description:

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

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

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

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

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

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

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

373+ Two 'ByteString' variants are provided:

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

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

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

377+ suitable for I\/O streaming tasks.

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

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

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

381+ and network protocols).

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

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

384+ serialisation or pretty printing.

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

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

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

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

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

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

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

392+ > import qualified Data.ByteString as BS

393+category: Data

394+exposed: True

395+exposed-modules:

396+ Data.ByteString Data.ByteString.Builder

397+ Data.ByteString.Builder.Extra Data.ByteString.Builder.Internal

398+ Data.ByteString.Builder.Prim Data.ByteString.Builder.Prim.Internal

399+ Data.ByteString.Char8 Data.ByteString.Internal Data.ByteString.Lazy

400+ Data.ByteString.Lazy.Builder Data.ByteString.Lazy.Builder.ASCII

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

402+ Data.ByteString.Lazy.Internal Data.ByteString.Short

403+ Data.ByteString.Short.Internal Data.ByteString.Unsafe

404+hidden-modules:

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

406+ Data.ByteString.Builder.Prim.ASCII

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

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

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

410+import-dirs:

411+library-dirs:

412+dynamic-library-dirs:

413+data-dir:

414+hs-libraries: HSbytestring-0.10.10.0

415+include-dirs:

416+includes: fpstring.h

417+depends:

418+ base-4.14.0.0 deepseq-1.4.4.0 ghc-prim-0.6.1 integer-gmp-1.0.3.0

419+haddock-interfaces:

420+haddock-html:

421+---

422+name: containers

423+version: 0.6.2.1

424+visibility: public

425+id: containers-0.6.2.1

426+key: containers-0.6.2.1

427+license: BSD-3-Clause

428+maintainer: libraries@haskell.org

429+synopsis: Assorted concrete container types

430+description:

431+ This package contains efficient general-purpose implementations

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

433+ trees, and graphs.

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

435+ operations see the [containers

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

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

438+ remains valid even if structures are shared.

439+category: Data Structures

440+exposed: True

441+exposed-modules:

442+ Data.Containers.ListUtils Data.Graph Data.IntMap

443+ Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy

444+ Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict

445+ Data.IntMap.Strict.Internal Data.IntSet Data.IntSet.Internal

446+ Data.Map Data.Map.Internal Data.Map.Internal.Debug Data.Map.Lazy

447+ Data.Map.Merge.Lazy Data.Map.Merge.Strict Data.Map.Strict

448+ Data.Map.Strict.Internal Data.Sequence Data.Sequence.Internal

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

450+ Utils.Containers.Internal.BitQueue

451+ Utils.Containers.Internal.BitUtil

452+ Utils.Containers.Internal.StrictPair

453+hidden-modules:

454+ Utils.Containers.Internal.State

455+ Utils.Containers.Internal.StrictMaybe

456+ Utils.Containers.Internal.PtrEquality

457+ Utils.Containers.Internal.Coercions

458+ Utils.Containers.Internal.TypeError

459+ Data.Map.Internal.DeprecatedShowTree

460+ Data.IntMap.Internal.DeprecatedDebug

461+import-dirs:

462+library-dirs:

463+dynamic-library-dirs:

464+data-dir:

465+hs-libraries: HScontainers-0.6.2.1

466+depends: array-0.5.4.0 base-4.14.0.0 deepseq-1.4.4.0

467+haddock-interfaces:

468+haddock-html:

469+---

470+name: deepseq

471+version: 1.4.4.0

472+visibility: public

473+id: deepseq-1.4.4.0

474+key: deepseq-1.4.4.0

475+license: BSD-3-Clause

476+maintainer: libraries@haskell.org

477+synopsis: Deep evaluation of data structures

478+description:

479+ This package provides methods for fully evaluating data structures

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

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

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

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

484+ wrong thread.

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

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

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

488+ components) which defines strategies for fully evaluating different

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

490+ details.

491+category: Control

492+exposed: True

493+exposed-modules: Control.DeepSeq

494+hidden-modules: Control.DeepSeq.BackDoor

495+import-dirs:

496+library-dirs:

497+dynamic-library-dirs:

498+data-dir:

499+hs-libraries: HSdeepseq-1.4.4.0

500+depends: array-0.5.4.0 base-4.14.0.0

501+haddock-interfaces:

502+haddock-html:

503+---

504+name: directory

505+version: 1.3.6.0

506+visibility: public

507+id: directory-1.3.6.0

508+key: directory-1.3.6.0

509+license: BSD-3-Clause

510+maintainer: libraries@haskell.org

511+synopsis: Platform-agnostic library for filesystem operations

512+description:

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

514+ directories in a portable way.

515+category: System

516+exposed: True

517+exposed-modules:

518+ System.Directory System.Directory.Internal

519+ System.Directory.Internal.Prelude

520+hidden-modules:

521+ System.Directory.Internal.C_utimensat

522+ System.Directory.Internal.Common System.Directory.Internal.Config

523+ System.Directory.Internal.Posix System.Directory.Internal.Windows

524+import-dirs:

525+library-dirs:

526+dynamic-library-dirs:

527+data-dir:

528+hs-libraries: HSdirectory-1.3.6.0

529+depends:

530+ base-4.14.0.0 filepath-1.4.2.1 time-1.9.3 unix-2.7.2.2

531+haddock-interfaces:

532+haddock-html:

533+---

534+name: exceptions

535+version: 0.10.4

536+visibility: public

537+id: exceptions-0.10.4

538+key: exceptions-0.10.4

539+license: BSD-3-Clause

540+copyright:

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

544+author: Edward A. Kmett

545+stability: provisional

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

547+synopsis: Extensible optionally-pure exceptions

548+description: Extensible optionally-pure exceptions.

549+category: Control, Exceptions, Monad

550+exposed: True

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

552+import-dirs:

553+library-dirs:

554+dynamic-library-dirs:

555+data-dir:

556+hs-libraries: HSexceptions-0.10.4

557+depends:

558+ base-4.14.0.0 mtl-2.2.2 stm-2.5.0.0 template-haskell-2.16.0.0

559+ transformers-0.5.6.2

560+haddock-interfaces:

561+haddock-html:

562+---

563+name: filepath

564+version: 1.4.2.1

565+visibility: public

566+id: filepath-1.4.2.1

567+key: filepath-1.4.2.1

568+license: BSD-3-Clause

569+copyright: Neil Mitchell 2005-2018

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

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

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

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

574+description:

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

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

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

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

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

580+category: System

581+exposed: True

582+exposed-modules:

583+ System.FilePath System.FilePath.Posix System.FilePath.Windows

584+import-dirs:

585+library-dirs:

586+dynamic-library-dirs:

587+data-dir:

588+hs-libraries: HSfilepath-1.4.2.1

589+depends: base-4.14.0.0

590+haddock-interfaces:

591+haddock-html:

592+---

593+name: ghc-boot

594+version: 8.10.1

595+visibility: public

596+id: ghc-boot-8.10.1

597+key: ghc-boot-8.10.1

598+license: BSD-3-Clause

599+maintainer: ghc-devs@haskell.org

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

601+description:

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

603+ libraries.

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

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

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

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

608+ suitable for modifying GHC package databases.

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

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

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

612+category: GHC

613+exposed: True

614+exposed-modules:

615+ GHC.BaseDir GHC.ForeignSrcLang GHC.HandleEncoding

616+ GHC.LanguageExtensions GHC.PackageDb GHC.Platform GHC.Platform.Host

617+ GHC.Serialized GHC.Settings GHC.UniqueSubdir GHC.Version

618+import-dirs:

619+library-dirs:

620+dynamic-library-dirs:

621+data-dir:

622+hs-libraries: HSghc-boot-8.10.1

623+depends:

624+ base-4.14.0.0 binary-0.8.8.0 bytestring-0.10.10.0

625+ containers-0.6.2.1 directory-1.3.6.0 filepath-1.4.2.1

626+ ghc-boot-th-8.10.1

627+haddock-interfaces:

628+haddock-html:

629+---

630+name: ghc-boot-th

631+version: 8.10.1

632+visibility: public

633+id: ghc-boot-th-8.10.1

634+key: ghc-boot-th-8.10.1

635+license: BSD-3-Clause

636+maintainer: ghc-devs@haskell.org

637+synopsis:

638+ Shared functionality between GHC and the @template-haskell@

639+ library

640+description:

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

642+ @template-haskell@ libraries.

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

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

645+ be depended upon by user code.

646+category: GHC

647+exposed: True

648+exposed-modules:

649+ GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme

650+import-dirs:

651+library-dirs:

652+dynamic-library-dirs:

653+data-dir:

654+hs-libraries: HSghc-boot-th-8.10.1

655+depends: base-4.14.0.0

656+haddock-interfaces:

657+haddock-html:

658+---

659+name: ghc-compact

660+version: 0.1.0.0

661+visibility: public

662+id: ghc-compact-0.1.0.0

663+key: ghc-compact-0.1.0.0

664+license: BSD-3-Clause

665+maintainer: libraries@haskell.org

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

667+description:

668+ This package provides minimal functionality for working with

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

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

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

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

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

674+ released).

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

676+ which allows efficient serialization and deserialization of structs

677+ for distributed computing.

678+category: Data

679+exposed: True

680+exposed-modules: GHC.Compact GHC.Compact.Serialized

681+import-dirs:

682+library-dirs:

683+dynamic-library-dirs:

684+data-dir:

685+hs-libraries: HSghc-compact-0.1.0.0

686+depends: base-4.14.0.0 bytestring-0.10.10.0 ghc-prim-0.6.1

687+haddock-interfaces:

688+haddock-html:

689+---

690+name: ghc-heap

691+version: 8.10.1

692+visibility: public

693+id: ghc-heap-8.10.1

694+key: ghc-heap-8.10.1

695+license: BSD-3-Clause

696+maintainer: libraries@haskell.org

697+synopsis: Functions for walking GHC's heap

698+description:

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

700+ and retrieving information about those data structures.

701+category: GHC

702+exposed: True

703+exposed-modules:

704+ GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures

705+ GHC.Exts.Heap.Constants GHC.Exts.Heap.InfoTable

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

707+ GHC.Exts.Heap.Utils

708+import-dirs:

709+library-dirs:

710+dynamic-library-dirs:

711+data-dir:

712+hs-libraries: HSghc-heap-8.10.1

713+depends: base-4.14.0.0 ghc-prim-0.6.1 rts

714+haddock-interfaces:

715+haddock-html:

716+---

717+name: ghc-prim

718+version: 0.6.1

719+visibility: public

720+id: ghc-prim-0.6.1

721+key: ghc-prim-0.6.1

722+license: BSD-3-Clause

723+maintainer: libraries@haskell.org

724+synopsis: GHC primitives

725+description:

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

727+category: GHC

728+exposed: True

729+exposed-modules:

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

731+ GHC.Prim.Ext GHC.PrimopWrappers GHC.Tuple GHC.Types GHC.Prim

732+import-dirs:

733+library-dirs:

734+dynamic-library-dirs:

735+data-dir:

736+hs-libraries: HSghc-prim-0.6.1

737+depends: rts

738+haddock-interfaces:

739+haddock-html:

740+---

741+name: ghci

742+version: 8.10.1

743+visibility: public

744+id: ghci-8.10.1

745+key: ghci-8.10.1

746+license: BSD-3-Clause

747+maintainer: ghc-devs@haskell.org

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

749+description:

750+ This library offers interfaces which mediate interactions between the

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

752+ backend.

753+category: GHC

754+exposed: True

755+exposed-modules:

756+ GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI

757+ GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes

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

759+ GHCi.TH.Binary SizedSeq

760+import-dirs:

761+library-dirs:

762+dynamic-library-dirs:

763+data-dir:

764+hs-libraries: HSghci-8.10.1

765+include-dirs:

766+depends:

767+ array-0.5.4.0 base-4.14.0.0 binary-0.8.8.0 bytestring-0.10.10.0

768+ containers-0.6.2.1 deepseq-1.4.4.0 filepath-1.4.2.1 ghc-boot-8.10.1

769+ ghc-boot-th-8.10.1 ghc-heap-8.10.1 template-haskell-2.16.0.0

770+ transformers-0.5.6.2 unix-2.7.2.2

771+haddock-interfaces:

772+haddock-html:

773+---

774+name: haskeline

775+version: 0.8.0.0

776+visibility: public

777+id: haskeline-0.8.0.0

778+key: haskeline-0.8.0.0

779+license: BSD-3-Clause

780+copyright: (c) Judah Jacobson

781+maintainer: Judah Jacobson <judah.jacobson@gmail.com>

782+author: Judah Jacobson

783+stability: Stable

784+homepage: https://github.com/judah/haskeline

785+synopsis:

786+ A command-line interface for user input, written in Haskell.

787+description:

788+ Haskeline provides a user interface for line input in command-line

789+ programs. This library is similar in purpose to readline, but since

790+ it is written in Haskell it is (hopefully) more easily used in other

791+ Haskell programs.

792+ Haskeline runs both on POSIX-compatible systems and on Windows.

793+category: User Interfaces

794+exposed: True

795+exposed-modules:

796+ System.Console.Haskeline System.Console.Haskeline.Completion

797+ System.Console.Haskeline.History System.Console.Haskeline.IO

798+hidden-modules:

799+ System.Console.Haskeline.Backend

800+ System.Console.Haskeline.Backend.WCWidth

801+ System.Console.Haskeline.Command

802+ System.Console.Haskeline.Command.Completion

803+ System.Console.Haskeline.Command.History

804+ System.Console.Haskeline.Command.KillRing

805+ System.Console.Haskeline.Directory System.Console.Haskeline.Emacs

806+ System.Console.Haskeline.InputT System.Console.Haskeline.Key

807+ System.Console.Haskeline.LineState System.Console.Haskeline.Monads

808+ System.Console.Haskeline.Prefs System.Console.Haskeline.Recover

809+ System.Console.Haskeline.RunCommand System.Console.Haskeline.Term

810+ System.Console.Haskeline.Command.Undo System.Console.Haskeline.Vi

811+ System.Console.Haskeline.Backend.Posix

812+ System.Console.Haskeline.Backend.Posix.Encoder

813+ System.Console.Haskeline.Backend.DumbTerm

814+import-dirs:

815+library-dirs:

816+dynamic-library-dirs:

817+data-dir:

818+hs-libraries: HShaskeline-0.8.0.0

819+depends:

820+ base-4.14.0.0 bytestring-0.10.10.0 containers-0.6.2.1

821+ directory-1.3.6.0 exceptions-0.10.4 filepath-1.4.2.1

822+ process-1.6.8.2 stm-2.5.0.0 transformers-0.5.6.2 unix-2.7.2.2

823+haddock-interfaces:

824+haddock-html:

825+---

826+name: hpc

827+version: 0.6.1.0

828+visibility: public

829+id: hpc-0.6.1.0

830+key: hpc-0.6.1.0

831+license: BSD-3-Clause

832+maintainer: ghc-devs@haskell.org

833+author: Andy Gill

834+synopsis: Code Coverage Library for Haskell

835+description:

836+ This package provides the code coverage library for Haskell.

837+ See <http://www.haskell.org/haskellwiki/Haskell_program_coverage> for more

838+ information.

839+category: Control

840+exposed: True

841+exposed-modules:

842+ Trace.Hpc.Mix Trace.Hpc.Reflect Trace.Hpc.Tix Trace.Hpc.Util

843+import-dirs:

844+library-dirs:

845+dynamic-library-dirs:

846+data-dir:

847+hs-libraries: HShpc-0.6.1.0

848+depends:

849+ base-4.14.0.0 containers-0.6.2.1 deepseq-1.4.4.0 directory-1.3.6.0

850+ filepath-1.4.2.1 time-1.9.3

851+haddock-interfaces:

852+haddock-html:

853+---

854+name: integer-gmp

855+version: 1.0.3.0

856+visibility: public

857+id: integer-gmp-1.0.3.0

858+key: integer-gmp-1.0.3.0

859+license: BSD-3-Clause

860+maintainer: hvr@gnu.org

861+author: Herbert Valerio Riedel

862+synopsis: Integer library based on GMP

863+description:

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

865+ 'Integer' type based on the

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

867+ This package provides access to the internal representation of

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

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

870+category: Numeric, Algebra

871+exposed: True

872+exposed-modules:

873+ GHC.Integer GHC.Integer.GMP.Internals GHC.Integer.Logarithms

874+ GHC.Integer.Logarithms.Internals

875+hidden-modules: GHC.Integer.Type

876+import-dirs:

877+library-dirs:

878+dynamic-library-dirs:

879+data-dir:

880+hs-libraries: HSinteger-gmp-1.0.3.0

881+extra-libraries: gmp

882+include-dirs:

883+depends: ghc-prim-0.6.1

884+haddock-interfaces:

885+haddock-html:

886+---

887+name: libiserv

888+version: 8.10.1

889+visibility: public

890+id: libiserv-8.10.1

891+key: libiserv-8.10.1

892+license: BSD-3-Clause

893+copyright: XXX

894+maintainer: XXX

895+author: XXX

896+synopsis: Provides shared functionality between iserv and iserv-proxy

897+category: Development

898+exposed: True

899+exposed-modules: GHCi.Utils Lib

900+import-dirs:

901+library-dirs:

902+dynamic-library-dirs:

903+data-dir:

904+hs-libraries: HSlibiserv-8.10.1

905+depends:

906+ base-4.14.0.0 binary-0.8.8.0 bytestring-0.10.10.0

907+ containers-0.6.2.1 deepseq-1.4.4.0 ghci-8.10.1 unix-2.7.2.2

908+haddock-interfaces:

909+haddock-html:

910+---

911+name: mtl

912+version: 2.2.2

913+visibility: public

914+id: mtl-2.2.2

915+key: mtl-2.2.2

916+license: BSD-3-Clause

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

918+author: Andy Gill

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

920+synopsis: Monad classes, using functional dependencies

921+description:

922+ Monad classes using functional dependencies, with instances

923+ for various monad transformers, inspired by the paper

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

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

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

927+category: Control

928+exposed: True

929+exposed-modules:

930+ Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error

931+ Control.Monad.Error.Class Control.Monad.Except

932+ Control.Monad.Identity Control.Monad.List Control.Monad.RWS

933+ Control.Monad.RWS.Class Control.Monad.RWS.Lazy

934+ Control.Monad.RWS.Strict Control.Monad.Reader

935+ Control.Monad.Reader.Class Control.Monad.State

936+ Control.Monad.State.Class Control.Monad.State.Lazy

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

938+ Control.Monad.Writer.Class Control.Monad.Writer.Lazy

939+ Control.Monad.Writer.Strict

940+import-dirs:

941+library-dirs:

942+dynamic-library-dirs:

943+data-dir:

944+hs-libraries: HSmtl-2.2.2

945+depends: base-4.14.0.0 transformers-0.5.6.2

946+haddock-interfaces:

947+haddock-html:

948+---

949+name: parsec

950+version: 3.1.14.0

951+visibility: public

952+id: parsec-3.1.14.0

953+key: parsec-3.1.14.0

954+license: BSD-3-Clause

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

956+author:

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

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

959+synopsis: Monadic parser combinators

960+description:

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

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

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

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

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

966+ input stream type.

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

968+ defaults for parsing 'Char'acter data.

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

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

971+ the future.

972+category: Parsing

973+exposed: True

974+exposed-modules:

975+ Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy

976+ Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error

977+ Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm

978+ Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String

979+ Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token

980+ Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char

981+ Text.ParserCombinators.Parsec.Combinator

982+ Text.ParserCombinators.Parsec.Error

983+ Text.ParserCombinators.Parsec.Expr

984+ Text.ParserCombinators.Parsec.Language

985+ Text.ParserCombinators.Parsec.Perm

986+ Text.ParserCombinators.Parsec.Pos

987+ Text.ParserCombinators.Parsec.Prim

988+ Text.ParserCombinators.Parsec.Token

989+import-dirs:

990+library-dirs:

991+dynamic-library-dirs:

992+data-dir:

993+hs-libraries: HSparsec-3.1.14.0

994+depends:

995+ base-4.14.0.0 bytestring-0.10.10.0 mtl-2.2.2 text-1.2.3.2

996+haddock-interfaces:

997+haddock-html:

998+---

999+name: pretty

1000+version: 1.1.3.6

1001+visibility: public

1002+id: pretty-1.1.3.6

1003+key: pretty-1.1.3.6

1004+license: BSD-3-Clause

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

1006+stability: Stable

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

1008+synopsis: Pretty-printing library

1009+description:

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

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

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

1013+ tools.

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

1015+ been heavily modified by Simon Peyton Jones.

1016+category: Text

1017+exposed: True

1018+exposed-modules:

1019+ Text.PrettyPrint Text.PrettyPrint.Annotated

1020+ Text.PrettyPrint.Annotated.HughesPJ

1021+ Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ

1022+ Text.PrettyPrint.HughesPJClass

1023+import-dirs:

1024+library-dirs:

1025+dynamic-library-dirs:

1026+data-dir:

1027+hs-libraries: HSpretty-1.1.3.6

1028+depends: base-4.14.0.0 deepseq-1.4.4.0 ghc-prim-0.6.1

1029+haddock-interfaces:

1030+haddock-html:

1031+---

1032+name: process

1033+version: 1.6.8.2

1034+visibility: public

1035+id: process-1.6.8.2

1036+key: process-1.6.8.2

1037+license: BSD-3-Clause

1038+maintainer: libraries@haskell.org

1039+synopsis: Process libraries

1040+description:

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

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

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

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

1045+ read more about it at

1046+ <https://github.com/fpco/typed-process/#readme>.

1047+category: System

1048+exposed: True

1049+exposed-modules: System.Cmd System.Process System.Process.Internals

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

1051+import-dirs:

1052+library-dirs:

1053+dynamic-library-dirs:

1054+data-dir:

1055+hs-libraries: HSprocess-1.6.8.2

1056+include-dirs:

1057+includes: runProcess.h

1058+depends:

1059+ base-4.14.0.0 deepseq-1.4.4.0 directory-1.3.6.0 filepath-1.4.2.1

1060+ unix-2.7.2.2

1061+haddock-interfaces:

1062+haddock-html:

1063+---

1064+name: stm

1065+version: 2.5.0.0

1066+visibility: public

1067+id: stm-2.5.0.0

1068+key: stm-2.5.0.0

1069+license: BSD-3-Clause

1070+maintainer: libraries@haskell.org

1071+homepage: https://wiki.haskell.org/Software_transactional_memory

1072+synopsis: Software Transactional Memory

1073+description:

1074+ Software Transactional Memory, or STM, is an abstraction for

1075+ concurrent communication. The main benefits of STM are

1076+ /composability/ and /modularity/. That is, using STM you can write

1077+ concurrent abstractions that can be easily composed with any other

1078+ abstraction built using STM, without exposing the details of how

1079+ your abstraction ensures safety. This is typically not the case

1080+ with other forms of concurrent communication, such as locks or

1081+ 'MVar's.

1082+category: Concurrency

1083+exposed: True

1084+exposed-modules:

1085+ Control.Concurrent.STM Control.Concurrent.STM.TArray

1086+ Control.Concurrent.STM.TBQueue Control.Concurrent.STM.TChan

1087+ Control.Concurrent.STM.TMVar Control.Concurrent.STM.TQueue

1088+ Control.Concurrent.STM.TSem Control.Concurrent.STM.TVar

1089+ Control.Monad.STM

1090+hidden-modules: Control.Sequential.STM

1091+import-dirs:

1092+library-dirs:

1093+dynamic-library-dirs:

1094+data-dir:

1095+hs-libraries: HSstm-2.5.0.0

1096+depends: array-0.5.4.0 base-4.14.0.0

1097+haddock-interfaces:

1098+haddock-html:

1099+---

1100+name: template-haskell

1101+version: 2.16.0.0

1102+visibility: public

1103+id: template-haskell-2.16.0.0

1104+key: template-haskell-2.16.0.0

1105+license: BSD-3-Clause

1106+maintainer: libraries@haskell.org

1107+synopsis: Support library for Template Haskell

1108+description:

1109+ This package provides modules containing facilities for manipulating

1110+ Haskell source code using Template Haskell.

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

1112+ information.

1113+category: Template Haskell

1114+exposed: True

1115+exposed-modules:

1116+ Language.Haskell.TH Language.Haskell.TH.LanguageExtensions

1117+ Language.Haskell.TH.Lib Language.Haskell.TH.Lib.Internal

1118+ Language.Haskell.TH.Ppr Language.Haskell.TH.PprLib

1119+ Language.Haskell.TH.Quote Language.Haskell.TH.Syntax

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

1121+import-dirs:

1122+library-dirs:

1123+dynamic-library-dirs:

1124+data-dir:

1125+hs-libraries: HStemplate-haskell-2.16.0.0

1126+depends:

1127+ base-4.14.0.0 ghc-boot-th-8.10.1 ghc-prim-0.6.1 pretty-1.1.3.6

1128+haddock-interfaces:

1129+haddock-html:

1130+---

1131+name: text

1132+version: 1.2.3.2

1133+visibility: public

1134+id: text-1.2.3.2

1135+key: text-1.2.3.2

1136+license: BSD-2-Clause

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

1138+maintainer:

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

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

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

1142+synopsis: An efficient packed Unicode text type.

1143+description:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1158+ clashes with Prelude functions, e.g.

1159+ > import qualified Data.Text as T

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

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

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

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

1164+ based on the well-respected and liberally

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

1166+category: Data, Text

1167+exposed: True

1168+exposed-modules:

1169+ Data.Text Data.Text.Array Data.Text.Encoding

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

1171+ Data.Text.Internal Data.Text.Internal.Builder

1172+ Data.Text.Internal.Builder.Functions

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

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

1175+ Data.Text.Internal.Encoding.Fusion

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

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

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

1179+ Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping

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

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

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

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

1184+ Data.Text.Internal.Private Data.Text.Internal.Read

1185+ Data.Text.Internal.Search Data.Text.Internal.Unsafe

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

1187+ Data.Text.Lazy Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int

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

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

1190+ Data.Text.Read Data.Text.Unsafe

1191+hidden-modules: Data.Text.Show

1192+import-dirs:

1193+library-dirs:

1194+dynamic-library-dirs:

1195+data-dir:

1196+hs-libraries: HStext-1.2.3.2

1197+depends:

1198+ array-0.5.4.0 base-4.14.0.0 binary-0.8.8.0 bytestring-0.10.10.0

1199+ deepseq-1.4.4.0 ghc-prim-0.6.1 integer-gmp-1.0.3.0

1200+haddock-interfaces:

1201+haddock-html:

1202+---

1203+name: time

1204+version: 1.9.3

1205+visibility: public

1206+id: time-1.9.3

1207+key: time-1.9.3

1208+license: BSD-3-Clause

1209+maintainer: <ashley@semantic.org>

1210+author: Ashley Yakeley

1211+stability: stable

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

1213+synopsis: A time library

1214+description: Time, clocks and calendars

1215+category: Time

1216+exposed: True

1217+exposed-modules:

1218+ Data.Time Data.Time.Calendar Data.Time.Calendar.Easter

1219+ Data.Time.Calendar.Julian Data.Time.Calendar.MonthDay

1220+ Data.Time.Calendar.OrdinalDate Data.Time.Calendar.WeekDate

1221+ Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System

1222+ Data.Time.Clock.TAI Data.Time.Format Data.Time.Format.ISO8601

1223+ Data.Time.Format.Internal Data.Time.LocalTime

1224+hidden-modules:

1225+ Data.Format Data.Time.Calendar.Private Data.Time.Calendar.Days

1226+ Data.Time.Calendar.Gregorian Data.Time.Calendar.CalendarDiffDays

1227+ Data.Time.Calendar.Week Data.Time.Calendar.JulianYearDay

1228+ Data.Time.Clock.Internal.DiffTime

1229+ Data.Time.Clock.Internal.AbsoluteTime

1230+ Data.Time.Clock.Internal.NominalDiffTime

1231+ Data.Time.Clock.Internal.POSIXTime

1232+ Data.Time.Clock.Internal.UniversalTime

1233+ Data.Time.Clock.Internal.SystemTime

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

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

1236+ Data.Time.LocalTime.Internal.TimeZone

1237+ Data.Time.LocalTime.Internal.TimeOfDay

1238+ Data.Time.LocalTime.Internal.CalendarDiffTime

1239+ Data.Time.LocalTime.Internal.LocalTime

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

1241+ Data.Time.Format.Locale Data.Time.Format.Format.Class

1242+ Data.Time.Format.Format.Instances Data.Time.Format.Parse.Class

1243+ Data.Time.Format.Parse.Instances

1244+import-dirs:

1245+library-dirs:

1246+dynamic-library-dirs:

1247+data-dir:

1248+hs-libraries: HStime-1.9.3

1249+include-dirs:

1250+depends: base-4.14.0.0 deepseq-1.4.4.0

1251+haddock-interfaces:

1252+haddock-html:

1253+---

1254+name: transformers

1255+version: 0.5.6.2

1256+visibility: public

1257+id: transformers-0.5.6.2

1258+key: transformers-0.5.6.2

1259+license: BSD-3-Clause

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

1261+author: Andy Gill, Ross Paterson

1262+synopsis: Concrete functor and monad transformers

1263+description:

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

1265+ the paper

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

1267+ Polymorphism\", by Mark P Jones,

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

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

1270+ This package contains:

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

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

1273+ operations and functions to lift operations associated with other

1274+ transformers.

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

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

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

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

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

1280+ introduced by monad transformers through other transformers.

1281+category: Control

1282+exposed: True

1283+exposed-modules:

1284+ Control.Applicative.Backwards Control.Applicative.Lift

1285+ Control.Monad.Signatures Control.Monad.Trans.Accum

1286+ Control.Monad.Trans.Class Control.Monad.Trans.Cont

1287+ Control.Monad.Trans.Error Control.Monad.Trans.Except

1288+ Control.Monad.Trans.Identity Control.Monad.Trans.List

1289+ Control.Monad.Trans.Maybe Control.Monad.Trans.RWS

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

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

1292+ Control.Monad.Trans.Select Control.Monad.Trans.State

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

1294+ Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS

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

1296+ Data.Functor.Constant Data.Functor.Reverse

1297+import-dirs:

1298+library-dirs:

1299+dynamic-library-dirs:

1300+data-dir:

1301+hs-libraries: HStransformers-0.5.6.2

1302+depends: base-4.14.0.0

1303+haddock-interfaces:

1304+haddock-html:

1305+---

1306+name: unix

1307+version: 2.7.2.2

1308+visibility: public

1309+id: unix-2.7.2.2

1310+key: unix-2.7.2.2

1311+license: BSD-3-Clause

1312+maintainer: libraries@haskell.org

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

1314+synopsis: POSIX functionality

1315+description:

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

1317+ services standardised by

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

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

1320+ Environments - IEEE Std. 1003.1).

1321+ The package is not supported under Windows.

1322+category: System

1323+exposed: True

1324+exposed-modules:

1325+ System.Posix System.Posix.ByteString

1326+ System.Posix.ByteString.FilePath System.Posix.Directory

1327+ System.Posix.Directory.ByteString System.Posix.DynamicLinker

1328+ System.Posix.DynamicLinker.ByteString

1329+ System.Posix.DynamicLinker.Module

1330+ System.Posix.DynamicLinker.Module.ByteString

1331+ System.Posix.DynamicLinker.Prim System.Posix.Env

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

1333+ System.Posix.Files System.Posix.Files.ByteString System.Posix.IO

1334+ System.Posix.IO.ByteString System.Posix.Process

1335+ System.Posix.Process.ByteString System.Posix.Process.Internals

1336+ System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem

1337+ System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp

1338+ System.Posix.Temp.ByteString System.Posix.Terminal

1339+ System.Posix.Terminal.ByteString System.Posix.Time

1340+ System.Posix.Unistd System.Posix.User

1341+hidden-modules:

1342+ System.Posix.Directory.Common System.Posix.DynamicLinker.Common

1343+ System.Posix.Files.Common System.Posix.IO.Common

1344+ System.Posix.Process.Common System.Posix.Terminal.Common

1345+import-dirs:

1346+library-dirs:

1347+dynamic-library-dirs:

1348+data-dir:

1349+hs-libraries: HSunix-2.7.2.2

1350+extra-libraries: rt util dl pthread

1351+include-dirs:

1352+includes: HsUnix.h execvpe.h

1353+depends: base-4.14.0.0 bytestring-0.10.10.0 time-1.9.3

1354+haddock-interfaces:

1355+haddock-html:

1356+---

1357+name: rts

1358+version: 1.0

1359+visibility: public

1360+id: rts

1361+key: rts

1362+license: BSD-3-Clause

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

1364+exposed: True

1365+library-dirs:

1366+hs-libraries: HSrts

1367+extra-libraries: m rt dl ffi numa pthread

1368+include-dirs:

1369+includes: Stg.h

1370+ld-options:

1371+ "-Wl,-u,base_GHCziTopHandler_runIO_closure"

1372+ "-Wl,-u,base_GHCziTopHandler_runNonIO_closure"

1373+ "-Wl,-u,ghczmprim_GHCziTuple_Z0T_closure"

1374+ "-Wl,-u,ghczmprim_GHCziTypes_True_closure"

1375+ "-Wl,-u,ghczmprim_GHCziTypes_False_closure"

1376+ "-Wl,-u,base_GHCziPack_unpackCString_closure"

1377+ "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure"

1378+ "-Wl,-u,base_GHCziIOziException_stackOverflow_closure"

1379+ "-Wl,-u,base_GHCziIOziException_heapOverflow_closure"

1380+ "-Wl,-u,base_GHCziIOziException_allocationLimitExceeded_closure"

1381+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"

1382+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"

1383+ "-Wl,-u,base_GHCziIOziException_cannotCompactFunction_closure"

1384+ "-Wl,-u,base_GHCziIOziException_cannotCompactPinned_closure"

1385+ "-Wl,-u,base_GHCziIOziException_cannotCompactMutable_closure"

1386+ "-Wl,-u,base_ControlziExceptionziBase_absentSumFieldError_closure"

1387+ "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure"

1388+ "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure"

1389+ "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure"

1390+ "-Wl,-u,base_GHCziConcziSync_runSparks_closure"

1391+ "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure"

1392+ "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"

1393+ "-Wl,-u,base_GHCziConcziSignal_runHandlersPtr_closure"

1394+ "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure"

1395+ "-Wl,-u,base_GHCziTopHandler_runMainIO_closure"

1396+ "-Wl,-u,ghczmprim_GHCziTypes_Czh_con_info"

1397+ "-Wl,-u,ghczmprim_GHCziTypes_Izh_con_info"

1398+ "-Wl,-u,ghczmprim_GHCziTypes_Fzh_con_info"

1399+ "-Wl,-u,ghczmprim_GHCziTypes_Dzh_con_info"

1400+ "-Wl,-u,ghczmprim_GHCziTypes_Wzh_con_info"

1401+ "-Wl,-u,base_GHCziPtr_Ptr_con_info"

1402+ "-Wl,-u,base_GHCziPtr_FunPtr_con_info"

1403+ "-Wl,-u,base_GHCziInt_I8zh_con_info"

1404+ "-Wl,-u,base_GHCziInt_I16zh_con_info"

1405+ "-Wl,-u,base_GHCziInt_I32zh_con_info"

1406+ "-Wl,-u,base_GHCziInt_I64zh_con_info"

1407+ "-Wl,-u,base_GHCziWord_W8zh_con_info"

1408+ "-Wl,-u,base_GHCziWord_W16zh_con_info"

1409+ "-Wl,-u,base_GHCziWord_W32zh_con_info"

1410+ "-Wl,-u,base_GHCziWord_W64zh_con_info"

1411+ "-Wl,-u,base_GHCziStable_StablePtr_con_info"

1412+ "-Wl,-u,hs_atomic_add8" "-Wl,-u,hs_atomic_add16"

1413+ "-Wl,-u,hs_atomic_add32" "-Wl,-u,hs_atomic_add64"

1414+ "-Wl,-u,hs_atomic_sub8" "-Wl,-u,hs_atomic_sub16"

1415+ "-Wl,-u,hs_atomic_sub32" "-Wl,-u,hs_atomic_sub64"

1416+ "-Wl,-u,hs_atomic_and8" "-Wl,-u,hs_atomic_and16"

1417+ "-Wl,-u,hs_atomic_and32" "-Wl,-u,hs_atomic_and64"

1418+ "-Wl,-u,hs_atomic_nand8" "-Wl,-u,hs_atomic_nand16"

1419+ "-Wl,-u,hs_atomic_nand32" "-Wl,-u,hs_atomic_nand64"

1420+ "-Wl,-u,hs_atomic_or8" "-Wl,-u,hs_atomic_or16"

1421+ "-Wl,-u,hs_atomic_or32" "-Wl,-u,hs_atomic_or64"

1422+ "-Wl,-u,hs_atomic_xor8" "-Wl,-u,hs_atomic_xor16"

1423+ "-Wl,-u,hs_atomic_xor32" "-Wl,-u,hs_atomic_xor64"

1424+ "-Wl,-u,hs_cmpxchg8" "-Wl,-u,hs_cmpxchg16" "-Wl,-u,hs_cmpxchg32"

1425+ "-Wl,-u,hs_cmpxchg64" "-Wl,-u,hs_atomicread8"

1426+ "-Wl,-u,hs_atomicread16" "-Wl,-u,hs_atomicread32"

1427+ "-Wl,-u,hs_atomicread64" "-Wl,-u,hs_atomicwrite8"

1428+ "-Wl,-u,hs_atomicwrite16" "-Wl,-u,hs_atomicwrite32"

1429+ "-Wl,-u,hs_atomicwrite64"

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.10.1-x86_64-linux/ghc-pkg/versionnew file+1

@@ -0,0 +1 @@

1+GHC package manager version 8.10.1

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.10.1-x86_64-linux/ghc/infonew file+66

@@ -0,0 +1,66 @@

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

2+ ,("GCC extra via C opts","")

3+ ,("C compiler flags","")

4+ ,("C++ compiler flags","")

5+ ,("C compiler link flags","-Wl,-z,noexecstack")

6+ ,("C compiler supports -no-pie","YES")

7+ ,("Haskell CPP flags","-E -undef -traditional")

8+ ,("ld flags","-z noexecstack")

9+ ,("ld supports compact unwind","YES")

10+ ,("ld supports build-id","YES")

11+ ,("ld supports filelist","NO")

12+ ,("ld is GNU ld","YES")

13+ ,("ar flags","q")

14+ ,("ar supports at file","YES")

15+ ,("touch command","touch")

16+ ,("dllwrap command","/bin/false")

17+ ,("windres command","/bin/false")

18+ ,("libtool command","libtool")

19+ ,("cross compiling","YES")

20+ ,("target platform string","aarch64-unknown-linux")

21+ ,("target os","OSLinux")

22+ ,("target arch","ArchARM64")

23+ ,("target word size","8")

24+ ,("target has GNU nonexec stack","YES")

25+ ,("target has .ident directive","YES")

26+ ,("target has subsections via symbols","NO")

27+ ,("target has RTS linker","YES")

28+ ,("Unregisterised","NO")

29+ ,("LLVM target","aarch64-unknown-linux")

30+ ,("LLVM llc command","llc")

31+ ,("LLVM opt command","opt")

32+ ,("LLVM clang command","clang")

33+ ,("integer library","integer-gmp")

34+ ,("Use interpreter","YES")

35+ ,("Use native code generator","NO")

36+ ,("Support SMP","YES")

37+ ,("RTS ways","l debug thr thr_debug thr_l thr_p thr_debug_p debug_p")

38+ ,("Tables next to code","YES")

39+ ,("Leading underscore","NO")

40+ ,("Use LibFFI","YES")

41+ ,("Use Threads","YES")

42+ ,("Use Debugging","NO")

43+ ,("RTS expects libdw","NO")

44+ ,("Project version","8.10.1")

45+ ,("Project Git commit id","5c3cadf5db0d7eb859ff2c278ab07585c7df17b5")

46+ ,("Booter version","8.8.3")

47+ ,("Stage","1")

48+ ,("Build platform","x86_64-unknown-linux")

49+ ,("Host platform","x86_64-unknown-linux")

50+ ,("Target platform","aarch64-unknown-linux")

51+ ,("Have interpreter","YES")

52+ ,("Object splitting supported","NO")

53+ ,("Have native code generator","NO")

54+ ,("Support dynamic-too","YES")

55+ ,("Support parallel --make","YES")

56+ ,("Support reexported-modules","YES")

57+ ,("Support thinning and renaming package flags","YES")

58+ ,("Support Backpack","YES")

59+ ,("Requires unified installed package IDs","YES")

60+ ,("Uses package keys","YES")

61+ ,("Uses unit IDs","YES")

62+ ,("Dynamic by default","NO")

63+ ,("GHC Dynamic","NO")

64+ ,("GHC Profiled","NO")

65+ ,("Debug on","NO")

66+ ]

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.10.1-x86_64-linux/ghc/numeric-versionnew file+1

@@ -0,0 +1 @@

1+8.10.1

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.10.1-x86_64-linux/ghc/supported-languagesnew file+255

@@ -0,0 +1,255 @@

1+Haskell98

2+Haskell2010

3+Unsafe

4+Trustworthy

5+Safe

6+AllowAmbiguousTypes

7+NoAllowAmbiguousTypes

8+AlternativeLayoutRule

9+NoAlternativeLayoutRule

10+AlternativeLayoutRuleTransitional

11+NoAlternativeLayoutRuleTransitional

12+Arrows

13+NoArrows

14+AutoDeriveTypeable

15+NoAutoDeriveTypeable

16+BangPatterns

17+NoBangPatterns

18+BinaryLiterals

19+NoBinaryLiterals

20+CApiFFI

21+NoCApiFFI

22+CPP

23+NoCPP

24+CUSKs

25+NoCUSKs

26+ConstrainedClassMethods

27+NoConstrainedClassMethods

28+ConstraintKinds

29+NoConstraintKinds

30+DataKinds

31+NoDataKinds

32+DatatypeContexts

33+NoDatatypeContexts

34+DefaultSignatures

35+NoDefaultSignatures

36+DeriveAnyClass

37+NoDeriveAnyClass

38+DeriveDataTypeable

39+NoDeriveDataTypeable

40+DeriveFoldable

41+NoDeriveFoldable

42+DeriveFunctor

43+NoDeriveFunctor

44+DeriveGeneric

45+NoDeriveGeneric

46+DeriveLift

47+NoDeriveLift

48+DeriveTraversable

49+NoDeriveTraversable

50+DerivingStrategies

51+NoDerivingStrategies

52+DerivingVia

53+NoDerivingVia

54+DisambiguateRecordFields

55+NoDisambiguateRecordFields

56+DoAndIfThenElse

57+NoDoAndIfThenElse

58+BlockArguments

59+NoBlockArguments

60+DoRec

61+NoDoRec

62+DuplicateRecordFields

63+NoDuplicateRecordFields

64+EmptyCase

65+NoEmptyCase

66+EmptyDataDecls

67+NoEmptyDataDecls

68+EmptyDataDeriving

69+NoEmptyDataDeriving

70+ExistentialQuantification

71+NoExistentialQuantification

72+ExplicitForAll

73+NoExplicitForAll

74+ExplicitNamespaces

75+NoExplicitNamespaces

76+ExtendedDefaultRules

77+NoExtendedDefaultRules

78+FlexibleContexts

79+NoFlexibleContexts

80+FlexibleInstances

81+NoFlexibleInstances

82+ForeignFunctionInterface

83+NoForeignFunctionInterface

84+FunctionalDependencies

85+NoFunctionalDependencies

86+GADTSyntax

87+NoGADTSyntax

88+GADTs

89+NoGADTs

90+GHCForeignImportPrim

91+NoGHCForeignImportPrim

92+GeneralizedNewtypeDeriving

93+NoGeneralizedNewtypeDeriving

94+GeneralisedNewtypeDeriving

95+NoGeneralisedNewtypeDeriving

96+ImplicitParams

97+NoImplicitParams

98+ImplicitPrelude

99+NoImplicitPrelude

100+ImportQualifiedPost

101+NoImportQualifiedPost

102+ImpredicativeTypes

103+NoImpredicativeTypes

104+IncoherentInstances

105+NoIncoherentInstances

106+TypeFamilyDependencies

107+NoTypeFamilyDependencies

108+InstanceSigs

109+NoInstanceSigs

110+ApplicativeDo

111+NoApplicativeDo

112+InterruptibleFFI

113+NoInterruptibleFFI

114+JavaScriptFFI

115+NoJavaScriptFFI

116+KindSignatures

117+NoKindSignatures

118+LambdaCase

119+NoLambdaCase

120+LiberalTypeSynonyms

121+NoLiberalTypeSynonyms

122+MagicHash

123+NoMagicHash

124+MonadComprehensions

125+NoMonadComprehensions

126+MonadFailDesugaring

127+NoMonadFailDesugaring

128+MonoLocalBinds

129+NoMonoLocalBinds

130+MonoPatBinds

131+NoMonoPatBinds

132+MonomorphismRestriction

133+NoMonomorphismRestriction

134+MultiParamTypeClasses

135+NoMultiParamTypeClasses

136+MultiWayIf

137+NoMultiWayIf

138+NumericUnderscores

139+NoNumericUnderscores

140+NPlusKPatterns

141+NoNPlusKPatterns

142+NamedFieldPuns

143+NoNamedFieldPuns

144+NamedWildCards

145+NoNamedWildCards

146+NegativeLiterals

147+NoNegativeLiterals

148+HexFloatLiterals

149+NoHexFloatLiterals

150+NondecreasingIndentation

151+NoNondecreasingIndentation

152+NullaryTypeClasses

153+NoNullaryTypeClasses

154+NumDecimals

155+NoNumDecimals

156+OverlappingInstances

157+NoOverlappingInstances

158+OverloadedLabels

159+NoOverloadedLabels

160+OverloadedLists

161+NoOverloadedLists

162+OverloadedStrings

163+NoOverloadedStrings

164+PackageImports

165+NoPackageImports

166+ParallelArrays

167+NoParallelArrays

168+ParallelListComp

169+NoParallelListComp

170+PartialTypeSignatures

171+NoPartialTypeSignatures

172+PatternGuards

173+NoPatternGuards

174+PatternSignatures

175+NoPatternSignatures

176+PatternSynonyms

177+NoPatternSynonyms

178+PolyKinds

179+NoPolyKinds

180+PolymorphicComponents

181+NoPolymorphicComponents

182+QuantifiedConstraints

183+NoQuantifiedConstraints

184+PostfixOperators

185+NoPostfixOperators

186+QuasiQuotes

187+NoQuasiQuotes

188+Rank2Types

189+NoRank2Types

190+RankNTypes

191+NoRankNTypes

192+RebindableSyntax

193+NoRebindableSyntax

194+RecordPuns

195+NoRecordPuns

196+RecordWildCards

197+NoRecordWildCards

198+RecursiveDo

199+NoRecursiveDo

200+RelaxedLayout

201+NoRelaxedLayout

202+RelaxedPolyRec

203+NoRelaxedPolyRec

204+RoleAnnotations

205+NoRoleAnnotations

206+ScopedTypeVariables

207+NoScopedTypeVariables

208+StandaloneDeriving

209+NoStandaloneDeriving

210+StarIsType

211+NoStarIsType

212+StaticPointers

213+NoStaticPointers

214+Strict

215+NoStrict

216+StrictData

217+NoStrictData

218+TemplateHaskell

219+NoTemplateHaskell

220+TemplateHaskellQuotes

221+NoTemplateHaskellQuotes

222+StandaloneKindSignatures

223+NoStandaloneKindSignatures

224+TraditionalRecordSyntax

225+NoTraditionalRecordSyntax

226+TransformListComp

227+NoTransformListComp

228+TupleSections

229+NoTupleSections

230+TypeApplications

231+NoTypeApplications

232+TypeInType

233+NoTypeInType

234+TypeFamilies

235+NoTypeFamilies

236+TypeOperators

237+NoTypeOperators

238+TypeSynonymInstances

239+NoTypeSynonymInstances

240+UnboxedTuples

241+NoUnboxedTuples

242+UnboxedSums

243+NoUnboxedSums

244+UndecidableInstances

245+NoUndecidableInstances

246+UndecidableSuperClasses

247+NoUndecidableSuperClasses

248+UnicodeSyntax

249+NoUnicodeSyntax

250+UnliftedFFITypes

251+NoUnliftedFFITypes

252+UnliftedNewtypes

253+NoUnliftedNewtypes

254+ViewPatterns

255+NoViewPatterns

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.10.1-x86_64-linux/ghc/versionnew file+1

@@ -0,0 +1 @@

1+The Glorious Glasgow Haskell Compilation System, version 8.10.1

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.6.5-x86_64-linux/ghc-pkg/dump-global+1−1

@@ -894,7 +894,7 @@ maintainer: glasgow-haskell-users@haskell.org

894894exposed: True

895895hs-libraries: HSrts

896896extra-libraries:

897− m rt dl ffi pthread

897+ m rt dl ffi numa pthread

898898includes:

899899 Stg.h

900900ld-options: "-Wl,-u,base_GHCziTopHandler_runIO_closure"

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.8.3-x86_64-linux/ghc-pkg/dump-global+1−1

@@ -1338,7 +1338,7 @@ maintainer: glasgow-haskell-users@haskell.org

13381338exposed: True

13391339library-dirs:

13401340hs-libraries: HSrts

1341−extra-libraries: m rt dl ffi pthread

1341+extra-libraries: m rt dl ffi numa pthread

13421342include-dirs:

13431343includes: Stg.h

13441344ld-options:

materialized/dummy-ghc/ghc-8.10.1-x86_64-darwin/ghc-pkg/dump-globalnew file+1625

@@ -0,0 +1,1625 @@