ecc6219 · haskell.nix · git.iko.soy

git.iko.soy/haskell.nix

on iko/ghcjs-patch-master help sign in

Add missing ghc 9.2.2 x86_64-darwin materialization (#1438)

ecc6219Hamish Mackenzie5 years ago

materialized/dummy-ghc/ghc-9.2.2-x86_64-darwin/ghc-pkg/dump-globalnew file+1834

compare with iko/ghcjs-patch-master

unifiedsplit

@@ -0,0 +1,1834 @@

1+name: Cabal

2+version: 3.6.3.0

3+visibility: public

4+id: Cabal-3.6.3.0

5+key: Cabal-3.6.3.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.3.0

176+depends:

177+ array-0.5.4.0 base-4.16.1.0 binary-0.8.9.0 bytestring-0.11.3.0

178+ containers-0.6.5.1 deepseq-1.4.6.1 directory-1.3.6.2

179+ filepath-1.4.2.2 mtl-2.2.2 parsec-3.1.15.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.1.0

213+haddock-interfaces:

214+haddock-html:

215+---

216+name: base

217+version: 4.16.1.0

218+visibility: public

219+id: base-4.16.1.0

220+key: base-4.16.1.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.1.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.1.0 bytestring-0.11.3.0 containers-0.6.5.1

360+haddock-interfaces:

361+haddock-html:

362+---

363+name: bytestring

364+version: 0.11.3.0

365+visibility: public

366+id: bytestring-0.11.3.0

367+key: bytestring-0.11.3.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.Builder.RealFloat Data.ByteString.Char8

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

419+ Data.ByteString.Lazy.Char8 Data.ByteString.Lazy.Internal

420+ Data.ByteString.Short Data.ByteString.Short.Internal

421+ Data.ByteString.Unsafe

422+hidden-modules:

423+ Data.ByteString.Builder.ASCII Data.ByteString.Builder.Prim.ASCII

424+ Data.ByteString.Builder.Prim.Binary

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

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

427+ Data.ByteString.Builder.RealFloat.F2S

428+ Data.ByteString.Builder.RealFloat.D2S

429+ Data.ByteString.Builder.RealFloat.Internal

430+ Data.ByteString.Builder.RealFloat.TableGenerator

431+ Data.ByteString.Lazy.Internal.Deque

432+import-dirs:

433+library-dirs:

434+dynamic-library-dirs:

435+data-dir:

436+hs-libraries: HSbytestring-0.11.3.0

437+include-dirs:

438+includes: fpstring.h

439+depends:

440+ base-4.16.1.0 deepseq-1.4.6.1 ghc-prim-0.8.0

441+ template-haskell-2.18.0.0

442+haddock-interfaces:

443+haddock-html:

444+---

445+name: containers

446+version: 0.6.5.1

447+visibility: public

448+id: containers-0.6.5.1

449+key: containers-0.6.5.1

450+license: BSD-3-Clause

451+maintainer: libraries@haskell.org

452+synopsis: Assorted concrete container types

453+description:

454+ This package contains efficient general-purpose implementations

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

456+ trees, and graphs.

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

458+ operations see the [containers

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

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

461+ remains valid even if structures are shared.

462+category: Data Structures

463+exposed: True

464+exposed-modules:

465+ Data.Containers.ListUtils Data.Graph Data.IntMap

466+ Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy

467+ Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict

468+ Data.IntMap.Strict.Internal Data.IntSet Data.IntSet.Internal

469+ Data.Map Data.Map.Internal Data.Map.Internal.Debug Data.Map.Lazy

470+ Data.Map.Merge.Lazy Data.Map.Merge.Strict Data.Map.Strict

471+ Data.Map.Strict.Internal Data.Sequence Data.Sequence.Internal

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

473+ Utils.Containers.Internal.BitQueue

474+ Utils.Containers.Internal.BitUtil

475+ Utils.Containers.Internal.StrictPair

476+hidden-modules:

477+ Utils.Containers.Internal.State

478+ Utils.Containers.Internal.StrictMaybe

479+ Utils.Containers.Internal.PtrEquality

480+ Utils.Containers.Internal.Coercions

481+ Utils.Containers.Internal.TypeError

482+ Data.Map.Internal.DeprecatedShowTree

483+ Data.IntMap.Internal.DeprecatedDebug

484+import-dirs:

485+library-dirs:

486+dynamic-library-dirs:

487+data-dir:

488+hs-libraries: HScontainers-0.6.5.1

489+depends: array-0.5.4.0 base-4.16.1.0 deepseq-1.4.6.1

490+haddock-interfaces:

491+haddock-html:

492+---

493+name: deepseq

494+version: 1.4.6.1

495+visibility: public

496+id: deepseq-1.4.6.1

497+key: deepseq-1.4.6.1

498+license: BSD-3-Clause

499+maintainer: libraries@haskell.org

500+synopsis: Deep evaluation of data structures

501+description:

502+ This package provides methods for fully evaluating data structures

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

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

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

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

507+ wrong thread.

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

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

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

511+ components) which defines strategies for fully evaluating different

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

513+ details.

514+category: Control

515+exposed: True

516+exposed-modules: Control.DeepSeq

517+hidden-modules: Control.DeepSeq.BackDoor

518+import-dirs:

519+library-dirs:

520+dynamic-library-dirs:

521+data-dir:

522+hs-libraries: HSdeepseq-1.4.6.1

523+depends: array-0.5.4.0 base-4.16.1.0

524+haddock-interfaces:

525+haddock-html:

526+---

527+name: directory

528+version: 1.3.6.2

529+visibility: public

530+id: directory-1.3.6.2

531+key: directory-1.3.6.2

532+license: BSD-3-Clause

533+maintainer: libraries@haskell.org

534+synopsis: Platform-agnostic library for filesystem operations

535+description:

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

537+ directories in a portable way.

538+category: System

539+exposed: True

540+exposed-modules:

541+ System.Directory System.Directory.Internal

542+ System.Directory.Internal.Prelude

543+hidden-modules:

544+ System.Directory.Internal.C_utimensat

545+ System.Directory.Internal.Common System.Directory.Internal.Config

546+ System.Directory.Internal.Posix System.Directory.Internal.Windows

547+import-dirs:

548+library-dirs:

549+dynamic-library-dirs:

550+data-dir:

551+hs-libraries: HSdirectory-1.3.6.2

552+depends:

553+ base-4.16.1.0 filepath-1.4.2.2 time-1.11.1.1 unix-2.7.2.2

554+haddock-interfaces:

555+haddock-html:

556+---

557+name: exceptions

558+version: 0.10.4

559+visibility: public

560+id: exceptions-0.10.4

561+key: exceptions-0.10.4

562+license: BSD-3-Clause

563+copyright:

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

567+author: Edward A. Kmett

568+stability: provisional

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

570+synopsis: Extensible optionally-pure exceptions

571+description: Extensible optionally-pure exceptions.

572+category: Control, Exceptions, Monad

573+exposed: True

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

575+import-dirs:

576+library-dirs:

577+dynamic-library-dirs:

578+data-dir:

579+hs-libraries: HSexceptions-0.10.4

580+depends:

581+ base-4.16.1.0 mtl-2.2.2 stm-2.5.0.2 template-haskell-2.18.0.0

582+ transformers-0.5.6.2

583+haddock-interfaces:

584+haddock-html:

585+---

586+name: filepath

587+version: 1.4.2.2

588+visibility: public

589+id: filepath-1.4.2.2

590+key: filepath-1.4.2.2

591+license: BSD-3-Clause

592+copyright: Neil Mitchell 2005-2020

593+maintainer: Julian Ospald <hasufell@posteo.de>

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

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

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

597+description:

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

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

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

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

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

603+category: System

604+exposed: True

605+exposed-modules:

606+ System.FilePath System.FilePath.Posix System.FilePath.Windows

607+import-dirs:

608+library-dirs:

609+dynamic-library-dirs:

610+data-dir:

611+hs-libraries: HSfilepath-1.4.2.2

612+depends: base-4.16.1.0

613+haddock-interfaces:

614+haddock-html:

615+---

616+name: ghc

617+version: 9.2.2

618+visibility: public

619+id: ghc-9.2.2

620+key: ghc-9.2.2

621+license: BSD-3-Clause

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

623+author: The GHC Team

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

625+synopsis: The GHC API

626+description:

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

628+ compiling Haskell programs. Important use cases are programs

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

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

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

632+ through this package.

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

634+ for more information.

635+category: Development

636+exposed-modules:

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

638+ GHC.Builtin.Types, GHC.Builtin.Types.Literals,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

656+ GHC.CmmToAsm.BlockLayout, GHC.CmmToAsm.CFG,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

691+ GHC.CmmToLlvm, GHC.CmmToLlvm.Base, GHC.CmmToLlvm.CodeGen,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

724+ GHC.Driver.Backpack, GHC.Driver.Backpack.Syntax,

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

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

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

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

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

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

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

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

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

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

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

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

737+ GHC.HsToCore.ListComp, GHC.HsToCore.Match,

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

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

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

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

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

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

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

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

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

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

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

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

750+ GHC.IfaceToCore, GHC.Linker, GHC.Linker.Dynamic,

751+ GHC.Linker.ExtraObj, GHC.Linker.Loader, GHC.Linker.MacOS,

752+ GHC.Linker.Static, GHC.Linker.Types, GHC.Linker.Unit,

753+ GHC.Linker.Windows, GHC.Llvm, GHC.Llvm.MetaData, GHC.Llvm.Ppr,

754+ GHC.Llvm.Syntax, GHC.Llvm.Types, GHC.Parser, GHC.Parser.Annotation,

755+ GHC.Parser.CharClass, GHC.Parser.Errors, GHC.Parser.Errors.Ppr,

756+ GHC.Parser.Header, GHC.Parser.Lexer, GHC.Parser.PostProcess,

757+ GHC.Parser.PostProcess.Haddock, GHC.Parser.Types, GHC.Parser.Utils,

758+ GHC.Platform, GHC.Platform.AArch64, GHC.Platform.ARM,

759+ GHC.Platform.ArchOS from ghc-boot-9.2.2:GHC.Platform.ArchOS,

760+ GHC.Platform.Constants,

761+ GHC.Platform.Host from ghc-boot-9.2.2:GHC.Platform.Host,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

785+ GHC.SysTools, GHC.SysTools.Ar, GHC.SysTools.BaseDir,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

808+ GHC.Types.CompleteMatch, GHC.Types.CostCentre,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

846+ Language.Haskell.Syntax.Type

847+import-dirs:

848+library-dirs:

849+dynamic-library-dirs:

850+data-dir:

851+hs-libraries: HSghc-9.2.2

852+include-dirs:

853+depends:

854+ array-0.5.4.0 base-4.16.1.0 binary-0.8.9.0 bytestring-0.11.3.0

855+ containers-0.6.5.1 deepseq-1.4.6.1 directory-1.3.6.2

856+ exceptions-0.10.4 filepath-1.4.2.2 ghc-boot-9.2.2 ghc-heap-9.2.2

857+ ghci-9.2.2 hpc-0.6.1.0 process-1.6.13.2 template-haskell-2.18.0.0

858+ terminfo-0.4.1.5 time-1.11.1.1 transformers-0.5.6.2 unix-2.7.2.2

859+haddock-interfaces:

860+haddock-html:

861+---

862+name: ghc-bignum

863+version: 1.2

864+visibility: public

865+id: ghc-bignum-1.2

866+key: ghc-bignum-1.2

867+license: BSD-3-Clause

868+maintainer: libraries@haskell.org

869+author: Sylvain Henry

870+synopsis: GHC BigNum library

871+description:

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

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

874+category: Numeric, Algebra, GHC

875+exposed: True

876+exposed-modules:

877+ GHC.Num.Backend GHC.Num.Backend.Native GHC.Num.Backend.Selected

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

879+ GHC.Num.WordArray

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

881+import-dirs:

882+library-dirs:

883+dynamic-library-dirs:

884+data-dir:

885+hs-libraries: HSghc-bignum-1.2

886+extra-libraries: gmp

887+include-dirs:

888+depends: ghc-prim-0.8.0

889+haddock-interfaces:

890+haddock-html:

891+---

892+name: ghc-boot

893+version: 9.2.2

894+visibility: public

895+id: ghc-boot-9.2.2

896+key: ghc-boot-9.2.2

897+license: BSD-3-Clause

898+maintainer: ghc-devs@haskell.org

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

900+description:

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

902+ libraries.

903+ .

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

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

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

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

908+ suitable for modifying GHC package databases.

909+ .

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

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

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

913+category: GHC

914+exposed: True

915+exposed-modules:

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

917+ GHC.ForeignSrcLang,

918+ GHC.ForeignSrcLang.Type from ghc-boot-th-9.2.2:GHC.ForeignSrcLang.Type,

919+ GHC.HandleEncoding, GHC.LanguageExtensions,

920+ GHC.LanguageExtensions.Type from ghc-boot-th-9.2.2:GHC.LanguageExtensions.Type,

921+ GHC.Lexeme from ghc-boot-th-9.2.2:GHC.Lexeme, GHC.Platform.ArchOS,

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

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

924+ GHC.Version

925+import-dirs:

926+library-dirs:

927+dynamic-library-dirs:

928+data-dir:

929+hs-libraries: HSghc-boot-9.2.2

930+depends:

931+ base-4.16.1.0 binary-0.8.9.0 bytestring-0.11.3.0 containers-0.6.5.1

932+ deepseq-1.4.6.1 directory-1.3.6.2 filepath-1.4.2.2

933+ ghc-boot-th-9.2.2 unix-2.7.2.2

934+haddock-interfaces:

935+haddock-html:

936+---

937+name: ghc-boot-th

938+version: 9.2.2

939+visibility: public

940+id: ghc-boot-th-9.2.2

941+key: ghc-boot-th-9.2.2

942+license: BSD-3-Clause

943+maintainer: ghc-devs@haskell.org

944+synopsis:

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

946+ library

947+description:

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

949+ @template-haskell@ libraries.

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

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

952+ be depended upon by user code.

953+category: GHC

954+exposed: True

955+exposed-modules:

956+ GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme

957+import-dirs:

958+library-dirs:

959+dynamic-library-dirs:

960+data-dir:

961+hs-libraries: HSghc-boot-th-9.2.2

962+depends: base-4.16.1.0

963+haddock-interfaces:

964+haddock-html:

965+---

966+name: ghc-compact

967+version: 0.1.0.0

968+visibility: public

969+id: ghc-compact-0.1.0.0

970+key: ghc-compact-0.1.0.0

971+license: BSD-3-Clause

972+maintainer: libraries@haskell.org

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

974+description:

975+ This package provides minimal functionality for working with

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

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

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

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

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

981+ released).

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

983+ which allows efficient serialization and deserialization of structs

984+ for distributed computing.

985+ This package provides a low-level API; see also the </package/compact

986+ compact package> which provides a user-facing API.

987+category: Data

988+exposed: True

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

990+import-dirs:

991+library-dirs:

992+dynamic-library-dirs:

993+data-dir:

994+hs-libraries: HSghc-compact-0.1.0.0

995+depends: base-4.16.1.0 bytestring-0.11.3.0 ghc-prim-0.8.0

996+haddock-interfaces:

997+haddock-html:

998+---

999+name: ghc-heap

1000+version: 9.2.2

1001+visibility: public

1002+id: ghc-heap-9.2.2

1003+key: ghc-heap-9.2.2

1004+license: BSD-3-Clause

1005+maintainer: libraries@haskell.org

1006+synopsis: Functions for walking GHC's heap

1007+description:

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

1009+ and retrieving information about those data structures.

1010+category: GHC

1011+exposed: True

1012+exposed-modules:

1013+ GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures

1014+ GHC.Exts.Heap.Constants GHC.Exts.Heap.FFIClosures

1015+ GHC.Exts.Heap.FFIClosures_ProfilingDisabled

1016+ GHC.Exts.Heap.FFIClosures_ProfilingEnabled GHC.Exts.Heap.InfoTable

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

1018+ GHC.Exts.Heap.ProfInfo.PeekProfInfo

1019+ GHC.Exts.Heap.ProfInfo.PeekProfInfo_ProfilingDisabled

1020+ GHC.Exts.Heap.ProfInfo.PeekProfInfo_ProfilingEnabled

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

1022+import-dirs:

1023+library-dirs:

1024+dynamic-library-dirs:

1025+data-dir:

1026+hs-libraries: HSghc-heap-9.2.2

1027+depends: base-4.16.1.0 containers-0.6.5.1 ghc-prim-0.8.0 rts

1028+haddock-interfaces:

1029+haddock-html:

1030+---

1031+name: ghc-prim

1032+version: 0.8.0

1033+visibility: public

1034+id: ghc-prim-0.8.0

1035+key: ghc-prim-0.8.0

1036+license: BSD-3-Clause

1037+maintainer: libraries@haskell.org

1038+synopsis: GHC primitives

1039+description:

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

1041+category: GHC

1042+exposed: True

1043+exposed-modules:

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

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

1046+ GHC.Prim

1047+import-dirs:

1048+library-dirs:

1049+dynamic-library-dirs:

1050+data-dir:

1051+hs-libraries: HSghc-prim-0.8.0

1052+depends: rts

1053+haddock-interfaces:

1054+haddock-html:

1055+---

1056+name: ghci

1057+version: 9.2.2

1058+visibility: public

1059+id: ghci-9.2.2

1060+key: ghci-9.2.2

1061+license: BSD-3-Clause

1062+maintainer: ghc-devs@haskell.org

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

1064+description:

1065+ This library offers interfaces which mediate interactions between the

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

1067+ backend.

1068+category: GHC

1069+exposed: True

1070+exposed-modules:

1071+ GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI

1072+ GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes

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

1074+ GHCi.TH.Binary

1075+import-dirs:

1076+library-dirs:

1077+dynamic-library-dirs:

1078+data-dir:

1079+hs-libraries: HSghci-9.2.2

1080+include-dirs:

1081+depends:

1082+ array-0.5.4.0 base-4.16.1.0 binary-0.8.9.0 bytestring-0.11.3.0

1083+ containers-0.6.5.1 deepseq-1.4.6.1 filepath-1.4.2.2 ghc-boot-9.2.2

1084+ ghc-heap-9.2.2 ghc-prim-0.8.0 rts template-haskell-2.18.0.0

1085+ transformers-0.5.6.2 unix-2.7.2.2

1086+haddock-interfaces:

1087+haddock-html:

1088+---

1089+name: haskeline

1090+version: 0.8.2

1091+visibility: public

1092+id: haskeline-0.8.2

1093+key: haskeline-0.8.2

1094+license: BSD-3-Clause

1095+copyright: (c) Judah Jacobson

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

1097+author: Judah Jacobson

1098+stability: Stable

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

1100+synopsis:

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

1102+description:

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

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

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

1106+ Haskell programs.

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

1108+category: User Interfaces

1109+exposed: True

1110+exposed-modules:

1111+ System.Console.Haskeline System.Console.Haskeline.Completion

1112+ System.Console.Haskeline.History System.Console.Haskeline.IO

1113+ System.Console.Haskeline.Internal

1114+hidden-modules:

1115+ System.Console.Haskeline.Backend

1116+ System.Console.Haskeline.Backend.WCWidth

1117+ System.Console.Haskeline.Command

1118+ System.Console.Haskeline.Command.Completion

1119+ System.Console.Haskeline.Command.History

1120+ System.Console.Haskeline.Command.KillRing

1121+ System.Console.Haskeline.Directory System.Console.Haskeline.Emacs

1122+ System.Console.Haskeline.InputT System.Console.Haskeline.Key

1123+ System.Console.Haskeline.LineState System.Console.Haskeline.Monads

1124+ System.Console.Haskeline.Prefs System.Console.Haskeline.Recover

1125+ System.Console.Haskeline.RunCommand System.Console.Haskeline.Term

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

1127+ System.Console.Haskeline.Backend.Posix

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

1129+ System.Console.Haskeline.Backend.DumbTerm

1130+ System.Console.Haskeline.Backend.Terminfo

1131+import-dirs:

1132+library-dirs:

1133+dynamic-library-dirs:

1134+data-dir:

1135+hs-libraries: HShaskeline-0.8.2

1136+depends:

1137+ base-4.16.1.0 bytestring-0.11.3.0 containers-0.6.5.1

1138+ directory-1.3.6.2 exceptions-0.10.4 filepath-1.4.2.2

1139+ process-1.6.13.2 stm-2.5.0.2 terminfo-0.4.1.5 transformers-0.5.6.2

1140+ unix-2.7.2.2

1141+haddock-interfaces:

1142+haddock-html:

1143+---

1144+name: hpc

1145+version: 0.6.1.0

1146+visibility: public

1147+id: hpc-0.6.1.0

1148+key: hpc-0.6.1.0

1149+license: BSD-3-Clause

1150+maintainer: ghc-devs@haskell.org

1151+author: Andy Gill

1152+synopsis: Code Coverage Library for Haskell

1153+description:

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

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

1156+ information.

1157+category: Control

1158+exposed: True

1159+exposed-modules:

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

1161+import-dirs:

1162+library-dirs:

1163+dynamic-library-dirs:

1164+data-dir:

1165+hs-libraries: HShpc-0.6.1.0

1166+depends:

1167+ base-4.16.1.0 containers-0.6.5.1 deepseq-1.4.6.1 directory-1.3.6.2

1168+ filepath-1.4.2.2 time-1.11.1.1

1169+haddock-interfaces:

1170+haddock-html:

1171+---

1172+name: integer-gmp

1173+version: 1.1

1174+visibility: public

1175+id: integer-gmp-1.1

1176+key: integer-gmp-1.1

1177+license: BSD-3-Clause

1178+maintainer: hvr@gnu.org

1179+author: Herbert Valerio Riedel

1180+synopsis: Integer library based on GMP

1181+description:

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

1183+ type based on the

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

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

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

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

1188+category: Numeric, Algebra

1189+exposed: True

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

1191+import-dirs:

1192+library-dirs:

1193+dynamic-library-dirs:

1194+data-dir:

1195+hs-libraries: HSinteger-gmp-1.1

1196+depends: base-4.16.1.0 ghc-bignum-1.2 ghc-prim-0.8.0

1197+haddock-interfaces:

1198+haddock-html:

1199+---

1200+name: libiserv

1201+version: 9.2.2

1202+visibility: public

1203+id: libiserv-9.2.2

1204+key: libiserv-9.2.2

1205+license: BSD-3-Clause

1206+copyright: XXX

1207+maintainer: XXX

1208+author: XXX

1209+synopsis:

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

1211+description:

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

1213+category: Development

1214+exposed: True

1215+exposed-modules: GHCi.Utils Lib

1216+import-dirs:

1217+library-dirs:

1218+dynamic-library-dirs:

1219+data-dir:

1220+hs-libraries: HSlibiserv-9.2.2

1221+depends:

1222+ base-4.16.1.0 binary-0.8.9.0 bytestring-0.11.3.0 containers-0.6.5.1

1223+ deepseq-1.4.6.1 ghci-9.2.2 unix-2.7.2.2

1224+haddock-interfaces:

1225+haddock-html:

1226+---

1227+name: mtl

1228+version: 2.2.2

1229+visibility: public

1230+id: mtl-2.2.2

1231+key: mtl-2.2.2

1232+license: BSD-3-Clause

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

1234+author: Andy Gill

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

1236+synopsis: Monad classes, using functional dependencies

1237+description:

1238+ Monad classes using functional dependencies, with instances

1239+ for various monad transformers, inspired by the paper

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

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

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

1243+category: Control

1244+exposed: True

1245+exposed-modules:

1246+ Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error

1247+ Control.Monad.Error.Class Control.Monad.Except

1248+ Control.Monad.Identity Control.Monad.List Control.Monad.RWS

1249+ Control.Monad.RWS.Class Control.Monad.RWS.Lazy

1250+ Control.Monad.RWS.Strict Control.Monad.Reader

1251+ Control.Monad.Reader.Class Control.Monad.State

1252+ Control.Monad.State.Class Control.Monad.State.Lazy

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

1254+ Control.Monad.Writer.Class Control.Monad.Writer.Lazy

1255+ Control.Monad.Writer.Strict

1256+import-dirs:

1257+library-dirs:

1258+dynamic-library-dirs:

1259+data-dir:

1260+hs-libraries: HSmtl-2.2.2

1261+depends: base-4.16.1.0 transformers-0.5.6.2

1262+haddock-interfaces:

1263+haddock-html:

1264+---

1265+name: parsec

1266+version: 3.1.15.0

1267+visibility: public

1268+id: parsec-3.1.15.0

1269+key: parsec-3.1.15.0

1270+license: BSD-2-Clause

1271+maintainer:

1272+ Oleg Grenrus <oleg.grenrus@iki.fi>, Herbert Valerio Riedel <hvr@gnu.org>

1273+author:

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

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

1276+synopsis: Monadic parser combinators

1277+description:

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

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

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

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

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

1283+ input stream type.

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

1285+ defaults for parsing 'Char'acter data.

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

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

1288+ the future.

1289+category: Parsing

1290+exposed: True

1291+exposed-modules:

1292+ Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy

1293+ Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error

1294+ Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm

1295+ Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String

1296+ Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token

1297+ Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char

1298+ Text.ParserCombinators.Parsec.Combinator

1299+ Text.ParserCombinators.Parsec.Error

1300+ Text.ParserCombinators.Parsec.Expr

1301+ Text.ParserCombinators.Parsec.Language

1302+ Text.ParserCombinators.Parsec.Perm

1303+ Text.ParserCombinators.Parsec.Pos

1304+ Text.ParserCombinators.Parsec.Prim

1305+ Text.ParserCombinators.Parsec.Token

1306+import-dirs:

1307+library-dirs:

1308+dynamic-library-dirs:

1309+data-dir:

1310+hs-libraries: HSparsec-3.1.15.0

1311+depends:

1312+ base-4.16.1.0 bytestring-0.11.3.0 mtl-2.2.2 text-1.2.5.0

1313+haddock-interfaces:

1314+haddock-html:

1315+---

1316+name: pretty

1317+version: 1.1.3.6

1318+visibility: public

1319+id: pretty-1.1.3.6

1320+key: pretty-1.1.3.6

1321+license: BSD-3-Clause

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

1323+stability: Stable

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

1325+synopsis: Pretty-printing library

1326+description:

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

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

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

1330+ tools.

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

1332+ been heavily modified by Simon Peyton Jones.

1333+category: Text

1334+exposed: True

1335+exposed-modules:

1336+ Text.PrettyPrint Text.PrettyPrint.Annotated

1337+ Text.PrettyPrint.Annotated.HughesPJ

1338+ Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ

1339+ Text.PrettyPrint.HughesPJClass

1340+import-dirs:

1341+library-dirs:

1342+dynamic-library-dirs:

1343+data-dir:

1344+hs-libraries: HSpretty-1.1.3.6

1345+depends: base-4.16.1.0 deepseq-1.4.6.1 ghc-prim-0.8.0

1346+haddock-interfaces:

1347+haddock-html:

1348+---

1349+name: process

1350+version: 1.6.13.2

1351+visibility: public

1352+id: process-1.6.13.2

1353+key: process-1.6.13.2

1354+license: BSD-3-Clause

1355+maintainer: libraries@haskell.org

1356+synopsis: Process libraries

1357+description:

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

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

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

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

1362+ read more about it at

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

1364+category: System

1365+exposed: True

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

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

1368+import-dirs:

1369+library-dirs:

1370+dynamic-library-dirs:

1371+data-dir:

1372+hs-libraries: HSprocess-1.6.13.2

1373+include-dirs:

1374+includes: runProcess.h

1375+depends:

1376+ base-4.16.1.0 deepseq-1.4.6.1 directory-1.3.6.2 filepath-1.4.2.2

1377+ unix-2.7.2.2

1378+haddock-interfaces:

1379+haddock-html:

1380+---

1381+name: stm

1382+version: 2.5.0.2

1383+visibility: public

1384+id: stm-2.5.0.2

1385+key: stm-2.5.0.2

1386+license: BSD-3-Clause

1387+maintainer: libraries@haskell.org

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

1389+synopsis: Software Transactional Memory

1390+description:

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

1392+ concurrent communication. The main benefits of STM are

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

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

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

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

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

1398+ 'MVar's.

1399+category: Concurrency

1400+exposed: True

1401+exposed-modules:

1402+ Control.Concurrent.STM Control.Concurrent.STM.TArray

1403+ Control.Concurrent.STM.TBQueue Control.Concurrent.STM.TChan

1404+ Control.Concurrent.STM.TMVar Control.Concurrent.STM.TQueue

1405+ Control.Concurrent.STM.TSem Control.Concurrent.STM.TVar

1406+ Control.Monad.STM

1407+hidden-modules: Control.Sequential.STM

1408+import-dirs:

1409+library-dirs:

1410+dynamic-library-dirs:

1411+data-dir:

1412+hs-libraries: HSstm-2.5.0.2

1413+depends: array-0.5.4.0 base-4.16.1.0

1414+haddock-interfaces:

1415+haddock-html:

1416+---

1417+name: template-haskell

1418+version: 2.18.0.0

1419+visibility: public

1420+id: template-haskell-2.18.0.0

1421+key: template-haskell-2.18.0.0

1422+license: BSD-3-Clause

1423+maintainer: libraries@haskell.org

1424+synopsis: Support library for Template Haskell

1425+description:

1426+ This package provides modules containing facilities for manipulating

1427+ Haskell source code using Template Haskell.

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

1429+ information.

1430+category: Template Haskell

1431+exposed: True

1432+exposed-modules:

1433+ Language.Haskell.TH Language.Haskell.TH.CodeDo

1434+ Language.Haskell.TH.LanguageExtensions Language.Haskell.TH.Lib

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

1436+ Language.Haskell.TH.PprLib Language.Haskell.TH.Quote

1437+ Language.Haskell.TH.Syntax

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

1439+import-dirs:

1440+library-dirs:

1441+dynamic-library-dirs:

1442+data-dir:

1443+hs-libraries: HStemplate-haskell-2.18.0.0

1444+depends:

1445+ base-4.16.1.0 ghc-boot-th-9.2.2 ghc-prim-0.8.0 pretty-1.1.3.6

1446+haddock-interfaces:

1447+haddock-html:

1448+---

1449+name: terminfo

1450+version: 0.4.1.5

1451+visibility: public

1452+id: terminfo-0.4.1.5

1453+key: terminfo-0.4.1.5

1454+license: BSD-3-Clause

1455+copyright: (c) Judah Jacobson

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

1457+author: Judah Jacobson

1458+stability: Stable

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

1460+synopsis: Haskell bindings to the terminfo library.

1461+description:

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

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

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

1465+category: User Interfaces

1466+exposed: True

1467+exposed-modules:

1468+ System.Console.Terminfo System.Console.Terminfo.Base

1469+ System.Console.Terminfo.Color System.Console.Terminfo.Cursor

1470+ System.Console.Terminfo.Edit System.Console.Terminfo.Effects

1471+ System.Console.Terminfo.Keys

1472+import-dirs:

1473+library-dirs:

1474+dynamic-library-dirs:

1475+data-dir:

1476+hs-libraries: HSterminfo-0.4.1.5

1477+extra-libraries: tinfo

1478+depends: base-4.16.1.0

1479+haddock-interfaces:

1480+haddock-html:

1481+---

1482+name: text

1483+version: 1.2.5.0

1484+visibility: public

1485+id: text-1.2.5.0

1486+key: text-1.2.5.0

1487+license: BSD-2-Clause

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

1489+maintainer:

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

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

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

1493+synopsis: An efficient packed Unicode text type.

1494+description:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1509+ clashes with Prelude functions, e.g.

1510+ > import qualified Data.Text as T

1511+ == ICU Support

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

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

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

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

1516+ based on the well-respected and liberally

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

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

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

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

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

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

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

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

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

1526+category: Data, Text

1527+exposed: True

1528+exposed-modules:

1529+ Data.Text Data.Text.Array Data.Text.Encoding

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

1531+ Data.Text.Internal Data.Text.Internal.Builder

1532+ Data.Text.Internal.Builder.Functions

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

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

1535+ Data.Text.Internal.ByteStringCompat

1536+ Data.Text.Internal.Encoding.Fusion

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

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

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

1540+ Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping

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

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

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

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

1545+ Data.Text.Internal.PrimCompat Data.Text.Internal.Private

1546+ Data.Text.Internal.Read Data.Text.Internal.Search

1547+ Data.Text.Internal.Unsafe Data.Text.Internal.Unsafe.Char

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

1549+ Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int

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

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

1552+ Data.Text.Read Data.Text.Unsafe

1553+hidden-modules: Data.Text.Show

1554+import-dirs:

1555+library-dirs:

1556+dynamic-library-dirs:

1557+data-dir:

1558+hs-libraries: HStext-1.2.5.0

1559+depends:

1560+ array-0.5.4.0 base-4.16.1.0 binary-0.8.9.0 bytestring-0.11.3.0

1561+ deepseq-1.4.6.1 ghc-prim-0.8.0 template-haskell-2.18.0.0

1562+haddock-interfaces:

1563+haddock-html:

1564+---

1565+name: time

1566+version: 1.11.1.1

1567+visibility: public

1568+id: time-1.11.1.1

1569+key: time-1.11.1.1

1570+license: BSD-3-Clause

1571+maintainer: <ashley@semantic.org>

1572+author: Ashley Yakeley

1573+stability: stable

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

1575+synopsis: A time library

1576+description: Time, clocks and calendars

1577+category: Time

1578+exposed: True

1579+exposed-modules:

1580+ Data.Time Data.Time.Calendar Data.Time.Calendar.Easter

1581+ Data.Time.Calendar.Julian Data.Time.Calendar.Month

1582+ Data.Time.Calendar.MonthDay Data.Time.Calendar.OrdinalDate

1583+ Data.Time.Calendar.Quarter Data.Time.Calendar.WeekDate

1584+ Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System

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

1586+ Data.Time.Format.Internal Data.Time.LocalTime

1587+hidden-modules:

1588+ Data.Format Data.Time.Calendar.Types Data.Time.Calendar.Private

1589+ Data.Time.Calendar.Days Data.Time.Calendar.Gregorian

1590+ Data.Time.Calendar.CalendarDiffDays Data.Time.Calendar.Week

1591+ Data.Time.Calendar.JulianYearDay Data.Time.Clock.Internal.DiffTime

1592+ Data.Time.Clock.Internal.AbsoluteTime

1593+ Data.Time.Clock.Internal.NominalDiffTime

1594+ Data.Time.Clock.Internal.POSIXTime

1595+ Data.Time.Clock.Internal.UniversalTime

1596+ Data.Time.Clock.Internal.SystemTime

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

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

1599+ Data.Time.LocalTime.Internal.TimeZone

1600+ Data.Time.LocalTime.Internal.TimeOfDay

1601+ Data.Time.LocalTime.Internal.CalendarDiffTime

1602+ Data.Time.LocalTime.Internal.LocalTime

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

1604+ Data.Time.Format.Locale Data.Time.Format.Format.Class

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

1606+ Data.Time.Format.Parse.Instances

1607+import-dirs:

1608+library-dirs:

1609+dynamic-library-dirs:

1610+data-dir:

1611+hs-libraries: HStime-1.11.1.1

1612+include-dirs:

1613+depends: base-4.16.1.0 deepseq-1.4.6.1

1614+haddock-interfaces:

1615+haddock-html:

1616+---

1617+name: transformers

1618+version: 0.5.6.2

1619+visibility: public

1620+id: transformers-0.5.6.2

1621+key: transformers-0.5.6.2

1622+license: BSD-3-Clause

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

1624+author: Andy Gill, Ross Paterson

1625+synopsis: Concrete functor and monad transformers

1626+description:

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

1628+ the paper

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

1630+ Polymorphism\", by Mark P Jones,

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

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

1633+ This package contains:

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

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

1636+ operations and functions to lift operations associated with other

1637+ transformers.

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

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

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

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

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

1643+ introduced by monad transformers through other transformers.

1644+category: Control

1645+exposed: True

1646+exposed-modules:

1647+ Control.Applicative.Backwards Control.Applicative.Lift

1648+ Control.Monad.Signatures Control.Monad.Trans.Accum

1649+ Control.Monad.Trans.Class Control.Monad.Trans.Cont

1650+ Control.Monad.Trans.Error Control.Monad.Trans.Except

1651+ Control.Monad.Trans.Identity Control.Monad.Trans.List

1652+ Control.Monad.Trans.Maybe Control.Monad.Trans.RWS

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

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

1655+ Control.Monad.Trans.Select Control.Monad.Trans.State

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

1657+ Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS

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

1659+ Data.Functor.Constant Data.Functor.Reverse

1660+import-dirs:

1661+library-dirs:

1662+dynamic-library-dirs:

1663+data-dir:

1664+hs-libraries: HStransformers-0.5.6.2

1665+depends: base-4.16.1.0

1666+haddock-interfaces:

1667+haddock-html:

1668+---

1669+name: unix

1670+version: 2.7.2.2

1671+visibility: public

1672+id: unix-2.7.2.2

1673+key: unix-2.7.2.2

1674+license: BSD-3-Clause

1675+maintainer: libraries@haskell.org

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

1677+synopsis: POSIX functionality

1678+description:

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

1680+ services standardised by

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

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

1683+ Environments - IEEE Std. 1003.1).

1684+ The package is not supported under Windows.

1685+category: System

1686+exposed: True

1687+exposed-modules:

1688+ System.Posix System.Posix.ByteString

1689+ System.Posix.ByteString.FilePath System.Posix.Directory

1690+ System.Posix.Directory.ByteString System.Posix.DynamicLinker

1691+ System.Posix.DynamicLinker.ByteString

1692+ System.Posix.DynamicLinker.Module

1693+ System.Posix.DynamicLinker.Module.ByteString

1694+ System.Posix.DynamicLinker.Prim System.Posix.Env

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

1696+ System.Posix.Files System.Posix.Files.ByteString System.Posix.IO

1697+ System.Posix.IO.ByteString System.Posix.Process

1698+ System.Posix.Process.ByteString System.Posix.Process.Internals

1699+ System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem

1700+ System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp

1701+ System.Posix.Temp.ByteString System.Posix.Terminal

1702+ System.Posix.Terminal.ByteString System.Posix.Time

1703+ System.Posix.Unistd System.Posix.User

1704+hidden-modules:

1705+ System.Posix.Directory.Common System.Posix.DynamicLinker.Common

1706+ System.Posix.Files.Common System.Posix.IO.Common

1707+ System.Posix.Process.Common System.Posix.Terminal.Common

1708+import-dirs:

1709+library-dirs:

1710+dynamic-library-dirs:

1711+data-dir:

1712+hs-libraries: HSunix-2.7.2.2

1713+include-dirs:

1714+includes: HsUnix.h execvpe.h

1715+depends: base-4.16.1.0 bytestring-0.11.3.0 time-1.11.1.1

1716+haddock-interfaces:

1717+haddock-html:

1718+---

1719+name: xhtml

1720+version: 3000.2.2.1

1721+visibility: public

1722+id: xhtml-3000.2.2.1

1723+key: xhtml-3000.2.2.1

1724+license: BSD-3-Clause

1725+copyright:

1726+ Bjorn Bringert 2004-2006, Andy Gill and the Oregon

1727+ Graduate Institute of Science and Technology, 1999-2001

1728+maintainer: Chris Dornan <chris@chrisdornan.com>

1729+author: Bjorn Bringert

1730+stability: Stable

1731+homepage: https://github.com/haskell/xhtml

1732+synopsis: An XHTML combinator library

1733+description:

1734+ This package provides combinators for producing

1735+ XHTML 1.0, including the Strict, Transitional and

1736+ Frameset variants.

1737+category: Web, XML, Pretty Printer

1738+exposed: True

1739+exposed-modules:

1740+ Text.XHtml Text.XHtml.Debug Text.XHtml.Frameset Text.XHtml.Strict

1741+ Text.XHtml.Table Text.XHtml.Transitional

1742+hidden-modules:

1743+ Text.XHtml.Strict.Attributes Text.XHtml.Strict.Elements

1744+ Text.XHtml.Frameset.Attributes Text.XHtml.Frameset.Elements

1745+ Text.XHtml.Transitional.Attributes Text.XHtml.Transitional.Elements

1746+ Text.XHtml.BlockTable Text.XHtml.Extras Text.XHtml.Internals

1747+import-dirs:

1748+library-dirs:

1749+dynamic-library-dirs:

1750+data-dir:

1751+hs-libraries: HSxhtml-3000.2.2.1

1752+depends: base-4.16.1.0

1753+haddock-interfaces:

1754+haddock-html:

1755+---

1756+name: rts

1757+version: 1.0.2

1758+visibility: public

1759+id: rts

1760+key: rts

1761+license: BSD-3-Clause

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

1763+exposed: True

1764+library-dirs:

1765+hs-libraries: HSrts

1766+extra-libraries: m dl ffi

1767+include-dirs:

1768+includes: Stg.h

1769+ld-options:

1770+ "-Wl,-u,_base_GHCziTopHandler_runIO_closure"

1771+ "-Wl,-u,_base_GHCziTopHandler_runNonIO_closure"

1772+ "-Wl,-u,_ghczmprim_GHCziTuple_Z0T_closure"

1773+ "-Wl,-u,_ghczmprim_GHCziTypes_True_closure"

1774+ "-Wl,-u,_ghczmprim_GHCziTypes_False_closure"

1775+ "-Wl,-u,_base_GHCziPack_unpackCString_closure"

1776+ "-Wl,-u,_base_GHCziWeak_runFinalizzerBatch_closure"

1777+ "-Wl,-u,_base_GHCziIOziException_stackOverflow_closure"

1778+ "-Wl,-u,_base_GHCziIOziException_heapOverflow_closure"

1779+ "-Wl,-u,_base_GHCziIOziException_allocationLimitExceeded_closure"

1780+ "-Wl,-u,_base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"

1781+ "-Wl,-u,_base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"

1782+ "-Wl,-u,_base_GHCziIOziException_cannotCompactFunction_closure"

1783+ "-Wl,-u,_base_GHCziIOziException_cannotCompactPinned_closure"

1784+ "-Wl,-u,_base_GHCziIOziException_cannotCompactMutable_closure"

1785+ "-Wl,-u,_base_GHCziIOPort_doubleReadException_closure"

1786+ "-Wl,-u,_base_ControlziExceptionziBase_nonTermination_closure"

1787+ "-Wl,-u,_base_ControlziExceptionziBase_nestedAtomically_closure"

1788+ "-Wl,-u,_base_GHCziEventziThread_blockedOnBadFD_closure"

1789+ "-Wl,-u,_base_GHCziExceptionziType_divZZeroException_closure"

1790+ "-Wl,-u,_base_GHCziExceptionziType_underflowException_closure"

1791+ "-Wl,-u,_base_GHCziExceptionziType_overflowException_closure"

1792+ "-Wl,-u,_base_GHCziConcziSync_runSparks_closure"

1793+ "-Wl,-u,_base_GHCziConcziIO_ensureIOManagerIsRunning_closure"

1794+ "-Wl,-u,_base_GHCziConcziIO_interruptIOManager_closure"

1795+ "-Wl,-u,_base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"

1796+ "-Wl,-u,_base_GHCziConcziSignal_runHandlersPtr_closure"

1797+ "-Wl,-u,_base_GHCziTopHandler_flushStdHandles_closure"

1798+ "-Wl,-u,_base_GHCziTopHandler_runMainIO_closure"

1799+ "-Wl,-u,_ghczmprim_GHCziTypes_Czh_con_info"

1800+ "-Wl,-u,_ghczmprim_GHCziTypes_Izh_con_info"

1801+ "-Wl,-u,_ghczmprim_GHCziTypes_Fzh_con_info"

1802+ "-Wl,-u,_ghczmprim_GHCziTypes_Dzh_con_info"

1803+ "-Wl,-u,_ghczmprim_GHCziTypes_Wzh_con_info"

1804+ "-Wl,-u,_base_GHCziPtr_Ptr_con_info"

1805+ "-Wl,-u,_base_GHCziPtr_FunPtr_con_info"

1806+ "-Wl,-u,_base_GHCziInt_I8zh_con_info"

1807+ "-Wl,-u,_base_GHCziInt_I16zh_con_info"

1808+ "-Wl,-u,_base_GHCziInt_I32zh_con_info"

1809+ "-Wl,-u,_base_GHCziInt_I64zh_con_info"

1810+ "-Wl,-u,_base_GHCziWord_W8zh_con_info"

1811+ "-Wl,-u,_base_GHCziWord_W16zh_con_info"

1812+ "-Wl,-u,_base_GHCziWord_W32zh_con_info"

1813+ "-Wl,-u,_base_GHCziWord_W64zh_con_info"

1814+ "-Wl,-u,_base_GHCziStable_StablePtr_con_info"

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

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

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

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

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

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

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

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

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

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

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

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

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

1828+ "-Wl,-u,_hs_cmpxchg64" "-Wl,-u,_hs_xchg8" "-Wl,-u,_hs_xchg16"

1829+ "-Wl,-u,_hs_xchg32" "-Wl,-u,_hs_xchg64" "-Wl,-u,_hs_atomicread8"

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

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

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

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

1834+ "-Wl,-U,___darwin_check_fd_set_overflow"

materialized/dummy-ghc/ghc-9.2.2-x86_64-darwin/ghc-pkg/versionnew file+1

@@ -0,0 +1 @@

1+GHC package manager version 9.2.2

materialized/dummy-ghc/ghc-9.2.2-x86_64-darwin/ghc/infonew file+66

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

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

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

3+ ,("C compiler flags","--target=x86_64-apple-darwin ")

4+ ,("C++ compiler flags","--target=x86_64-apple-darwin ")

5+ ,("C compiler link flags","--target=x86_64-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","x86_64-apple-darwin")

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

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

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","YES")

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

32+ ,("Unregisterised","NO")

33+ ,("LLVM target","x86_64-apple-darwin")

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

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

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

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

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

39+ ,("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")

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

41+ ,("Leading underscore","YES")

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

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

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

45+ ,("Project Git commit id","fbaee70d380973f71fa6e9e15be746532e5a4fc5")

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

47+ ,("Stage","2")

48+ ,("Build platform","x86_64-apple-darwin")

49+ ,("Host platform","x86_64-apple-darwin")

50+ ,("Target platform","x86_64-apple-darwin")

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

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

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

54+ ,("Target default backend","NCG")

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

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

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

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

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

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

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

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

63+ ,("GHC Dynamic","YES")

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

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

66+ ]

materialized/dummy-ghc/ghc-9.2.2-x86_64-darwin/ghc/numeric-versionnew file+1

@@ -0,0 +1 @@

1+9.2.2

materialized/dummy-ghc/ghc-9.2.2-x86_64-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.2-x86_64-darwin/ghc/versionnew file+1

@@ -0,0 +1 @@

1+The Glorious Glasgow Haskell Compilation System, version 9.2.2