24b421c · haskell.nix · git.iko.soy

build.nix+1−1

compare with iko/ghcjs-patch-master

unifiedsplit

@@ -22,7 +22,7 @@ in rec {

22 tools = pkgs.lib.optionalAttrs (ifdLevel >= 3) (

23 pkgs.recurseIntoAttrs ({

24 cabal-latest = tool compiler-nix-name "cabal" "latest";

25− } // pkgs.lib.optionalAttrs (compiler-nix-name != "ghc901") {

25+ } // pkgs.lib.optionalAttrs (!__elem compiler-nix-name ["ghc901" "ghc921"]) {

26 hls-latest = tool compiler-nix-name "haskell-language-server" "latest";

27 hlint-latest = tool compiler-nix-name "hlint" (if compiler-nix-name == "ghc865" then "3.2.7" else "latest");

28 })

builder/default.nix+1−1

@@ -46,7 +46,7 @@ let

46 hoogleLocal = let

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

48 in { packages ? [], hoogle ? pkgs.buildPackages.haskell-nix.tool compiler.nix-name "hoogle" {

49− version = "5.0.17.15";

49+ version = "5.0.18.2";

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

51 }

52 }:

ci.nix+9−8

@@ -37,19 +37,20 @@

37 ghc8105 = false;

38 ghc8106 = false;

39 ghc8107 = true;

40− ghc901 = true;

40+ ghc901 = false;

41+ ghc921 = true;

41 ghc810420210212 = false;

42 ghc810420210212 = false;

42 });

43 });

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

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

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

45+ nixpkgs.lib.filter (v: v != "aarch64-darwin" || (

45− linux = "x86_64-linux";

46+ # aarch64-darwin requires ghc 8.10.7 and does not work on older nixpkgs

46− darwin = "x86_64-darwin";

47+ !__elem compiler-nix-name ["ghc865" "ghc884" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901"]

47− };

48+ && !__elem nixpkgsName ["R2009" "R2105"])) supportedSystems) (v: v);

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

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

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

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

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

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

51 let lib = nixpkgs.lib;

52 let lib = nixpkgs.lib;

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

53+ in lib.optionalAttrs (nixpkgsName == "unstable" && (__elem compiler-nix-name ["ghc8107"]) && system != "aarch64-darwin") {

53 inherit (lib.systems.examples) ghcjs;

54 inherit (lib.systems.examples) ghcjs;

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

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

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

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

@@ -67,7 +68,7 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:

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

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

68 genericPkgs = import pinnedNixpkgsSrc {};

69 genericPkgs = import pinnedNixpkgsSrc {};

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

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

70− dimension "System" (systems genericPkgs) (systemName: system:

71+ dimension "System" (systems nixpkgsName genericPkgs compiler-nix-name) (systemName: system:

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

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

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

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

73 platformFilter = platformFilterGeneric pkgs system;

74 platformFilter = platformFilterGeneric pkgs system;

compiler/ghc/default.nix+3−5

@@ -133,7 +133,7 @@ let

133 '';

134

135 # Splicer will pull out correct variations

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

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

137 ++ [targetLibffi]

138 ++ lib.optional (!enableIntegerSimple) gmp

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

@@ -268,9 +268,7 @@ stdenv.mkDerivation (rec {

268

269 # Save generated files for needed when building ghcjs

270 mkdir -p $generated/includes/dist-derivedconstants/header

271− cp includes/dist-derivedconstants/header/GHCConstantsHaskellExports.hs \

271+ cp includes/dist-derivedconstants/header/GHCConstantsHaskell*.hs \

272− includes/dist-derivedconstants/header/GHCConstantsHaskellType.hs \

273− includes/dist-derivedconstants/header/GHCConstantsHaskellWrappers.hs \

274 $generated/includes/dist-derivedconstants/header

272 $generated/includes/dist-derivedconstants/header

275 if [[ -f includes/ghcplatform.h ]]; then

273 if [[ -f includes/ghcplatform.h ]]; then

276 cp includes/ghcplatform.h $generated/includes

274 cp includes/ghcplatform.h $generated/includes

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

350 dontStrip = true;

348 dontStrip = true;

351 dontPatchELF = true;

349 dontPatchELF = true;

352 noAuditTmpdir = true;

350 noAuditTmpdir = true;

353−} // lib.optionalAttrs (__elem ghc-version ["8.10.5" "8.10.6" "8.10.7"] && stdenv.buildPlatform.isDarwin) {

351+} // lib.optionalAttrs (__elem ghc-version ["8.10.5" "8.10.6" "8.10.7" "9.2.1"] && stdenv.buildPlatform.isDarwin) {

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

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

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

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

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

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

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

@@ -7,6 +7,7 @@ for each, though not all are cached or tested by CI):

7- 8.8.{1,2,3,4}

8- 8.10.{1,2,3,4,5}

9- 9.0.1

10+- 9.2.1

10

11

11The following table shows the Nixpkgs/GHC versions which are built/cached, and

12The following table shows the Nixpkgs/GHC versions which are built/cached, and

12which of those are further tested. If you use a combination of Nixpkgs version

13which of those are further tested. If you use a combination of Nixpkgs version

@@ -27,9 +28,10 @@ really should use an instance of Nixpkgs provided by `haskell.nix` itself.

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

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

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

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

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

30| unstable | `nixpkgs-unstable` | 8.10.5 | `ghc8105` | No |

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

31+| unstable | `nixpkgs-unstable` | 8.10.6 | `ghc8106` | No |

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

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

32−| unstable | `nixpkgs-unstable` | 9.0.1 | `ghc901` | Yes |

33+| unstable | `nixpkgs-unstable` | 9.0.1 | `ghc901` | No |

34+| unstable | `nixpkgs-unstable` | 9.2.1 | `ghc921` | Yes |

33

35

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

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

35for the source of truth about what is built and tested (in the off chance this

37for the source of truth about what is built and tested (in the off chance this

flake.lock+3−3

@@ -133,11 +133,11 @@

133 "nix-tools": {

134 "flake": false,

135 "locked": {

136− "lastModified": 1627889534,

136+ "lastModified": 1636018067,

137− "narHash": "sha256-9eEbK2nrRp6rYGQoBv6LO9IA/ANZpofwAkxMuGBD45Y=",

137+ "narHash": "sha256-ng306fkuwr6V/malWtt3979iAC4yMVDDH2ViwYB6sQE=",

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

139 "repo": "nix-tools",

140− "rev": "15d2e4b61cb63ff351f3c490c12c4d89eafd31a1",

140+ "rev": "ed5bd7215292deba55d6ab7a4e8c21f8b1564dda",

141 "type": "github"

142 },

143 "original": {

materialized/dummy-ghc/ghc-9.2.1-aarch64-darwin/ghc-pkg/dump-globalnew file+1826

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

1+name: Cabal

2+version: 3.6.0.0

3+visibility: public

4+id: Cabal-3.6.0.0

5+key: Cabal-3.6.0.0

6+license: BSD-3-Clause

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

8+maintainer: cabal-devel@haskell.org

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

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

11+synopsis: A framework for packaging Haskell software

12+description:

13+ The Haskell Common Architecture for Building Applications and

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

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

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

17+ organizing, and cataloging Haskell libraries and tools.

18+category: Distribution

19+exposed: True

20+exposed-modules:

21+ Distribution.Backpack Distribution.Backpack.ComponentsGraph

22+ Distribution.Backpack.Configure

23+ Distribution.Backpack.ConfiguredComponent

24+ Distribution.Backpack.DescribeUnitId

25+ Distribution.Backpack.FullUnitId

26+ Distribution.Backpack.LinkedComponent

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

28+ Distribution.Backpack.PreModuleShape Distribution.CabalSpecVersion

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

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

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

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

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

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

35+ Distribution.Compat.NonEmptySet Distribution.Compat.Parsing

36+ Distribution.Compat.Prelude.Internal Distribution.Compat.Process

37+ Distribution.Compat.ResponseFile Distribution.Compat.Semigroup

38+ Distribution.Compat.Stack Distribution.Compat.Time

39+ Distribution.Compat.Typeable Distribution.Compiler

40+ Distribution.FieldGrammar Distribution.FieldGrammar.Class

41+ Distribution.FieldGrammar.FieldDescrs

42+ Distribution.FieldGrammar.Newtypes Distribution.FieldGrammar.Parsec

43+ Distribution.FieldGrammar.Pretty Distribution.Fields

44+ Distribution.Fields.ConfVar Distribution.Fields.Field

45+ Distribution.Fields.Lexer Distribution.Fields.LexerMonad

46+ Distribution.Fields.ParseResult Distribution.Fields.Parser

47+ Distribution.Fields.Pretty Distribution.InstalledPackageInfo

48+ Distribution.License Distribution.Make Distribution.ModuleName

49+ Distribution.Package Distribution.PackageDescription

50+ Distribution.PackageDescription.Check

51+ Distribution.PackageDescription.Configuration

52+ Distribution.PackageDescription.FieldGrammar

53+ Distribution.PackageDescription.Parsec

54+ Distribution.PackageDescription.PrettyPrint

55+ Distribution.PackageDescription.Quirks

56+ Distribution.PackageDescription.Utils Distribution.Parsec

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

58+ Distribution.Parsec.Position Distribution.Parsec.Warning

59+ Distribution.Pretty Distribution.ReadE Distribution.SPDX

60+ Distribution.SPDX.License Distribution.SPDX.LicenseExceptionId

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

62+ Distribution.SPDX.LicenseListVersion

63+ Distribution.SPDX.LicenseReference Distribution.Simple

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

65+ Distribution.Simple.Build.Macros

66+ Distribution.Simple.Build.PathsModule

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

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

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

70+ Distribution.Simple.Configure Distribution.Simple.Flag

71+ Distribution.Simple.GHC Distribution.Simple.GHCJS

72+ Distribution.Simple.Glob Distribution.Simple.Haddock

73+ Distribution.Simple.HaskellSuite Distribution.Simple.Hpc

74+ Distribution.Simple.Install Distribution.Simple.InstallDirs

75+ Distribution.Simple.InstallDirs.Internal

76+ Distribution.Simple.LocalBuildInfo Distribution.Simple.PackageIndex

77+ Distribution.Simple.PreProcess Distribution.Simple.PreProcess.Unlit

78+ Distribution.Simple.Program Distribution.Simple.Program.Ar

79+ Distribution.Simple.Program.Builtin Distribution.Simple.Program.Db

80+ Distribution.Simple.Program.Find Distribution.Simple.Program.GHC

81+ Distribution.Simple.Program.HcPkg Distribution.Simple.Program.Hpc

82+ Distribution.Simple.Program.Internal Distribution.Simple.Program.Ld

83+ Distribution.Simple.Program.ResponseFile

84+ Distribution.Simple.Program.Run Distribution.Simple.Program.Script

85+ Distribution.Simple.Program.Strip Distribution.Simple.Program.Types

86+ Distribution.Simple.Register Distribution.Simple.Setup

87+ Distribution.Simple.ShowBuildInfo Distribution.Simple.SrcDist

88+ Distribution.Simple.Test Distribution.Simple.Test.ExeV10

89+ Distribution.Simple.Test.LibV09 Distribution.Simple.Test.Log

90+ Distribution.Simple.UHC Distribution.Simple.UserHooks

91+ Distribution.Simple.Utils Distribution.System

92+ Distribution.TestSuite Distribution.Text

93+ Distribution.Types.AbiDependency Distribution.Types.AbiHash

94+ Distribution.Types.AnnotatedId Distribution.Types.Benchmark

95+ Distribution.Types.Benchmark.Lens

96+ Distribution.Types.BenchmarkInterface

97+ Distribution.Types.BenchmarkType Distribution.Types.BuildInfo

98+ Distribution.Types.BuildInfo.Lens Distribution.Types.BuildType

99+ Distribution.Types.Component Distribution.Types.ComponentId

100+ Distribution.Types.ComponentInclude

101+ Distribution.Types.ComponentLocalBuildInfo

102+ Distribution.Types.ComponentName

103+ Distribution.Types.ComponentRequestedSpec

104+ Distribution.Types.CondTree Distribution.Types.Condition

105+ Distribution.Types.ConfVar Distribution.Types.Dependency

106+ Distribution.Types.DependencyMap Distribution.Types.ExeDependency

107+ Distribution.Types.Executable Distribution.Types.Executable.Lens

108+ Distribution.Types.ExecutableScope Distribution.Types.ExposedModule

109+ Distribution.Types.Flag Distribution.Types.ForeignLib

110+ Distribution.Types.ForeignLib.Lens

111+ Distribution.Types.ForeignLibOption

112+ Distribution.Types.ForeignLibType

113+ Distribution.Types.GenericPackageDescription

114+ Distribution.Types.GenericPackageDescription.Lens

115+ Distribution.Types.GivenComponent

116+ Distribution.Types.HookedBuildInfo

117+ Distribution.Types.IncludeRenaming

118+ Distribution.Types.InstalledPackageInfo

119+ Distribution.Types.InstalledPackageInfo.FieldGrammar

120+ Distribution.Types.InstalledPackageInfo.Lens

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

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

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

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

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

126+ Distribution.Types.ModuleRenaming

127+ Distribution.Types.MungedPackageId

128+ Distribution.Types.MungedPackageName

129+ Distribution.Types.PackageDescription

130+ Distribution.Types.PackageDescription.Lens

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

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

133+ Distribution.Types.PackageVersionConstraint

134+ Distribution.Types.PkgconfigDependency

135+ Distribution.Types.PkgconfigName

136+ Distribution.Types.PkgconfigVersion

137+ Distribution.Types.PkgconfigVersionRange

138+ Distribution.Types.SetupBuildInfo

139+ Distribution.Types.SetupBuildInfo.Lens

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

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

142+ Distribution.Types.TestSuite.Lens

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

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

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

146+ Distribution.Types.VersionInterval.Legacy

147+ Distribution.Types.VersionRange

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

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

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

151+ Distribution.Utils.NubList Distribution.Utils.Path

152+ Distribution.Utils.Progress Distribution.Utils.ShortText

153+ Distribution.Utils.Structured Distribution.Verbosity

154+ Distribution.Verbosity.Internal Distribution.Version

155+ Language.Haskell.Extension

156+hidden-modules:

157+ Distribution.Backpack.PreExistingComponent

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

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

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

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

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

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

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

165+ Distribution.Utils.String Distribution.Simple.Build.Macros.Z

166+ Distribution.Simple.Build.PathsModule.Z

167+ Distribution.Simple.GHC.EnvironmentParser

168+ Distribution.Simple.GHC.Internal Distribution.Simple.GHC.ImplInfo

169+ Distribution.Simple.Utils.Json Distribution.ZinzaPrelude

170+ Paths_Cabal

171+import-dirs:

172+library-dirs:

173+dynamic-library-dirs:

174+data-dir:

175+hs-libraries: HSCabal-3.6.0.0

176+depends:

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

178+ containers-0.6.5.1 deepseq-1.4.6.0 directory-1.3.6.2

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

180+ process-1.6.13.2 text-1.2.5.0 time-1.11.1.1 transformers-0.5.6.2

181+ unix-2.7.2.2

182+haddock-interfaces:

183+haddock-html:

184+---

185+name: array

186+version: 0.5.4.0

187+visibility: public

188+id: array-0.5.4.0

189+key: array-0.5.4.0

190+license: BSD-3-Clause

191+maintainer: libraries@haskell.org

192+synopsis: Mutable and immutable arrays

193+description:

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

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

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

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

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

199+category: Data Structures

200+exposed: True

201+exposed-modules:

202+ Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO

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

204+ Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe

205+ Data.Array.Storable Data.Array.Storable.Internals

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

207+import-dirs:

208+library-dirs:

209+dynamic-library-dirs:

210+data-dir:

211+hs-libraries: HSarray-0.5.4.0

212+depends: base-4.16.0.0

213+haddock-interfaces:

214+haddock-html:

215+---

216+name: base

217+version: 4.16.0.0

218+visibility: public

219+id: base-4.16.0.0

220+key: base-4.16.0.0

221+license: BSD-3-Clause

222+maintainer: libraries@haskell.org

223+synopsis: Basic libraries

224+description:

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

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

227+ structures to parsing combinators and debugging utilities.

228+category: Prelude

229+exposed: True

230+exposed-modules:

231+ Control.Applicative, Control.Arrow, Control.Category,

232+ Control.Concurrent, Control.Concurrent.Chan,

233+ Control.Concurrent.MVar, Control.Concurrent.QSem,

234+ Control.Concurrent.QSemN, Control.Exception,

235+ Control.Exception.Base, Control.Monad, Control.Monad.Fail,

236+ Control.Monad.Fix, Control.Monad.IO.Class, Control.Monad.Instances,

237+ Control.Monad.ST, Control.Monad.ST.Lazy,

238+ Control.Monad.ST.Lazy.Safe, Control.Monad.ST.Lazy.Unsafe,

239+ Control.Monad.ST.Safe, Control.Monad.ST.Strict,

240+ Control.Monad.ST.Unsafe, Control.Monad.Zip, Data.Bifoldable,

241+ Data.Bifunctor, Data.Bitraversable, Data.Bits, Data.Bool,

242+ Data.Char, Data.Coerce, Data.Complex, Data.Data, Data.Dynamic,

243+ Data.Either, Data.Eq, Data.Fixed, Data.Foldable, Data.Function,

244+ Data.Functor, Data.Functor.Classes, Data.Functor.Compose,

245+ Data.Functor.Const, Data.Functor.Contravariant,

246+ Data.Functor.Identity, Data.Functor.Product, Data.Functor.Sum,

247+ Data.IORef, Data.Int, Data.Ix, Data.Kind, Data.List,

248+ Data.List.NonEmpty, Data.Maybe, Data.Monoid, Data.Ord, Data.Proxy,

249+ Data.Ratio, Data.STRef, Data.STRef.Lazy, Data.STRef.Strict,

250+ Data.Semigroup, Data.String, Data.Traversable, Data.Tuple,

251+ Data.Type.Bool, Data.Type.Coercion, Data.Type.Equality,

252+ Data.Type.Ord, Data.Typeable, Data.Unique, Data.Version, Data.Void,

253+ Data.Word, Debug.Trace, Foreign, Foreign.C, Foreign.C.Error,

254+ Foreign.C.String, Foreign.C.Types, Foreign.Concurrent,

255+ Foreign.ForeignPtr, Foreign.ForeignPtr.Safe,

256+ Foreign.ForeignPtr.Unsafe, Foreign.Marshal, Foreign.Marshal.Alloc,

257+ Foreign.Marshal.Array, Foreign.Marshal.Error, Foreign.Marshal.Pool,

258+ Foreign.Marshal.Safe, Foreign.Marshal.Unsafe,

259+ Foreign.Marshal.Utils, Foreign.Ptr, Foreign.Safe,

260+ Foreign.StablePtr, Foreign.Storable, GHC.Arr, GHC.Base, GHC.Bits,

261+ GHC.ByteOrder, GHC.Char, GHC.Clock, GHC.Conc, GHC.Conc.IO,

262+ GHC.Conc.Signal, GHC.Conc.Sync, GHC.ConsoleHandler, GHC.Constants,

263+ GHC.Desugar, GHC.Enum, GHC.Environment, GHC.Err, GHC.Event,

264+ GHC.Event.TimeOut, GHC.Exception, GHC.Exception.Type,

265+ GHC.ExecutionStack, GHC.ExecutionStack.Internal, GHC.Exts,

266+ GHC.Fingerprint, GHC.Fingerprint.Type, GHC.Float,

267+ GHC.Float.ConversionUtils, GHC.Float.RealFracMethods, GHC.Foreign,

268+ GHC.ForeignPtr, GHC.GHCi, GHC.GHCi.Helpers, GHC.Generics, GHC.IO,

269+ GHC.IO.Buffer, GHC.IO.BufferedIO, GHC.IO.Device, GHC.IO.Encoding,

270+ GHC.IO.Encoding.CodePage, GHC.IO.Encoding.Failure,

271+ GHC.IO.Encoding.Iconv, GHC.IO.Encoding.Latin1,

272+ GHC.IO.Encoding.Types, GHC.IO.Encoding.UTF16,

273+ GHC.IO.Encoding.UTF32, GHC.IO.Encoding.UTF8, GHC.IO.Exception,

274+ GHC.IO.FD, GHC.IO.Handle, GHC.IO.Handle.FD,

275+ GHC.IO.Handle.Internals, GHC.IO.Handle.Lock, GHC.IO.Handle.Text,

276+ GHC.IO.Handle.Types, GHC.IO.IOMode, GHC.IO.StdHandles,

277+ GHC.IO.SubSystem, GHC.IO.Unsafe, GHC.IOArray, GHC.IOPort,

278+ GHC.IORef, GHC.Int, GHC.Integer, GHC.Integer.Logarithms, GHC.Ix,

279+ GHC.List, GHC.MVar, GHC.Maybe, GHC.Natural, GHC.Num,

280+ GHC.Num.BigNat from ghc-bignum-1.2:GHC.Num.BigNat,

281+ GHC.Num.Integer from ghc-bignum-1.2:GHC.Num.Integer,

282+ GHC.Num.Natural from ghc-bignum-1.2:GHC.Num.Natural, GHC.OldList,

283+ GHC.OverloadedLabels, GHC.Pack, GHC.Profiling, GHC.Ptr,

284+ GHC.RTS.Flags, GHC.Read, GHC.Real, GHC.Records, GHC.ResponseFile,

285+ GHC.ST, GHC.STRef, GHC.Show, GHC.Stable, GHC.StableName, GHC.Stack,

286+ GHC.Stack.CCS, GHC.Stack.Types, GHC.StaticPtr, GHC.Stats,

287+ GHC.Storable, GHC.TopHandler, GHC.TypeLits, GHC.TypeLits.Internal,

288+ GHC.TypeNats, GHC.TypeNats.Internal, GHC.Unicode, GHC.Weak,

289+ GHC.Word, Numeric, Numeric.Natural, Prelude, System.CPUTime,

290+ System.Console.GetOpt, System.Environment,

291+ System.Environment.Blank, System.Exit, System.IO, System.IO.Error,

292+ System.IO.Unsafe, System.Info, System.Mem, System.Mem.StableName,

293+ System.Mem.Weak, System.Posix.Internals, System.Posix.Types,

294+ System.Timeout, Text.ParserCombinators.ReadP,

295+ Text.ParserCombinators.ReadPrec, Text.Printf, Text.Read,

296+ Text.Read.Lex, Text.Show, Text.Show.Functions, Type.Reflection,

297+ Type.Reflection.Unsafe, Unsafe.Coerce

298+hidden-modules:

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

300+ Data.OldList Data.Semigroup.Internal Data.Typeable.Internal

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

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

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

304+ GHC.StaticPtr.Internal GHC.Event.Internal.Types

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

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

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

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

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

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

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

312+import-dirs:

313+library-dirs:

314+dynamic-library-dirs:

315+data-dir:

316+hs-libraries: HSbase-4.16.0.0

317+extra-libraries: iconv

318+include-dirs:

319+includes: HsBase.h

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

321+haddock-interfaces:

322+haddock-html:

323+---

324+name: binary

325+version: 0.8.9.0

326+visibility: public

327+id: binary-0.8.9.0

328+key: binary-0.8.9.0

329+license: BSD-3-Clause

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

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

332+stability: provisional

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

334+synopsis:

335+ Binary serialisation for Haskell values using lazy ByteStrings

336+description:

337+ Efficient, pure binary serialisation using lazy ByteStrings.

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

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

340+ The format used can be automatically generated, or

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

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

343+ so this library should be suitable for high performance

344+ scenarios.

345+category: Data, Parsing

346+exposed: True

347+exposed-modules:

348+ Data.Binary Data.Binary.Builder Data.Binary.Get

349+ Data.Binary.Get.Internal Data.Binary.Put

350+hidden-modules:

351+ Data.Binary.Class Data.Binary.Internal Data.Binary.Generic

352+ Data.Binary.FloatCast

353+import-dirs:

354+library-dirs:

355+dynamic-library-dirs:

356+data-dir:

357+hs-libraries: HSbinary-0.8.9.0

358+depends:

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

360+haddock-interfaces:

361+haddock-html:

362+---

363+name: bytestring

364+version: 0.11.1.0

365+visibility: public

366+id: bytestring-0.11.1.0

367+key: bytestring-0.11.1.0

368+license: BSD-3-Clause

369+copyright:

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

371+ (c) Duncan Coutts 2006-2015,

372+ (c) David Roundy 2003-2005,

373+ (c) Jasper Van der Jeugt 2010,

374+ (c) Simon Meier 2010-2013.

375+maintainer:

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

377+author:

378+ Don Stewart,

379+ Duncan Coutts

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

381+synopsis:

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

383+description:

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

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

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

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

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

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

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

391+ Two 'ByteString' variants are provided:

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

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

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

395+ suitable for I\/O streaming tasks.

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

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

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

399+ and network protocols).

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

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

402+ serialisation or pretty printing.

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

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

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

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

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

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

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

410+ > import qualified Data.ByteString as BS

411+category: Data

412+exposed: True

413+exposed-modules:

414+ Data.ByteString Data.ByteString.Builder

415+ Data.ByteString.Builder.Extra Data.ByteString.Builder.Internal

416+ Data.ByteString.Builder.Prim Data.ByteString.Builder.Prim.Internal

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

418+ Data.ByteString.Lazy.Char8 Data.ByteString.Lazy.Internal

419+ Data.ByteString.Short Data.ByteString.Short.Internal

420+ Data.ByteString.Unsafe

421+hidden-modules:

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

423+ Data.ByteString.Builder.Prim.ASCII

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

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

426+import-dirs:

427+library-dirs:

428+dynamic-library-dirs:

429+data-dir:

430+hs-libraries: HSbytestring-0.11.1.0

431+include-dirs:

432+includes: fpstring.h

433+depends:

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

435+haddock-interfaces:

436+haddock-html:

437+---

438+name: containers

439+version: 0.6.5.1

440+visibility: public

441+id: containers-0.6.5.1

442+key: containers-0.6.5.1

443+license: BSD-3-Clause

444+maintainer: libraries@haskell.org

445+synopsis: Assorted concrete container types

446+description:

447+ This package contains efficient general-purpose implementations

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

449+ trees, and graphs.

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

451+ operations see the [containers

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

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

454+ remains valid even if structures are shared.

455+category: Data Structures

456+exposed: True

457+exposed-modules:

458+ Data.Containers.ListUtils Data.Graph Data.IntMap

459+ Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy

460+ Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict

461+ Data.IntMap.Strict.Internal Data.IntSet Data.IntSet.Internal

462+ Data.Map Data.Map.Internal Data.Map.Internal.Debug Data.Map.Lazy

463+ Data.Map.Merge.Lazy Data.Map.Merge.Strict Data.Map.Strict

464+ Data.Map.Strict.Internal Data.Sequence Data.Sequence.Internal

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

466+ Utils.Containers.Internal.BitQueue

467+ Utils.Containers.Internal.BitUtil

468+ Utils.Containers.Internal.StrictPair

469+hidden-modules:

470+ Utils.Containers.Internal.State

471+ Utils.Containers.Internal.StrictMaybe

472+ Utils.Containers.Internal.PtrEquality

473+ Utils.Containers.Internal.Coercions

474+ Utils.Containers.Internal.TypeError

475+ Data.Map.Internal.DeprecatedShowTree

476+ Data.IntMap.Internal.DeprecatedDebug

477+import-dirs:

478+library-dirs:

479+dynamic-library-dirs:

480+data-dir:

481+hs-libraries: HScontainers-0.6.5.1

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

483+haddock-interfaces:

484+haddock-html:

485+---

486+name: deepseq

487+version: 1.4.6.0

488+visibility: public

489+id: deepseq-1.4.6.0

490+key: deepseq-1.4.6.0

491+license: BSD-3-Clause

492+maintainer: libraries@haskell.org

493+synopsis: Deep evaluation of data structures

494+description:

495+ This package provides methods for fully evaluating data structures

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

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

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

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

500+ wrong thread.

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

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

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

504+ components) which defines strategies for fully evaluating different

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

506+ details.

507+category: Control

508+exposed: True

509+exposed-modules: Control.DeepSeq

510+hidden-modules: Control.DeepSeq.BackDoor

511+import-dirs:

512+library-dirs:

513+dynamic-library-dirs:

514+data-dir:

515+hs-libraries: HSdeepseq-1.4.6.0

516+depends: array-0.5.4.0 base-4.16.0.0

517+haddock-interfaces:

518+haddock-html:

519+---

520+name: directory

521+version: 1.3.6.2

522+visibility: public

523+id: directory-1.3.6.2

524+key: directory-1.3.6.2

525+license: BSD-3-Clause

526+maintainer: libraries@haskell.org

527+synopsis: Platform-agnostic library for filesystem operations

528+description:

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

530+ directories in a portable way.

531+category: System

532+exposed: True

533+exposed-modules:

534+ System.Directory System.Directory.Internal

535+ System.Directory.Internal.Prelude

536+hidden-modules:

537+ System.Directory.Internal.C_utimensat

538+ System.Directory.Internal.Common System.Directory.Internal.Config

539+ System.Directory.Internal.Posix System.Directory.Internal.Windows

540+import-dirs:

541+library-dirs:

542+dynamic-library-dirs:

543+data-dir:

544+hs-libraries: HSdirectory-1.3.6.2

545+depends:

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

547+haddock-interfaces:

548+haddock-html:

549+---

550+name: exceptions

551+version: 0.10.4

552+visibility: public

553+id: exceptions-0.10.4

554+key: exceptions-0.10.4

555+license: BSD-3-Clause

556+copyright:

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

560+author: Edward A. Kmett

561+stability: provisional

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

563+synopsis: Extensible optionally-pure exceptions

564+description: Extensible optionally-pure exceptions.

565+category: Control, Exceptions, Monad

566+exposed: True

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

568+import-dirs:

569+library-dirs:

570+dynamic-library-dirs:

571+data-dir:

572+hs-libraries: HSexceptions-0.10.4

573+depends:

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

575+ transformers-0.5.6.2

576+haddock-interfaces:

577+haddock-html:

578+---

579+name: filepath

580+version: 1.4.2.1

581+visibility: public

582+id: filepath-1.4.2.1

583+key: filepath-1.4.2.1

584+license: BSD-3-Clause

585+copyright: Neil Mitchell 2005-2020

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

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

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

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

590+description:

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

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

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

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

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

596+category: System

597+exposed: True

598+exposed-modules:

599+ System.FilePath System.FilePath.Posix System.FilePath.Windows

600+import-dirs:

601+library-dirs:

602+dynamic-library-dirs:

603+data-dir:

604+hs-libraries: HSfilepath-1.4.2.1

605+depends: base-4.16.0.0

606+haddock-interfaces:

607+haddock-html:

608+---

609+name: ghc

610+version: 9.2.1

611+visibility: public

612+id: ghc-9.2.1

613+key: ghc-9.2.1

614+license: BSD-3-Clause

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

616+author: The GHC Team

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

618+synopsis: The GHC API

619+description:

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

621+ compiling Haskell programs. Important use cases are programs

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

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

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

625+ through this package.

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

627+ for more information.

628+category: Development

629+exposed-modules:

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

631+ GHC.Builtin.Types, GHC.Builtin.Types.Literals,

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

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

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

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

636+ GHC.Cmm.ContFlowOpt, GHC.Cmm.Dataflow, GHC.Cmm.Dataflow.Block,

637+ GHC.Cmm.Dataflow.Collections, GHC.Cmm.Dataflow.Graph,

638+ GHC.Cmm.Dataflow.Label, GHC.Cmm.DebugBlock, GHC.Cmm.Expr,

639+ GHC.Cmm.Graph, GHC.Cmm.Info, GHC.Cmm.Info.Build, GHC.Cmm.LRegSet,

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

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

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

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

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

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

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

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

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

649+ GHC.CmmToAsm.BlockLayout, GHC.CmmToAsm.CFG,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

684+ GHC.CmmToLlvm, GHC.CmmToLlvm.Base, GHC.CmmToLlvm.CodeGen,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

717+ GHC.Driver.Backpack, GHC.Driver.Backpack.Syntax,

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

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

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

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

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

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

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

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

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

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

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

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

730+ GHC.HsToCore.ListComp, GHC.HsToCore.Match,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

750+ GHC.Parser.PostProcess, GHC.Parser.PostProcess.Haddock,

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

752+ GHC.Platform.AArch64, GHC.Platform.ARM,

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

754+ GHC.Platform.Constants,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

779+ GHC.SysTools, GHC.SysTools.Ar, GHC.SysTools.BaseDir,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

802+ GHC.Types.CompleteMatch, GHC.Types.CostCentre,

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

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

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

806+ GHC.Types.ForeignStubs, GHC.Types.HpcInfo, GHC.Types.IPE,

807+ GHC.Types.Id, GHC.Types.Id.Info, GHC.Types.Id.Make,

808+ GHC.Types.Literal, GHC.Types.Meta, GHC.Types.Name,

809+ GHC.Types.Name.Cache, GHC.Types.Name.Env,

810+ GHC.Types.Name.Occurrence, GHC.Types.Name.Ppr,

811+ GHC.Types.Name.Reader, GHC.Types.Name.Set, GHC.Types.Name.Shape,

812+ GHC.Types.RepType, GHC.Types.SafeHaskell, GHC.Types.SourceError,

813+ GHC.Types.SourceFile, GHC.Types.SourceText, GHC.Types.SrcLoc,

814+ GHC.Types.Target, GHC.Types.Tickish, GHC.Types.TyThing,

815+ GHC.Types.TyThing.Ppr, GHC.Types.TypeEnv, GHC.Types.Unique,

816+ GHC.Types.Unique.DFM, GHC.Types.Unique.DSet, GHC.Types.Unique.FM,

817+ GHC.Types.Unique.Map, GHC.Types.Unique.SDFM, GHC.Types.Unique.Set,

818+ GHC.Types.Unique.Supply, GHC.Types.Var, GHC.Types.Var.Env,

819+ GHC.Types.Var.Set, GHC.Unit, GHC.Unit.Env, GHC.Unit.External,

820+ GHC.Unit.Finder, GHC.Unit.Finder.Types, GHC.Unit.Home,

821+ GHC.Unit.Home.ModInfo, GHC.Unit.Info, GHC.Unit.Module,

822+ GHC.Unit.Module.Deps, GHC.Unit.Module.Env, GHC.Unit.Module.Graph,

823+ GHC.Unit.Module.Imported, GHC.Unit.Module.Location,

824+ GHC.Unit.Module.ModDetails, GHC.Unit.Module.ModGuts,

825+ GHC.Unit.Module.ModIface, GHC.Unit.Module.ModSummary,

826+ GHC.Unit.Module.Name, GHC.Unit.Module.Status,

827+ GHC.Unit.Module.Warnings, GHC.Unit.Parser, GHC.Unit.Ppr,

828+ GHC.Unit.State, GHC.Unit.Types, GHC.Utils.Asm, GHC.Utils.Binary,

829+ GHC.Utils.Binary.Typeable, GHC.Utils.BufHandle,

830+ GHC.Utils.CliOption, GHC.Utils.Error, GHC.Utils.Exception,

831+ GHC.Utils.FV, GHC.Utils.Fingerprint, GHC.Utils.GlobalVars,

832+ GHC.Utils.IO.Unsafe, GHC.Utils.Json, GHC.Utils.Lexeme,

833+ GHC.Utils.Logger, GHC.Utils.Misc, GHC.Utils.Monad,

834+ GHC.Utils.Monad.State, GHC.Utils.Outputable, GHC.Utils.Panic,

835+ GHC.Utils.Panic.Plain, GHC.Utils.Ppr, GHC.Utils.Ppr.Colour,

836+ GHC.Utils.TmpFs, Language.Haskell.Syntax,

837+ Language.Haskell.Syntax.Binds, Language.Haskell.Syntax.Decls,

838+ Language.Haskell.Syntax.Expr, Language.Haskell.Syntax.Extension,

839+ Language.Haskell.Syntax.Lit, Language.Haskell.Syntax.Pat,

840+ Language.Haskell.Syntax.Type

841+import-dirs:

842+library-dirs:

843+dynamic-library-dirs:

844+data-dir:

845+hs-libraries: HSghc-9.2.1

846+include-dirs:

847+depends:

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

849+ containers-0.6.5.1 deepseq-1.4.6.0 directory-1.3.6.2

850+ exceptions-0.10.4 filepath-1.4.2.1 ghc-boot-9.2.1 ghc-heap-9.2.1

851+ ghci-9.2.1 hpc-0.6.1.0 parsec-3.1.14.0 process-1.6.13.2

852+ template-haskell-2.18.0.0 terminfo-0.4.1.5 time-1.11.1.1

853+ transformers-0.5.6.2 unix-2.7.2.2

854+haddock-interfaces:

855+haddock-html:

856+---

857+name: ghc-bignum

858+version: 1.2

859+visibility: public

860+id: ghc-bignum-1.2

861+key: ghc-bignum-1.2

862+license: BSD-3-Clause

863+maintainer: libraries@haskell.org

864+author: Sylvain Henry

865+synopsis: GHC BigNum library

866+description:

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

868+ 'BigNat', 'Natural' and 'Integer' types.

869+category: Numeric, Algebra, GHC

870+exposed: True

871+exposed-modules:

872+ GHC.Num.Backend GHC.Num.Backend.Native GHC.Num.Backend.Selected

873+ GHC.Num.BigNat GHC.Num.Integer GHC.Num.Natural GHC.Num.Primitives

874+ GHC.Num.WordArray

875+hidden-modules: GHC.Num.Backend.GMP

876+import-dirs:

877+library-dirs:

878+dynamic-library-dirs:

879+data-dir:

880+hs-libraries: HSghc-bignum-1.2

881+extra-libraries: gmp

882+include-dirs:

883+depends: ghc-prim-0.8.0

884+haddock-interfaces:

885+haddock-html:

886+---

887+name: ghc-boot

888+version: 9.2.1

889+visibility: public

890+id: ghc-boot-9.2.1

891+key: ghc-boot-9.2.1

892+license: BSD-3-Clause

893+maintainer: ghc-devs@haskell.org

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

895+description:

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

897+ libraries.

898+ .

899+ A note about "GHC.Unit.Database": it only deals with the subset of

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

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

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

903+ suitable for modifying GHC package databases.

904+ .

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

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

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

908+category: GHC

909+exposed: True

910+exposed-modules:

911+ GHC.BaseDir, GHC.Data.ShortText, GHC.Data.SizedSeq,

912+ GHC.ForeignSrcLang,

913+ GHC.ForeignSrcLang.Type from ghc-boot-th-9.2.1:GHC.ForeignSrcLang.Type,

914+ GHC.HandleEncoding, GHC.LanguageExtensions,

915+ GHC.LanguageExtensions.Type from ghc-boot-th-9.2.1:GHC.LanguageExtensions.Type,

916+ GHC.Lexeme from ghc-boot-th-9.2.1:GHC.Lexeme, GHC.Platform.ArchOS,

917+ GHC.Platform.Host, GHC.Serialized, GHC.Settings.Utils,

918+ GHC.UniqueSubdir, GHC.Unit.Database, GHC.Utils.Encoding,

919+ GHC.Version

920+import-dirs:

921+library-dirs:

922+dynamic-library-dirs:

923+data-dir:

924+hs-libraries: HSghc-boot-9.2.1

925+depends:

926+ base-4.16.0.0 binary-0.8.9.0 bytestring-0.11.1.0 containers-0.6.5.1

927+ deepseq-1.4.6.0 directory-1.3.6.2 filepath-1.4.2.1

928+ ghc-boot-th-9.2.1

929+haddock-interfaces:

930+haddock-html:

931+---

932+name: ghc-boot-th

933+version: 9.2.1

934+visibility: public

935+id: ghc-boot-th-9.2.1

936+key: ghc-boot-th-9.2.1

937+license: BSD-3-Clause

938+maintainer: ghc-devs@haskell.org

939+synopsis:

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

941+ library

942+description:

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

944+ @template-haskell@ libraries.

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

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

947+ be depended upon by user code.

948+category: GHC

949+exposed: True

950+exposed-modules:

951+ GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme

952+import-dirs:

953+library-dirs:

954+dynamic-library-dirs:

955+data-dir:

956+hs-libraries: HSghc-boot-th-9.2.1

957+depends: base-4.16.0.0

958+haddock-interfaces:

959+haddock-html:

960+---

961+name: ghc-compact

962+version: 0.1.0.0

963+visibility: public

964+id: ghc-compact-0.1.0.0

965+key: ghc-compact-0.1.0.0

966+license: BSD-3-Clause

967+maintainer: libraries@haskell.org

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

969+description:

970+ This package provides minimal functionality for working with

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

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

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

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

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

976+ released).

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

978+ which allows efficient serialization and deserialization of structs

979+ for distributed computing.

980+category: Data

981+exposed: True

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

983+import-dirs:

984+library-dirs:

985+dynamic-library-dirs:

986+data-dir:

987+hs-libraries: HSghc-compact-0.1.0.0

988+depends: base-4.16.0.0 bytestring-0.11.1.0 ghc-prim-0.8.0

989+haddock-interfaces:

990+haddock-html:

991+---

992+name: ghc-heap

993+version: 9.2.1

994+visibility: public

995+id: ghc-heap-9.2.1

996+key: ghc-heap-9.2.1

997+license: BSD-3-Clause

998+maintainer: libraries@haskell.org

999+synopsis: Functions for walking GHC's heap

1000+description:

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

1002+ and retrieving information about those data structures.

1003+category: GHC

1004+exposed: True

1005+exposed-modules:

1006+ GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures

1007+ GHC.Exts.Heap.Constants GHC.Exts.Heap.FFIClosures

1008+ GHC.Exts.Heap.FFIClosures_ProfilingDisabled

1009+ GHC.Exts.Heap.FFIClosures_ProfilingEnabled GHC.Exts.Heap.InfoTable

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

1011+ GHC.Exts.Heap.ProfInfo.PeekProfInfo

1012+ GHC.Exts.Heap.ProfInfo.PeekProfInfo_ProfilingDisabled

1013+ GHC.Exts.Heap.ProfInfo.PeekProfInfo_ProfilingEnabled

1014+ GHC.Exts.Heap.ProfInfo.Types GHC.Exts.Heap.Utils

1015+import-dirs:

1016+library-dirs:

1017+dynamic-library-dirs:

1018+data-dir:

1019+hs-libraries: HSghc-heap-9.2.1

1020+depends: base-4.16.0.0 containers-0.6.5.1 ghc-prim-0.8.0 rts

1021+haddock-interfaces:

1022+haddock-html:

1023+---

1024+name: ghc-prim

1025+version: 0.8.0

1026+visibility: public

1027+id: ghc-prim-0.8.0

1028+key: ghc-prim-0.8.0

1029+license: BSD-3-Clause

1030+maintainer: libraries@haskell.org

1031+synopsis: GHC primitives

1032+description:

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

1034+category: GHC

1035+exposed: True

1036+exposed-modules:

1037+ GHC.CString GHC.Classes GHC.Debug GHC.Magic GHC.Prim.Exception

1038+ GHC.Prim.Ext GHC.Prim.Panic GHC.PrimopWrappers GHC.Tuple GHC.Types

1039+ GHC.Prim

1040+import-dirs:

1041+library-dirs:

1042+dynamic-library-dirs:

1043+data-dir:

1044+hs-libraries: HSghc-prim-0.8.0

1045+depends: rts

1046+haddock-interfaces:

1047+haddock-html:

1048+---

1049+name: ghci

1050+version: 9.2.1

1051+visibility: public

1052+id: ghci-9.2.1

1053+key: ghci-9.2.1

1054+license: BSD-3-Clause

1055+maintainer: ghc-devs@haskell.org

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

1057+description:

1058+ This library offers interfaces which mediate interactions between the

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

1060+ backend.

1061+category: GHC

1062+exposed: True

1063+exposed-modules:

1064+ GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI

1065+ GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes

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

1067+ GHCi.TH.Binary

1068+import-dirs:

1069+library-dirs:

1070+dynamic-library-dirs:

1071+data-dir:

1072+hs-libraries: HSghci-9.2.1

1073+include-dirs:

1074+depends:

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

1076+ containers-0.6.5.1 deepseq-1.4.6.0 filepath-1.4.2.1 ghc-boot-9.2.1

1077+ ghc-heap-9.2.1 ghc-prim-0.8.0 rts template-haskell-2.18.0.0

1078+ transformers-0.5.6.2 unix-2.7.2.2

1079+haddock-interfaces:

1080+haddock-html:

1081+---

1082+name: haskeline

1083+version: 0.8.2

1084+visibility: public

1085+id: haskeline-0.8.2

1086+key: haskeline-0.8.2

1087+license: BSD-3-Clause

1088+copyright: (c) Judah Jacobson

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

1090+author: Judah Jacobson

1091+stability: Stable

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

1093+synopsis:

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

1095+description:

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

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

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

1099+ Haskell programs.

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

1101+category: User Interfaces

1102+exposed: True

1103+exposed-modules:

1104+ System.Console.Haskeline System.Console.Haskeline.Completion

1105+ System.Console.Haskeline.History System.Console.Haskeline.IO

1106+ System.Console.Haskeline.Internal

1107+hidden-modules:

1108+ System.Console.Haskeline.Backend

1109+ System.Console.Haskeline.Backend.WCWidth

1110+ System.Console.Haskeline.Command

1111+ System.Console.Haskeline.Command.Completion

1112+ System.Console.Haskeline.Command.History

1113+ System.Console.Haskeline.Command.KillRing

1114+ System.Console.Haskeline.Directory System.Console.Haskeline.Emacs

1115+ System.Console.Haskeline.InputT System.Console.Haskeline.Key

1116+ System.Console.Haskeline.LineState System.Console.Haskeline.Monads

1117+ System.Console.Haskeline.Prefs System.Console.Haskeline.Recover

1118+ System.Console.Haskeline.RunCommand System.Console.Haskeline.Term

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

1120+ System.Console.Haskeline.Backend.Posix

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

1122+ System.Console.Haskeline.Backend.DumbTerm

1123+ System.Console.Haskeline.Backend.Terminfo

1124+import-dirs:

1125+library-dirs:

1126+dynamic-library-dirs:

1127+data-dir:

1128+hs-libraries: HShaskeline-0.8.2

1129+depends:

1130+ base-4.16.0.0 bytestring-0.11.1.0 containers-0.6.5.1

1131+ directory-1.3.6.2 exceptions-0.10.4 filepath-1.4.2.1

1132+ process-1.6.13.2 stm-2.5.0.0 terminfo-0.4.1.5 transformers-0.5.6.2

1133+ unix-2.7.2.2

1134+haddock-interfaces:

1135+haddock-html:

1136+---

1137+name: hpc

1138+version: 0.6.1.0

1139+visibility: public

1140+id: hpc-0.6.1.0

1141+key: hpc-0.6.1.0

1142+license: BSD-3-Clause

1143+maintainer: ghc-devs@haskell.org

1144+author: Andy Gill

1145+synopsis: Code Coverage Library for Haskell

1146+description:

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

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

1149+ information.

1150+category: Control

1151+exposed: True

1152+exposed-modules:

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

1154+import-dirs:

1155+library-dirs:

1156+dynamic-library-dirs:

1157+data-dir:

1158+hs-libraries: HShpc-0.6.1.0

1159+depends:

1160+ base-4.16.0.0 containers-0.6.5.1 deepseq-1.4.6.0 directory-1.3.6.2

1161+ filepath-1.4.2.1 time-1.11.1.1

1162+haddock-interfaces:

1163+haddock-html:

1164+---

1165+name: integer-gmp

1166+version: 1.1

1167+visibility: public

1168+id: integer-gmp-1.1

1169+key: integer-gmp-1.1

1170+license: BSD-3-Clause

1171+maintainer: hvr@gnu.org

1172+author: Herbert Valerio Riedel

1173+synopsis: Integer library based on GMP

1174+description:

1175+ This package used to provide an implementation of the standard 'Integer'

1176+ type based on the

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

1178+ It is now deprecated in favor of the 'ghc-bignum' package.

1179+ Its purpose is to provide backward compatibility for codes directly

1180+ depending on the `integer-gmp` package.

1181+category: Numeric, Algebra

1182+exposed: True

1183+exposed-modules: GHC.Integer.GMP.Internals

1184+import-dirs:

1185+library-dirs:

1186+dynamic-library-dirs:

1187+data-dir:

1188+hs-libraries: HSinteger-gmp-1.1

1189+depends: base-4.16.0.0 ghc-bignum-1.2 ghc-prim-0.8.0

1190+haddock-interfaces:

1191+haddock-html:

1192+---

1193+name: libiserv

1194+version: 9.2.1

1195+visibility: public

1196+id: libiserv-9.2.1

1197+key: libiserv-9.2.1

1198+license: BSD-3-Clause

1199+copyright: XXX

1200+maintainer: XXX

1201+author: XXX

1202+synopsis:

1203+ Provides shared functionality between iserv and iserv-proxy.

1204+description:

1205+ Provides shared functionality between iserv and iserv-proxy.

1206+category: Development

1207+exposed: True

1208+exposed-modules: GHCi.Utils Lib

1209+import-dirs:

1210+library-dirs:

1211+dynamic-library-dirs:

1212+data-dir:

1213+hs-libraries: HSlibiserv-9.2.1

1214+depends:

1215+ base-4.16.0.0 binary-0.8.9.0 bytestring-0.11.1.0 containers-0.6.5.1

1216+ deepseq-1.4.6.0 ghci-9.2.1 unix-2.7.2.2

1217+haddock-interfaces:

1218+haddock-html:

1219+---

1220+name: mtl

1221+version: 2.2.2

1222+visibility: public

1223+id: mtl-2.2.2

1224+key: mtl-2.2.2

1225+license: BSD-3-Clause

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

1227+author: Andy Gill

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

1229+synopsis: Monad classes, using functional dependencies

1230+description:

1231+ Monad classes using functional dependencies, with instances

1232+ for various monad transformers, inspired by the paper

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

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

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

1236+category: Control

1237+exposed: True

1238+exposed-modules:

1239+ Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error

1240+ Control.Monad.Error.Class Control.Monad.Except

1241+ Control.Monad.Identity Control.Monad.List Control.Monad.RWS

1242+ Control.Monad.RWS.Class Control.Monad.RWS.Lazy

1243+ Control.Monad.RWS.Strict Control.Monad.Reader

1244+ Control.Monad.Reader.Class Control.Monad.State

1245+ Control.Monad.State.Class Control.Monad.State.Lazy

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

1247+ Control.Monad.Writer.Class Control.Monad.Writer.Lazy

1248+ Control.Monad.Writer.Strict

1249+import-dirs:

1250+library-dirs:

1251+dynamic-library-dirs:

1252+data-dir:

1253+hs-libraries: HSmtl-2.2.2

1254+depends: base-4.16.0.0 transformers-0.5.6.2

1255+haddock-interfaces:

1256+haddock-html:

1257+---

1258+name: parsec

1259+version: 3.1.14.0

1260+visibility: public

1261+id: parsec-3.1.14.0

1262+key: parsec-3.1.14.0

1263+license: BSD-3-Clause

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

1265+author:

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

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

1268+synopsis: Monadic parser combinators

1269+description:

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

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

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

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

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

1275+ input stream type.

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

1277+ defaults for parsing 'Char'acter data.

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

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

1280+ the future.

1281+category: Parsing

1282+exposed: True

1283+exposed-modules:

1284+ Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy

1285+ Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error

1286+ Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm

1287+ Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String

1288+ Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token

1289+ Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char

1290+ Text.ParserCombinators.Parsec.Combinator

1291+ Text.ParserCombinators.Parsec.Error

1292+ Text.ParserCombinators.Parsec.Expr

1293+ Text.ParserCombinators.Parsec.Language

1294+ Text.ParserCombinators.Parsec.Perm

1295+ Text.ParserCombinators.Parsec.Pos

1296+ Text.ParserCombinators.Parsec.Prim

1297+ Text.ParserCombinators.Parsec.Token

1298+import-dirs:

1299+library-dirs:

1300+dynamic-library-dirs:

1301+data-dir:

1302+hs-libraries: HSparsec-3.1.14.0

1303+depends:

1304+ base-4.16.0.0 bytestring-0.11.1.0 mtl-2.2.2 text-1.2.5.0

1305+haddock-interfaces:

1306+haddock-html:

1307+---

1308+name: pretty

1309+version: 1.1.3.6

1310+visibility: public

1311+id: pretty-1.1.3.6

1312+key: pretty-1.1.3.6

1313+license: BSD-3-Clause

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

1315+stability: Stable

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

1317+synopsis: Pretty-printing library

1318+description:

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

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

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

1322+ tools.

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

1324+ been heavily modified by Simon Peyton Jones.

1325+category: Text

1326+exposed: True

1327+exposed-modules:

1328+ Text.PrettyPrint Text.PrettyPrint.Annotated

1329+ Text.PrettyPrint.Annotated.HughesPJ

1330+ Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ

1331+ Text.PrettyPrint.HughesPJClass

1332+import-dirs:

1333+library-dirs:

1334+dynamic-library-dirs:

1335+data-dir:

1336+hs-libraries: HSpretty-1.1.3.6

1337+depends: base-4.16.0.0 deepseq-1.4.6.0 ghc-prim-0.8.0

1338+haddock-interfaces:

1339+haddock-html:

1340+---

1341+name: process

1342+version: 1.6.13.2

1343+visibility: public

1344+id: process-1.6.13.2

1345+key: process-1.6.13.2

1346+license: BSD-3-Clause

1347+maintainer: libraries@haskell.org

1348+synopsis: Process libraries

1349+description:

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

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

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

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

1354+ read more about it at

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

1356+category: System

1357+exposed: True

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

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

1360+import-dirs:

1361+library-dirs:

1362+dynamic-library-dirs:

1363+data-dir:

1364+hs-libraries: HSprocess-1.6.13.2

1365+include-dirs:

1366+includes: runProcess.h

1367+depends:

1368+ base-4.16.0.0 deepseq-1.4.6.0 directory-1.3.6.2 filepath-1.4.2.1

1369+ unix-2.7.2.2

1370+haddock-interfaces:

1371+haddock-html:

1372+---

1373+name: stm

1374+version: 2.5.0.0

1375+visibility: public

1376+id: stm-2.5.0.0

1377+key: stm-2.5.0.0

1378+license: BSD-3-Clause

1379+maintainer: libraries@haskell.org

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

1381+synopsis: Software Transactional Memory

1382+description:

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

1384+ concurrent communication. The main benefits of STM are

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

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

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

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

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

1390+ 'MVar's.

1391+category: Concurrency

1392+exposed: True

1393+exposed-modules:

1394+ Control.Concurrent.STM Control.Concurrent.STM.TArray

1395+ Control.Concurrent.STM.TBQueue Control.Concurrent.STM.TChan

1396+ Control.Concurrent.STM.TMVar Control.Concurrent.STM.TQueue

1397+ Control.Concurrent.STM.TSem Control.Concurrent.STM.TVar

1398+ Control.Monad.STM

1399+hidden-modules: Control.Sequential.STM

1400+import-dirs:

1401+library-dirs:

1402+dynamic-library-dirs:

1403+data-dir:

1404+hs-libraries: HSstm-2.5.0.0

1405+depends: array-0.5.4.0 base-4.16.0.0

1406+haddock-interfaces:

1407+haddock-html:

1408+---

1409+name: template-haskell

1410+version: 2.18.0.0

1411+visibility: public

1412+id: template-haskell-2.18.0.0

1413+key: template-haskell-2.18.0.0

1414+license: BSD-3-Clause

1415+maintainer: libraries@haskell.org

1416+synopsis: Support library for Template Haskell

1417+description:

1418+ This package provides modules containing facilities for manipulating

1419+ Haskell source code using Template Haskell.

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

1421+ information.

1422+category: Template Haskell

1423+exposed: True

1424+exposed-modules:

1425+ Language.Haskell.TH Language.Haskell.TH.CodeDo

1426+ Language.Haskell.TH.LanguageExtensions Language.Haskell.TH.Lib

1427+ Language.Haskell.TH.Lib.Internal Language.Haskell.TH.Ppr

1428+ Language.Haskell.TH.PprLib Language.Haskell.TH.Quote

1429+ Language.Haskell.TH.Syntax

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

1431+import-dirs:

1432+library-dirs:

1433+dynamic-library-dirs:

1434+data-dir:

1435+hs-libraries: HStemplate-haskell-2.18.0.0

1436+depends:

1437+ base-4.16.0.0 ghc-boot-th-9.2.1 ghc-prim-0.8.0 pretty-1.1.3.6

1438+haddock-interfaces:

1439+haddock-html:

1440+---

1441+name: terminfo

1442+version: 0.4.1.5

1443+visibility: public

1444+id: terminfo-0.4.1.5

1445+key: terminfo-0.4.1.5

1446+license: BSD-3-Clause

1447+copyright: (c) Judah Jacobson

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

1449+author: Judah Jacobson

1450+stability: Stable

1451+homepage: https://github.com/judah/terminfo

1452+synopsis: Haskell bindings to the terminfo library.

1453+description:

1454+ This library provides an interface to the terminfo database (via bindings to the

1455+ curses library). <http://en.wikipedia.org/wiki/Terminfo Terminfo> allows POSIX

1456+ systems to interact with a variety of terminals using a standard set of capabilities.

1457+category: User Interfaces

1458+exposed: True

1459+exposed-modules:

1460+ System.Console.Terminfo System.Console.Terminfo.Base

1461+ System.Console.Terminfo.Color System.Console.Terminfo.Cursor

1462+ System.Console.Terminfo.Edit System.Console.Terminfo.Effects

1463+ System.Console.Terminfo.Keys

1464+import-dirs:

1465+library-dirs:

1466+dynamic-library-dirs:

1467+data-dir:

1468+hs-libraries: HSterminfo-0.4.1.5

1469+extra-libraries: tinfo

1470+depends: base-4.16.0.0

1471+haddock-interfaces:

1472+haddock-html:

1473+---

1474+name: text

1475+version: 1.2.5.0

1476+visibility: public

1477+id: text-1.2.5.0

1478+key: text-1.2.5.0

1479+license: BSD-2-Clause

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

1481+maintainer:

1482+ Haskell Text Team <andrew.lelechenko@gmail.com>, Core Libraries Committee

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

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

1485+synopsis: An efficient packed Unicode text type.

1486+description:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1501+ clashes with Prelude functions, e.g.

1502+ > import qualified Data.Text as T

1503+ == ICU Support

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

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

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

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

1508+ based on the well-respected and liberally

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

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

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

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

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

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

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

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

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

1518+category: Data, Text

1519+exposed: True

1520+exposed-modules:

1521+ Data.Text Data.Text.Array Data.Text.Encoding

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

1523+ Data.Text.Internal Data.Text.Internal.Builder

1524+ Data.Text.Internal.Builder.Functions

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

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

1527+ Data.Text.Internal.ByteStringCompat

1528+ Data.Text.Internal.Encoding.Fusion

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

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

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

1532+ Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping

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

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

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

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

1537+ Data.Text.Internal.PrimCompat Data.Text.Internal.Private

1538+ Data.Text.Internal.Read Data.Text.Internal.Search

1539+ Data.Text.Internal.Unsafe Data.Text.Internal.Unsafe.Char

1540+ Data.Text.Internal.Unsafe.Shift Data.Text.Lazy

1541+ Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int

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

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

1544+ Data.Text.Read Data.Text.Unsafe

1545+hidden-modules: Data.Text.Show

1546+import-dirs:

1547+library-dirs:

1548+dynamic-library-dirs:

1549+data-dir:

1550+hs-libraries: HStext-1.2.5.0

1551+depends:

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

1553+ deepseq-1.4.6.0 ghc-prim-0.8.0 template-haskell-2.18.0.0

1554+haddock-interfaces:

1555+haddock-html:

1556+---

1557+name: time

1558+version: 1.11.1.1

1559+visibility: public

1560+id: time-1.11.1.1

1561+key: time-1.11.1.1

1562+license: BSD-3-Clause

1563+maintainer: <ashley@semantic.org>

1564+author: Ashley Yakeley

1565+stability: stable

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

1567+synopsis: A time library

1568+description: Time, clocks and calendars

1569+category: Time

1570+exposed: True

1571+exposed-modules:

1572+ Data.Time Data.Time.Calendar Data.Time.Calendar.Easter

1573+ Data.Time.Calendar.Julian Data.Time.Calendar.Month

1574+ Data.Time.Calendar.MonthDay Data.Time.Calendar.OrdinalDate

1575+ Data.Time.Calendar.Quarter Data.Time.Calendar.WeekDate

1576+ Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System

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

1578+ Data.Time.Format.Internal Data.Time.LocalTime

1579+hidden-modules:

1580+ Data.Format Data.Time.Calendar.Types Data.Time.Calendar.Private

1581+ Data.Time.Calendar.Days Data.Time.Calendar.Gregorian

1582+ Data.Time.Calendar.CalendarDiffDays Data.Time.Calendar.Week

1583+ Data.Time.Calendar.JulianYearDay Data.Time.Clock.Internal.DiffTime

1584+ Data.Time.Clock.Internal.AbsoluteTime

1585+ Data.Time.Clock.Internal.NominalDiffTime

1586+ Data.Time.Clock.Internal.POSIXTime

1587+ Data.Time.Clock.Internal.UniversalTime

1588+ Data.Time.Clock.Internal.SystemTime

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

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

1591+ Data.Time.LocalTime.Internal.TimeZone

1592+ Data.Time.LocalTime.Internal.TimeOfDay

1593+ Data.Time.LocalTime.Internal.CalendarDiffTime

1594+ Data.Time.LocalTime.Internal.LocalTime

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

1596+ Data.Time.Format.Locale Data.Time.Format.Format.Class

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

1598+ Data.Time.Format.Parse.Instances

1599+import-dirs:

1600+library-dirs:

1601+dynamic-library-dirs:

1602+data-dir:

1603+hs-libraries: HStime-1.11.1.1

1604+include-dirs:

1605+depends: base-4.16.0.0 deepseq-1.4.6.0

1606+haddock-interfaces:

1607+haddock-html:

1608+---

1609+name: transformers

1610+version: 0.5.6.2

1611+visibility: public

1612+id: transformers-0.5.6.2

1613+key: transformers-0.5.6.2

1614+license: BSD-3-Clause

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

1616+author: Andy Gill, Ross Paterson

1617+synopsis: Concrete functor and monad transformers

1618+description:

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

1620+ the paper

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

1622+ Polymorphism\", by Mark P Jones,

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

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

1625+ This package contains:

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

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

1628+ operations and functions to lift operations associated with other

1629+ transformers.

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

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

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

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

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

1635+ introduced by monad transformers through other transformers.

1636+category: Control

1637+exposed: True

1638+exposed-modules:

1639+ Control.Applicative.Backwards Control.Applicative.Lift

1640+ Control.Monad.Signatures Control.Monad.Trans.Accum

1641+ Control.Monad.Trans.Class Control.Monad.Trans.Cont

1642+ Control.Monad.Trans.Error Control.Monad.Trans.Except

1643+ Control.Monad.Trans.Identity Control.Monad.Trans.List

1644+ Control.Monad.Trans.Maybe Control.Monad.Trans.RWS

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

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

1647+ Control.Monad.Trans.Select Control.Monad.Trans.State

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

1649+ Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS

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

1651+ Data.Functor.Constant Data.Functor.Reverse

1652+import-dirs:

1653+library-dirs:

1654+dynamic-library-dirs:

1655+data-dir:

1656+hs-libraries: HStransformers-0.5.6.2

1657+depends: base-4.16.0.0

1658+haddock-interfaces:

1659+haddock-html:

1660+---

1661+name: unix

1662+version: 2.7.2.2

1663+visibility: public

1664+id: unix-2.7.2.2

1665+key: unix-2.7.2.2

1666+license: BSD-3-Clause

1667+maintainer: libraries@haskell.org

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

1669+synopsis: POSIX functionality

1670+description:

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

1672+ services standardised by

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

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

1675+ Environments - IEEE Std. 1003.1).

1676+ The package is not supported under Windows.

1677+category: System

1678+exposed: True

1679+exposed-modules:

1680+ System.Posix System.Posix.ByteString

1681+ System.Posix.ByteString.FilePath System.Posix.Directory

1682+ System.Posix.Directory.ByteString System.Posix.DynamicLinker

1683+ System.Posix.DynamicLinker.ByteString

1684+ System.Posix.DynamicLinker.Module

1685+ System.Posix.DynamicLinker.Module.ByteString

1686+ System.Posix.DynamicLinker.Prim System.Posix.Env

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

1688+ System.Posix.Files System.Posix.Files.ByteString System.Posix.IO

1689+ System.Posix.IO.ByteString System.Posix.Process

1690+ System.Posix.Process.ByteString System.Posix.Process.Internals

1691+ System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem

1692+ System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp

1693+ System.Posix.Temp.ByteString System.Posix.Terminal

1694+ System.Posix.Terminal.ByteString System.Posix.Time

1695+ System.Posix.Unistd System.Posix.User

1696+hidden-modules:

1697+ System.Posix.Directory.Common System.Posix.DynamicLinker.Common

1698+ System.Posix.Files.Common System.Posix.IO.Common

1699+ System.Posix.Process.Common System.Posix.Terminal.Common

1700+import-dirs:

1701+library-dirs:

1702+dynamic-library-dirs:

1703+data-dir:

1704+hs-libraries: HSunix-2.7.2.2

1705+include-dirs:

1706+includes: HsUnix.h execvpe.h

1707+depends: base-4.16.0.0 bytestring-0.11.1.0 time-1.11.1.1

1708+haddock-interfaces:

1709+haddock-html:

1710+---

1711+name: xhtml

1712+version: 3000.2.2.1

1713+visibility: public

1714+id: xhtml-3000.2.2.1

1715+key: xhtml-3000.2.2.1

1716+license: BSD-3-Clause

1717+copyright:

1718+ Bjorn Bringert 2004-2006, Andy Gill and the Oregon

1719+ Graduate Institute of Science and Technology, 1999-2001

1720+maintainer: Chris Dornan <chris@chrisdornan.com>

1721+author: Bjorn Bringert

1722+stability: Stable

1723+homepage: https://github.com/haskell/xhtml

1724+synopsis: An XHTML combinator library

1725+description:

1726+ This package provides combinators for producing

1727+ XHTML 1.0, including the Strict, Transitional and

1728+ Frameset variants.

1729+category: Web, XML, Pretty Printer

1730+exposed: True

1731+exposed-modules:

1732+ Text.XHtml Text.XHtml.Debug Text.XHtml.Frameset Text.XHtml.Strict

1733+ Text.XHtml.Table Text.XHtml.Transitional

1734+hidden-modules:

1735+ Text.XHtml.Strict.Attributes Text.XHtml.Strict.Elements

1736+ Text.XHtml.Frameset.Attributes Text.XHtml.Frameset.Elements

1737+ Text.XHtml.Transitional.Attributes Text.XHtml.Transitional.Elements

1738+ Text.XHtml.BlockTable Text.XHtml.Extras Text.XHtml.Internals

1739+import-dirs:

1740+library-dirs:

1741+dynamic-library-dirs:

1742+data-dir:

1743+hs-libraries: HSxhtml-3000.2.2.1

1744+depends: base-4.16.0.0

1745+haddock-interfaces:

1746+haddock-html:

1747+---

1748+name: rts

1749+version: 1.0.2

1750+visibility: public

1751+id: rts

1752+key: rts

1753+license: BSD-3-Clause

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

1755+exposed: True

1756+library-dirs:

1757+hs-libraries: HSrts

1758+extra-libraries: m dl ffi

1759+include-dirs:

1760+includes: Stg.h

1761+ld-options:

1762+ "-Wl,-u,_base_GHCziTopHandler_runIO_closure"

1763+ "-Wl,-u,_base_GHCziTopHandler_runNonIO_closure"

1764+ "-Wl,-u,_ghczmprim_GHCziTuple_Z0T_closure"

1765+ "-Wl,-u,_ghczmprim_GHCziTypes_True_closure"

1766+ "-Wl,-u,_ghczmprim_GHCziTypes_False_closure"

1767+ "-Wl,-u,_base_GHCziPack_unpackCString_closure"

1768+ "-Wl,-u,_base_GHCziWeak_runFinalizzerBatch_closure"

1769+ "-Wl,-u,_base_GHCziIOziException_stackOverflow_closure"

1770+ "-Wl,-u,_base_GHCziIOziException_heapOverflow_closure"

1771+ "-Wl,-u,_base_GHCziIOziException_allocationLimitExceeded_closure"

1772+ "-Wl,-u,_base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"

1773+ "-Wl,-u,_base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"

1774+ "-Wl,-u,_base_GHCziIOziException_cannotCompactFunction_closure"

1775+ "-Wl,-u,_base_GHCziIOziException_cannotCompactPinned_closure"

1776+ "-Wl,-u,_base_GHCziIOziException_cannotCompactMutable_closure"

1777+ "-Wl,-u,_base_GHCziIOPort_doubleReadException_closure"

1778+ "-Wl,-u,_base_ControlziExceptionziBase_nonTermination_closure"

1779+ "-Wl,-u,_base_ControlziExceptionziBase_nestedAtomically_closure"

1780+ "-Wl,-u,_base_GHCziEventziThread_blockedOnBadFD_closure"

1781+ "-Wl,-u,_base_GHCziExceptionziType_divZZeroException_closure"

1782+ "-Wl,-u,_base_GHCziExceptionziType_underflowException_closure"

1783+ "-Wl,-u,_base_GHCziExceptionziType_overflowException_closure"

1784+ "-Wl,-u,_base_GHCziConcziSync_runSparks_closure"

1785+ "-Wl,-u,_base_GHCziConcziIO_ensureIOManagerIsRunning_closure"

1786+ "-Wl,-u,_base_GHCziConcziIO_interruptIOManager_closure"

1787+ "-Wl,-u,_base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"

1788+ "-Wl,-u,_base_GHCziConcziSignal_runHandlersPtr_closure"

1789+ "-Wl,-u,_base_GHCziTopHandler_flushStdHandles_closure"

1790+ "-Wl,-u,_base_GHCziTopHandler_runMainIO_closure"

1791+ "-Wl,-u,_ghczmprim_GHCziTypes_Czh_con_info"

1792+ "-Wl,-u,_ghczmprim_GHCziTypes_Izh_con_info"

1793+ "-Wl,-u,_ghczmprim_GHCziTypes_Fzh_con_info"

1794+ "-Wl,-u,_ghczmprim_GHCziTypes_Dzh_con_info"

1795+ "-Wl,-u,_ghczmprim_GHCziTypes_Wzh_con_info"

1796+ "-Wl,-u,_base_GHCziPtr_Ptr_con_info"

1797+ "-Wl,-u,_base_GHCziPtr_FunPtr_con_info"

1798+ "-Wl,-u,_base_GHCziInt_I8zh_con_info"

1799+ "-Wl,-u,_base_GHCziInt_I16zh_con_info"

1800+ "-Wl,-u,_base_GHCziInt_I32zh_con_info"

1801+ "-Wl,-u,_base_GHCziInt_I64zh_con_info"

1802+ "-Wl,-u,_base_GHCziWord_W8zh_con_info"

1803+ "-Wl,-u,_base_GHCziWord_W16zh_con_info"

1804+ "-Wl,-u,_base_GHCziWord_W32zh_con_info"

1805+ "-Wl,-u,_base_GHCziWord_W64zh_con_info"

1806+ "-Wl,-u,_base_GHCziStable_StablePtr_con_info"

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

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

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

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

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

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

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

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

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

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

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

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

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

1820+ "-Wl,-u,_hs_cmpxchg64" "-Wl,-u,_hs_xchg8" "-Wl,-u,_hs_xchg16"

1821+ "-Wl,-u,_hs_xchg32" "-Wl,-u,_hs_xchg64" "-Wl,-u,_hs_atomicread8"

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

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

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

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

1826+ "-Wl,-U,___darwin_check_fd_set_overflow"

materialized/dummy-ghc/ghc-9.2.1-aarch64-darwin/ghc-pkg/versionnew file+1

@@ -0,0 +1 @@

1+GHC package manager version 9.2.1

materialized/dummy-ghc/ghc-9.2.1-aarch64-darwin/ghc/infonew file+67

@@ -0,0 +1,67 @@

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

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

3+ ,("C compiler flags","--target=arm64-apple-darwin ")

4+ ,("C++ compiler flags","--target=arm64-apple-darwin ")

5+ ,("C compiler link flags","--target=arm64-apple-darwin ")

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

7+ ,("Haskell CPP flags","-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs")

8+ ,("ld flags","")

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

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

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

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

13+ ,("Merge objects flags","-r")

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

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

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","NO")

23+ ,("target platform string","aarch64-apple-darwin")

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

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

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

27+ ,("target word big endian","NO")

28+ ,("target has GNU nonexec stack","NO")

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

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

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

32+ ,("Unregisterised","NO")

33+ ,("LLVM target","arm64-apple-darwin")

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

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

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

37+ ,("bignum backend","gmp")

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

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

40+ ,("RTS ways","l debug thr thr_debug thr_l thr_p dyn debug_dyn thr_dyn thr_debug_dyn l_dyn thr_l_dyn thr_debug_p debug_p")

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

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

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

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

45+ ,("Project version","9.2.1")

46+ ,("Project Git commit id","82e6bf12786908ccda643dd1dceb42abcc97290c")

47+ ,("Booter version","8.10.7")

48+ ,("Stage","2")

49+ ,("Build platform","aarch64-apple-darwin")

50+ ,("Host platform","aarch64-apple-darwin")

51+ ,("Target platform","aarch64-apple-darwin")

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

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

54+ ,("Have native code generator","YES")

55+ ,("Target default backend","NCG")

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

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

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

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

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

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

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

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

64+ ,("GHC Dynamic","YES")

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

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

67+ ]

materialized/dummy-ghc/ghc-9.2.1-aarch64-darwin/ghc/numeric-versionnew file+1

@@ -0,0 +1 @@

1+9.2.1

materialized/dummy-ghc/ghc-9.2.1-aarch64-darwin/ghc/supported-languagesnew file+266

@@ -0,0 +1,266 @@

1+Haskell98

2+Haskell2010

3+GHC2021

4+Unsafe

5+Trustworthy

6+Safe

7+AllowAmbiguousTypes

8+NoAllowAmbiguousTypes

9+AlternativeLayoutRule

10+NoAlternativeLayoutRule

11+AlternativeLayoutRuleTransitional

12+NoAlternativeLayoutRuleTransitional

13+Arrows

14+NoArrows

15+AutoDeriveTypeable

16+NoAutoDeriveTypeable

17+BangPatterns

18+NoBangPatterns

19+BinaryLiterals

20+NoBinaryLiterals

21+CApiFFI

22+NoCApiFFI

23+CPP

24+NoCPP

25+CUSKs

26+NoCUSKs

27+ConstrainedClassMethods

28+NoConstrainedClassMethods

29+ConstraintKinds

30+NoConstraintKinds

31+DataKinds

32+NoDataKinds

33+DatatypeContexts

34+NoDatatypeContexts

35+DefaultSignatures

36+NoDefaultSignatures

37+DeriveAnyClass

38+NoDeriveAnyClass

39+DeriveDataTypeable

40+NoDeriveDataTypeable

41+DeriveFoldable

42+NoDeriveFoldable

43+DeriveFunctor

44+NoDeriveFunctor

45+DeriveGeneric

46+NoDeriveGeneric

47+DeriveLift

48+NoDeriveLift

49+DeriveTraversable

50+NoDeriveTraversable

51+DerivingStrategies

52+NoDerivingStrategies

53+DerivingVia

54+NoDerivingVia

55+DisambiguateRecordFields

56+NoDisambiguateRecordFields

57+DoAndIfThenElse

58+NoDoAndIfThenElse

59+BlockArguments

60+NoBlockArguments

61+DoRec

62+NoDoRec

63+DuplicateRecordFields

64+NoDuplicateRecordFields

65+FieldSelectors

66+NoFieldSelectors

67+EmptyCase

68+NoEmptyCase

69+EmptyDataDecls

70+NoEmptyDataDecls

71+EmptyDataDeriving

72+NoEmptyDataDeriving

73+ExistentialQuantification

74+NoExistentialQuantification

75+ExplicitForAll

76+NoExplicitForAll

77+ExplicitNamespaces

78+NoExplicitNamespaces

79+ExtendedDefaultRules

80+NoExtendedDefaultRules

81+FlexibleContexts

82+NoFlexibleContexts

83+FlexibleInstances

84+NoFlexibleInstances

85+ForeignFunctionInterface

86+NoForeignFunctionInterface

87+FunctionalDependencies

88+NoFunctionalDependencies

89+GADTSyntax

90+NoGADTSyntax

91+GADTs

92+NoGADTs

93+GHCForeignImportPrim

94+NoGHCForeignImportPrim

95+GeneralizedNewtypeDeriving

96+NoGeneralizedNewtypeDeriving

97+GeneralisedNewtypeDeriving

98+NoGeneralisedNewtypeDeriving

99+ImplicitParams

100+NoImplicitParams

101+ImplicitPrelude

102+NoImplicitPrelude

103+ImportQualifiedPost

104+NoImportQualifiedPost

105+ImpredicativeTypes

106+NoImpredicativeTypes

107+IncoherentInstances

108+NoIncoherentInstances

109+TypeFamilyDependencies

110+NoTypeFamilyDependencies

111+InstanceSigs

112+NoInstanceSigs

113+ApplicativeDo

114+NoApplicativeDo

115+InterruptibleFFI

116+NoInterruptibleFFI

117+JavaScriptFFI

118+NoJavaScriptFFI

119+KindSignatures

120+NoKindSignatures

121+LambdaCase

122+NoLambdaCase

123+LexicalNegation

124+NoLexicalNegation

125+LiberalTypeSynonyms

126+NoLiberalTypeSynonyms

127+LinearTypes

128+NoLinearTypes

129+MagicHash

130+NoMagicHash

131+MonadComprehensions

132+NoMonadComprehensions

133+MonoLocalBinds

134+NoMonoLocalBinds

135+MonomorphismRestriction

136+NoMonomorphismRestriction

137+MultiParamTypeClasses

138+NoMultiParamTypeClasses

139+MultiWayIf

140+NoMultiWayIf

141+NumericUnderscores

142+NoNumericUnderscores

143+NPlusKPatterns

144+NoNPlusKPatterns

145+NamedFieldPuns

146+NoNamedFieldPuns

147+NamedWildCards

148+NoNamedWildCards

149+NegativeLiterals

150+NoNegativeLiterals

151+HexFloatLiterals

152+NoHexFloatLiterals

153+NondecreasingIndentation

154+NoNondecreasingIndentation

155+NullaryTypeClasses

156+NoNullaryTypeClasses

157+NumDecimals

158+NoNumDecimals

159+OverlappingInstances

160+NoOverlappingInstances

161+OverloadedLabels

162+NoOverloadedLabels

163+OverloadedLists

164+NoOverloadedLists

165+OverloadedStrings

166+NoOverloadedStrings

167+PackageImports

168+NoPackageImports

169+ParallelArrays

170+NoParallelArrays

171+ParallelListComp

172+NoParallelListComp

173+PartialTypeSignatures

174+NoPartialTypeSignatures

175+PatternGuards

176+NoPatternGuards

177+PatternSignatures

178+NoPatternSignatures

179+PatternSynonyms

180+NoPatternSynonyms

181+PolyKinds

182+NoPolyKinds

183+PolymorphicComponents

184+NoPolymorphicComponents

185+QuantifiedConstraints

186+NoQuantifiedConstraints

187+PostfixOperators

188+NoPostfixOperators

189+QuasiQuotes

190+NoQuasiQuotes

191+QualifiedDo

192+NoQualifiedDo

193+Rank2Types

194+NoRank2Types

195+RankNTypes

196+NoRankNTypes

197+RebindableSyntax

198+NoRebindableSyntax

199+OverloadedRecordDot

200+NoOverloadedRecordDot

201+OverloadedRecordUpdate

202+NoOverloadedRecordUpdate

203+RecordPuns

204+NoRecordPuns

205+RecordWildCards

206+NoRecordWildCards

207+RecursiveDo

208+NoRecursiveDo

209+RelaxedLayout

210+NoRelaxedLayout

211+RelaxedPolyRec

212+NoRelaxedPolyRec

213+RoleAnnotations

214+NoRoleAnnotations

215+ScopedTypeVariables

216+NoScopedTypeVariables

217+StandaloneDeriving

218+NoStandaloneDeriving

219+StarIsType

220+NoStarIsType

221+StaticPointers

222+NoStaticPointers

223+Strict

224+NoStrict

225+StrictData

226+NoStrictData

227+TemplateHaskell

228+NoTemplateHaskell

229+TemplateHaskellQuotes

230+NoTemplateHaskellQuotes

231+StandaloneKindSignatures

232+NoStandaloneKindSignatures

233+TraditionalRecordSyntax

234+NoTraditionalRecordSyntax

235+TransformListComp

236+NoTransformListComp

237+TupleSections

238+NoTupleSections

239+TypeApplications

240+NoTypeApplications

241+TypeInType

242+NoTypeInType

243+TypeFamilies

244+NoTypeFamilies

245+TypeOperators

246+NoTypeOperators

247+TypeSynonymInstances

248+NoTypeSynonymInstances

249+UnboxedTuples

250+NoUnboxedTuples

251+UnboxedSums

252+NoUnboxedSums

253+UndecidableInstances

254+NoUndecidableInstances

255+UndecidableSuperClasses

256+NoUndecidableSuperClasses

257+UnicodeSyntax

258+NoUnicodeSyntax

259+UnliftedDatatypes

260+NoUnliftedDatatypes

261+UnliftedFFITypes

262+NoUnliftedFFITypes

263+UnliftedNewtypes

264+NoUnliftedNewtypes

265+ViewPatterns

266+NoViewPatterns

materialized/dummy-ghc/ghc-9.2.1-aarch64-darwin/ghc/versionnew file+1

@@ -0,0 +1 @@

1+The Glorious Glasgow Haskell Compilation System, version 9.2.1

materialized/dummy-ghc/ghc-9.2.1-x86_64-darwin/ghc-pkg/dump-globalnew file+1826