f624ca5 · haskell.nix · git.iko.soy

.buildkite/pipeline.yml+5−5

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

11steps:

2− - label: 'Run tests with ghc8105'

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

2+ - label: 'Run tests with ghc8106'

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

44 agents:

55 system: x86_64-linux

66

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

1414 agents:

1515 system: x86_64-linux

1616

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

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

1818 command:

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

19+ - nix-build build.nix -A maintainer-scripts.check-closure-size --argstr compiler-nix-name ghc8106 -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 ghc8105 -o check-path-support.sh

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

4040 - ./check-path-support.sh

ci.nix+6−5

@@ -29,12 +29,13 @@

2929 ghc8105 = false;

3030 } // nixpkgs.lib.optionalAttrs (nixpkgsName == "R2105") {

3131 ghc865 = false;

32− ghc8105 = true;

32+ ghc8106 = true;

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

3434 ghc865 = false;

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

3636 ghc8104 = false;

37− ghc8105 = true;

37+ ghc8105 = false;

38+ ghc8106 = true;

3839 ghc901 = true;

3940 ghc810420210212 = false;

4041 });

@@ -47,13 +48,13 @@

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

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

4950 let lib = nixpkgs.lib;

50− in lib.optionalAttrs (nixpkgsName == "unstable" && (__elem compiler-nix-name ["ghc8105"])) {

51+ in lib.optionalAttrs (nixpkgsName == "unstable" && (__elem compiler-nix-name ["ghc8106"])) {

5152 inherit (lib.systems.examples) ghcjs;

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

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

54+ nixpkgsName == "unstable" && (__elem compiler-nix-name ["ghc8106"])) {

5455 # Windows cross compilation is currently broken on macOS

5556 inherit (lib.systems.examples) mingwW64;

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

57+ } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && compiler-nix-name == "ghc8106") {

5758 # Musl cross only works on linux

5859 # aarch64 cross only works on linux

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

compiler/ghc/default.nix+1−1

@@ -350,7 +350,7 @@ stdenv.mkDerivation (rec {

350350 dontStrip = true;

351351 dontPatchELF = true;

352352 noAuditTmpdir = true;

353−} // lib.optionalAttrs (ghc-version == "8.10.5" && stdenv.buildPlatform.isDarwin) {

353+} // lib.optionalAttrs ((ghc-version == "8.10.5" || ghc-version == "8.10.6") && stdenv.buildPlatform.isDarwin) {

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

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

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

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

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

11{

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

3− "rev": "e4cd4232a31f6371c761acd93853702f4c7ca74c",

4− "sha256": "sha256-cdFMJQXuXrdafyOWGbtiH5mZ2Wgzu8fuZKbOzUK6ouA=",

3+ "rev": "929e11f7d8109ac3c761b1beec5f7d3995b59564",

4+ "sha256": "0dqqldj5ljblb9dmnj68gampp4hxrb5pc77dln3wrd8sdb8b8jlw",

55 "fetchSubmodules": true

66}

default.nix+10−5

@@ -13,11 +13,16 @@ let

1313 sha256 = "sha256:054nsfqh3wy6v6bjamw0k91xl8v1rc5x2laic8mphrkrhzvyz5hi";

1414 };

1515 self = import flake-compat {

16− # This is a workaround for https://github.com/edolstra/flake-compat/issues/25:

17− # If we're in pure-eval mode (signified by lack of builtins.currentSystem), then we

18− # bypass flake-compat's rootSrc cleaning by evading its detection of this as a git

19− # repo

20− src = if builtins ? currentSystem then ./. else { outPath = ./.; };

16+ # We bypass flake-compat's rootSrc cleaning by evading its detection of this as a git

17+ # repo.

18+ # This is done for 3 reasons:

19+ # * To workaround https://github.com/edolstra/flake-compat/issues/25

20+ # * Make `updateMaterilized` scripts work (if filtering is done by `flake-compat`

21+ # the `updateMaterilized` scripts will try to update the copy in the store).

22+ # * Allow more granular filtering done by the tests (the use of `cleanGit` and `cleanSourceWith`

23+ # in `test/default.nix`). If `flake-compat` copies the whole git repo, any change to the

24+ # repo causes a change of input for all tests.

25+ src = { outPath = ./.; };

2126 inherit pkgs;

2227 };

2328in self.defaultNix // (self.defaultNix.internal.compat

docs/reference/supported-ghc-versions.md+4−3

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

2121|------------------|--------------------|-------------|-----------------------|---------------|

2222| 20.09 | `nixpkgs-2009` | 8.6.5 | `ghc865` | No |

23−| 20.09 | `nixpkgs-2009` | 8.10.5 | `ghc8105` | No |

23+| 20.09 | `nixpkgs-2009` | 8.10.6 | `ghc8106` | No |

2424| 21.05 | `nixpkgs-2105` | 8.6.5 | `ghc865` | No |

25−| 21.05 | `nixpkgs-2105` | 8.10.5 | `ghc8105` | Yes |

25+| 21.05 | `nixpkgs-2105` | 8.10.6 | `ghc8106` | Yes |

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

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

2828| unstable | `nixpkgs-unstable` | 8.10.4 | `ghc8104` | No |

29−| unstable | `nixpkgs-unstable` | 8.10.5 | `ghc8105` | Yes |

29+| unstable | `nixpkgs-unstable` | 8.10.5 | `ghc8105` | No |

30+| unstable | `nixpkgs-unstable` | 8.10.6 | `ghc8106` | Yes |

3031| unstable | `nixpkgs-unstable` | 9.0.1 | `ghc901` | Yes |

3132

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

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

@@ -81,16 +81,16 @@ The configuration arguments for `Hix` can be (from highest precedence to lowest)

8181

8282* Placed in `~/.config/hix/hix.conf`

8383

84−For example to build with GHC 8.10.5:

84+For example to build with GHC 8.10.6:

8585

8686```

87−hix-shell --argstr compiler-nix-name ghc8105 --run 'cabal build'

87+hix-shell --argstr compiler-nix-name ghc8106 --run 'cabal build'

8888```

8989

9090or add a `nix/hix.nix` or `~/.config/hix/hix.conf` file:

9191

9292```nix

93−{ compiler-nix-name = "ghc8105"; }

93+{ compiler-nix-name = "ghc8106"; }

9494```

9595

9696Here are just a few of the other configuration arguments you could use

lib/ghcjs-project.nix+3−3

@@ -23,7 +23,7 @@

2323{ src

2424, compiler-nix-name

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

26−, ghcjsVersion

26+, ghcjsVersion # Version in the ghcjs.cabal file (that we will replace)

2727, ghcVersion ? ghc.version

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

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

@@ -135,9 +135,9 @@ let

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

136136 src = configured-src;

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

138− compiler-nix-name = if isGhcjs810 then "ghc8105" else if isGhcjs88 then "ghc884" else "ghc865";

138+ inherit compiler-nix-name;

139139 configureArgs = pkgs.lib.optionalString (isGhcjs88 && !isGhcjs810) "--constraint='Cabal >=3.0.2.0 && <3.1'";

140− materialized = ../materialized + (if isGhcjs810 then "/ghcjs8105" else if isGhcjs88 then "/ghcjs884" else "/ghcjs865");

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

141141 modules = [

142142 {

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

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.10.6-x86_64-linux/ghc-pkg/dump-globalnew file+1443

@@ -0,0 +1,1443 @@

1+name: Cabal

2+version: 3.2.1.0

3+visibility: public

4+id: Cabal-3.2.1.0

5+key: Cabal-3.2.1.0

6+license: BSD-3-Clause

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

8+maintainer: cabal-devel@haskell.org

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

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

11+synopsis: A framework for packaging Haskell software

12+description:

13+ The Haskell Common Architecture for Building Applications and

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

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

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

17+ organizing, and cataloging Haskell libraries and tools.

18+category: Distribution

19+exposed: True

20+exposed-modules:

21+ Distribution.Backpack Distribution.Backpack.ComponentsGraph

22+ Distribution.Backpack.Configure

23+ Distribution.Backpack.ConfiguredComponent

24+ Distribution.Backpack.DescribeUnitId

25+ Distribution.Backpack.FullUnitId

26+ Distribution.Backpack.LinkedComponent

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

28+ Distribution.Backpack.PreModuleShape Distribution.CabalSpecVersion

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

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

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

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

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

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

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

36+ Distribution.Compat.Process Distribution.Compat.ResponseFile

37+ Distribution.Compat.Semigroup Distribution.Compat.Stack

38+ Distribution.Compat.Time Distribution.Compat.Typeable

39+ Distribution.Compiler Distribution.FieldGrammar

40+ Distribution.FieldGrammar.Class

41+ Distribution.FieldGrammar.FieldDescrs

42+ Distribution.FieldGrammar.Parsec Distribution.FieldGrammar.Pretty

43+ Distribution.Fields Distribution.Fields.ConfVar

44+ Distribution.Fields.Field Distribution.Fields.Lexer

45+ Distribution.Fields.LexerMonad Distribution.Fields.ParseResult

46+ Distribution.Fields.Parser Distribution.Fields.Pretty

47+ Distribution.InstalledPackageInfo Distribution.License

48+ Distribution.Make Distribution.ModuleName Distribution.Package

49+ Distribution.PackageDescription

50+ Distribution.PackageDescription.Check

51+ Distribution.PackageDescription.Configuration

52+ Distribution.PackageDescription.FieldGrammar

53+ Distribution.PackageDescription.Parsec

54+ Distribution.PackageDescription.PrettyPrint

55+ Distribution.PackageDescription.Quirks

56+ Distribution.PackageDescription.Utils Distribution.Parsec

57+ Distribution.Parsec.Error Distribution.Parsec.FieldLineStream

58+ Distribution.Parsec.Newtypes Distribution.Parsec.Position

59+ Distribution.Parsec.Warning Distribution.Pretty Distribution.ReadE

60+ Distribution.SPDX Distribution.SPDX.License

61+ Distribution.SPDX.LicenseExceptionId

62+ Distribution.SPDX.LicenseExpression Distribution.SPDX.LicenseId

63+ Distribution.SPDX.LicenseListVersion

64+ Distribution.SPDX.LicenseReference Distribution.Simple

65+ Distribution.Simple.Bench Distribution.Simple.Build

66+ Distribution.Simple.Build.Macros

67+ Distribution.Simple.Build.PathsModule

68+ Distribution.Simple.BuildPaths Distribution.Simple.BuildTarget

69+ Distribution.Simple.BuildToolDepends Distribution.Simple.CCompiler

70+ Distribution.Simple.Command Distribution.Simple.Compiler

71+ Distribution.Simple.Configure Distribution.Simple.Doctest

72+ Distribution.Simple.Flag Distribution.Simple.GHC

73+ Distribution.Simple.GHCJS Distribution.Simple.Glob

74+ Distribution.Simple.Haddock Distribution.Simple.HaskellSuite

75+ Distribution.Simple.Hpc Distribution.Simple.Install

76+ Distribution.Simple.InstallDirs

77+ Distribution.Simple.InstallDirs.Internal

78+ Distribution.Simple.LocalBuildInfo Distribution.Simple.PackageIndex

79+ Distribution.Simple.PreProcess Distribution.Simple.PreProcess.Unlit

80+ Distribution.Simple.Program Distribution.Simple.Program.Ar

81+ Distribution.Simple.Program.Builtin Distribution.Simple.Program.Db

82+ Distribution.Simple.Program.Find Distribution.Simple.Program.GHC

83+ Distribution.Simple.Program.HcPkg Distribution.Simple.Program.Hpc

84+ Distribution.Simple.Program.Internal Distribution.Simple.Program.Ld

85+ Distribution.Simple.Program.ResponseFile

86+ Distribution.Simple.Program.Run Distribution.Simple.Program.Script

87+ Distribution.Simple.Program.Strip Distribution.Simple.Program.Types

88+ Distribution.Simple.Register Distribution.Simple.Setup

89+ Distribution.Simple.ShowBuildInfo Distribution.Simple.SrcDist

90+ Distribution.Simple.Test Distribution.Simple.Test.ExeV10

91+ Distribution.Simple.Test.LibV09 Distribution.Simple.Test.Log

92+ Distribution.Simple.UHC Distribution.Simple.UserHooks

93+ Distribution.Simple.Utils Distribution.System

94+ Distribution.TestSuite Distribution.Text

95+ Distribution.Types.AbiDependency Distribution.Types.AbiHash

96+ Distribution.Types.AnnotatedId Distribution.Types.Benchmark

97+ Distribution.Types.Benchmark.Lens

98+ Distribution.Types.BenchmarkInterface

99+ Distribution.Types.BenchmarkType Distribution.Types.BuildInfo

100+ Distribution.Types.BuildInfo.Lens Distribution.Types.BuildType

101+ Distribution.Types.Component Distribution.Types.ComponentId

102+ Distribution.Types.ComponentInclude

103+ Distribution.Types.ComponentLocalBuildInfo

104+ Distribution.Types.ComponentName

105+ Distribution.Types.ComponentRequestedSpec

106+ Distribution.Types.CondTree Distribution.Types.Condition

107+ Distribution.Types.ConfVar Distribution.Types.Dependency

108+ Distribution.Types.DependencyMap Distribution.Types.ExeDependency

109+ Distribution.Types.Executable Distribution.Types.Executable.Lens

110+ Distribution.Types.ExecutableScope Distribution.Types.ExposedModule

111+ Distribution.Types.Flag Distribution.Types.ForeignLib

112+ Distribution.Types.ForeignLib.Lens

113+ Distribution.Types.ForeignLibOption

114+ Distribution.Types.ForeignLibType

115+ Distribution.Types.GenericPackageDescription

116+ Distribution.Types.GenericPackageDescription.Lens

117+ Distribution.Types.GivenComponent

118+ Distribution.Types.HookedBuildInfo

119+ Distribution.Types.IncludeRenaming

120+ Distribution.Types.InstalledPackageInfo

121+ Distribution.Types.InstalledPackageInfo.FieldGrammar

122+ Distribution.Types.InstalledPackageInfo.Lens

123+ Distribution.Types.LegacyExeDependency Distribution.Types.Lens

124+ Distribution.Types.Library Distribution.Types.Library.Lens

125+ Distribution.Types.LibraryName Distribution.Types.LibraryVisibility

126+ Distribution.Types.LocalBuildInfo Distribution.Types.Mixin

127+ Distribution.Types.Module Distribution.Types.ModuleReexport

128+ Distribution.Types.ModuleRenaming

129+ Distribution.Types.MungedPackageId

130+ Distribution.Types.MungedPackageName

131+ Distribution.Types.PackageDescription

132+ Distribution.Types.PackageDescription.Lens

133+ Distribution.Types.PackageId Distribution.Types.PackageId.Lens

134+ Distribution.Types.PackageName Distribution.Types.PackageName.Magic

135+ Distribution.Types.PackageVersionConstraint

136+ Distribution.Types.PkgconfigDependency

137+ Distribution.Types.PkgconfigName

138+ Distribution.Types.PkgconfigVersion

139+ Distribution.Types.PkgconfigVersionRange

140+ Distribution.Types.SetupBuildInfo

141+ Distribution.Types.SetupBuildInfo.Lens

142+ Distribution.Types.SourceRepo Distribution.Types.SourceRepo.Lens

143+ Distribution.Types.TargetInfo Distribution.Types.TestSuite

144+ Distribution.Types.TestSuite.Lens

145+ Distribution.Types.TestSuiteInterface Distribution.Types.TestType

146+ Distribution.Types.UnitId Distribution.Types.UnqualComponentName

147+ Distribution.Types.Version Distribution.Types.VersionInterval

148+ Distribution.Types.VersionRange

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

150+ Distribution.Utils.IOData Distribution.Utils.LogProgress

151+ Distribution.Utils.MD5 Distribution.Utils.MapAccum

152+ Distribution.Utils.NubList Distribution.Utils.Progress

153+ Distribution.Utils.ShortText Distribution.Utils.Structured

154+ Distribution.Verbosity Distribution.Verbosity.Internal

155+ Distribution.Version Language.Haskell.Extension

156+hidden-modules:

157+ Distribution.Backpack.PreExistingComponent

158+ Distribution.Backpack.ReadyComponent Distribution.Backpack.MixLink

159+ Distribution.Backpack.ModuleScope Distribution.Backpack.UnifyM

160+ Distribution.Backpack.Id Distribution.Utils.UnionFind

161+ Distribution.Utils.Base62 Distribution.Compat.Async

162+ Distribution.Compat.CopyFile Distribution.Compat.GetShortPathName

163+ Distribution.Compat.MonadFail Distribution.Compat.Prelude

164+ Distribution.Compat.SnocList Distribution.GetOpt Distribution.Lex

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

166+ Distribution.Simple.GHC.Internal Distribution.Simple.GHC.ImplInfo

167+ Distribution.Simple.Utils.Json Paths_Cabal

168+import-dirs:

169+library-dirs:

170+dynamic-library-dirs:

171+data-dir:

172+hs-libraries: HSCabal-3.2.1.0

173+depends:

174+ array-0.5.4.0 base-4.14.3.0 binary-0.8.8.0 bytestring-0.10.12.0

175+ containers-0.6.5.1 deepseq-1.4.4.0 directory-1.3.6.0

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

177+ process-1.6.13.2 text-1.2.4.1 time-1.9.3 transformers-0.5.6.2

178+ unix-2.7.2.2

179+haddock-interfaces:

180+haddock-html:

181+---

182+name: array

183+version: 0.5.4.0

184+visibility: public

185+id: array-0.5.4.0

186+key: array-0.5.4.0

187+license: BSD-3-Clause

188+maintainer: libraries@haskell.org

189+synopsis: Mutable and immutable arrays

190+description:

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

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

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

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

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

196+category: Data Structures

197+exposed: True

198+exposed-modules:

199+ Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO

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

201+ Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe

202+ Data.Array.Storable Data.Array.Storable.Internals

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

204+import-dirs:

205+library-dirs:

206+dynamic-library-dirs:

207+data-dir:

208+hs-libraries: HSarray-0.5.4.0

209+depends: base-4.14.3.0

210+haddock-interfaces:

211+haddock-html:

212+---

213+name: base

214+version: 4.14.3.0

215+visibility: public

216+id: base-4.14.3.0

217+key: base-4.14.3.0

218+license: BSD-3-Clause

219+maintainer: libraries@haskell.org

220+synopsis: Basic libraries

221+description:

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

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

224+ structures to parsing combinators and debugging utilities.

225+category: Prelude

226+exposed: True

227+exposed-modules:

228+ Control.Applicative Control.Arrow Control.Category

229+ Control.Concurrent Control.Concurrent.Chan Control.Concurrent.MVar

230+ Control.Concurrent.QSem Control.Concurrent.QSemN Control.Exception

231+ Control.Exception.Base Control.Monad Control.Monad.Fail

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

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

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

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

236+ Data.Bifoldable Data.Bifunctor Data.Bitraversable Data.Bits

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

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

239+ Data.Functor Data.Functor.Classes Data.Functor.Compose

240+ Data.Functor.Const Data.Functor.Contravariant Data.Functor.Identity

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

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

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

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

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

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

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

248+ Foreign.C.Types Foreign.Concurrent Foreign.ForeignPtr

249+ Foreign.ForeignPtr.Safe Foreign.ForeignPtr.Unsafe Foreign.Marshal

250+ Foreign.Marshal.Alloc Foreign.Marshal.Array Foreign.Marshal.Error

251+ Foreign.Marshal.Pool Foreign.Marshal.Safe Foreign.Marshal.Unsafe

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

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

254+ GHC.Conc GHC.Conc.IO GHC.Conc.Signal GHC.Conc.Sync

255+ GHC.ConsoleHandler GHC.Constants GHC.Desugar GHC.Enum

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

257+ GHC.ExecutionStack GHC.ExecutionStack.Internal GHC.Exts

258+ GHC.Fingerprint GHC.Fingerprint.Type GHC.Float

259+ GHC.Float.ConversionUtils GHC.Float.RealFracMethods GHC.Foreign

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

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

262+ GHC.IO.Encoding.CodePage GHC.IO.Encoding.Failure

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

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

265+ GHC.IO.Exception GHC.IO.FD GHC.IO.Handle GHC.IO.Handle.FD

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

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

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

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

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

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

272+ GHC.StableName GHC.Stack GHC.Stack.CCS GHC.Stack.Types

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

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

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

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

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

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

279+ System.Timeout Text.ParserCombinators.ReadP

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

281+ Text.Show Text.Show.Functions Type.Reflection

282+ Type.Reflection.Unsafe Unsafe.Coerce

283+hidden-modules:

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

285+ Data.OldList Data.Semigroup.Internal Data.Typeable.Internal

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

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

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

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

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

291+ GHC.Event.Control GHC.Event.EPoll GHC.Event.IntTable

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

293+ GHC.Event.Poll GHC.Event.Thread GHC.Event.TimerManager

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

295+ System.CPUTime.Posix.Times System.CPUTime.Posix.RUsage

296+ System.CPUTime.Unsupported

297+import-dirs:

298+library-dirs:

299+dynamic-library-dirs:

300+data-dir:

301+hs-libraries: HSbase-4.14.3.0

302+include-dirs:

303+includes: HsBase.h

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

305+haddock-interfaces:

306+haddock-html:

307+---

308+name: binary

309+version: 0.8.8.0

310+visibility: public

311+id: binary-0.8.8.0

312+key: binary-0.8.8.0

313+license: BSD-3-Clause

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

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

316+stability: provisional

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

318+synopsis:

319+ Binary serialisation for Haskell values using lazy ByteStrings

320+description:

321+ Efficient, pure binary serialisation using lazy ByteStrings.

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

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

324+ The format used can be automatically generated, or

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

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

327+ so this library should be suitable for high performance

328+ scenarios.

329+category: Data, Parsing

330+exposed: True

331+exposed-modules:

332+ Data.Binary Data.Binary.Builder Data.Binary.Get

333+ Data.Binary.Get.Internal Data.Binary.Put

334+hidden-modules:

335+ Data.Binary.Class Data.Binary.Internal Data.Binary.Generic

336+ Data.Binary.FloatCast

337+import-dirs:

338+library-dirs:

339+dynamic-library-dirs:

340+data-dir:

341+hs-libraries: HSbinary-0.8.8.0

342+depends:

343+ array-0.5.4.0 base-4.14.3.0 bytestring-0.10.12.0 containers-0.6.5.1

344+haddock-interfaces:

345+haddock-html:

346+---

347+name: bytestring

348+version: 0.10.12.0

349+visibility: public

350+id: bytestring-0.10.12.0

351+key: bytestring-0.10.12.0

352+license: BSD-3-Clause

353+copyright:

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

355+ (c) Duncan Coutts 2006-2015,

356+ (c) David Roundy 2003-2005,

357+ (c) Jasper Van der Jeugt 2010,

358+ (c) Simon Meier 2010-2013.

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

360+author:

361+ Don Stewart,

362+ Duncan Coutts

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

364+synopsis:

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

366+description:

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

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

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

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

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

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

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

374+ Two 'ByteString' variants are provided:

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

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

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

378+ suitable for I\/O streaming tasks.

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

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

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

382+ and network protocols).

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

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

385+ serialisation or pretty printing.

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

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

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

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

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

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

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

393+ > import qualified Data.ByteString as BS

394+category: Data

395+exposed: True

396+exposed-modules:

397+ Data.ByteString Data.ByteString.Builder

398+ Data.ByteString.Builder.Extra Data.ByteString.Builder.Internal

399+ Data.ByteString.Builder.Prim Data.ByteString.Builder.Prim.Internal

400+ Data.ByteString.Char8 Data.ByteString.Internal Data.ByteString.Lazy

401+ Data.ByteString.Lazy.Builder Data.ByteString.Lazy.Builder.ASCII

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

403+ Data.ByteString.Lazy.Internal Data.ByteString.Short

404+ Data.ByteString.Short.Internal Data.ByteString.Unsafe

405+hidden-modules:

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

407+ Data.ByteString.Builder.Prim.ASCII

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

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

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

411+import-dirs:

412+library-dirs:

413+dynamic-library-dirs:

414+data-dir:

415+hs-libraries: HSbytestring-0.10.12.0

416+include-dirs:

417+includes: fpstring.h

418+depends:

419+ base-4.14.3.0 deepseq-1.4.4.0 ghc-prim-0.6.1 integer-gmp-1.0.3.0

420+haddock-interfaces:

421+haddock-html:

422+---

423+name: containers

424+version: 0.6.5.1

425+visibility: public

426+id: containers-0.6.5.1

427+key: containers-0.6.5.1

428+license: BSD-3-Clause

429+maintainer: libraries@haskell.org

430+synopsis: Assorted concrete container types

431+description:

432+ This package contains efficient general-purpose implementations

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

434+ trees, and graphs.

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

436+ operations see the [containers

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

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

439+ remains valid even if structures are shared.

440+category: Data Structures

441+exposed: True

442+exposed-modules:

443+ Data.Containers.ListUtils Data.Graph Data.IntMap

444+ Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy

445+ Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict

446+ Data.IntMap.Strict.Internal Data.IntSet Data.IntSet.Internal

447+ Data.Map Data.Map.Internal Data.Map.Internal.Debug Data.Map.Lazy

448+ Data.Map.Merge.Lazy Data.Map.Merge.Strict Data.Map.Strict

449+ Data.Map.Strict.Internal Data.Sequence Data.Sequence.Internal

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

451+ Utils.Containers.Internal.BitQueue

452+ Utils.Containers.Internal.BitUtil

453+ Utils.Containers.Internal.StrictPair

454+hidden-modules:

455+ Utils.Containers.Internal.State

456+ Utils.Containers.Internal.StrictMaybe

457+ Utils.Containers.Internal.PtrEquality

458+ Utils.Containers.Internal.Coercions

459+ Utils.Containers.Internal.TypeError

460+ Data.Map.Internal.DeprecatedShowTree

461+ Data.IntMap.Internal.DeprecatedDebug

462+import-dirs:

463+library-dirs:

464+dynamic-library-dirs:

465+data-dir:

466+hs-libraries: HScontainers-0.6.5.1

467+depends: array-0.5.4.0 base-4.14.3.0 deepseq-1.4.4.0

468+haddock-interfaces:

469+haddock-html:

470+---

471+name: deepseq

472+version: 1.4.4.0

473+visibility: public

474+id: deepseq-1.4.4.0

475+key: deepseq-1.4.4.0

476+license: BSD-3-Clause

477+maintainer: libraries@haskell.org

478+synopsis: Deep evaluation of data structures

479+description:

480+ This package provides methods for fully evaluating data structures

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

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

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

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

485+ wrong thread.

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

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

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

489+ components) which defines strategies for fully evaluating different

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

491+ details.

492+category: Control

493+exposed: True

494+exposed-modules: Control.DeepSeq

495+hidden-modules: Control.DeepSeq.BackDoor

496+import-dirs:

497+library-dirs:

498+dynamic-library-dirs:

499+data-dir:

500+hs-libraries: HSdeepseq-1.4.4.0

501+depends: array-0.5.4.0 base-4.14.3.0

502+haddock-interfaces:

503+haddock-html:

504+---

505+name: directory

506+version: 1.3.6.0

507+visibility: public

508+id: directory-1.3.6.0

509+key: directory-1.3.6.0

510+license: BSD-3-Clause

511+maintainer: libraries@haskell.org

512+synopsis: Platform-agnostic library for filesystem operations

513+description:

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

515+ directories in a portable way.

516+category: System

517+exposed: True

518+exposed-modules:

519+ System.Directory System.Directory.Internal

520+ System.Directory.Internal.Prelude

521+hidden-modules:

522+ System.Directory.Internal.C_utimensat

523+ System.Directory.Internal.Common System.Directory.Internal.Config

524+ System.Directory.Internal.Posix System.Directory.Internal.Windows

525+import-dirs:

526+library-dirs:

527+dynamic-library-dirs:

528+data-dir:

529+hs-libraries: HSdirectory-1.3.6.0

530+depends:

531+ base-4.14.3.0 filepath-1.4.2.1 time-1.9.3 unix-2.7.2.2

532+haddock-interfaces:

533+haddock-html:

534+---

535+name: exceptions

536+version: 0.10.4

537+visibility: public

538+id: exceptions-0.10.4

539+key: exceptions-0.10.4

540+license: BSD-3-Clause

541+copyright:

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

545+author: Edward A. Kmett

546+stability: provisional

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

548+synopsis: Extensible optionally-pure exceptions

549+description: Extensible optionally-pure exceptions.

550+category: Control, Exceptions, Monad

551+exposed: True

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

553+import-dirs:

554+library-dirs:

555+dynamic-library-dirs:

556+data-dir:

557+hs-libraries: HSexceptions-0.10.4

558+depends:

559+ base-4.14.3.0 mtl-2.2.2 stm-2.5.0.1 template-haskell-2.16.0.0

560+ transformers-0.5.6.2

561+haddock-interfaces:

562+haddock-html:

563+---

564+name: filepath

565+version: 1.4.2.1

566+visibility: public

567+id: filepath-1.4.2.1

568+key: filepath-1.4.2.1

569+license: BSD-3-Clause

570+copyright: Neil Mitchell 2005-2018

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

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

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

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

575+description:

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

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

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

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

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

581+category: System

582+exposed: True

583+exposed-modules:

584+ System.FilePath System.FilePath.Posix System.FilePath.Windows

585+import-dirs:

586+library-dirs:

587+dynamic-library-dirs:

588+data-dir:

589+hs-libraries: HSfilepath-1.4.2.1

590+depends: base-4.14.3.0

591+haddock-interfaces:

592+haddock-html:

593+---

594+name: ghc-boot

595+version: 8.10.6

596+visibility: public

597+id: ghc-boot-8.10.6

598+key: ghc-boot-8.10.6

599+license: BSD-3-Clause

600+maintainer: ghc-devs@haskell.org

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

602+description:

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

604+ libraries.

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

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

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

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

609+ suitable for modifying GHC package databases.

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

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

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

613+category: GHC

614+exposed: True

615+exposed-modules:

616+ GHC.BaseDir GHC.ForeignSrcLang GHC.HandleEncoding

617+ GHC.LanguageExtensions GHC.PackageDb GHC.Platform GHC.Platform.Host

618+ GHC.Serialized GHC.Settings GHC.UniqueSubdir GHC.Version

619+import-dirs:

620+library-dirs:

621+dynamic-library-dirs:

622+data-dir:

623+hs-libraries: HSghc-boot-8.10.6

624+depends:

625+ base-4.14.3.0 binary-0.8.8.0 bytestring-0.10.12.0

626+ containers-0.6.5.1 directory-1.3.6.0 filepath-1.4.2.1

627+ ghc-boot-th-8.10.6

628+haddock-interfaces:

629+haddock-html:

630+---

631+name: ghc-boot-th

632+version: 8.10.6

633+visibility: public

634+id: ghc-boot-th-8.10.6

635+key: ghc-boot-th-8.10.6

636+license: BSD-3-Clause

637+maintainer: ghc-devs@haskell.org

638+synopsis:

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

640+ library

641+description:

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

643+ @template-haskell@ libraries.

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

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

646+ be depended upon by user code.

647+category: GHC

648+exposed: True

649+exposed-modules:

650+ GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme

651+import-dirs:

652+library-dirs:

653+dynamic-library-dirs:

654+data-dir:

655+hs-libraries: HSghc-boot-th-8.10.6

656+depends: base-4.14.3.0

657+haddock-interfaces:

658+haddock-html:

659+---

660+name: ghc-compact

661+version: 0.1.0.0

662+visibility: public

663+id: ghc-compact-0.1.0.0

664+key: ghc-compact-0.1.0.0

665+license: BSD-3-Clause

666+maintainer: libraries@haskell.org

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

668+description:

669+ This package provides minimal functionality for working with

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

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

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

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

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

675+ released).

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

677+ which allows efficient serialization and deserialization of structs

678+ for distributed computing.

679+category: Data

680+exposed: True

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

682+import-dirs:

683+library-dirs:

684+dynamic-library-dirs:

685+data-dir:

686+hs-libraries: HSghc-compact-0.1.0.0

687+depends: base-4.14.3.0 bytestring-0.10.12.0 ghc-prim-0.6.1

688+haddock-interfaces:

689+haddock-html:

690+---

691+name: ghc-heap

692+version: 8.10.6

693+visibility: public

694+id: ghc-heap-8.10.6

695+key: ghc-heap-8.10.6

696+license: BSD-3-Clause

697+maintainer: libraries@haskell.org

698+synopsis: Functions for walking GHC's heap

699+description:

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

701+ and retrieving information about those data structures.

702+category: GHC

703+exposed: True

704+exposed-modules:

705+ GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures

706+ GHC.Exts.Heap.Constants GHC.Exts.Heap.InfoTable

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

708+ GHC.Exts.Heap.Utils

709+import-dirs:

710+library-dirs:

711+dynamic-library-dirs:

712+data-dir:

713+hs-libraries: HSghc-heap-8.10.6

714+depends: base-4.14.3.0 ghc-prim-0.6.1 rts

715+haddock-interfaces:

716+haddock-html:

717+---

718+name: ghc-prim

719+version: 0.6.1

720+visibility: public

721+id: ghc-prim-0.6.1

722+key: ghc-prim-0.6.1

723+license: BSD-3-Clause

724+maintainer: libraries@haskell.org

725+synopsis: GHC primitives

726+description:

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

728+category: GHC

729+exposed: True

730+exposed-modules:

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

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

733+import-dirs:

734+library-dirs:

735+dynamic-library-dirs:

736+data-dir:

737+hs-libraries: HSghc-prim-0.6.1

738+extra-libraries: gcc c m

739+depends: rts

740+haddock-interfaces:

741+haddock-html:

742+---

743+name: ghci

744+version: 8.10.6

745+visibility: public

746+id: ghci-8.10.6

747+key: ghci-8.10.6

748+license: BSD-3-Clause

749+maintainer: ghc-devs@haskell.org

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

751+description:

752+ This library offers interfaces which mediate interactions between the

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

754+ backend.

755+category: GHC

756+exposed: True

757+exposed-modules:

758+ GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI

759+ GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes

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

761+ GHCi.TH.Binary SizedSeq

762+import-dirs:

763+library-dirs:

764+dynamic-library-dirs:

765+data-dir:

766+hs-libraries: HSghci-8.10.6

767+include-dirs:

768+depends:

769+ array-0.5.4.0 base-4.14.3.0 binary-0.8.8.0 bytestring-0.10.12.0

770+ containers-0.6.5.1 deepseq-1.4.4.0 filepath-1.4.2.1 ghc-boot-8.10.6

771+ ghc-boot-th-8.10.6 ghc-heap-8.10.6 rts template-haskell-2.16.0.0

772+ transformers-0.5.6.2 unix-2.7.2.2

773+haddock-interfaces:

774+haddock-html:

775+---

776+name: haskeline

777+version: 0.8.2

778+visibility: public

779+id: haskeline-0.8.2

780+key: haskeline-0.8.2

781+license: BSD-3-Clause

782+copyright: (c) Judah Jacobson

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

784+author: Judah Jacobson

785+stability: Stable

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

787+synopsis:

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

789+description:

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

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

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

793+ Haskell programs.

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

795+category: User Interfaces

796+exposed: True

797+exposed-modules:

798+ System.Console.Haskeline System.Console.Haskeline.Completion

799+ System.Console.Haskeline.History System.Console.Haskeline.IO

800+ System.Console.Haskeline.Internal

801+hidden-modules:

802+ System.Console.Haskeline.Backend

803+ System.Console.Haskeline.Backend.WCWidth

804+ System.Console.Haskeline.Command

805+ System.Console.Haskeline.Command.Completion

806+ System.Console.Haskeline.Command.History

807+ System.Console.Haskeline.Command.KillRing

808+ System.Console.Haskeline.Directory System.Console.Haskeline.Emacs

809+ System.Console.Haskeline.InputT System.Console.Haskeline.Key

810+ System.Console.Haskeline.LineState System.Console.Haskeline.Monads

811+ System.Console.Haskeline.Prefs System.Console.Haskeline.Recover

812+ System.Console.Haskeline.RunCommand System.Console.Haskeline.Term

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

814+ System.Console.Haskeline.Backend.Posix

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

816+ System.Console.Haskeline.Backend.DumbTerm

817+import-dirs:

818+library-dirs:

819+dynamic-library-dirs:

820+data-dir:

821+hs-libraries: HShaskeline-0.8.2

822+depends:

823+ base-4.14.3.0 bytestring-0.10.12.0 containers-0.6.5.1

824+ directory-1.3.6.0 exceptions-0.10.4 filepath-1.4.2.1

825+ process-1.6.13.2 stm-2.5.0.1 transformers-0.5.6.2 unix-2.7.2.2

826+haddock-interfaces:

827+haddock-html:

828+---

829+name: hpc

830+version: 0.6.1.0

831+visibility: public

832+id: hpc-0.6.1.0

833+key: hpc-0.6.1.0

834+license: BSD-3-Clause

835+maintainer: ghc-devs@haskell.org

836+author: Andy Gill

837+synopsis: Code Coverage Library for Haskell

838+description:

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

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

841+ information.

842+category: Control

843+exposed: True

844+exposed-modules:

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

846+import-dirs:

847+library-dirs:

848+dynamic-library-dirs:

849+data-dir:

850+hs-libraries: HShpc-0.6.1.0

851+depends:

852+ base-4.14.3.0 containers-0.6.5.1 deepseq-1.4.4.0 directory-1.3.6.0

853+ filepath-1.4.2.1 time-1.9.3

854+haddock-interfaces:

855+haddock-html:

856+---

857+name: integer-gmp

858+version: 1.0.3.0

859+visibility: public

860+id: integer-gmp-1.0.3.0

861+key: integer-gmp-1.0.3.0

862+license: BSD-3-Clause

863+maintainer: hvr@gnu.org

864+author: Herbert Valerio Riedel

865+synopsis: Integer library based on GMP

866+description:

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

868+ 'Integer' type based on the

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

870+ This package provides access to the internal representation of

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

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

873+category: Numeric, Algebra

874+exposed: True

875+exposed-modules:

876+ GHC.Integer GHC.Integer.GMP.Internals GHC.Integer.Logarithms

877+ GHC.Integer.Logarithms.Internals

878+hidden-modules: GHC.Integer.Type

879+import-dirs:

880+library-dirs:

881+dynamic-library-dirs:

882+data-dir:

883+hs-libraries: HSinteger-gmp-1.0.3.0

884+extra-libraries: gmp

885+include-dirs:

886+depends: ghc-prim-0.6.1

887+haddock-interfaces:

888+haddock-html:

889+---

890+name: libiserv

891+version: 8.10.6

892+visibility: public

893+id: libiserv-8.10.6

894+key: libiserv-8.10.6

895+license: BSD-3-Clause

896+copyright: XXX

897+maintainer: XXX

898+author: XXX

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

900+category: Development

901+exposed: True

902+exposed-modules: GHCi.Utils Lib

903+import-dirs:

904+library-dirs:

905+dynamic-library-dirs:

906+data-dir:

907+hs-libraries: HSlibiserv-8.10.6

908+depends:

909+ base-4.14.3.0 binary-0.8.8.0 bytestring-0.10.12.0

910+ containers-0.6.5.1 deepseq-1.4.4.0 ghci-8.10.6 unix-2.7.2.2

911+haddock-interfaces:

912+haddock-html:

913+---

914+name: mtl

915+version: 2.2.2

916+visibility: public

917+id: mtl-2.2.2

918+key: mtl-2.2.2

919+license: BSD-3-Clause

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

921+author: Andy Gill

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

923+synopsis: Monad classes, using functional dependencies

924+description:

925+ Monad classes using functional dependencies, with instances

926+ for various monad transformers, inspired by the paper

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

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

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

930+category: Control

931+exposed: True

932+exposed-modules:

933+ Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error

934+ Control.Monad.Error.Class Control.Monad.Except

935+ Control.Monad.Identity Control.Monad.List Control.Monad.RWS

936+ Control.Monad.RWS.Class Control.Monad.RWS.Lazy

937+ Control.Monad.RWS.Strict Control.Monad.Reader

938+ Control.Monad.Reader.Class Control.Monad.State

939+ Control.Monad.State.Class Control.Monad.State.Lazy

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

941+ Control.Monad.Writer.Class Control.Monad.Writer.Lazy

942+ Control.Monad.Writer.Strict

943+import-dirs:

944+library-dirs:

945+dynamic-library-dirs:

946+data-dir:

947+hs-libraries: HSmtl-2.2.2

948+depends: base-4.14.3.0 transformers-0.5.6.2

949+haddock-interfaces:

950+haddock-html:

951+---

952+name: parsec

953+version: 3.1.14.0

954+visibility: public

955+id: parsec-3.1.14.0

956+key: parsec-3.1.14.0

957+license: BSD-3-Clause

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

959+author:

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

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

962+synopsis: Monadic parser combinators

963+description:

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

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

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

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

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

969+ input stream type.

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

971+ defaults for parsing 'Char'acter data.

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

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

974+ the future.

975+category: Parsing

976+exposed: True

977+exposed-modules:

978+ Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy

979+ Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error

980+ Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm

981+ Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String

982+ Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token

983+ Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char

984+ Text.ParserCombinators.Parsec.Combinator

985+ Text.ParserCombinators.Parsec.Error

986+ Text.ParserCombinators.Parsec.Expr

987+ Text.ParserCombinators.Parsec.Language

988+ Text.ParserCombinators.Parsec.Perm

989+ Text.ParserCombinators.Parsec.Pos

990+ Text.ParserCombinators.Parsec.Prim

991+ Text.ParserCombinators.Parsec.Token

992+import-dirs:

993+library-dirs:

994+dynamic-library-dirs:

995+data-dir:

996+hs-libraries: HSparsec-3.1.14.0

997+depends:

998+ base-4.14.3.0 bytestring-0.10.12.0 mtl-2.2.2 text-1.2.4.1

999+haddock-interfaces:

1000+haddock-html:

1001+---

1002+name: pretty

1003+version: 1.1.3.6

1004+visibility: public

1005+id: pretty-1.1.3.6

1006+key: pretty-1.1.3.6

1007+license: BSD-3-Clause

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

1009+stability: Stable

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

1011+synopsis: Pretty-printing library

1012+description:

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

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

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

1016+ tools.

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

1018+ been heavily modified by Simon Peyton Jones.

1019+category: Text

1020+exposed: True

1021+exposed-modules:

1022+ Text.PrettyPrint Text.PrettyPrint.Annotated

1023+ Text.PrettyPrint.Annotated.HughesPJ

1024+ Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ

1025+ Text.PrettyPrint.HughesPJClass

1026+import-dirs:

1027+library-dirs:

1028+dynamic-library-dirs:

1029+data-dir:

1030+hs-libraries: HSpretty-1.1.3.6

1031+depends: base-4.14.3.0 deepseq-1.4.4.0 ghc-prim-0.6.1

1032+haddock-interfaces:

1033+haddock-html:

1034+---

1035+name: process

1036+version: 1.6.13.2

1037+visibility: public

1038+id: process-1.6.13.2

1039+key: process-1.6.13.2

1040+license: BSD-3-Clause

1041+maintainer: libraries@haskell.org

1042+synopsis: Process libraries

1043+description:

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

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

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

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

1048+ read more about it at

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

1050+category: System

1051+exposed: True

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

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

1054+import-dirs:

1055+library-dirs:

1056+dynamic-library-dirs:

1057+data-dir:

1058+hs-libraries: HSprocess-1.6.13.2

1059+include-dirs:

1060+includes: runProcess.h

1061+depends:

1062+ base-4.14.3.0 deepseq-1.4.4.0 directory-1.3.6.0 filepath-1.4.2.1

1063+ unix-2.7.2.2

1064+haddock-interfaces:

1065+haddock-html:

1066+---

1067+name: stm

1068+version: 2.5.0.1

1069+visibility: public

1070+id: stm-2.5.0.1

1071+key: stm-2.5.0.1

1072+license: BSD-3-Clause

1073+maintainer: libraries@haskell.org

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

1075+synopsis: Software Transactional Memory

1076+description:

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

1078+ concurrent communication. The main benefits of STM are

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

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

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

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

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

1084+ 'MVar's.

1085+category: Concurrency

1086+exposed: True

1087+exposed-modules:

1088+ Control.Concurrent.STM Control.Concurrent.STM.TArray

1089+ Control.Concurrent.STM.TBQueue Control.Concurrent.STM.TChan

1090+ Control.Concurrent.STM.TMVar Control.Concurrent.STM.TQueue

1091+ Control.Concurrent.STM.TSem Control.Concurrent.STM.TVar

1092+ Control.Monad.STM

1093+hidden-modules: Control.Sequential.STM

1094+import-dirs:

1095+library-dirs:

1096+dynamic-library-dirs:

1097+data-dir:

1098+hs-libraries: HSstm-2.5.0.1

1099+depends: array-0.5.4.0 base-4.14.3.0

1100+haddock-interfaces:

1101+haddock-html:

1102+---

1103+name: template-haskell

1104+version: 2.16.0.0

1105+visibility: public

1106+id: template-haskell-2.16.0.0

1107+key: template-haskell-2.16.0.0

1108+license: BSD-3-Clause

1109+maintainer: libraries@haskell.org

1110+synopsis: Support library for Template Haskell

1111+description:

1112+ This package provides modules containing facilities for manipulating

1113+ Haskell source code using Template Haskell.

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

1115+ information.

1116+category: Template Haskell

1117+exposed: True

1118+exposed-modules:

1119+ Language.Haskell.TH Language.Haskell.TH.LanguageExtensions

1120+ Language.Haskell.TH.Lib Language.Haskell.TH.Lib.Internal

1121+ Language.Haskell.TH.Ppr Language.Haskell.TH.PprLib

1122+ Language.Haskell.TH.Quote Language.Haskell.TH.Syntax

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

1124+import-dirs:

1125+library-dirs:

1126+dynamic-library-dirs:

1127+data-dir:

1128+hs-libraries: HStemplate-haskell-2.16.0.0

1129+depends:

1130+ base-4.14.3.0 ghc-boot-th-8.10.6 ghc-prim-0.6.1 pretty-1.1.3.6

1131+haddock-interfaces:

1132+haddock-html:

1133+---

1134+name: text

1135+version: 1.2.4.1

1136+visibility: public

1137+id: text-1.2.4.1

1138+key: text-1.2.4.1

1139+license: BSD-2-Clause

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

1141+maintainer:

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

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

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

1145+synopsis: An efficient packed Unicode text type.

1146+description:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1161+ clashes with Prelude functions, e.g.

1162+ > import qualified Data.Text as T

1163+ == ICU Support

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

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

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

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

1168+ based on the well-respected and liberally

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

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

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

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

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

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

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

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

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

1178+category: Data, Text

1179+exposed: True

1180+exposed-modules:

1181+ Data.Text Data.Text.Array Data.Text.Encoding

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

1183+ Data.Text.Internal Data.Text.Internal.Builder

1184+ Data.Text.Internal.Builder.Functions

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

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

1187+ Data.Text.Internal.ByteStringCompat

1188+ Data.Text.Internal.Encoding.Fusion

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

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

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

1192+ Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping

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

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

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

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

1197+ Data.Text.Internal.Private Data.Text.Internal.Read

1198+ Data.Text.Internal.Search Data.Text.Internal.Unsafe

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

1200+ Data.Text.Lazy Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int

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

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

1203+ Data.Text.Read Data.Text.Unsafe

1204+hidden-modules: Data.Text.Show

1205+import-dirs:

1206+library-dirs:

1207+dynamic-library-dirs:

1208+data-dir:

1209+hs-libraries: HStext-1.2.4.1

1210+depends:

1211+ array-0.5.4.0 base-4.14.3.0 binary-0.8.8.0 bytestring-0.10.12.0

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

1213+ template-haskell-2.16.0.0

1214+haddock-interfaces:

1215+haddock-html:

1216+---

1217+name: time

1218+version: 1.9.3

1219+visibility: public

1220+id: time-1.9.3

1221+key: time-1.9.3

1222+license: BSD-3-Clause

1223+maintainer: <ashley@semantic.org>

1224+author: Ashley Yakeley

1225+stability: stable

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

1227+synopsis: A time library

1228+description: Time, clocks and calendars

1229+category: Time

1230+exposed: True

1231+exposed-modules:

1232+ Data.Time Data.Time.Calendar Data.Time.Calendar.Easter

1233+ Data.Time.Calendar.Julian Data.Time.Calendar.MonthDay

1234+ Data.Time.Calendar.OrdinalDate Data.Time.Calendar.WeekDate

1235+ Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System

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

1237+ Data.Time.Format.Internal Data.Time.LocalTime

1238+hidden-modules:

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

1240+ Data.Time.Calendar.Gregorian Data.Time.Calendar.CalendarDiffDays

1241+ Data.Time.Calendar.Week Data.Time.Calendar.JulianYearDay

1242+ Data.Time.Clock.Internal.DiffTime

1243+ Data.Time.Clock.Internal.AbsoluteTime

1244+ Data.Time.Clock.Internal.NominalDiffTime

1245+ Data.Time.Clock.Internal.POSIXTime

1246+ Data.Time.Clock.Internal.UniversalTime

1247+ Data.Time.Clock.Internal.SystemTime

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

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

1250+ Data.Time.LocalTime.Internal.TimeZone

1251+ Data.Time.LocalTime.Internal.TimeOfDay

1252+ Data.Time.LocalTime.Internal.CalendarDiffTime

1253+ Data.Time.LocalTime.Internal.LocalTime

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

1255+ Data.Time.Format.Locale Data.Time.Format.Format.Class

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

1257+ Data.Time.Format.Parse.Instances

1258+import-dirs:

1259+library-dirs:

1260+dynamic-library-dirs:

1261+data-dir:

1262+hs-libraries: HStime-1.9.3

1263+include-dirs:

1264+depends: base-4.14.3.0 deepseq-1.4.4.0

1265+haddock-interfaces:

1266+haddock-html:

1267+---

1268+name: transformers

1269+version: 0.5.6.2

1270+visibility: public

1271+id: transformers-0.5.6.2

1272+key: transformers-0.5.6.2

1273+license: BSD-3-Clause

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

1275+author: Andy Gill, Ross Paterson

1276+synopsis: Concrete functor and monad transformers

1277+description:

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

1279+ the paper

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

1281+ Polymorphism\", by Mark P Jones,

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

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

1284+ This package contains:

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

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

1287+ operations and functions to lift operations associated with other

1288+ transformers.

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

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

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

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

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

1294+ introduced by monad transformers through other transformers.

1295+category: Control

1296+exposed: True

1297+exposed-modules:

1298+ Control.Applicative.Backwards Control.Applicative.Lift

1299+ Control.Monad.Signatures Control.Monad.Trans.Accum

1300+ Control.Monad.Trans.Class Control.Monad.Trans.Cont

1301+ Control.Monad.Trans.Error Control.Monad.Trans.Except

1302+ Control.Monad.Trans.Identity Control.Monad.Trans.List

1303+ Control.Monad.Trans.Maybe Control.Monad.Trans.RWS

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

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

1306+ Control.Monad.Trans.Select Control.Monad.Trans.State

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

1308+ Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS

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

1310+ Data.Functor.Constant Data.Functor.Reverse

1311+import-dirs:

1312+library-dirs:

1313+dynamic-library-dirs:

1314+data-dir:

1315+hs-libraries: HStransformers-0.5.6.2

1316+depends: base-4.14.3.0

1317+haddock-interfaces:

1318+haddock-html:

1319+---

1320+name: unix

1321+version: 2.7.2.2

1322+visibility: public

1323+id: unix-2.7.2.2

1324+key: unix-2.7.2.2

1325+license: BSD-3-Clause

1326+maintainer: libraries@haskell.org

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

1328+synopsis: POSIX functionality

1329+description:

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

1331+ services standardised by

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

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

1334+ Environments - IEEE Std. 1003.1).

1335+ The package is not supported under Windows.

1336+category: System

1337+exposed: True

1338+exposed-modules:

1339+ System.Posix System.Posix.ByteString

1340+ System.Posix.ByteString.FilePath System.Posix.Directory

1341+ System.Posix.Directory.ByteString System.Posix.DynamicLinker

1342+ System.Posix.DynamicLinker.ByteString

1343+ System.Posix.DynamicLinker.Module

1344+ System.Posix.DynamicLinker.Module.ByteString

1345+ System.Posix.DynamicLinker.Prim System.Posix.Env

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

1347+ System.Posix.Files System.Posix.Files.ByteString System.Posix.IO

1348+ System.Posix.IO.ByteString System.Posix.Process

1349+ System.Posix.Process.ByteString System.Posix.Process.Internals

1350+ System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem

1351+ System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp

1352+ System.Posix.Temp.ByteString System.Posix.Terminal

1353+ System.Posix.Terminal.ByteString System.Posix.Time

1354+ System.Posix.Unistd System.Posix.User

1355+hidden-modules:

1356+ System.Posix.Directory.Common System.Posix.DynamicLinker.Common

1357+ System.Posix.Files.Common System.Posix.IO.Common

1358+ System.Posix.Process.Common System.Posix.Terminal.Common

1359+import-dirs:

1360+library-dirs:

1361+dynamic-library-dirs:

1362+data-dir:

1363+hs-libraries: HSunix-2.7.2.2

1364+extra-libraries: rt util dl pthread

1365+include-dirs:

1366+includes: HsUnix.h execvpe.h

1367+depends: base-4.14.3.0 bytestring-0.10.12.0 time-1.9.3

1368+haddock-interfaces:

1369+haddock-html:

1370+---

1371+name: rts

1372+version: 1.0.1

1373+visibility: public

1374+id: rts

1375+key: rts

1376+license: BSD-3-Clause

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

1378+exposed: True

1379+library-dirs:

1380+hs-libraries: HSrts

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

1382+include-dirs:

1383+includes: Stg.h

1384+ld-options:

1385+ "-Wl,-u,base_GHCziTopHandler_runIO_closure"

1386+ "-Wl,-u,base_GHCziTopHandler_runNonIO_closure"

1387+ "-Wl,-u,ghczmprim_GHCziTuple_Z0T_closure"

1388+ "-Wl,-u,ghczmprim_GHCziTypes_True_closure"

1389+ "-Wl,-u,ghczmprim_GHCziTypes_False_closure"

1390+ "-Wl,-u,base_GHCziPack_unpackCString_closure"

1391+ "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure"

1392+ "-Wl,-u,base_GHCziIOziException_stackOverflow_closure"

1393+ "-Wl,-u,base_GHCziIOziException_heapOverflow_closure"

1394+ "-Wl,-u,base_GHCziIOziException_allocationLimitExceeded_closure"

1395+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"

1396+ "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"

1397+ "-Wl,-u,base_GHCziIOziException_cannotCompactFunction_closure"

1398+ "-Wl,-u,base_GHCziIOziException_cannotCompactPinned_closure"

1399+ "-Wl,-u,base_GHCziIOziException_cannotCompactMutable_closure"

1400+ "-Wl,-u,base_ControlziExceptionziBase_absentSumFieldError_closure"

1401+ "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure"

1402+ "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure"

1403+ "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure"

1404+ "-Wl,-u,base_GHCziConcziSync_runSparks_closure"

1405+ "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure"

1406+ "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"

1407+ "-Wl,-u,base_GHCziConcziSignal_runHandlersPtr_closure"

1408+ "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure"

1409+ "-Wl,-u,base_GHCziTopHandler_runMainIO_closure"

1410+ "-Wl,-u,ghczmprim_GHCziTypes_Czh_con_info"

1411+ "-Wl,-u,ghczmprim_GHCziTypes_Izh_con_info"

1412+ "-Wl,-u,ghczmprim_GHCziTypes_Fzh_con_info"

1413+ "-Wl,-u,ghczmprim_GHCziTypes_Dzh_con_info"

1414+ "-Wl,-u,ghczmprim_GHCziTypes_Wzh_con_info"

1415+ "-Wl,-u,base_GHCziPtr_Ptr_con_info"

1416+ "-Wl,-u,base_GHCziPtr_FunPtr_con_info"

1417+ "-Wl,-u,base_GHCziInt_I8zh_con_info"

1418+ "-Wl,-u,base_GHCziInt_I16zh_con_info"

1419+ "-Wl,-u,base_GHCziInt_I32zh_con_info"

1420+ "-Wl,-u,base_GHCziInt_I64zh_con_info"

1421+ "-Wl,-u,base_GHCziWord_W8zh_con_info"

1422+ "-Wl,-u,base_GHCziWord_W16zh_con_info"

1423+ "-Wl,-u,base_GHCziWord_W32zh_con_info"

1424+ "-Wl,-u,base_GHCziWord_W64zh_con_info"

1425+ "-Wl,-u,base_GHCziStable_StablePtr_con_info"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1443+ "-Wl,-u,hs_atomicwrite64"

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

@@ -0,0 +1 @@

1+GHC package manager version 8.10.6

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.10.6-x86_64-linux/ghc/infonew file+69

@@ -0,0 +1,69 @@

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+ ,("Merge objects flags","-r")

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

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

16+ ,("otool command","otool")

17+ ,("install_name_tool command","install_name_tool")

18+ ,("touch command","touch")

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

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

21+ ,("libtool command","libtool")

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

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

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

25+ ,("target arch","ArchAArch64")

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

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

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

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

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

31+ ,("Unregisterised","NO")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

47+ ,("Project version","8.10.6")

48+ ,("Project Git commit id","f7b3359be12030d762b299681e1aeef0292417ce")

49+ ,("Booter version","8.6.5")

50+ ,("Stage","1")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

68+ ,("Debug on","NO")

69+ ]

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

@@ -0,0 +1 @@

1+8.10.6

materialized/dummy-ghc/aarch64-unknown-linux-gnu-aarch64-unknown-linux-gnu-ghc-8.10.6-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.6-x86_64-linux/ghc/versionnew file+1

@@ -0,0 +1 @@

1+The Glorious Glasgow Haskell Compilation System, version 8.10.6

materialized/dummy-ghc/ghc-8.10.6-x86_64-darwin/ghc-pkg/dump-globalnew file+1638

@@ -0,0 +1,1638 @@