cacfba0 · haskell.nix · git.iko.soy

git.iko.soy/haskell.nix

on iko/ghcjs-patch-master help sign in

Replace ghc 8.8.3 with 8.8.4 (#766)

Also adds some tooling/docs for adding new ghc versions (see `docs/adding-new-ghc.md`)

commitcacfba0b45bff4dafe4ae4b25445babf3e7e2180 authorHamish Mackenzie <Hamish.Mackenzie@iohk.io> dateTue 21 Jul 2020, 14:10 (6 years ago) parentd6cf503

107 files changed+15701−67

compare with iko/ghcjs-patch-master

unifiedsplit

.buildkite/pipeline.yml+5−5

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

11steps:

2− - label: 'Run tests with ghc883'

3− command: "./test/tests.sh ghc883"

2+ - label: 'Run tests with ghc884'

3+ command: "./test/tests.sh ghc884"

44 agents:

55 system: x86_64-linux

@@ -14,9 +14,9 @@ steps:

1414 agents:

1515 system: x86_64-linux

1616

17− - label: 'Check closure size with ghc883'

17+ - label: 'Check closure size with ghc884'

1818 command:

19− - nix-build build.nix -A maintainer-scripts.check-closure-size --argstr compiler-nix-name ghc883 -o check-closure-size.sh

19+ - nix-build build.nix -A maintainer-scripts.check-closure-size --argstr compiler-nix-name ghc884 -o check-closure-size.sh

2020 - echo "+++ Closure size (MB)"

2121 - ./check-closure-size.sh

2222 agents:

@@ -36,5 +36,5 @@ steps:

3636

3737 - label: 'Make sure non store paths like can be used as src'

3838 command:

39− - nix-build build.nix -A maintainer-scripts.check-path-support --argstr compiler-nix-name ghc883 -o check-path-support.sh

39+ - nix-build build.nix -A maintainer-scripts.check-path-support --argstr compiler-nix-name ghc884 -o check-path-support.sh

4040 - ./check-path-support.sh

changelog.md+5−1

@@ -1,7 +1,11 @@

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

22that will impact users.

4−## July ?, 2020

4+## July 21, 2020

5+* Added GHC 8.8.4 and replaced 8.8.3 in tests and as the ghc

6+ used to build nix-tools for stack projects.

8+## July 20, 2020

59* Changed `haskell-nix.roots` and `p.roots` to single derivations.

610

711## July 8, 2020

ci.nix+1−1

@@ -16,7 +16,7 @@

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

1717 ghc865 = {};

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

19− ghc883 = {};

19+ ghc884 = {};

2020 ghc8101 = {};

2121 });

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

docs/adding-new-ghc.mdnew file+31

@@ -0,0 +1,31 @@

1+# Adding a new GHC version to haskell.nix

3+## Update `overlays/bootstrap.nix`

5+Each ghc version is defined in this file. Duplicate one of the exising

6+ghc version definitions and replace the version numbers. Make sure

7+you update the `spec.sha256` or the other versions source will be used.

8+Check the LLVM version that should be used in the

9+[ghc wiki](https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler/backends/llvm/installing).

10+

11+

12+## Update the materialized files

13+

14+In the haskell.nix repo run:

15+

16+```

17+mkdir materialized/ghc884

18+nix-build scripts/check-compiler-materialization --argstr compiler-nix-name ghc884

19+```

20+

21+The `nix-build` command will fail with something like:

22+

23+```

24+Materialized nix used for dummy-data-x86_64-unknown-linux-musl-ghc-8.10.1 incorrect. To fix run: /nix/store/wnwpyrhv4nxgyljz3f20gdpspjxvm7h4-updateMaterialized

25+```

26+

27+Run the `updateMaterialized` script and repat the `nix-build` until it no longer fails.

28+If the failure is not a problem with materialization and no `updateMaterialized` script

29+is provided then you may need to fix the failure another way or (if it only relates to

30+one of the cross compilers) modify `scripts/check-compiler-materialization/default.nix`

31+so that it skips that compiler.

docs/dev/installing-nix-tools.md+2−2

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

33To build the latest `nix-tools` and store the result at `./nt`, run:

55```bash

6−nix build -f https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz pkgs.haskell-nix.nix-tools.ghc883 --out-link nt

6+nix build -f https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz pkgs.haskell-nix.nix-tools.ghc884 --out-link nt

77```

99If you would like to then install `nix-tools` into your profile, run:

@@ -22,5 +22,5 @@ understand something that the documentation doesn't cover.

2222git clone https://github.com/input-output-hk/nix-tools

2323git clone https://github.com/input-output-hk/haskell.nix

2424cd haskell.nix

25−nix build -f . pkgs.haskell-nix.nix-tools.ghc883 --arg sourcesOverride '{ nix-tools = ../nix-tools; }' --out-link nt

25+nix build -f . pkgs.haskell-nix.nix-tools.ghc884 --arg sourcesOverride '{ nix-tools = ../nix-tools; }' --out-link nt

2626```

docs/reference/library.md+1−1

@@ -270,7 +270,7 @@ needed for `importAndFilterProject`.

270270|----------------------|------|---------------------|

271271| `name` | String | Optional name for better error messages. |

272272| `src` | Path | Location of the cabal project files. |

273−| `compiler-nix-name` | String | The name of the ghc compiler to use eg. "ghc883" |

273+| `compiler-nix-name` | String | The name of the ghc compiler to use eg. "ghc884" |

274274| `index-state` | Timestamp | Optional hackage index-state, eg. "2019-10-10T00:00:00Z". |

275275| `index-sha256` | Sha256 | Optional hash of the truncated hackage index-state. |

276276| `plan-sha256` | Sha256 | Optional hash of the plan-to-nix output (makes the plan-to-nix step a fixed output derivation). |

docs/troubleshooting.md+1−1

@@ -66,7 +66,7 @@ So this is expected, unfortunately.

6666

6767### How do I prevent the evaluation-time dependencies of my project from being garbage-collected?

6868

69−The `haskell-nix.roots "ghc883"` should include all the evaluation-time dependencies

69+The `haskell-nix.roots "ghc884"` should include all the evaluation-time dependencies

7070and the main build time dependecies of a project using ghc 8.8.3.

7171So you can add that to the relevant GC root.

7272In practice, if you're using a CI system like Hydra/Hercules, this means adding it to a job in `release.nix`/`ci.nix`.

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

@@ -53,7 +53,7 @@ Add `default.nix`:

5353 src = ./.;

5454 };

5555 # For `cabal.project` based projects specify the GHC version to use.

56− compiler-nix-name = "ghc883"; # Not used for `stack.yaml` based projects.

56+ compiler-nix-name = "ghc884"; # Not used for `stack.yaml` based projects.

5757}

5858```

5959

docs/tutorials/materialization.md+7−7

@@ -42,7 +42,7 @@ file that looks like this:

4242let inherit (import ./. {}) sources nixpkgsArgs;

4343 pkgs = import sources.nixpkgs nixpkgsArgs;

4444 hlint = pkgs.haskell-nix.hackage-package {

45− compiler-nix-name = "ghc883";

45+ compiler-nix-name = "ghc884";

4646 name = "hlint";

4747 version = "2.2.11";

4848 };

@@ -67,7 +67,7 @@ inputs. For cabal projects this means we must specify the

6767let inherit (import ./. {}) sources nixpkgsArgs;

6868 pkgs = import sources.nixpkgs nixpkgsArgs;

6969 hlint = pkgs.haskell-nix.hackage-package {

70− compiler-nix-name = "ghc883";

70+ compiler-nix-name = "ghc884";

7171 name = "hlint";

7272 version = "2.2.11";

7373 index-state = "2020-04-15T00:00:00Z";

@@ -96,7 +96,7 @@ stack projects)

9696let inherit (import ./. {}) sources nixpkgsArgs;

9797 pkgs = import sources.nixpkgs nixpkgsArgs;

9898 hlint = pkgs.haskell-nix.hackage-package {

99− compiler-nix-name = "ghc883";

99+ compiler-nix-name = "ghc884";

100100 name = "hlint";

101101 version = "2.2.11";

102102 index-state = "2020-04-15T00:00:00Z";

@@ -126,7 +126,7 @@ To capture the nix we can do something like:

126126let inherit (import ./. {}) sources nixpkgsArgs;

127127 pkgs = import sources.nixpkgs nixpkgsArgs;

128128 hlint = pkgs.haskell-nix.hackage-package {

129− compiler-nix-name = "ghc883";

129+ compiler-nix-name = "ghc884";

130130 name = "hlint";

131131 version = "2.2.11";

132132 index-state = "2020-04-15T00:00:00Z";

@@ -161,7 +161,7 @@ If we choose to add the `checkMaterialization` flag you would have:

161161let inherit (import ./. {}) sources nixpkgsArgs;

162162 pkgs = import sources.nixpkgs nixpkgsArgs;

163163 hlint = pkgs.haskell-nix.hackage-package {

164− compiler-nix-name = "ghc883";

164+ compiler-nix-name = "ghc884";

165165 name = "hlint";

166166 version = "2.2.10";

167167 index-state = "2020-04-15T00:00:00Z";

@@ -206,7 +206,7 @@ For instance:

206206let inherit (import ./. {}) sources nixpkgsArgs;

207207 pkgs = import sources.nixpkgs nixpkgsArgs;

208208 hlint = pkgs.haskell-nix.hackage-project {

209− compiler-nix-name = "ghc883";

209+ compiler-nix-name = "ghc884";

210210 name = "hlint";

211211 version = "2.2.10";

212212 index-state = "2020-04-15T00:00:00Z";

@@ -245,7 +245,7 @@ let inherit (import ./. {}) sources nixpkgsArgs;

245245 pkgs = import sources.nixpkgs nixpkgsArgs;

246246 hlintPlan = /nix/store/kk047cqsjvbj4w8psv4l05abdcnyrqdc-hlint-plan-to-nix-pkgs;

247247 hlint = pkgs.haskell-nix.hackage-package {

248− compiler-nix-name = "ghc883";

248+ compiler-nix-name = "ghc884";

249249 name = "hlint";

250250 version = "2.2.11";

251251 index-state = "2020-04-15T00:00:00Z";

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

@@ -8,7 +8,7 @@ let readIfExists = src: fileName:

88in

99{ name ? src.name or null # optional name for better error messages

1010, src

11−, compiler-nix-name # The name of the ghc compiler to use eg. "ghc883"

11+, compiler-nix-name # The name of the ghc compiler to use eg. "ghc884"

1212, index-state ? null # Hackage index-state, eg. "2019-10-10T00:00:00Z"

1313, index-sha256 ? null # The hash of the truncated hackage index-state

1414, plan-sha256 ? null # The hash of the plan-to-nix output (makes the plan-to-nix step a fixed output derivation)

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.10.1-x86_64-linux/ghc/info+1−1

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

4343 ,("RTS expects libdw","NO")

4444 ,("Project version","8.10.1")

4545 ,("Project Git commit id","5c3cadf5db0d7eb859ff2c278ab07585c7df17b5")

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

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

4747 ,("Stage","1")

4848 ,("Build platform","x86_64-unknown-linux")

4949 ,("Host platform","x86_64-unknown-linux")

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.8.4-x86_64-linux/ghc-pkg/dump-globalnew file+1404

@@ -0,0 +1,1404 @@

1+name: Cabal

2+version: 3.0.1.0

3+visibility: public

4+id: Cabal-3.0.1.0

5+key: Cabal-3.0.1.0

6+license: BSD-3-Clause

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

8+maintainer: cabal-devel@haskell.org

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

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

11+synopsis: A framework for packaging Haskell software

12+description:

13+ The Haskell Common Architecture for Building Applications and

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

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

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

17+ organizing, and cataloging Haskell libraries and tools.

18+category: Distribution

19+exposed: True

20+exposed-modules:

21+ Distribution.Backpack Distribution.Backpack.ComponentsGraph

22+ Distribution.Backpack.Configure

23+ Distribution.Backpack.ConfiguredComponent

24+ Distribution.Backpack.DescribeUnitId

25+ Distribution.Backpack.FullUnitId

26+ Distribution.Backpack.LinkedComponent

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

28+ Distribution.Backpack.PreModuleShape Distribution.CabalSpecVersion

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

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

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

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

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

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

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

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

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

38+ Distribution.Compiler Distribution.FieldGrammar

39+ Distribution.FieldGrammar.Class

40+ Distribution.FieldGrammar.FieldDescrs

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

42+ Distribution.Fields Distribution.Fields.ConfVar

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

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

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

46+ Distribution.InstalledPackageInfo Distribution.License

47+ Distribution.Make Distribution.ModuleName Distribution.Package

48+ Distribution.PackageDescription

49+ Distribution.PackageDescription.Check

50+ Distribution.PackageDescription.Configuration

51+ Distribution.PackageDescription.FieldGrammar

52+ Distribution.PackageDescription.Parsec

53+ Distribution.PackageDescription.PrettyPrint

54+ Distribution.PackageDescription.Quirks

55+ Distribution.PackageDescription.Utils Distribution.Parsec

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

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

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

59+ Distribution.SPDX Distribution.SPDX.License

60+ Distribution.SPDX.LicenseExceptionId

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

62+ Distribution.SPDX.LicenseListVersion

63+ Distribution.SPDX.LicenseReference Distribution.Simple

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

65+ Distribution.Simple.Build.Macros

66+ Distribution.Simple.Build.PathsModule

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

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

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

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

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

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

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

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

75+ Distribution.Simple.InstallDirs

76+ Distribution.Simple.InstallDirs.Internal

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

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

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

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

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

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

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

84+ Distribution.Simple.Program.ResponseFile

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

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

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

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

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

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

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

92+ Distribution.Simple.Utils Distribution.System

93+ Distribution.TestSuite Distribution.Text

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

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

96+ Distribution.Types.Benchmark.Lens

97+ Distribution.Types.BenchmarkInterface

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

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

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

101+ Distribution.Types.ComponentInclude

102+ Distribution.Types.ComponentLocalBuildInfo

103+ Distribution.Types.ComponentName

104+ Distribution.Types.ComponentRequestedSpec

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

106+ Distribution.Types.Dependency Distribution.Types.DependencyMap

107+ Distribution.Types.ExeDependency Distribution.Types.Executable

108+ Distribution.Types.Executable.Lens

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

110+ Distribution.Types.ForeignLib Distribution.Types.ForeignLib.Lens

111+ Distribution.Types.ForeignLibOption

112+ Distribution.Types.ForeignLibType

113+ Distribution.Types.GenericPackageDescription

114+ Distribution.Types.GenericPackageDescription.Lens

115+ Distribution.Types.GivenComponent

116+ Distribution.Types.HookedBuildInfo

117+ Distribution.Types.IncludeRenaming

118+ Distribution.Types.InstalledPackageInfo

119+ Distribution.Types.InstalledPackageInfo.FieldGrammar

120+ Distribution.Types.InstalledPackageInfo.Lens

121+ Distribution.Types.LegacyExeDependency Distribution.Types.Lens

122+ Distribution.Types.Library Distribution.Types.Library.Lens

123+ Distribution.Types.LibraryName Distribution.Types.LibraryVisibility

124+ Distribution.Types.LocalBuildInfo Distribution.Types.Mixin

125+ Distribution.Types.Module Distribution.Types.ModuleReexport

126+ Distribution.Types.ModuleRenaming

127+ Distribution.Types.MungedPackageId

128+ Distribution.Types.MungedPackageName

129+ Distribution.Types.PackageDescription

130+ Distribution.Types.PackageDescription.Lens

131+ Distribution.Types.PackageId Distribution.Types.PackageId.Lens

132+ Distribution.Types.PackageName Distribution.Types.PackageName.Magic

133+ Distribution.Types.PackageVersionConstraint

134+ Distribution.Types.PkgconfigDependency

135+ Distribution.Types.PkgconfigName

136+ Distribution.Types.PkgconfigVersion

137+ Distribution.Types.PkgconfigVersionRange

138+ Distribution.Types.SetupBuildInfo

139+ Distribution.Types.SetupBuildInfo.Lens

140+ Distribution.Types.SourceRepo Distribution.Types.SourceRepo.Lens

141+ Distribution.Types.TargetInfo Distribution.Types.TestSuite

142+ Distribution.Types.TestSuite.Lens

143+ Distribution.Types.TestSuiteInterface Distribution.Types.TestType

144+ Distribution.Types.UnitId Distribution.Types.UnqualComponentName

145+ Distribution.Types.Version Distribution.Types.VersionInterval

146+ Distribution.Types.VersionRange

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

148+ Distribution.Utils.IOData Distribution.Utils.LogProgress

149+ Distribution.Utils.MapAccum Distribution.Utils.NubList

150+ Distribution.Utils.Progress Distribution.Utils.ShortText

151+ Distribution.Verbosity Distribution.Verbosity.Internal

152+ Distribution.Version Language.Haskell.Extension

153+hidden-modules:

154+ Distribution.Backpack.PreExistingComponent

155+ Distribution.Backpack.ReadyComponent Distribution.Backpack.MixLink

156+ Distribution.Backpack.ModuleScope Distribution.Backpack.UnifyM

157+ Distribution.Backpack.Id Distribution.Utils.UnionFind

158+ Distribution.Utils.Base62 Distribution.Compat.CopyFile

159+ Distribution.Compat.GetShortPathName Distribution.Compat.MonadFail

160+ Distribution.Compat.Prelude Distribution.Compat.SnocList

161+ Distribution.GetOpt Distribution.Lex Distribution.Utils.String

162+ Distribution.Simple.GHC.EnvironmentParser

163+ Distribution.Simple.GHC.Internal Distribution.Simple.GHC.ImplInfo

164+ Distribution.Simple.Utils.Json Paths_Cabal

165+import-dirs:

166+library-dirs:

167+dynamic-library-dirs:

168+data-dir:

169+hs-libraries: HSCabal-3.0.1.0

170+depends:

171+ array-0.5.4.0 base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.1

172+ containers-0.6.2.1 deepseq-1.4.4.0 directory-1.3.6.0

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

174+ process-1.6.9.0 text-1.2.4.0 time-1.9.3 transformers-0.5.6.2

175+ unix-2.7.2.2

176+haddock-interfaces:

177+haddock-html:

178+---

179+name: array

180+version: 0.5.4.0

181+visibility: public

182+id: array-0.5.4.0

183+key: array-0.5.4.0

184+license: BSD-3-Clause

185+maintainer: libraries@haskell.org

186+synopsis: Mutable and immutable arrays

187+description:

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

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

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

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

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

193+category: Data Structures

194+exposed: True

195+exposed-modules:

196+ Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO

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

198+ Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe

199+ Data.Array.Storable Data.Array.Storable.Internals

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

201+import-dirs:

202+library-dirs:

203+dynamic-library-dirs:

204+data-dir:

205+hs-libraries: HSarray-0.5.4.0

206+depends: base-4.13.0.0

207+haddock-interfaces:

208+haddock-html:

209+---

210+name: base

211+version: 4.13.0.0

212+visibility: public

213+id: base-4.13.0.0

214+key: base-4.13.0.0

215+license: BSD-3-Clause

216+maintainer: libraries@haskell.org

217+synopsis: Basic libraries

218+description:

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

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

221+ structures to parsing combinators and debugging utilities.

222+category: Prelude

223+exposed: True

224+exposed-modules:

225+ Control.Applicative Control.Arrow Control.Category

226+ Control.Concurrent Control.Concurrent.Chan Control.Concurrent.MVar

227+ Control.Concurrent.QSem Control.Concurrent.QSemN Control.Exception

228+ Control.Exception.Base Control.Monad Control.Monad.Fail

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

230+ Control.Monad.ST Control.Monad.ST.Lazy Control.Monad.ST.Lazy.Safe

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

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

233+ Data.Bifoldable Data.Bifunctor Data.Bitraversable Data.Bits

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

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

236+ Data.Functor Data.Functor.Classes Data.Functor.Compose

237+ Data.Functor.Const Data.Functor.Contravariant Data.Functor.Identity

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

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

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

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

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

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

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

245+ Foreign.C.Types Foreign.Concurrent Foreign.ForeignPtr

246+ Foreign.ForeignPtr.Safe Foreign.ForeignPtr.Unsafe Foreign.Marshal

247+ Foreign.Marshal.Alloc Foreign.Marshal.Array Foreign.Marshal.Error

248+ Foreign.Marshal.Pool Foreign.Marshal.Safe Foreign.Marshal.Unsafe

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

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

251+ GHC.Conc GHC.Conc.IO GHC.Conc.Signal GHC.Conc.Sync

252+ GHC.ConsoleHandler GHC.Constants GHC.Desugar GHC.Enum

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

254+ GHC.ExecutionStack GHC.ExecutionStack.Internal GHC.Exts

255+ GHC.Fingerprint GHC.Fingerprint.Type GHC.Float

256+ GHC.Float.ConversionUtils GHC.Float.RealFracMethods GHC.Foreign

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

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

259+ GHC.IO.Encoding.CodePage GHC.IO.Encoding.Failure

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

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

262+ GHC.IO.Exception GHC.IO.FD GHC.IO.Handle GHC.IO.Handle.FD

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

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

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

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

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

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

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

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

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

272+ System.Console.GetOpt System.Environment System.Environment.Blank

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

274+ System.Mem System.Mem.StableName System.Mem.Weak

275+ System.Posix.Internals System.Posix.Types System.Timeout

276+ Text.ParserCombinators.ReadP Text.ParserCombinators.ReadPrec

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

278+ Type.Reflection Type.Reflection.Unsafe Unsafe.Coerce

279+hidden-modules:

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

281+ Data.OldList Data.Semigroup.Internal Data.Typeable.Internal

282+ Foreign.ForeignPtr.Imp GHC.StaticPtr.Internal

283+ System.Environment.ExecutablePath System.CPUTime.Utils

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

285+ GHC.Event.IntTable GHC.Event.Internal GHC.Event.KQueue

286+ GHC.Event.Manager GHC.Event.PSQ GHC.Event.Poll GHC.Event.Thread

287+ GHC.Event.TimerManager GHC.Event.Unique

288+ System.CPUTime.Posix.ClockGetTime System.CPUTime.Posix.Times

289+ System.CPUTime.Posix.RUsage System.CPUTime.Unsupported

290+import-dirs:

291+library-dirs:

292+dynamic-library-dirs:

293+data-dir:

294+hs-libraries: HSbase-4.13.0.0

295+include-dirs:

296+includes: HsBase.h

297+depends: ghc-prim-0.5.3 integer-gmp-1.0.2.0 rts

298+haddock-interfaces:

299+haddock-html:

300+---

301+name: binary

302+version: 0.8.7.0

303+visibility: public

304+id: binary-0.8.7.0

305+key: binary-0.8.7.0

306+license: BSD-3-Clause

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

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

309+stability: provisional

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

311+synopsis:

312+ Binary serialisation for Haskell values using lazy ByteStrings

313+description:

314+ Efficient, pure binary serialisation using lazy ByteStrings.

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

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

317+ The format used can be automatically generated, or

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

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

320+ so this library should be suitable for high performance

321+ scenarios.

322+category: Data, Parsing

323+exposed: True

324+exposed-modules:

325+ Data.Binary Data.Binary.Builder Data.Binary.Get

326+ Data.Binary.Get.Internal Data.Binary.Put

327+hidden-modules:

328+ Data.Binary.Class Data.Binary.Internal Data.Binary.Generic

329+ Data.Binary.FloatCast

330+import-dirs:

331+library-dirs:

332+dynamic-library-dirs:

333+data-dir:

334+hs-libraries: HSbinary-0.8.7.0

335+depends:

336+ array-0.5.4.0 base-4.13.0.0 bytestring-0.10.10.1 containers-0.6.2.1

337+haddock-interfaces:

338+haddock-html:

339+---

340+name: bytestring

341+version: 0.10.10.1

342+visibility: public

343+id: bytestring-0.10.10.1

344+key: bytestring-0.10.10.1

345+license: BSD-3-Clause

346+copyright:

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

348+ (c) Duncan Coutts 2006-2015,

349+ (c) David Roundy 2003-2005,

350+ (c) Jasper Van der Jeugt 2010,

351+ (c) Simon Meier 2010-2013.

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

353+author:

354+ Don Stewart,

355+ Duncan Coutts

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

357+synopsis:

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

359+description:

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

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

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

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

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

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

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

367+ Two 'ByteString' variants are provided:

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

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

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

371+ suitable for I\/O streaming tasks.

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

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

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

375+ and network protocols).

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

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

378+ serialisation or pretty printing.

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

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

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

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

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

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

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

386+ > import qualified Data.ByteString as BS

387+category: Data

388+exposed: True

389+exposed-modules:

390+ Data.ByteString Data.ByteString.Builder

391+ Data.ByteString.Builder.Extra Data.ByteString.Builder.Internal

392+ Data.ByteString.Builder.Prim Data.ByteString.Builder.Prim.Internal

393+ Data.ByteString.Char8 Data.ByteString.Internal Data.ByteString.Lazy

394+ Data.ByteString.Lazy.Builder Data.ByteString.Lazy.Builder.ASCII

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

396+ Data.ByteString.Lazy.Internal Data.ByteString.Short

397+ Data.ByteString.Short.Internal Data.ByteString.Unsafe

398+hidden-modules:

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

400+ Data.ByteString.Builder.Prim.ASCII

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

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

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

404+import-dirs:

405+library-dirs:

406+dynamic-library-dirs:

407+data-dir:

408+hs-libraries: HSbytestring-0.10.10.1

409+include-dirs:

410+includes: fpstring.h

411+depends:

412+ base-4.13.0.0 deepseq-1.4.4.0 ghc-prim-0.5.3 integer-gmp-1.0.2.0

413+haddock-interfaces:

414+haddock-html:

415+---

416+name: containers

417+version: 0.6.2.1

418+visibility: public

419+id: containers-0.6.2.1

420+key: containers-0.6.2.1

421+license: BSD-3-Clause

422+maintainer: libraries@haskell.org

423+synopsis: Assorted concrete container types

424+description:

425+ This package contains efficient general-purpose implementations

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

427+ trees, and graphs.

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

429+ operations see the [containers

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

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

432+ remains valid even if structures are shared.

433+category: Data Structures

434+exposed: True

435+exposed-modules:

436+ Data.Containers.ListUtils Data.Graph Data.IntMap

437+ Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy

438+ Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict

439+ Data.IntMap.Strict.Internal Data.IntSet Data.IntSet.Internal

440+ Data.Map Data.Map.Internal Data.Map.Internal.Debug Data.Map.Lazy

441+ Data.Map.Merge.Lazy Data.Map.Merge.Strict Data.Map.Strict

442+ Data.Map.Strict.Internal Data.Sequence Data.Sequence.Internal

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

444+ Utils.Containers.Internal.BitQueue

445+ Utils.Containers.Internal.BitUtil

446+ Utils.Containers.Internal.StrictPair

447+hidden-modules:

448+ Utils.Containers.Internal.State

449+ Utils.Containers.Internal.StrictMaybe

450+ Utils.Containers.Internal.PtrEquality

451+ Utils.Containers.Internal.Coercions

452+ Utils.Containers.Internal.TypeError

453+ Data.Map.Internal.DeprecatedShowTree

454+ Data.IntMap.Internal.DeprecatedDebug

455+import-dirs:

456+library-dirs:

457+dynamic-library-dirs:

458+data-dir:

459+hs-libraries: HScontainers-0.6.2.1

460+depends: array-0.5.4.0 base-4.13.0.0 deepseq-1.4.4.0

461+haddock-interfaces:

462+haddock-html:

463+---

464+name: deepseq

465+version: 1.4.4.0

466+visibility: public

467+id: deepseq-1.4.4.0

468+key: deepseq-1.4.4.0

469+license: BSD-3-Clause

470+maintainer: libraries@haskell.org

471+synopsis: Deep evaluation of data structures

472+description:

473+ This package provides methods for fully evaluating data structures

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

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

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

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

478+ wrong thread.

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

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

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

482+ components) which defines strategies for fully evaluating different

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

484+ details.

485+category: Control

486+exposed: True

487+exposed-modules: Control.DeepSeq

488+hidden-modules: Control.DeepSeq.BackDoor

489+import-dirs:

490+library-dirs:

491+dynamic-library-dirs:

492+data-dir:

493+hs-libraries: HSdeepseq-1.4.4.0

494+depends: array-0.5.4.0 base-4.13.0.0

495+haddock-interfaces:

496+haddock-html:

497+---

498+name: directory

499+version: 1.3.6.0

500+visibility: public

501+id: directory-1.3.6.0

502+key: directory-1.3.6.0

503+license: BSD-3-Clause

504+maintainer: libraries@haskell.org

505+synopsis: Platform-agnostic library for filesystem operations

506+description:

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

508+ directories in a portable way.

509+category: System

510+exposed: True

511+exposed-modules:

512+ System.Directory System.Directory.Internal

513+ System.Directory.Internal.Prelude

514+hidden-modules:

515+ System.Directory.Internal.C_utimensat

516+ System.Directory.Internal.Common System.Directory.Internal.Config

517+ System.Directory.Internal.Posix System.Directory.Internal.Windows

518+import-dirs:

519+library-dirs:

520+dynamic-library-dirs:

521+data-dir:

522+hs-libraries: HSdirectory-1.3.6.0

523+depends:

524+ base-4.13.0.0 filepath-1.4.2.1 time-1.9.3 unix-2.7.2.2

525+haddock-interfaces:

526+haddock-html:

527+---

528+name: filepath

529+version: 1.4.2.1

530+visibility: public

531+id: filepath-1.4.2.1

532+key: filepath-1.4.2.1

533+license: BSD-3-Clause

534+copyright: Neil Mitchell 2005-2018

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

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

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

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

539+description:

540+ This package provides functionality for manipulating @FilePath@ values, and is shipped with both <https://www.haskell.org/ghc/ GHC> and the <https://www.haskell.org/platform/ Haskell Platform>. It provides three modules:

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

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

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

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

545+category: System

546+exposed: True

547+exposed-modules:

548+ System.FilePath System.FilePath.Posix System.FilePath.Windows

549+import-dirs:

550+library-dirs:

551+dynamic-library-dirs:

552+data-dir:

553+hs-libraries: HSfilepath-1.4.2.1

554+depends: base-4.13.0.0

555+haddock-interfaces:

556+haddock-html:

557+---

558+name: ghc-boot

559+version: 8.8.4

560+visibility: public

561+id: ghc-boot-8.8.4

562+key: ghc-boot-8.8.4

563+license: BSD-3-Clause

564+maintainer: ghc-devs@haskell.org

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

566+description:

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

568+ libraries.

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

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

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

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

573+ suitable for modifying GHC package databases.

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

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

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

577+category: GHC

578+exposed: True

579+exposed-modules:

580+ GHC.ForeignSrcLang GHC.HandleEncoding GHC.LanguageExtensions

581+ GHC.PackageDb GHC.Serialized

582+import-dirs:

583+library-dirs:

584+dynamic-library-dirs:

585+data-dir:

586+hs-libraries: HSghc-boot-8.8.4

587+depends:

588+ base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.1 directory-1.3.6.0

589+ filepath-1.4.2.1 ghc-boot-th-8.8.4

590+haddock-interfaces:

591+haddock-html:

592+---

593+name: ghc-boot-th

594+version: 8.8.4

595+visibility: public

596+id: ghc-boot-th-8.8.4

597+key: ghc-boot-th-8.8.4

598+license: BSD-3-Clause

599+maintainer: ghc-devs@haskell.org

600+synopsis:

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

602+ library

603+description:

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

605+ @template-haskell@ libraries.

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

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

608+ be depended upon by user code.

609+category: GHC

610+exposed: True

611+exposed-modules:

612+ GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme

613+import-dirs:

614+library-dirs:

615+dynamic-library-dirs:

616+data-dir:

617+hs-libraries: HSghc-boot-th-8.8.4

618+depends: base-4.13.0.0

619+haddock-interfaces:

620+haddock-html:

621+---

622+name: ghc-compact

623+version: 0.1.0.0

624+visibility: public

625+id: ghc-compact-0.1.0.0

626+key: ghc-compact-0.1.0.0

627+license: BSD-3-Clause

628+maintainer: libraries@haskell.org

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

630+description:

631+ This package provides minimal functionality for working with

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

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

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

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

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

637+ released).

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

639+ which allows efficient serialization and deserialization of structs

640+ for distributed computing.

641+category: Data

642+exposed: True

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

644+import-dirs:

645+library-dirs:

646+dynamic-library-dirs:

647+data-dir:

648+hs-libraries: HSghc-compact-0.1.0.0

649+depends: base-4.13.0.0 bytestring-0.10.10.1 ghc-prim-0.5.3

650+haddock-interfaces:

651+haddock-html:

652+---

653+name: ghc-heap

654+version: 8.8.4

655+visibility: public

656+id: ghc-heap-8.8.4

657+key: ghc-heap-8.8.4

658+license: BSD-3-Clause

659+maintainer: libraries@haskell.org

660+synopsis: Functions for walking GHC's heap

661+description:

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

663+ and retrieving information about those data structures.

664+category: GHC

665+exposed: True

666+exposed-modules:

667+ GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures

668+ GHC.Exts.Heap.Constants GHC.Exts.Heap.InfoTable

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

670+ GHC.Exts.Heap.Utils

671+import-dirs:

672+library-dirs:

673+dynamic-library-dirs:

674+data-dir:

675+hs-libraries: HSghc-heap-8.8.4

676+depends: base-4.13.0.0 ghc-prim-0.5.3 rts

677+haddock-interfaces:

678+haddock-html:

679+---

680+name: ghc-prim

681+version: 0.5.3

682+visibility: public

683+id: ghc-prim-0.5.3

684+key: ghc-prim-0.5.3

685+license: BSD-3-Clause

686+maintainer: libraries@haskell.org

687+synopsis: GHC primitives

688+description:

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

690+category: GHC

691+exposed: True

692+exposed-modules:

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

694+ GHC.PrimopWrappers GHC.Tuple GHC.Types GHC.Prim

695+import-dirs:

696+library-dirs:

697+dynamic-library-dirs:

698+data-dir:

699+hs-libraries: HSghc-prim-0.5.3

700+extra-libraries: c m

701+include-dirs:

702+depends: rts

703+haddock-interfaces:

704+haddock-html:

705+---

706+name: ghci

707+version: 8.8.4

708+visibility: public

709+id: ghci-8.8.4

710+key: ghci-8.8.4

711+license: BSD-3-Clause

712+maintainer: ghc-devs@haskell.org

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

714+description:

715+ This library offers interfaces which mediate interactions between the

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

717+ backend.

718+category: GHC

719+exposed: True

720+exposed-modules:

721+ GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI

722+ GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes

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

724+ GHCi.TH.Binary SizedSeq

725+import-dirs:

726+library-dirs:

727+dynamic-library-dirs:

728+data-dir:

729+hs-libraries: HSghci-8.8.4

730+include-dirs:

731+depends:

732+ array-0.5.4.0 base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.1

733+ containers-0.6.2.1 deepseq-1.4.4.0 filepath-1.4.2.1 ghc-boot-8.8.4

734+ ghc-boot-th-8.8.4 ghc-heap-8.8.4 template-haskell-2.15.0.0

735+ transformers-0.5.6.2 unix-2.7.2.2

736+haddock-interfaces:

737+haddock-html:

738+---

739+name: haskeline

740+version: 0.7.5.0

741+visibility: public

742+id: haskeline-0.7.5.0

743+key: haskeline-0.7.5.0

744+license: BSD-3-Clause

745+copyright: (c) Judah Jacobson

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

747+author: Judah Jacobson

748+stability: Stable

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

750+synopsis:

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

752+description:

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

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

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

756+ Haskell programs.

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

758+category: User Interfaces

759+exposed: True

760+exposed-modules:

761+ System.Console.Haskeline System.Console.Haskeline.Completion

762+ System.Console.Haskeline.History System.Console.Haskeline.IO

763+ System.Console.Haskeline.MonadException

764+hidden-modules:

765+ System.Console.Haskeline.Backend

766+ System.Console.Haskeline.Backend.WCWidth

767+ System.Console.Haskeline.Command

768+ System.Console.Haskeline.Command.Completion

769+ System.Console.Haskeline.Command.History

770+ System.Console.Haskeline.Command.KillRing

771+ System.Console.Haskeline.Directory System.Console.Haskeline.Emacs

772+ System.Console.Haskeline.InputT System.Console.Haskeline.Key

773+ System.Console.Haskeline.LineState System.Console.Haskeline.Monads

774+ System.Console.Haskeline.Prefs System.Console.Haskeline.Recover

775+ System.Console.Haskeline.RunCommand System.Console.Haskeline.Term

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

777+ System.Console.Haskeline.Backend.Posix

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

779+ System.Console.Haskeline.Backend.DumbTerm

780+import-dirs:

781+library-dirs:

782+dynamic-library-dirs:

783+data-dir:

784+hs-libraries: HShaskeline-0.7.5.0

785+depends:

786+ base-4.13.0.0 bytestring-0.10.10.1 containers-0.6.2.1

787+ directory-1.3.6.0 filepath-1.4.2.1 process-1.6.9.0 stm-2.5.0.0

788+ transformers-0.5.6.2 unix-2.7.2.2

789+haddock-interfaces:

790+haddock-html:

791+---

792+name: hpc

793+version: 0.6.0.3

794+visibility: public

795+id: hpc-0.6.0.3

796+key: hpc-0.6.0.3

797+license: BSD-3-Clause

798+maintainer: ghc-devs@haskell.org

799+author: Andy Gill

800+synopsis: Code Coverage Library for Haskell

801+description:

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

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

804+ information.

805+category: Control

806+exposed: True

807+exposed-modules:

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

809+import-dirs:

810+library-dirs:

811+dynamic-library-dirs:

812+data-dir:

813+hs-libraries: HShpc-0.6.0.3

814+depends:

815+ base-4.13.0.0 containers-0.6.2.1 directory-1.3.6.0 filepath-1.4.2.1

816+ time-1.9.3

817+haddock-interfaces:

818+haddock-html:

819+---

820+name: integer-gmp

821+version: 1.0.2.0

822+visibility: public

823+id: integer-gmp-1.0.2.0

824+key: integer-gmp-1.0.2.0

825+license: BSD-3-Clause

826+maintainer: hvr@gnu.org

827+author: Herbert Valerio Riedel

828+synopsis: Integer library based on GMP

829+description:

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

831+ 'Integer' type based on the

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

833+ This package provides access to the internal representation of

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

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

836+category: Numeric, Algebra

837+exposed: True

838+exposed-modules:

839+ GHC.Integer GHC.Integer.GMP.Internals GHC.Integer.Logarithms

840+ GHC.Integer.Logarithms.Internals

841+hidden-modules: GHC.Integer.Type

842+import-dirs:

843+library-dirs:

844+dynamic-library-dirs:

845+data-dir:

846+hs-libraries: HSinteger-gmp-1.0.2.0

847+extra-libraries: gmp

848+include-dirs:

849+depends: ghc-prim-0.5.3

850+haddock-interfaces:

851+haddock-html:

852+---

853+name: libiserv

854+version: 8.8.4

855+visibility: public

856+id: libiserv-8.8.4

857+key: libiserv-8.8.4

858+license: BSD-3-Clause

859+copyright: XXX

860+maintainer: XXX

861+author: XXX

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

863+category: Development

864+exposed: True

865+exposed-modules: GHCi.Utils Lib

866+import-dirs:

867+library-dirs:

868+dynamic-library-dirs:

869+data-dir:

870+hs-libraries: HSlibiserv-8.8.4

871+depends:

872+ base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.1

873+ containers-0.6.2.1 deepseq-1.4.4.0 ghci-8.8.4 unix-2.7.2.2

874+haddock-interfaces:

875+haddock-html:

876+---

877+name: mtl

878+version: 2.2.2

879+visibility: public

880+id: mtl-2.2.2

881+key: mtl-2.2.2

882+license: BSD-3-Clause

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

884+author: Andy Gill

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

886+synopsis: Monad classes, using functional dependencies

887+description:

888+ Monad classes using functional dependencies, with instances

889+ for various monad transformers, inspired by the paper

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

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

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

893+category: Control

894+exposed: True

895+exposed-modules:

896+ Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error

897+ Control.Monad.Error.Class Control.Monad.Except

898+ Control.Monad.Identity Control.Monad.List Control.Monad.RWS

899+ Control.Monad.RWS.Class Control.Monad.RWS.Lazy

900+ Control.Monad.RWS.Strict Control.Monad.Reader

901+ Control.Monad.Reader.Class Control.Monad.State

902+ Control.Monad.State.Class Control.Monad.State.Lazy

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

904+ Control.Monad.Writer.Class Control.Monad.Writer.Lazy

905+ Control.Monad.Writer.Strict

906+import-dirs:

907+library-dirs:

908+dynamic-library-dirs:

909+data-dir:

910+hs-libraries: HSmtl-2.2.2

911+depends: base-4.13.0.0 transformers-0.5.6.2

912+haddock-interfaces:

913+haddock-html:

914+---

915+name: parsec

916+version: 3.1.14.0

917+visibility: public

918+id: parsec-3.1.14.0

919+key: parsec-3.1.14.0

920+license: BSD-3-Clause

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

922+author:

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

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

925+synopsis: Monadic parser combinators

926+description:

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

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

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

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

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

932+ input stream type.

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

934+ defaults for parsing 'Char'acter data.

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

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

937+ the future.

938+category: Parsing

939+exposed: True

940+exposed-modules:

941+ Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy

942+ Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error

943+ Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm

944+ Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String

945+ Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token

946+ Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char

947+ Text.ParserCombinators.Parsec.Combinator

948+ Text.ParserCombinators.Parsec.Error

949+ Text.ParserCombinators.Parsec.Expr

950+ Text.ParserCombinators.Parsec.Language

951+ Text.ParserCombinators.Parsec.Perm

952+ Text.ParserCombinators.Parsec.Pos

953+ Text.ParserCombinators.Parsec.Prim

954+ Text.ParserCombinators.Parsec.Token

955+import-dirs:

956+library-dirs:

957+dynamic-library-dirs:

958+data-dir:

959+hs-libraries: HSparsec-3.1.14.0

960+depends:

961+ base-4.13.0.0 bytestring-0.10.10.1 mtl-2.2.2 text-1.2.4.0

962+haddock-interfaces:

963+haddock-html:

964+---

965+name: pretty

966+version: 1.1.3.6

967+visibility: public

968+id: pretty-1.1.3.6

969+key: pretty-1.1.3.6

970+license: BSD-3-Clause

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

972+stability: Stable

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

974+synopsis: Pretty-printing library

975+description:

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

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

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

979+ tools.

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

981+ been heavily modified by Simon Peyton Jones.

982+category: Text

983+exposed: True

984+exposed-modules:

985+ Text.PrettyPrint Text.PrettyPrint.Annotated

986+ Text.PrettyPrint.Annotated.HughesPJ

987+ Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ

988+ Text.PrettyPrint.HughesPJClass

989+import-dirs:

990+library-dirs:

991+dynamic-library-dirs:

992+data-dir:

993+hs-libraries: HSpretty-1.1.3.6

994+depends: base-4.13.0.0 deepseq-1.4.4.0 ghc-prim-0.5.3

995+haddock-interfaces:

996+haddock-html:

997+---

998+name: process

999+version: 1.6.9.0

1000+visibility: public

1001+id: process-1.6.9.0

1002+key: process-1.6.9.0

1003+license: BSD-3-Clause

1004+maintainer: libraries@haskell.org

1005+synopsis: Process libraries

1006+description:

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

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

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

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

1011+ read more about it at

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

1013+category: System

1014+exposed: True

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

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

1017+import-dirs:

1018+library-dirs:

1019+dynamic-library-dirs:

1020+data-dir:

1021+hs-libraries: HSprocess-1.6.9.0

1022+include-dirs:

1023+includes: runProcess.h

1024+depends:

1025+ base-4.13.0.0 deepseq-1.4.4.0 directory-1.3.6.0 filepath-1.4.2.1

1026+ unix-2.7.2.2

1027+haddock-interfaces:

1028+haddock-html:

1029+---

1030+name: stm

1031+version: 2.5.0.0

1032+visibility: public

1033+id: stm-2.5.0.0

1034+key: stm-2.5.0.0

1035+license: BSD-3-Clause

1036+maintainer: libraries@haskell.org

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

1038+synopsis: Software Transactional Memory

1039+description:

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

1041+ concurrent communication. The main benefits of STM are

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

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

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

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

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

1047+ 'MVar's.

1048+category: Concurrency

1049+exposed: True

1050+exposed-modules:

1051+ Control.Concurrent.STM Control.Concurrent.STM.TArray

1052+ Control.Concurrent.STM.TBQueue Control.Concurrent.STM.TChan

1053+ Control.Concurrent.STM.TMVar Control.Concurrent.STM.TQueue

1054+ Control.Concurrent.STM.TSem Control.Concurrent.STM.TVar

1055+ Control.Monad.STM

1056+hidden-modules: Control.Sequential.STM

1057+import-dirs:

1058+library-dirs:

1059+dynamic-library-dirs:

1060+data-dir:

1061+hs-libraries: HSstm-2.5.0.0

1062+depends: array-0.5.4.0 base-4.13.0.0

1063+haddock-interfaces:

1064+haddock-html:

1065+---

1066+name: template-haskell

1067+version: 2.15.0.0

1068+visibility: public

1069+id: template-haskell-2.15.0.0

1070+key: template-haskell-2.15.0.0

1071+license: BSD-3-Clause

1072+maintainer: libraries@haskell.org

1073+synopsis: Support library for Template Haskell

1074+description:

1075+ This package provides modules containing facilities for manipulating

1076+ Haskell source code using Template Haskell.

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

1078+ information.

1079+category: Template Haskell

1080+exposed: True

1081+exposed-modules:

1082+ Language.Haskell.TH Language.Haskell.TH.LanguageExtensions

1083+ Language.Haskell.TH.Lib Language.Haskell.TH.Lib.Internal

1084+ Language.Haskell.TH.Ppr Language.Haskell.TH.PprLib

1085+ Language.Haskell.TH.Quote Language.Haskell.TH.Syntax

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

1087+import-dirs:

1088+library-dirs:

1089+dynamic-library-dirs:

1090+data-dir:

1091+hs-libraries: HStemplate-haskell-2.15.0.0

1092+depends: base-4.13.0.0 ghc-boot-th-8.8.4 pretty-1.1.3.6

1093+haddock-interfaces:

1094+haddock-html:

1095+---

1096+name: text

1097+version: 1.2.4.0

1098+visibility: public

1099+id: text-1.2.4.0

1100+key: text-1.2.4.0

1101+license: BSD-2-Clause

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

1103+maintainer:

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

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

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

1107+synopsis: An efficient packed Unicode text type.

1108+description:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1123+ clashes with Prelude functions, e.g.

1124+ > import qualified Data.Text as T

1125+ == ICU Support

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

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

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

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

1130+ based on the well-respected and liberally

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

1132+ == Internal Representation: UTF-16 vs. UTF-8

1133+ Currently the @text@ library uses UTF-16 as its internal representation

1134+ which is [neither a fixed-width nor always the most dense representation](http://utf8everywhere.org/)

1135+ for Unicode text. We're currently investigating the feasibility

1136+ of [changing Text's internal representation to UTF-8](https://github.com/text-utf8)

1137+ and if you need such a 'Text' type right now you might be interested in using the spin-off

1138+ packages <https://hackage.haskell.org/package/text-utf8 text-utf8> and

1139+ <https://hackage.haskell.org/package/text-short text-short>.

1140+category: Data, Text

1141+exposed: True

1142+exposed-modules:

1143+ Data.Text Data.Text.Array Data.Text.Encoding

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

1145+ Data.Text.Internal Data.Text.Internal.Builder

1146+ Data.Text.Internal.Builder.Functions

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

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

1149+ Data.Text.Internal.Encoding.Fusion

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

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

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

1153+ Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping

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

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

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

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

1158+ Data.Text.Internal.Private Data.Text.Internal.Read

1159+ Data.Text.Internal.Search Data.Text.Internal.Unsafe

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

1161+ Data.Text.Lazy Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int

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

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

1164+ Data.Text.Read Data.Text.Unsafe

1165+hidden-modules: Data.Text.Show

1166+import-dirs:

1167+library-dirs:

1168+dynamic-library-dirs:

1169+data-dir:

1170+hs-libraries: HStext-1.2.4.0

1171+depends:

1172+ array-0.5.4.0 base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.1

1173+ deepseq-1.4.4.0 ghc-prim-0.5.3 integer-gmp-1.0.2.0

1174+ template-haskell-2.15.0.0

1175+haddock-interfaces:

1176+haddock-html:

1177+---

1178+name: time

1179+version: 1.9.3

1180+visibility: public

1181+id: time-1.9.3

1182+key: time-1.9.3

1183+license: BSD-3-Clause

1184+maintainer: <ashley@semantic.org>

1185+author: Ashley Yakeley

1186+stability: stable

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

1188+synopsis: A time library

1189+description: Time, clocks and calendars

1190+category: Time

1191+exposed: True

1192+exposed-modules:

1193+ Data.Time Data.Time.Calendar Data.Time.Calendar.Easter

1194+ Data.Time.Calendar.Julian Data.Time.Calendar.MonthDay

1195+ Data.Time.Calendar.OrdinalDate Data.Time.Calendar.WeekDate

1196+ Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System

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

1198+ Data.Time.Format.Internal Data.Time.LocalTime

1199+hidden-modules:

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

1201+ Data.Time.Calendar.Gregorian Data.Time.Calendar.CalendarDiffDays

1202+ Data.Time.Calendar.Week Data.Time.Calendar.JulianYearDay

1203+ Data.Time.Clock.Internal.DiffTime

1204+ Data.Time.Clock.Internal.AbsoluteTime

1205+ Data.Time.Clock.Internal.NominalDiffTime

1206+ Data.Time.Clock.Internal.POSIXTime

1207+ Data.Time.Clock.Internal.UniversalTime

1208+ Data.Time.Clock.Internal.SystemTime

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

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

1211+ Data.Time.LocalTime.Internal.TimeZone

1212+ Data.Time.LocalTime.Internal.TimeOfDay

1213+ Data.Time.LocalTime.Internal.CalendarDiffTime

1214+ Data.Time.LocalTime.Internal.LocalTime

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

1216+ Data.Time.Format.Locale Data.Time.Format.Format.Class

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

1218+ Data.Time.Format.Parse.Instances

1219+import-dirs:

1220+library-dirs:

1221+dynamic-library-dirs:

1222+data-dir:

1223+hs-libraries: HStime-1.9.3

1224+include-dirs:

1225+depends: base-4.13.0.0 deepseq-1.4.4.0

1226+haddock-interfaces:

1227+haddock-html:

1228+---

1229+name: transformers

1230+version: 0.5.6.2

1231+visibility: public

1232+id: transformers-0.5.6.2

1233+key: transformers-0.5.6.2

1234+license: BSD-3-Clause

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

1236+author: Andy Gill, Ross Paterson

1237+synopsis: Concrete functor and monad transformers

1238+description:

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

1240+ the paper

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

1242+ Polymorphism\", by Mark P Jones,

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

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

1245+ This package contains:

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

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

1248+ operations and functions to lift operations associated with other

1249+ transformers.

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

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

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

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

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

1255+ introduced by monad transformers through other transformers.

1256+category: Control

1257+exposed: True

1258+exposed-modules:

1259+ Control.Applicative.Backwards Control.Applicative.Lift

1260+ Control.Monad.Signatures Control.Monad.Trans.Accum

1261+ Control.Monad.Trans.Class Control.Monad.Trans.Cont

1262+ Control.Monad.Trans.Error Control.Monad.Trans.Except

1263+ Control.Monad.Trans.Identity Control.Monad.Trans.List

1264+ Control.Monad.Trans.Maybe Control.Monad.Trans.RWS

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

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

1267+ Control.Monad.Trans.Select Control.Monad.Trans.State

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

1269+ Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS

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

1271+ Data.Functor.Constant Data.Functor.Reverse

1272+import-dirs:

1273+library-dirs:

1274+dynamic-library-dirs:

1275+data-dir:

1276+hs-libraries: HStransformers-0.5.6.2

1277+depends: base-4.13.0.0

1278+haddock-interfaces:

1279+haddock-html:

1280+---

1281+name: unix

1282+version: 2.7.2.2

1283+visibility: public

1284+id: unix-2.7.2.2

1285+key: unix-2.7.2.2

1286+license: BSD-3-Clause

1287+maintainer: libraries@haskell.org

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

1289+synopsis: POSIX functionality

1290+description:

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

1292+ services standardised by

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

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

1295+ Environments - IEEE Std. 1003.1).

1296+ The package is not supported under Windows.

1297+category: System

1298+exposed: True

1299+exposed-modules:

1300+ System.Posix System.Posix.ByteString

1301+ System.Posix.ByteString.FilePath System.Posix.Directory

1302+ System.Posix.Directory.ByteString System.Posix.DynamicLinker

1303+ System.Posix.DynamicLinker.ByteString

1304+ System.Posix.DynamicLinker.Module

1305+ System.Posix.DynamicLinker.Module.ByteString

1306+ System.Posix.DynamicLinker.Prim System.Posix.Env

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

1308+ System.Posix.Files System.Posix.Files.ByteString System.Posix.IO

1309+ System.Posix.IO.ByteString System.Posix.Process

1310+ System.Posix.Process.ByteString System.Posix.Process.Internals

1311+ System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem

1312+ System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp

1313+ System.Posix.Temp.ByteString System.Posix.Terminal

1314+ System.Posix.Terminal.ByteString System.Posix.Time

1315+ System.Posix.Unistd System.Posix.User

1316+hidden-modules:

1317+ System.Posix.Directory.Common System.Posix.DynamicLinker.Common

1318+ System.Posix.Files.Common System.Posix.IO.Common

1319+ System.Posix.Process.Common System.Posix.Terminal.Common

1320+import-dirs:

1321+library-dirs:

1322+dynamic-library-dirs:

1323+data-dir:

1324+hs-libraries: HSunix-2.7.2.2

1325+extra-libraries: rt util dl pthread

1326+include-dirs:

1327+includes: HsUnix.h execvpe.h

1328+depends: base-4.13.0.0 bytestring-0.10.10.1 time-1.9.3

1329+haddock-interfaces:

1330+haddock-html:

1331+---

1332+name: rts

1333+version: 1.0

1334+visibility: public

1335+id: rts

1336+key: rts

1337+license: BSD-3-Clause

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

1339+exposed: True

1340+library-dirs:

1341+hs-libraries: HSrts

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

1343+include-dirs:

1344+includes: Stg.h

1345+ld-options:

1346+ "-Wl,-u,base_GHCziTopHandler_runIO_closure"

1347+ "-Wl,-u,base_GHCziTopHandler_runNonIO_closure"

1348+ "-Wl,-u,ghczmprim_GHCziTuple_Z0T_closure"

1349+ "-Wl,-u,ghczmprim_GHCziTypes_True_closure"

1350+ "-Wl,-u,ghczmprim_GHCziTypes_False_closure"

1351+ "-Wl,-u,base_GHCziPack_unpackCString_closure"

1352+ "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure"

1353+ "-Wl,-u,base_GHCziIOziException_stackOverflow_closure"

1354+ "-Wl,-u,base_GHCziIOziException_heapOverflow_closure"

1355+ "-Wl,-u,base_GHCziIOziException_allocationLimitExceeded_closure"

1356+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"

1357+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"

1358+ "-Wl,-u,base_GHCziIOziException_cannotCompactFunction_closure"

1359+ "-Wl,-u,base_GHCziIOziException_cannotCompactPinned_closure"

1360+ "-Wl,-u,base_GHCziIOziException_cannotCompactMutable_closure"

1361+ "-Wl,-u,base_ControlziExceptionziBase_absentSumFieldError_closure"

1362+ "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure"

1363+ "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure"

1364+ "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure"

1365+ "-Wl,-u,base_GHCziConcziSync_runSparks_closure"

1366+ "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure"

1367+ "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"

1368+ "-Wl,-u,base_GHCziConcziSignal_runHandlersPtr_closure"

1369+ "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure"

1370+ "-Wl,-u,base_GHCziTopHandler_runMainIO_closure"

1371+ "-Wl,-u,ghczmprim_GHCziTypes_Czh_con_info"

1372+ "-Wl,-u,ghczmprim_GHCziTypes_Izh_con_info"

1373+ "-Wl,-u,ghczmprim_GHCziTypes_Fzh_con_info"

1374+ "-Wl,-u,ghczmprim_GHCziTypes_Dzh_con_info"

1375+ "-Wl,-u,ghczmprim_GHCziTypes_Wzh_con_info"

1376+ "-Wl,-u,base_GHCziPtr_Ptr_con_info"

1377+ "-Wl,-u,base_GHCziPtr_FunPtr_con_info"

1378+ "-Wl,-u,base_GHCziInt_I8zh_con_info"

1379+ "-Wl,-u,base_GHCziInt_I16zh_con_info"

1380+ "-Wl,-u,base_GHCziInt_I32zh_con_info"

1381+ "-Wl,-u,base_GHCziInt_I64zh_con_info"

1382+ "-Wl,-u,base_GHCziWord_W8zh_con_info"

1383+ "-Wl,-u,base_GHCziWord_W16zh_con_info"

1384+ "-Wl,-u,base_GHCziWord_W32zh_con_info"

1385+ "-Wl,-u,base_GHCziWord_W64zh_con_info"

1386+ "-Wl,-u,base_GHCziStable_StablePtr_con_info"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1404+ "-Wl,-u,hs_atomicwrite64"

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

@@ -0,0 +1 @@

1+GHC package manager version 8.8.4

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.8.4-x86_64-linux/ghc/infonew file+57

@@ -0,0 +1,57 @@

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

2+ ,("GCC extra via C opts"," -fwrapv -fno-builtin")

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

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

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

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

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

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

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

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

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

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

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

14+ ,("touch command","touch")

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

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

17+ ,("libtool command","libtool")

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

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

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

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

22+ ,("target has GNU nonexec stack","True")

23+ ,("target has .ident directive","True")

24+ ,("target has subsections via symbols","False")

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

26+ ,("Unregisterised","NO")

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

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

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

30+ ,("Project version","8.8.4")

31+ ,("Project Git commit id","6cf8f835267581d551ca6695b3b02c34797e2cf4")

32+ ,("Booter version","8.4.4")

33+ ,("Stage","1")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

51+ ,("Uses unit IDs","YES")

52+ ,("Dynamic by default","NO")

53+ ,("GHC Dynamic","NO")

54+ ,("GHC Profiled","NO")

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

56+ ,("Debug on","False")

57+ ]

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.8.4-x86_64-linux/ghc/numeric-versionnew file+1

@@ -0,0 +1 @@

1+8.8.4

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.8.4-x86_64-linux/ghc/supported-languagesnew file+247

@@ -0,0 +1,247 @@

1+Haskell98

2+Haskell2010

3+Unsafe

4+Trustworthy

5+Safe

6+AllowAmbiguousTypes

7+NoAllowAmbiguousTypes

8+AlternativeLayoutRule

9+NoAlternativeLayoutRule

10+AlternativeLayoutRuleTransitional

11+NoAlternativeLayoutRuleTransitional

12+Arrows

13+NoArrows

14+AutoDeriveTypeable

15+NoAutoDeriveTypeable

16+BangPatterns

17+NoBangPatterns

18+BinaryLiterals

19+NoBinaryLiterals

20+CApiFFI

21+NoCApiFFI

22+CPP

23+NoCPP

24+ConstrainedClassMethods

25+NoConstrainedClassMethods

26+ConstraintKinds

27+NoConstraintKinds

28+DataKinds

29+NoDataKinds

30+DatatypeContexts

31+NoDatatypeContexts

32+DefaultSignatures

33+NoDefaultSignatures

34+DeriveAnyClass

35+NoDeriveAnyClass

36+DeriveDataTypeable

37+NoDeriveDataTypeable

38+DeriveFoldable

39+NoDeriveFoldable

40+DeriveFunctor

41+NoDeriveFunctor

42+DeriveGeneric

43+NoDeriveGeneric

44+DeriveLift

45+NoDeriveLift

46+DeriveTraversable

47+NoDeriveTraversable

48+DerivingStrategies

49+NoDerivingStrategies

50+DerivingVia

51+NoDerivingVia

52+DisambiguateRecordFields

53+NoDisambiguateRecordFields

54+DoAndIfThenElse

55+NoDoAndIfThenElse

56+BlockArguments

57+NoBlockArguments

58+DoRec

59+NoDoRec

60+DuplicateRecordFields

61+NoDuplicateRecordFields

62+EmptyCase

63+NoEmptyCase

64+EmptyDataDecls

65+NoEmptyDataDecls

66+EmptyDataDeriving

67+NoEmptyDataDeriving

68+ExistentialQuantification

69+NoExistentialQuantification

70+ExplicitForAll

71+NoExplicitForAll

72+ExplicitNamespaces

73+NoExplicitNamespaces

74+ExtendedDefaultRules

75+NoExtendedDefaultRules

76+FlexibleContexts

77+NoFlexibleContexts

78+FlexibleInstances

79+NoFlexibleInstances

80+ForeignFunctionInterface

81+NoForeignFunctionInterface

82+FunctionalDependencies

83+NoFunctionalDependencies

84+GADTSyntax

85+NoGADTSyntax

86+GADTs

87+NoGADTs

88+GHCForeignImportPrim

89+NoGHCForeignImportPrim

90+GeneralizedNewtypeDeriving

91+NoGeneralizedNewtypeDeriving

92+GeneralisedNewtypeDeriving

93+NoGeneralisedNewtypeDeriving

94+ImplicitParams

95+NoImplicitParams

96+ImplicitPrelude

97+NoImplicitPrelude

98+ImpredicativeTypes

99+NoImpredicativeTypes

100+IncoherentInstances

101+NoIncoherentInstances

102+TypeFamilyDependencies

103+NoTypeFamilyDependencies

104+InstanceSigs

105+NoInstanceSigs

106+ApplicativeDo

107+NoApplicativeDo

108+InterruptibleFFI

109+NoInterruptibleFFI

110+JavaScriptFFI

111+NoJavaScriptFFI

112+KindSignatures

113+NoKindSignatures

114+LambdaCase

115+NoLambdaCase

116+LiberalTypeSynonyms

117+NoLiberalTypeSynonyms

118+MagicHash

119+NoMagicHash

120+MonadComprehensions

121+NoMonadComprehensions

122+MonadFailDesugaring

123+NoMonadFailDesugaring

124+MonoLocalBinds

125+NoMonoLocalBinds

126+MonoPatBinds

127+NoMonoPatBinds

128+MonomorphismRestriction

129+NoMonomorphismRestriction

130+MultiParamTypeClasses

131+NoMultiParamTypeClasses

132+MultiWayIf

133+NoMultiWayIf

134+NumericUnderscores

135+NoNumericUnderscores

136+NPlusKPatterns

137+NoNPlusKPatterns

138+NamedFieldPuns

139+NoNamedFieldPuns

140+NamedWildCards

141+NoNamedWildCards

142+NegativeLiterals

143+NoNegativeLiterals

144+HexFloatLiterals

145+NoHexFloatLiterals

146+NondecreasingIndentation

147+NoNondecreasingIndentation

148+NullaryTypeClasses

149+NoNullaryTypeClasses

150+NumDecimals

151+NoNumDecimals

152+OverlappingInstances

153+NoOverlappingInstances

154+OverloadedLabels

155+NoOverloadedLabels

156+OverloadedLists

157+NoOverloadedLists

158+OverloadedStrings

159+NoOverloadedStrings

160+PackageImports

161+NoPackageImports

162+ParallelArrays

163+NoParallelArrays

164+ParallelListComp

165+NoParallelListComp

166+PartialTypeSignatures

167+NoPartialTypeSignatures

168+PatternGuards

169+NoPatternGuards

170+PatternSignatures

171+NoPatternSignatures

172+PatternSynonyms

173+NoPatternSynonyms

174+PolyKinds

175+NoPolyKinds

176+PolymorphicComponents

177+NoPolymorphicComponents

178+QuantifiedConstraints

179+NoQuantifiedConstraints

180+PostfixOperators

181+NoPostfixOperators

182+QuasiQuotes

183+NoQuasiQuotes

184+Rank2Types

185+NoRank2Types

186+RankNTypes

187+NoRankNTypes

188+RebindableSyntax

189+NoRebindableSyntax

190+RecordPuns

191+NoRecordPuns

192+RecordWildCards

193+NoRecordWildCards

194+RecursiveDo

195+NoRecursiveDo

196+RelaxedLayout

197+NoRelaxedLayout

198+RelaxedPolyRec

199+NoRelaxedPolyRec

200+RoleAnnotations

201+NoRoleAnnotations

202+ScopedTypeVariables

203+NoScopedTypeVariables

204+StandaloneDeriving

205+NoStandaloneDeriving

206+StarIsType

207+NoStarIsType

208+StaticPointers

209+NoStaticPointers

210+Strict

211+NoStrict

212+StrictData

213+NoStrictData

214+TemplateHaskell

215+NoTemplateHaskell

216+TemplateHaskellQuotes

217+NoTemplateHaskellQuotes

218+TraditionalRecordSyntax

219+NoTraditionalRecordSyntax

220+TransformListComp

221+NoTransformListComp

222+TupleSections

223+NoTupleSections

224+TypeApplications

225+NoTypeApplications

226+TypeInType

227+NoTypeInType

228+TypeFamilies

229+NoTypeFamilies

230+TypeOperators

231+NoTypeOperators

232+TypeSynonymInstances

233+NoTypeSynonymInstances

234+UnboxedTuples

235+NoUnboxedTuples

236+UnboxedSums

237+NoUnboxedSums

238+UndecidableInstances

239+NoUndecidableInstances

240+UndecidableSuperClasses

241+NoUndecidableSuperClasses

242+UnicodeSyntax

243+NoUnicodeSyntax

244+UnliftedFFITypes

245+NoUnliftedFFITypes

246+ViewPatterns

247+NoViewPatterns

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

@@ -0,0 +1 @@

1+The Glorious Glasgow Haskell Compilation System, version 8.8.4

materialized/dummy-ghc/ghc-8.10.1-x86_64-darwin/ghc/info+1−1

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

4343 ,("RTS expects libdw","NO")

4444 ,("Project version","8.10.1")

4545 ,("Project Git commit id","5c3cadf5db0d7eb859ff2c278ab07585c7df17b5")

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

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

4747 ,("Stage","2")

4848 ,("Build platform","x86_64-apple-darwin")

4949 ,("Host platform","x86_64-apple-darwin")

materialized/dummy-ghc/ghc-8.10.1-x86_64-linux/ghc/info+1−1

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

4343 ,("RTS expects libdw","NO")

4444 ,("Project version","8.10.1")

4545 ,("Project Git commit id","5c3cadf5db0d7eb859ff2c278ab07585c7df17b5")

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

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

4747 ,("Stage","2")

4848 ,("Build platform","x86_64-unknown-linux")

4949 ,("Host platform","x86_64-unknown-linux")

materialized/dummy-ghc/ghc-8.8.4-x86_64-darwin/ghc-pkg/dump-globalnew file+1591

@@ -0,0 +1,1591 @@