name:                 Cabal
version:              3.6.3.0
visibility:           public
id:                   Cabal-3.6.3.0
key:                  Cabal-3.6.3.0
license:              BSD-3-Clause
copyright:            2003-2021, Cabal Development Team (see AUTHORS file)
maintainer:           cabal-devel@haskell.org
author:               Cabal Development Team <cabal-devel@haskell.org>
homepage:             http://www.haskell.org/cabal/
synopsis:             A framework for packaging Haskell software
description:
    The Haskell Common Architecture for Building Applications and
    Libraries: a framework defining a common interface for authors to more
    easily build their Haskell applications in a portable way.
    The Haskell Cabal is part of a larger infrastructure for distributing,
    organizing, and cataloging Haskell libraries and tools.
category:             Distribution
exposed:              True
exposed-modules:
    Distribution.Backpack Distribution.Backpack.ComponentsGraph
    Distribution.Backpack.Configure
    Distribution.Backpack.ConfiguredComponent
    Distribution.Backpack.DescribeUnitId
    Distribution.Backpack.FullUnitId
    Distribution.Backpack.LinkedComponent
    Distribution.Backpack.ModSubst Distribution.Backpack.ModuleShape
    Distribution.Backpack.PreModuleShape Distribution.CabalSpecVersion
    Distribution.Compat.Binary Distribution.Compat.CharParsing
    Distribution.Compat.CreatePipe Distribution.Compat.DList
    Distribution.Compat.Directory Distribution.Compat.Environment
    Distribution.Compat.Exception Distribution.Compat.FilePath
    Distribution.Compat.Graph Distribution.Compat.Internal.TempFile
    Distribution.Compat.Lens Distribution.Compat.Newtype
    Distribution.Compat.NonEmptySet Distribution.Compat.Parsing
    Distribution.Compat.Prelude.Internal Distribution.Compat.Process
    Distribution.Compat.ResponseFile Distribution.Compat.Semigroup
    Distribution.Compat.Stack Distribution.Compat.Time
    Distribution.Compat.Typeable Distribution.Compiler
    Distribution.FieldGrammar Distribution.FieldGrammar.Class
    Distribution.FieldGrammar.FieldDescrs
    Distribution.FieldGrammar.Newtypes Distribution.FieldGrammar.Parsec
    Distribution.FieldGrammar.Pretty Distribution.Fields
    Distribution.Fields.ConfVar Distribution.Fields.Field
    Distribution.Fields.Lexer Distribution.Fields.LexerMonad
    Distribution.Fields.ParseResult Distribution.Fields.Parser
    Distribution.Fields.Pretty Distribution.InstalledPackageInfo
    Distribution.License Distribution.Make Distribution.ModuleName
    Distribution.Package Distribution.PackageDescription
    Distribution.PackageDescription.Check
    Distribution.PackageDescription.Configuration
    Distribution.PackageDescription.FieldGrammar
    Distribution.PackageDescription.Parsec
    Distribution.PackageDescription.PrettyPrint
    Distribution.PackageDescription.Quirks
    Distribution.PackageDescription.Utils Distribution.Parsec
    Distribution.Parsec.Error Distribution.Parsec.FieldLineStream
    Distribution.Parsec.Position Distribution.Parsec.Warning
    Distribution.Pretty Distribution.ReadE Distribution.SPDX
    Distribution.SPDX.License Distribution.SPDX.LicenseExceptionId
    Distribution.SPDX.LicenseExpression Distribution.SPDX.LicenseId
    Distribution.SPDX.LicenseListVersion
    Distribution.SPDX.LicenseReference Distribution.Simple
    Distribution.Simple.Bench Distribution.Simple.Build
    Distribution.Simple.Build.Macros
    Distribution.Simple.Build.PathsModule
    Distribution.Simple.BuildPaths Distribution.Simple.BuildTarget
    Distribution.Simple.BuildToolDepends Distribution.Simple.CCompiler
    Distribution.Simple.Command Distribution.Simple.Compiler
    Distribution.Simple.Configure Distribution.Simple.Flag
    Distribution.Simple.GHC Distribution.Simple.GHCJS
    Distribution.Simple.Glob Distribution.Simple.Haddock
    Distribution.Simple.HaskellSuite Distribution.Simple.Hpc
    Distribution.Simple.Install Distribution.Simple.InstallDirs
    Distribution.Simple.InstallDirs.Internal
    Distribution.Simple.LocalBuildInfo Distribution.Simple.PackageIndex
    Distribution.Simple.PreProcess Distribution.Simple.PreProcess.Unlit
    Distribution.Simple.Program Distribution.Simple.Program.Ar
    Distribution.Simple.Program.Builtin Distribution.Simple.Program.Db
    Distribution.Simple.Program.Find Distribution.Simple.Program.GHC
    Distribution.Simple.Program.HcPkg Distribution.Simple.Program.Hpc
    Distribution.Simple.Program.Internal Distribution.Simple.Program.Ld
    Distribution.Simple.Program.ResponseFile
    Distribution.Simple.Program.Run Distribution.Simple.Program.Script
    Distribution.Simple.Program.Strip Distribution.Simple.Program.Types
    Distribution.Simple.Register Distribution.Simple.Setup
    Distribution.Simple.ShowBuildInfo Distribution.Simple.SrcDist
    Distribution.Simple.Test Distribution.Simple.Test.ExeV10
    Distribution.Simple.Test.LibV09 Distribution.Simple.Test.Log
    Distribution.Simple.UHC Distribution.Simple.UserHooks
    Distribution.Simple.Utils Distribution.System
    Distribution.TestSuite Distribution.Text
    Distribution.Types.AbiDependency Distribution.Types.AbiHash
    Distribution.Types.AnnotatedId Distribution.Types.Benchmark
    Distribution.Types.Benchmark.Lens
    Distribution.Types.BenchmarkInterface
    Distribution.Types.BenchmarkType Distribution.Types.BuildInfo
    Distribution.Types.BuildInfo.Lens Distribution.Types.BuildType
    Distribution.Types.Component Distribution.Types.ComponentId
    Distribution.Types.ComponentInclude
    Distribution.Types.ComponentLocalBuildInfo
    Distribution.Types.ComponentName
    Distribution.Types.ComponentRequestedSpec
    Distribution.Types.CondTree Distribution.Types.Condition
    Distribution.Types.ConfVar Distribution.Types.Dependency
    Distribution.Types.DependencyMap Distribution.Types.ExeDependency
    Distribution.Types.Executable Distribution.Types.Executable.Lens
    Distribution.Types.ExecutableScope Distribution.Types.ExposedModule
    Distribution.Types.Flag Distribution.Types.ForeignLib
    Distribution.Types.ForeignLib.Lens
    Distribution.Types.ForeignLibOption
    Distribution.Types.ForeignLibType
    Distribution.Types.GenericPackageDescription
    Distribution.Types.GenericPackageDescription.Lens
    Distribution.Types.GivenComponent
    Distribution.Types.HookedBuildInfo
    Distribution.Types.IncludeRenaming
    Distribution.Types.InstalledPackageInfo
    Distribution.Types.InstalledPackageInfo.FieldGrammar
    Distribution.Types.InstalledPackageInfo.Lens
    Distribution.Types.LegacyExeDependency Distribution.Types.Lens
    Distribution.Types.Library Distribution.Types.Library.Lens
    Distribution.Types.LibraryName Distribution.Types.LibraryVisibility
    Distribution.Types.LocalBuildInfo Distribution.Types.Mixin
    Distribution.Types.Module Distribution.Types.ModuleReexport
    Distribution.Types.ModuleRenaming
    Distribution.Types.MungedPackageId
    Distribution.Types.MungedPackageName
    Distribution.Types.PackageDescription
    Distribution.Types.PackageDescription.Lens
    Distribution.Types.PackageId Distribution.Types.PackageId.Lens
    Distribution.Types.PackageName Distribution.Types.PackageName.Magic
    Distribution.Types.PackageVersionConstraint
    Distribution.Types.PkgconfigDependency
    Distribution.Types.PkgconfigName
    Distribution.Types.PkgconfigVersion
    Distribution.Types.PkgconfigVersionRange
    Distribution.Types.SetupBuildInfo
    Distribution.Types.SetupBuildInfo.Lens
    Distribution.Types.SourceRepo Distribution.Types.SourceRepo.Lens
    Distribution.Types.TargetInfo Distribution.Types.TestSuite
    Distribution.Types.TestSuite.Lens
    Distribution.Types.TestSuiteInterface Distribution.Types.TestType
    Distribution.Types.UnitId Distribution.Types.UnqualComponentName
    Distribution.Types.Version Distribution.Types.VersionInterval
    Distribution.Types.VersionInterval.Legacy
    Distribution.Types.VersionRange
    Distribution.Types.VersionRange.Internal Distribution.Utils.Generic
    Distribution.Utils.IOData Distribution.Utils.LogProgress
    Distribution.Utils.MD5 Distribution.Utils.MapAccum
    Distribution.Utils.NubList Distribution.Utils.Path
    Distribution.Utils.Progress Distribution.Utils.ShortText
    Distribution.Utils.Structured Distribution.Verbosity
    Distribution.Verbosity.Internal Distribution.Version
    Language.Haskell.Extension
hidden-modules:
    Distribution.Backpack.PreExistingComponent
    Distribution.Backpack.ReadyComponent Distribution.Backpack.MixLink
    Distribution.Backpack.ModuleScope Distribution.Backpack.UnifyM
    Distribution.Backpack.Id Distribution.Utils.UnionFind
    Distribution.Utils.Base62 Distribution.Compat.Async
    Distribution.Compat.CopyFile Distribution.Compat.GetShortPathName
    Distribution.Compat.MonadFail Distribution.Compat.Prelude
    Distribution.Compat.SnocList Distribution.GetOpt Distribution.Lex
    Distribution.Utils.String Distribution.Simple.Build.Macros.Z
    Distribution.Simple.Build.PathsModule.Z
    Distribution.Simple.GHC.EnvironmentParser
    Distribution.Simple.GHC.Internal Distribution.Simple.GHC.ImplInfo
    Distribution.Simple.Utils.Json Distribution.ZinzaPrelude
    Paths_Cabal
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSCabal-3.6.3.0
depends:
    array-0.5.4.0 base-4.16.4.0 binary-0.8.9.0 bytestring-0.11.3.1
    containers-0.6.5.1 deepseq-1.4.6.1 directory-1.3.6.2
    filepath-1.4.2.2 mtl-2.2.2 parsec-3.1.15.0 pretty-1.1.3.6
    process-1.6.16.0 text-1.2.5.0 time-1.11.1.1 transformers-0.5.6.2
    unix-2.7.2.2
haddock-interfaces:
haddock-html:
---
name:                 array
version:              0.5.4.0
visibility:           public
id:                   array-0.5.4.0
key:                  array-0.5.4.0
license:              BSD-3-Clause
maintainer:           libraries@haskell.org
synopsis:             Mutable and immutable arrays
description:
    In addition to providing the "Data.Array" module
    <http://www.haskell.org/onlinereport/haskell2010/haskellch14.html as specified in the Haskell 2010 Language Report>,
    this package also defines the classes 'IArray' of
    immutable arrays and 'MArray' of arrays mutable within appropriate
    monads, as well as some instances of these classes.
category:             Data Structures
exposed:              True
exposed-modules:
    Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO
    Data.Array.IO.Internals Data.Array.IO.Safe Data.Array.MArray
    Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe
    Data.Array.Storable Data.Array.Storable.Internals
    Data.Array.Storable.Safe Data.Array.Unboxed Data.Array.Unsafe
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSarray-0.5.4.0
depends:              base-4.16.4.0
haddock-interfaces:
haddock-html:
---
name:                 base
version:              4.16.4.0
visibility:           public
id:                   base-4.16.4.0
key:                  base-4.16.4.0
license:              BSD-3-Clause
maintainer:           libraries@haskell.org
synopsis:             Basic libraries
description:
    This package contains the Standard Haskell "Prelude" and its support libraries,
    and a large collection of useful libraries ranging from data
    structures to parsing combinators and debugging utilities.
category:             Prelude
exposed:              True
exposed-modules:
    Control.Applicative, Control.Arrow, Control.Category,
    Control.Concurrent, Control.Concurrent.Chan,
    Control.Concurrent.MVar, Control.Concurrent.QSem,
    Control.Concurrent.QSemN, Control.Exception,
    Control.Exception.Base, Control.Monad, Control.Monad.Fail,
    Control.Monad.Fix, Control.Monad.IO.Class, Control.Monad.Instances,
    Control.Monad.ST, Control.Monad.ST.Lazy,
    Control.Monad.ST.Lazy.Safe, Control.Monad.ST.Lazy.Unsafe,
    Control.Monad.ST.Safe, Control.Monad.ST.Strict,
    Control.Monad.ST.Unsafe, Control.Monad.Zip, Data.Bifoldable,
    Data.Bifunctor, Data.Bitraversable, Data.Bits, Data.Bool,
    Data.Char, Data.Coerce, Data.Complex, Data.Data, Data.Dynamic,
    Data.Either, Data.Eq, Data.Fixed, Data.Foldable, Data.Function,
    Data.Functor, Data.Functor.Classes, Data.Functor.Compose,
    Data.Functor.Const, Data.Functor.Contravariant,
    Data.Functor.Identity, Data.Functor.Product, Data.Functor.Sum,
    Data.IORef, Data.Int, Data.Ix, Data.Kind, Data.List,
    Data.List.NonEmpty, Data.Maybe, Data.Monoid, Data.Ord, Data.Proxy,
    Data.Ratio, Data.STRef, Data.STRef.Lazy, Data.STRef.Strict,
    Data.Semigroup, Data.String, Data.Traversable, Data.Tuple,
    Data.Type.Bool, Data.Type.Coercion, Data.Type.Equality,
    Data.Type.Ord, Data.Typeable, Data.Unique, Data.Version, Data.Void,
    Data.Word, Debug.Trace, Foreign, Foreign.C, Foreign.C.Error,
    Foreign.C.String, Foreign.C.Types, Foreign.Concurrent,
    Foreign.ForeignPtr, Foreign.ForeignPtr.Safe,
    Foreign.ForeignPtr.Unsafe, Foreign.Marshal, Foreign.Marshal.Alloc,
    Foreign.Marshal.Array, Foreign.Marshal.Error, Foreign.Marshal.Pool,
    Foreign.Marshal.Safe, Foreign.Marshal.Unsafe,
    Foreign.Marshal.Utils, Foreign.Ptr, Foreign.Safe,
    Foreign.StablePtr, Foreign.Storable, GHC.Arr, GHC.Base, GHC.Bits,
    GHC.ByteOrder, GHC.Char, GHC.Clock, GHC.Conc, GHC.Conc.IO,
    GHC.Conc.Signal, GHC.Conc.Sync, GHC.ConsoleHandler, GHC.Constants,
    GHC.Desugar, GHC.Enum, GHC.Environment, GHC.Err, GHC.Event,
    GHC.Event.TimeOut, GHC.Exception, GHC.Exception.Type,
    GHC.ExecutionStack, GHC.ExecutionStack.Internal, GHC.Exts,
    GHC.Fingerprint, GHC.Fingerprint.Type, GHC.Float,
    GHC.Float.ConversionUtils, GHC.Float.RealFracMethods, GHC.Foreign,
    GHC.ForeignPtr, GHC.GHCi, GHC.GHCi.Helpers, GHC.Generics, GHC.IO,
    GHC.IO.Buffer, GHC.IO.BufferedIO, GHC.IO.Device, GHC.IO.Encoding,
    GHC.IO.Encoding.CodePage, GHC.IO.Encoding.Failure,
    GHC.IO.Encoding.Iconv, GHC.IO.Encoding.Latin1,
    GHC.IO.Encoding.Types, GHC.IO.Encoding.UTF16,
    GHC.IO.Encoding.UTF32, GHC.IO.Encoding.UTF8, GHC.IO.Exception,
    GHC.IO.FD, GHC.IO.Handle, GHC.IO.Handle.FD,
    GHC.IO.Handle.Internals, GHC.IO.Handle.Lock, GHC.IO.Handle.Text,
    GHC.IO.Handle.Types, GHC.IO.IOMode, GHC.IO.StdHandles,
    GHC.IO.SubSystem, GHC.IO.Unsafe, GHC.IOArray, GHC.IOPort,
    GHC.IORef, GHC.Int, GHC.Integer, GHC.Integer.Logarithms, GHC.Ix,
    GHC.List, GHC.MVar, GHC.Maybe, GHC.Natural, GHC.Num,
    GHC.Num.BigNat from ghc-bignum-1.2:GHC.Num.BigNat,
    GHC.Num.Integer from ghc-bignum-1.2:GHC.Num.Integer,
    GHC.Num.Natural from ghc-bignum-1.2:GHC.Num.Natural, GHC.OldList,
    GHC.OverloadedLabels, GHC.Pack, GHC.Profiling, GHC.Ptr,
    GHC.RTS.Flags, GHC.Read, GHC.Real, GHC.Records, GHC.ResponseFile,
    GHC.ST, GHC.STRef, GHC.Show, GHC.Stable, GHC.StableName, GHC.Stack,
    GHC.Stack.CCS, GHC.Stack.Types, GHC.StaticPtr, GHC.Stats,
    GHC.Storable, GHC.TopHandler, GHC.TypeLits, GHC.TypeLits.Internal,
    GHC.TypeNats, GHC.TypeNats.Internal, GHC.Unicode, GHC.Weak,
    GHC.Word, Numeric, Numeric.Natural, Prelude, System.CPUTime,
    System.Console.GetOpt, System.Environment,
    System.Environment.Blank, System.Exit, System.IO, System.IO.Error,
    System.IO.Unsafe, System.Info, System.Mem, System.Mem.StableName,
    System.Mem.Weak, System.Posix.Internals, System.Posix.Types,
    System.Timeout, Text.ParserCombinators.ReadP,
    Text.ParserCombinators.ReadPrec, Text.Printf, Text.Read,
    Text.Read.Lex, Text.Show, Text.Show.Functions, Type.Reflection,
    Type.Reflection.Unsafe, Unsafe.Coerce
hidden-modules:
    Control.Monad.ST.Imp Control.Monad.ST.Lazy.Imp Data.Functor.Utils
    Data.OldList Data.Semigroup.Internal Data.Typeable.Internal
    Foreign.ForeignPtr.Imp GHC.IO.Handle.Lock.Common
    GHC.IO.Handle.Lock.Flock GHC.IO.Handle.Lock.LinuxOFD
    GHC.IO.Handle.Lock.NoOp GHC.IO.Handle.Lock.Windows
    GHC.StaticPtr.Internal GHC.Event.Arr GHC.Event.Array
    GHC.Event.Internal GHC.Event.Internal.Types GHC.Event.IntTable
    GHC.Event.IntVar GHC.Event.PSQ GHC.Event.Unique
    System.Environment.ExecutablePath System.CPUTime.Utils
    GHC.Event.Control GHC.Event.EPoll GHC.Event.KQueue
    GHC.Event.Manager GHC.Event.Poll GHC.Event.Thread
    GHC.Event.TimerManager System.CPUTime.Posix.ClockGetTime
    System.CPUTime.Posix.Times System.CPUTime.Posix.RUsage
    System.CPUTime.Unsupported
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSbase-4.16.4.0
include-dirs:
includes:             HsBase.h
depends:              ghc-bignum-1.2 ghc-prim-0.8.0 rts
haddock-interfaces:
haddock-html:
---
name:                 binary
version:              0.8.9.0
visibility:           public
id:                   binary-0.8.9.0
key:                  binary-0.8.9.0
license:              BSD-3-Clause
maintainer:           Lennart Kolmodin, Don Stewart <dons00@gmail.com>
author:               Lennart Kolmodin <kolmodin@gmail.com>
stability:            provisional
homepage:             https://github.com/kolmodin/binary
synopsis:
    Binary serialisation for Haskell values using lazy ByteStrings
description:
    Efficient, pure binary serialisation using lazy ByteStrings.
    Haskell values may be encoded to and from binary formats,
    written to disk as binary, or sent over the network.
    The format used can be automatically generated, or
    you can choose to implement a custom format if needed.
    Serialisation speeds of over 1 G\/sec have been observed,
    so this library should be suitable for high performance
    scenarios.
category:             Data, Parsing
exposed:              True
exposed-modules:
    Data.Binary Data.Binary.Builder Data.Binary.Get
    Data.Binary.Get.Internal Data.Binary.Put
hidden-modules:
    Data.Binary.Class Data.Binary.Internal Data.Binary.Generic
    Data.Binary.FloatCast
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSbinary-0.8.9.0
depends:
    array-0.5.4.0 base-4.16.4.0 bytestring-0.11.3.1 containers-0.6.5.1
haddock-interfaces:
haddock-html:
---
name:                 bytestring
version:              0.11.3.1
visibility:           public
id:                   bytestring-0.11.3.1
key:                  bytestring-0.11.3.1
license:              BSD-3-Clause
copyright:
    Copyright (c) Don Stewart          2005-2009,
    (c) Duncan Coutts        2006-2015,
    (c) David Roundy         2003-2005,
    (c) Jasper Van der Jeugt 2010,
    (c) Simon Meier          2010-2013.
maintainer:
    Haskell Bytestring Team <andrew.lelechenko@gmail.com>, Core Libraries Committee
author:
    Don Stewart,
    Duncan Coutts
homepage:             https://github.com/haskell/bytestring
synopsis:
    Fast, compact, strict and lazy byte strings with a list interface
description:
    An efficient compact, immutable byte string type (both strict and lazy)
    suitable for binary or 8-bit character data.
    The 'ByteString' type represents sequences of bytes or 8-bit characters.
    It is suitable for high performance use, both in terms of large data
    quantities, or high speed requirements. The 'ByteString' functions follow
    the same style as Haskell\'s ordinary lists, so it is easy to convert code
    from using 'String' to 'ByteString'.
    Two 'ByteString' variants are provided:
    * Strict 'ByteString's keep the string as a single large array. This
    makes them convenient for passing data between C and Haskell.
    * Lazy 'ByteString's use a lazy list of strict chunks which makes it
    suitable for I\/O streaming tasks.
    The @Char8@ modules provide a character-based view of the same
    underlying 'ByteString' types. This makes it convenient to handle mixed
    binary and 8-bit character content (which is common in many file formats
    and network protocols).
    The 'Builder' module provides an efficient way to build up 'ByteString's
    in an ad-hoc way by repeated concatenation. This is ideal for fast
    serialisation or pretty printing.
    There is also a 'ShortByteString' type which has a lower memory overhead
    and can be converted to or from a 'ByteString'. It is suitable for keeping
    many short strings in memory.
    'ByteString's are not designed for Unicode. For Unicode strings you should
    use the 'Text' type from the @text@ package.
    These modules are intended to be imported qualified, to avoid name clashes
    with "Prelude" functions, e.g.
    > import qualified Data.ByteString as BS
category:             Data
exposed:              True
exposed-modules:
    Data.ByteString Data.ByteString.Builder
    Data.ByteString.Builder.Extra Data.ByteString.Builder.Internal
    Data.ByteString.Builder.Prim Data.ByteString.Builder.Prim.Internal
    Data.ByteString.Builder.RealFloat Data.ByteString.Char8
    Data.ByteString.Internal Data.ByteString.Lazy
    Data.ByteString.Lazy.Char8 Data.ByteString.Lazy.Internal
    Data.ByteString.Short Data.ByteString.Short.Internal
    Data.ByteString.Unsafe
hidden-modules:
    Data.ByteString.Builder.ASCII Data.ByteString.Builder.Prim.ASCII
    Data.ByteString.Builder.Prim.Binary
    Data.ByteString.Builder.Prim.Internal.Base16
    Data.ByteString.Builder.Prim.Internal.Floating
    Data.ByteString.Builder.RealFloat.F2S
    Data.ByteString.Builder.RealFloat.D2S
    Data.ByteString.Builder.RealFloat.Internal
    Data.ByteString.Builder.RealFloat.TableGenerator
    Data.ByteString.Lazy.Internal.Deque
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSbytestring-0.11.3.1
include-dirs:
includes:             fpstring.h
depends:
    base-4.16.4.0 deepseq-1.4.6.1 ghc-prim-0.8.0
    template-haskell-2.18.0.0
haddock-interfaces:
haddock-html:
---
name:                 containers
version:              0.6.5.1
visibility:           public
id:                   containers-0.6.5.1
key:                  containers-0.6.5.1
license:              BSD-3-Clause
maintainer:           libraries@haskell.org
synopsis:             Assorted concrete container types
description:
    This package contains efficient general-purpose implementations
    of various immutable container types including sets, maps, sequences,
    trees, and graphs.
    For a walkthrough of what this package provides with examples of common
    operations see the [containers
    introduction](https://haskell-containers.readthedocs.io).
    The declared cost of each operation is either worst-case or amortized, but
    remains valid even if structures are shared.
category:             Data Structures
exposed:              True
exposed-modules:
    Data.Containers.ListUtils Data.Graph Data.IntMap
    Data.IntMap.Internal Data.IntMap.Internal.Debug Data.IntMap.Lazy
    Data.IntMap.Merge.Lazy Data.IntMap.Merge.Strict Data.IntMap.Strict
    Data.IntMap.Strict.Internal Data.IntSet Data.IntSet.Internal
    Data.Map Data.Map.Internal Data.Map.Internal.Debug Data.Map.Lazy
    Data.Map.Merge.Lazy Data.Map.Merge.Strict Data.Map.Strict
    Data.Map.Strict.Internal Data.Sequence Data.Sequence.Internal
    Data.Sequence.Internal.Sorting Data.Set Data.Set.Internal Data.Tree
    Utils.Containers.Internal.BitQueue
    Utils.Containers.Internal.BitUtil
    Utils.Containers.Internal.StrictPair
hidden-modules:
    Utils.Containers.Internal.State
    Utils.Containers.Internal.StrictMaybe
    Utils.Containers.Internal.PtrEquality
    Utils.Containers.Internal.Coercions
    Utils.Containers.Internal.TypeError
    Data.Map.Internal.DeprecatedShowTree
    Data.IntMap.Internal.DeprecatedDebug
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HScontainers-0.6.5.1
depends:              array-0.5.4.0 base-4.16.4.0 deepseq-1.4.6.1
haddock-interfaces:
haddock-html:
---
name:                 deepseq
version:              1.4.6.1
visibility:           public
id:                   deepseq-1.4.6.1
key:                  deepseq-1.4.6.1
license:              BSD-3-Clause
maintainer:           libraries@haskell.org
synopsis:             Deep evaluation of data structures
description:
    This package provides methods for fully evaluating data structures
    (\"deep evaluation\"). Deep evaluation is often used for adding
    strictness to a program, e.g. in order to force pending exceptions,
    remove space leaks, or force lazy I/O to happen. It is also useful
    in parallel programs, to ensure pending work does not migrate to the
    wrong thread.
    The primary use of this package is via the 'deepseq' function, a
    \"deep\" version of 'seq'. It is implemented on top of an 'NFData'
    typeclass (\"Normal Form Data\", data structures with no unevaluated
    components) which defines strategies for fully evaluating different
    data types. See module documentation in "Control.DeepSeq" for more
    details.
category:             Control
exposed:              True
exposed-modules:      Control.DeepSeq
hidden-modules:       Control.DeepSeq.BackDoor
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSdeepseq-1.4.6.1
depends:              array-0.5.4.0 base-4.16.4.0
haddock-interfaces:
haddock-html:
---
name:                 directory
version:              1.3.6.2
visibility:           public
id:                   directory-1.3.6.2
key:                  directory-1.3.6.2
license:              BSD-3-Clause
maintainer:           libraries@haskell.org
synopsis:             Platform-agnostic library for filesystem operations
description:
    This library provides a basic set of operations for manipulating files and
    directories in a portable way.
category:             System
exposed:              True
exposed-modules:
    System.Directory System.Directory.Internal
    System.Directory.Internal.Prelude
hidden-modules:
    System.Directory.Internal.C_utimensat
    System.Directory.Internal.Common System.Directory.Internal.Config
    System.Directory.Internal.Posix System.Directory.Internal.Windows
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSdirectory-1.3.6.2
depends:
    base-4.16.4.0 filepath-1.4.2.2 time-1.11.1.1 unix-2.7.2.2
haddock-interfaces:
haddock-html:
---
name:                 exceptions
version:              0.10.4
visibility:           public
id:                   exceptions-0.10.4
key:                  exceptions-0.10.4
license:              BSD-3-Clause
copyright:
    Copyright (C) 2013-2015 Edward A. Kmett
    Copyright (C) 2012 Google Inc.
maintainer:           Edward A. Kmett <ekmett@gmail.com>
author:               Edward A. Kmett
stability:            provisional
homepage:             http://github.com/ekmett/exceptions/
synopsis:             Extensible optionally-pure exceptions
description:          Extensible optionally-pure exceptions.
category:             Control, Exceptions, Monad
exposed:              True
exposed-modules:      Control.Monad.Catch Control.Monad.Catch.Pure
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSexceptions-0.10.4
depends:
    base-4.16.4.0 mtl-2.2.2 stm-2.5.0.2 template-haskell-2.18.0.0
    transformers-0.5.6.2
haddock-interfaces:
haddock-html:
---
name:                 filepath
version:              1.4.2.2
visibility:           public
id:                   filepath-1.4.2.2
key:                  filepath-1.4.2.2
license:              BSD-3-Clause
copyright:            Neil Mitchell 2005-2020
maintainer:           Julian Ospald <hasufell@posteo.de>
author:               Neil Mitchell <ndmitchell@gmail.com>
homepage:             https://github.com/haskell/filepath#readme
synopsis:             Library for manipulating FilePaths in a cross platform way.
description:
    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:
    * "System.FilePath.Posix" manipulates POSIX\/Linux style @FilePath@ values (with @\/@ as the path separator).
    * "System.FilePath.Windows" manipulates Windows style @FilePath@ values (with either @\\@ or @\/@ as the path separator, and deals with drives).
    * "System.FilePath" is an alias for the module appropriate to your platform.
    All three modules provide the same API, and the same documentation (calling out differences in the different variants).
category:             System
exposed:              True
exposed-modules:
    System.FilePath System.FilePath.Posix System.FilePath.Windows
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSfilepath-1.4.2.2
depends:              base-4.16.4.0
haddock-interfaces:
haddock-html:
---
name:                 ghc
version:              9.2.5
visibility:           public
id:                   ghc-9.2.5
key:                  ghc-9.2.5
license:              BSD-3-Clause
maintainer:           glasgow-haskell-users@haskell.org
author:               The GHC Team
homepage:             http://www.haskell.org/ghc/
synopsis:             The GHC API
description:
    GHC's functionality can be useful for more things than just
    compiling Haskell programs. Important use cases are programs
    that analyse (and perhaps transform) Haskell code. Others
    include loading Haskell code dynamically in a GHCi-like manner.
    For this reason, a lot of GHC's functionality is made available
    through this package.
    See <https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler>
    for more information.
category:             Development
exposed-modules:
    GHC, GHC.Builtin.Names, GHC.Builtin.Names.TH, GHC.Builtin.PrimOps,
    GHC.Builtin.Types, GHC.Builtin.Types.Literals,
    GHC.Builtin.Types.Prim, GHC.Builtin.Uniques, GHC.Builtin.Utils,
    GHC.ByteCode.Asm, GHC.ByteCode.InfoTable, GHC.ByteCode.Instr,
    GHC.ByteCode.Linker, GHC.ByteCode.Types, GHC.Cmm, GHC.Cmm.BlockId,
    GHC.Cmm.CLabel, GHC.Cmm.CallConv, GHC.Cmm.CommonBlockElim,
    GHC.Cmm.ContFlowOpt, GHC.Cmm.Dataflow, GHC.Cmm.Dataflow.Block,
    GHC.Cmm.Dataflow.Collections, GHC.Cmm.Dataflow.Graph,
    GHC.Cmm.Dataflow.Label, GHC.Cmm.DebugBlock, GHC.Cmm.Expr,
    GHC.Cmm.Graph, GHC.Cmm.Info, GHC.Cmm.Info.Build, GHC.Cmm.LRegSet,
    GHC.Cmm.LayoutStack, GHC.Cmm.Lexer, GHC.Cmm.Lint, GHC.Cmm.Liveness,
    GHC.Cmm.MachOp, GHC.Cmm.Node, GHC.Cmm.Opt, GHC.Cmm.Parser,
    GHC.Cmm.Parser.Monad, GHC.Cmm.Pipeline, GHC.Cmm.Ppr,
    GHC.Cmm.Ppr.Decl, GHC.Cmm.Ppr.Expr, GHC.Cmm.ProcPoint,
    GHC.Cmm.Sink, GHC.Cmm.Switch, GHC.Cmm.Switch.Implement,
    GHC.Cmm.Type, GHC.Cmm.Utils, GHC.CmmToAsm, GHC.CmmToAsm.AArch64,
    GHC.CmmToAsm.AArch64.CodeGen, GHC.CmmToAsm.AArch64.Cond,
    GHC.CmmToAsm.AArch64.Instr, GHC.CmmToAsm.AArch64.Ppr,
    GHC.CmmToAsm.AArch64.RegInfo, GHC.CmmToAsm.AArch64.Regs,
    GHC.CmmToAsm.BlockLayout, GHC.CmmToAsm.CFG,
    GHC.CmmToAsm.CFG.Dominators, GHC.CmmToAsm.CFG.Weight,
    GHC.CmmToAsm.CPrim, GHC.CmmToAsm.Config, GHC.CmmToAsm.Dwarf,
    GHC.CmmToAsm.Dwarf.Constants, GHC.CmmToAsm.Dwarf.Types,
    GHC.CmmToAsm.Format, GHC.CmmToAsm.Instr, GHC.CmmToAsm.Monad,
    GHC.CmmToAsm.PIC, GHC.CmmToAsm.PPC, GHC.CmmToAsm.PPC.CodeGen,
    GHC.CmmToAsm.PPC.Cond, GHC.CmmToAsm.PPC.Instr,
    GHC.CmmToAsm.PPC.Ppr, GHC.CmmToAsm.PPC.RegInfo,
    GHC.CmmToAsm.PPC.Regs, GHC.CmmToAsm.Ppr, GHC.CmmToAsm.Reg.Graph,
    GHC.CmmToAsm.Reg.Graph.Base, GHC.CmmToAsm.Reg.Graph.Coalesce,
    GHC.CmmToAsm.Reg.Graph.Spill, GHC.CmmToAsm.Reg.Graph.SpillClean,
    GHC.CmmToAsm.Reg.Graph.SpillCost, GHC.CmmToAsm.Reg.Graph.Stats,
    GHC.CmmToAsm.Reg.Graph.TrivColorable, GHC.CmmToAsm.Reg.Graph.X86,
    GHC.CmmToAsm.Reg.Linear, GHC.CmmToAsm.Reg.Linear.AArch64,
    GHC.CmmToAsm.Reg.Linear.Base, GHC.CmmToAsm.Reg.Linear.FreeRegs,
    GHC.CmmToAsm.Reg.Linear.JoinToTargets, GHC.CmmToAsm.Reg.Linear.PPC,
    GHC.CmmToAsm.Reg.Linear.SPARC, GHC.CmmToAsm.Reg.Linear.StackMap,
    GHC.CmmToAsm.Reg.Linear.State, GHC.CmmToAsm.Reg.Linear.Stats,
    GHC.CmmToAsm.Reg.Linear.X86, GHC.CmmToAsm.Reg.Linear.X86_64,
    GHC.CmmToAsm.Reg.Liveness, GHC.CmmToAsm.Reg.Target,
    GHC.CmmToAsm.Reg.Utils, GHC.CmmToAsm.SPARC,
    GHC.CmmToAsm.SPARC.AddrMode, GHC.CmmToAsm.SPARC.Base,
    GHC.CmmToAsm.SPARC.CodeGen, GHC.CmmToAsm.SPARC.CodeGen.Amode,
    GHC.CmmToAsm.SPARC.CodeGen.Base,
    GHC.CmmToAsm.SPARC.CodeGen.CondCode,
    GHC.CmmToAsm.SPARC.CodeGen.Expand,
    GHC.CmmToAsm.SPARC.CodeGen.Gen32, GHC.CmmToAsm.SPARC.CodeGen.Gen64,
    GHC.CmmToAsm.SPARC.CodeGen.Sanity, GHC.CmmToAsm.SPARC.Cond,
    GHC.CmmToAsm.SPARC.Imm, GHC.CmmToAsm.SPARC.Instr,
    GHC.CmmToAsm.SPARC.Ppr, GHC.CmmToAsm.SPARC.Regs,
    GHC.CmmToAsm.SPARC.ShortcutJump, GHC.CmmToAsm.SPARC.Stack,
    GHC.CmmToAsm.Types, GHC.CmmToAsm.Utils, GHC.CmmToAsm.X86,
    GHC.CmmToAsm.X86.CodeGen, GHC.CmmToAsm.X86.Cond,
    GHC.CmmToAsm.X86.Instr, GHC.CmmToAsm.X86.Ppr,
    GHC.CmmToAsm.X86.RegInfo, GHC.CmmToAsm.X86.Regs, GHC.CmmToC,
    GHC.CmmToLlvm, GHC.CmmToLlvm.Base, GHC.CmmToLlvm.CodeGen,
    GHC.CmmToLlvm.Data, GHC.CmmToLlvm.Mangler, GHC.CmmToLlvm.Ppr,
    GHC.CmmToLlvm.Regs, GHC.Core, GHC.Core.Class, GHC.Core.Coercion,
    GHC.Core.Coercion.Axiom, GHC.Core.Coercion.Opt, GHC.Core.ConLike,
    GHC.Core.DataCon, GHC.Core.FVs, GHC.Core.FamInstEnv,
    GHC.Core.InstEnv, GHC.Core.Lint, GHC.Core.Make, GHC.Core.Map.Expr,
    GHC.Core.Map.Type, GHC.Core.Multiplicity, GHC.Core.Opt.Arity,
    GHC.Core.Opt.CSE, GHC.Core.Opt.CallArity, GHC.Core.Opt.CallerCC,
    GHC.Core.Opt.ConstantFold, GHC.Core.Opt.CprAnal,
    GHC.Core.Opt.DmdAnal, GHC.Core.Opt.Exitify, GHC.Core.Opt.FloatIn,
    GHC.Core.Opt.FloatOut, GHC.Core.Opt.LiberateCase,
    GHC.Core.Opt.Monad, GHC.Core.Opt.OccurAnal, GHC.Core.Opt.Pipeline,
    GHC.Core.Opt.SetLevels, GHC.Core.Opt.Simplify,
    GHC.Core.Opt.Simplify.Env, GHC.Core.Opt.Simplify.Monad,
    GHC.Core.Opt.Simplify.Utils, GHC.Core.Opt.SpecConstr,
    GHC.Core.Opt.Specialise, GHC.Core.Opt.StaticArgs,
    GHC.Core.Opt.WorkWrap, GHC.Core.Opt.WorkWrap.Utils,
    GHC.Core.PatSyn, GHC.Core.Ppr, GHC.Core.Predicate, GHC.Core.Rules,
    GHC.Core.Seq, GHC.Core.SimpleOpt, GHC.Core.Stats, GHC.Core.Subst,
    GHC.Core.Tidy, GHC.Core.TyCo.FVs, GHC.Core.TyCo.Ppr,
    GHC.Core.TyCo.Rep, GHC.Core.TyCo.Subst, GHC.Core.TyCo.Tidy,
    GHC.Core.TyCon, GHC.Core.TyCon.Env, GHC.Core.TyCon.RecWalk,
    GHC.Core.TyCon.Set, GHC.Core.Type, GHC.Core.Unfold,
    GHC.Core.Unfold.Make, GHC.Core.Unify, GHC.Core.UsageEnv,
    GHC.Core.Utils, GHC.CoreToIface, GHC.CoreToStg, GHC.CoreToStg.Prep,
    GHC.Data.Bag, GHC.Data.Bitmap, GHC.Data.BooleanFormula,
    GHC.Data.EnumSet, GHC.Data.FastMutInt, GHC.Data.FastString,
    GHC.Data.FastString.Env, GHC.Data.FiniteMap, GHC.Data.Graph.Base,
    GHC.Data.Graph.Color, GHC.Data.Graph.Directed, GHC.Data.Graph.Ops,
    GHC.Data.Graph.Ppr, GHC.Data.Graph.UnVar, GHC.Data.IOEnv,
    GHC.Data.List.SetOps, GHC.Data.Maybe, GHC.Data.OrdList,
    GHC.Data.Pair, GHC.Data.Stream, GHC.Data.StringBuffer,
    GHC.Data.TrieMap, GHC.Data.UnionFind, GHC.Driver.Backend,
    GHC.Driver.Backpack, GHC.Driver.Backpack.Syntax,
    GHC.Driver.CmdLine, GHC.Driver.CodeOutput, GHC.Driver.Config,
    GHC.Driver.Env, GHC.Driver.Env.Types, GHC.Driver.Errors,
    GHC.Driver.Flags, GHC.Driver.Hooks, GHC.Driver.Main,
    GHC.Driver.Make, GHC.Driver.MakeFile, GHC.Driver.Monad,
    GHC.Driver.Phases, GHC.Driver.Pipeline, GHC.Driver.Pipeline.Monad,
    GHC.Driver.Plugins, GHC.Driver.Ppr, GHC.Driver.Session, GHC.Hs,
    GHC.Hs.Binds, GHC.Hs.Decls, GHC.Hs.Doc, GHC.Hs.Dump, GHC.Hs.Expr,
    GHC.Hs.Extension, GHC.Hs.ImpExp, GHC.Hs.Instances, GHC.Hs.Lit,
    GHC.Hs.Pat, GHC.Hs.Stats, GHC.Hs.Type, GHC.Hs.Utils, GHC.HsToCore,
    GHC.HsToCore.Arrows, GHC.HsToCore.Binds, GHC.HsToCore.Coverage,
    GHC.HsToCore.Docs, GHC.HsToCore.Expr, GHC.HsToCore.Foreign.Call,
    GHC.HsToCore.Foreign.Decl, GHC.HsToCore.GuardedRHSs,
    GHC.HsToCore.ListComp, GHC.HsToCore.Match,
    GHC.HsToCore.Match.Constructor, GHC.HsToCore.Match.Literal,
    GHC.HsToCore.Monad, GHC.HsToCore.Pmc, GHC.HsToCore.Pmc.Check,
    GHC.HsToCore.Pmc.Desugar, GHC.HsToCore.Pmc.Ppr,
    GHC.HsToCore.Pmc.Solver, GHC.HsToCore.Pmc.Solver.Types,
    GHC.HsToCore.Pmc.Types, GHC.HsToCore.Pmc.Utils, GHC.HsToCore.Quote,
    GHC.HsToCore.Types, GHC.HsToCore.Usage, GHC.HsToCore.Utils,
    GHC.Iface.Binary, GHC.Iface.Env, GHC.Iface.Ext.Ast,
    GHC.Iface.Ext.Binary, GHC.Iface.Ext.Debug, GHC.Iface.Ext.Fields,
    GHC.Iface.Ext.Types, GHC.Iface.Ext.Utils, GHC.Iface.Load,
    GHC.Iface.Make, GHC.Iface.Recomp, GHC.Iface.Recomp.Binary,
    GHC.Iface.Recomp.Flags, GHC.Iface.Rename, GHC.Iface.Syntax,
    GHC.Iface.Tidy, GHC.Iface.Tidy.StaticPtrTable, GHC.Iface.Type,
    GHC.IfaceToCore, GHC.Linker, GHC.Linker.Dynamic,
    GHC.Linker.ExtraObj, GHC.Linker.Loader, GHC.Linker.MacOS,
    GHC.Linker.Static, GHC.Linker.Types, GHC.Linker.Unit,
    GHC.Linker.Windows, GHC.Llvm, GHC.Llvm.MetaData, GHC.Llvm.Ppr,
    GHC.Llvm.Syntax, GHC.Llvm.Types, GHC.Parser, GHC.Parser.Annotation,
    GHC.Parser.CharClass, GHC.Parser.Errors, GHC.Parser.Errors.Ppr,
    GHC.Parser.Header, GHC.Parser.Lexer, GHC.Parser.PostProcess,
    GHC.Parser.PostProcess.Haddock, GHC.Parser.Types, GHC.Parser.Utils,
    GHC.Platform, GHC.Platform.AArch64, GHC.Platform.ARM,
    GHC.Platform.ArchOS from ghc-boot-9.2.5:GHC.Platform.ArchOS,
    GHC.Platform.Constants,
    GHC.Platform.Host from ghc-boot-9.2.5:GHC.Platform.Host,
    GHC.Platform.NoRegs, GHC.Platform.PPC, GHC.Platform.Profile,
    GHC.Platform.RISCV64, GHC.Platform.Reg, GHC.Platform.Reg.Class,
    GHC.Platform.Regs, GHC.Platform.S390X, GHC.Platform.SPARC,
    GHC.Platform.Ways, GHC.Platform.X86, GHC.Platform.X86_64,
    GHC.Plugins, GHC.Prelude, GHC.Rename.Bind, GHC.Rename.Env,
    GHC.Rename.Expr, GHC.Rename.Fixity, GHC.Rename.HsType,
    GHC.Rename.Module, GHC.Rename.Names, GHC.Rename.Pat,
    GHC.Rename.Splice, GHC.Rename.Unbound, GHC.Rename.Utils,
    GHC.Runtime.Context, GHC.Runtime.Debugger, GHC.Runtime.Eval,
    GHC.Runtime.Eval.Types, GHC.Runtime.Heap.Inspect,
    GHC.Runtime.Heap.Layout, GHC.Runtime.Interpreter,
    GHC.Runtime.Interpreter.Types, GHC.Runtime.Loader, GHC.Settings,
    GHC.Settings.Config, GHC.Settings.Constants, GHC.Settings.IO,
    GHC.Stg.CSE, GHC.Stg.Debug, GHC.Stg.DepAnal, GHC.Stg.FVs,
    GHC.Stg.Lift, GHC.Stg.Lift.Analysis, GHC.Stg.Lift.Monad,
    GHC.Stg.Lint, GHC.Stg.Pipeline, GHC.Stg.Stats, GHC.Stg.Subst,
    GHC.Stg.Syntax, GHC.Stg.Unarise, GHC.StgToByteCode, GHC.StgToCmm,
    GHC.StgToCmm.ArgRep, GHC.StgToCmm.Bind, GHC.StgToCmm.CgUtils,
    GHC.StgToCmm.Closure, GHC.StgToCmm.DataCon, GHC.StgToCmm.Env,
    GHC.StgToCmm.Expr, GHC.StgToCmm.ExtCode, GHC.StgToCmm.Foreign,
    GHC.StgToCmm.Heap, GHC.StgToCmm.Hpc, GHC.StgToCmm.Layout,
    GHC.StgToCmm.Lit, GHC.StgToCmm.Monad, GHC.StgToCmm.Prim,
    GHC.StgToCmm.Prof, GHC.StgToCmm.Ticky, GHC.StgToCmm.Types,
    GHC.StgToCmm.Utils, GHC.SysTools, GHC.SysTools.Ar,
    GHC.SysTools.BaseDir, GHC.SysTools.Elf, GHC.SysTools.Info,
    GHC.SysTools.Process, GHC.SysTools.Tasks, GHC.SysTools.Terminal,
    GHC.Tc.Deriv, GHC.Tc.Deriv.Functor, GHC.Tc.Deriv.Generate,
    GHC.Tc.Deriv.Generics, GHC.Tc.Deriv.Infer, GHC.Tc.Deriv.Utils,
    GHC.Tc.Errors, GHC.Tc.Errors.Hole, GHC.Tc.Errors.Hole.FitTypes,
    GHC.Tc.Gen.Annotation, GHC.Tc.Gen.App, GHC.Tc.Gen.Arrow,
    GHC.Tc.Gen.Bind, GHC.Tc.Gen.Default, GHC.Tc.Gen.Export,
    GHC.Tc.Gen.Expr, GHC.Tc.Gen.Foreign, GHC.Tc.Gen.Head,
    GHC.Tc.Gen.HsType, GHC.Tc.Gen.Match, GHC.Tc.Gen.Pat,
    GHC.Tc.Gen.Rule, GHC.Tc.Gen.Sig, GHC.Tc.Gen.Splice,
    GHC.Tc.Instance.Class, GHC.Tc.Instance.Family,
    GHC.Tc.Instance.FunDeps, GHC.Tc.Instance.Typeable, GHC.Tc.Module,
    GHC.Tc.Plugin, GHC.Tc.Solver, GHC.Tc.Solver.Canonical,
    GHC.Tc.Solver.Interact, GHC.Tc.Solver.Monad, GHC.Tc.Solver.Rewrite,
    GHC.Tc.TyCl, GHC.Tc.TyCl.Build, GHC.Tc.TyCl.Class,
    GHC.Tc.TyCl.Instance, GHC.Tc.TyCl.PatSyn, GHC.Tc.TyCl.Utils,
    GHC.Tc.Types, GHC.Tc.Types.Constraint, GHC.Tc.Types.EvTerm,
    GHC.Tc.Types.Evidence, GHC.Tc.Types.Origin, GHC.Tc.Utils.Backpack,
    GHC.Tc.Utils.Env, GHC.Tc.Utils.Instantiate, GHC.Tc.Utils.Monad,
    GHC.Tc.Utils.TcMType, GHC.Tc.Utils.TcType, GHC.Tc.Utils.Unify,
    GHC.Tc.Utils.Zonk, GHC.Tc.Validity, GHC.ThToHs,
    GHC.Types.Annotations, GHC.Types.Avail, GHC.Types.Basic,
    GHC.Types.CompleteMatch, GHC.Types.CostCentre,
    GHC.Types.CostCentre.State, GHC.Types.Cpr, GHC.Types.Demand,
    GHC.Types.Error, GHC.Types.FieldLabel, GHC.Types.Fixity,
    GHC.Types.Fixity.Env, GHC.Types.ForeignCall,
    GHC.Types.ForeignStubs, GHC.Types.HpcInfo, GHC.Types.IPE,
    GHC.Types.Id, GHC.Types.Id.Info, GHC.Types.Id.Make,
    GHC.Types.Literal, GHC.Types.Meta, GHC.Types.Name,
    GHC.Types.Name.Cache, GHC.Types.Name.Env,
    GHC.Types.Name.Occurrence, GHC.Types.Name.Ppr,
    GHC.Types.Name.Reader, GHC.Types.Name.Set, GHC.Types.Name.Shape,
    GHC.Types.RepType, GHC.Types.SafeHaskell, GHC.Types.SourceError,
    GHC.Types.SourceFile, GHC.Types.SourceText, GHC.Types.SrcLoc,
    GHC.Types.Target, GHC.Types.Tickish, GHC.Types.TyThing,
    GHC.Types.TyThing.Ppr, GHC.Types.TypeEnv, GHC.Types.Unique,
    GHC.Types.Unique.DFM, GHC.Types.Unique.DSet, GHC.Types.Unique.FM,
    GHC.Types.Unique.Map, GHC.Types.Unique.SDFM, GHC.Types.Unique.Set,
    GHC.Types.Unique.Supply, GHC.Types.Var, GHC.Types.Var.Env,
    GHC.Types.Var.Set, GHC.Unit, GHC.Unit.Env, GHC.Unit.External,
    GHC.Unit.Finder, GHC.Unit.Finder.Types, GHC.Unit.Home,
    GHC.Unit.Home.ModInfo, GHC.Unit.Info, GHC.Unit.Module,
    GHC.Unit.Module.Deps, GHC.Unit.Module.Env, GHC.Unit.Module.Graph,
    GHC.Unit.Module.Imported, GHC.Unit.Module.Location,
    GHC.Unit.Module.ModDetails, GHC.Unit.Module.ModGuts,
    GHC.Unit.Module.ModIface, GHC.Unit.Module.ModSummary,
    GHC.Unit.Module.Name, GHC.Unit.Module.Status,
    GHC.Unit.Module.Warnings, GHC.Unit.Parser, GHC.Unit.Ppr,
    GHC.Unit.State, GHC.Unit.Types, GHC.Utils.Asm, GHC.Utils.Binary,
    GHC.Utils.Binary.Typeable, GHC.Utils.BufHandle,
    GHC.Utils.CliOption, GHC.Utils.Error, GHC.Utils.Exception,
    GHC.Utils.FV, GHC.Utils.Fingerprint, GHC.Utils.GlobalVars,
    GHC.Utils.IO.Unsafe, GHC.Utils.Json, GHC.Utils.Lexeme,
    GHC.Utils.Logger, GHC.Utils.Misc, GHC.Utils.Monad,
    GHC.Utils.Monad.State, GHC.Utils.Outputable, GHC.Utils.Panic,
    GHC.Utils.Panic.Plain, GHC.Utils.Ppr, GHC.Utils.Ppr.Colour,
    GHC.Utils.TmpFs, Language.Haskell.Syntax,
    Language.Haskell.Syntax.Binds, Language.Haskell.Syntax.Decls,
    Language.Haskell.Syntax.Expr, Language.Haskell.Syntax.Extension,
    Language.Haskell.Syntax.Lit, Language.Haskell.Syntax.Pat,
    Language.Haskell.Syntax.Type
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSghc-9.2.5
include-dirs:
depends:
    array-0.5.4.0 base-4.16.4.0 binary-0.8.9.0 bytestring-0.11.3.1
    containers-0.6.5.1 deepseq-1.4.6.1 directory-1.3.6.2
    exceptions-0.10.4 filepath-1.4.2.2 ghc-boot-9.2.5 ghc-heap-9.2.5
    ghci-9.2.5 hpc-0.6.1.0 process-1.6.16.0 template-haskell-2.18.0.0
    terminfo-0.4.1.5 time-1.11.1.1 transformers-0.5.6.2 unix-2.7.2.2
haddock-interfaces:
haddock-html:
---
name:                 ghc-bignum
version:              1.2
visibility:           public
id:                   ghc-bignum-1.2
key:                  ghc-bignum-1.2
license:              BSD-3-Clause
maintainer:           libraries@haskell.org
author:               Sylvain Henry
synopsis:             GHC BigNum library
description:
    This package provides the low-level implementation of the standard
    'BigNat', 'Natural' and 'Integer' types.
category:             Numeric, Algebra, GHC
exposed:              True
exposed-modules:
    GHC.Num.Backend GHC.Num.Backend.Native GHC.Num.Backend.Selected
    GHC.Num.BigNat GHC.Num.Integer GHC.Num.Natural GHC.Num.Primitives
    GHC.Num.WordArray
hidden-modules:       GHC.Num.Backend.GMP
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSghc-bignum-1.2
extra-libraries:      gmp
include-dirs:
depends:              ghc-prim-0.8.0
haddock-interfaces:
haddock-html:
---
name:                 ghc-boot
version:              9.2.5
visibility:           public
id:                   ghc-boot-9.2.5
key:                  ghc-boot-9.2.5
license:              BSD-3-Clause
maintainer:           ghc-devs@haskell.org
synopsis:             Shared functionality between GHC and its boot libraries
description:
    This library is shared between GHC, ghc-pkg, and other boot
    libraries.
    .
    A note about "GHC.Unit.Database": it only deals with the subset of
    the package database that the compiler cares about: modules
    paths etc and not package metadata like description, authors
    etc. It is thus not a library interface to ghc-pkg and is *not*
    suitable for modifying GHC package databases.
    .
    The package database format and this library are constructed in
    such a way that while ghc-pkg depends on Cabal, the GHC library
    and program do not have to depend on Cabal.
category:             GHC
exposed:              True
exposed-modules:
    GHC.BaseDir, GHC.Data.ShortText, GHC.Data.SizedSeq,
    GHC.ForeignSrcLang,
    GHC.ForeignSrcLang.Type from ghc-boot-th-9.2.5:GHC.ForeignSrcLang.Type,
    GHC.HandleEncoding, GHC.LanguageExtensions,
    GHC.LanguageExtensions.Type from ghc-boot-th-9.2.5:GHC.LanguageExtensions.Type,
    GHC.Lexeme from ghc-boot-th-9.2.5:GHC.Lexeme, GHC.Platform.ArchOS,
    GHC.Platform.Host, GHC.Serialized, GHC.Settings.Utils,
    GHC.UniqueSubdir, GHC.Unit.Database, GHC.Utils.Encoding,
    GHC.Version
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSghc-boot-9.2.5
depends:
    base-4.16.4.0 binary-0.8.9.0 bytestring-0.11.3.1 containers-0.6.5.1
    deepseq-1.4.6.1 directory-1.3.6.2 filepath-1.4.2.2
    ghc-boot-th-9.2.5 unix-2.7.2.2
haddock-interfaces:
haddock-html:
---
name:                 ghc-boot-th
version:              9.2.5
visibility:           public
id:                   ghc-boot-th-9.2.5
key:                  ghc-boot-th-9.2.5
license:              BSD-3-Clause
maintainer:           ghc-devs@haskell.org
synopsis:
    Shared functionality between GHC and the @template-haskell@
    library
description:
    This library contains various bits shared between the @ghc@ and
    @template-haskell@ libraries.
    This package exists to ensure that @template-haskell@ has a
    minimal set of transitive dependencies, since it is intended to
    be depended upon by user code.
category:             GHC
exposed:              True
exposed-modules:
    GHC.ForeignSrcLang.Type GHC.LanguageExtensions.Type GHC.Lexeme
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSghc-boot-th-9.2.5
depends:              base-4.16.4.0
haddock-interfaces:
haddock-html:
---
name:                 ghc-compact
version:              0.1.0.0
visibility:           public
id:                   ghc-compact-0.1.0.0
key:                  ghc-compact-0.1.0.0
license:              BSD-3-Clause
maintainer:           libraries@haskell.org
synopsis:             In memory storage of deeply evaluated data structure
description:
    This package provides minimal functionality for working with
    "compact regions", which hold a fully evaluated Haskell object graph.
    These regions maintain the invariant that no pointers live inside the struct
    that point outside it, which ensures efficient garbage collection without
    ever reading the structure contents (effectively, it works as a manually
    managed "oldest generation" which is never freed until the whole is
    released).
    Internally, the struct is stored a single contiguous block of memory,
    which allows efficient serialization and deserialization of structs
    for distributed computing.
    This package provides a low-level API; see also the </package/compact
    compact package> which provides a user-facing API.
category:             Data
exposed:              True
exposed-modules:      GHC.Compact GHC.Compact.Serialized
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSghc-compact-0.1.0.0
depends:              base-4.16.4.0 bytestring-0.11.3.1 ghc-prim-0.8.0
haddock-interfaces:
haddock-html:
---
name:                 ghc-heap
version:              9.2.5
visibility:           public
id:                   ghc-heap-9.2.5
key:                  ghc-heap-9.2.5
license:              BSD-3-Clause
maintainer:           libraries@haskell.org
synopsis:             Functions for walking GHC's heap
description:
    This package provides functions for walking the GHC heap data structures
    and retrieving information about those data structures.
category:             GHC
exposed:              True
exposed-modules:
    GHC.Exts.Heap GHC.Exts.Heap.ClosureTypes GHC.Exts.Heap.Closures
    GHC.Exts.Heap.Constants GHC.Exts.Heap.FFIClosures
    GHC.Exts.Heap.FFIClosures_ProfilingDisabled
    GHC.Exts.Heap.FFIClosures_ProfilingEnabled GHC.Exts.Heap.InfoTable
    GHC.Exts.Heap.InfoTable.Types GHC.Exts.Heap.InfoTableProf
    GHC.Exts.Heap.ProfInfo.PeekProfInfo
    GHC.Exts.Heap.ProfInfo.PeekProfInfo_ProfilingDisabled
    GHC.Exts.Heap.ProfInfo.PeekProfInfo_ProfilingEnabled
    GHC.Exts.Heap.ProfInfo.Types GHC.Exts.Heap.Utils
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSghc-heap-9.2.5
depends:              base-4.16.4.0 containers-0.6.5.1 ghc-prim-0.8.0 rts
haddock-interfaces:
haddock-html:
---
name:                 ghc-prim
version:              0.8.0
visibility:           public
id:                   ghc-prim-0.8.0
key:                  ghc-prim-0.8.0
license:              BSD-3-Clause
maintainer:           libraries@haskell.org
synopsis:             GHC primitives
description:
    This package contains the primitive types and operations supplied by GHC.
category:             GHC
exposed:              True
exposed-modules:
    GHC.CString GHC.Classes GHC.Debug GHC.Magic GHC.Prim.Exception
    GHC.Prim.Ext GHC.Prim.Panic GHC.PrimopWrappers GHC.Tuple GHC.Types
    GHC.Prim
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSghc-prim-0.8.0
extra-libraries:      c m
depends:              rts
haddock-interfaces:
haddock-html:
---
name:                 ghci
version:              9.2.5
visibility:           public
id:                   ghci-9.2.5
key:                  ghci-9.2.5
license:              BSD-3-Clause
maintainer:           ghc-devs@haskell.org
synopsis:             The library supporting GHC's interactive interpreter
description:
    This library offers interfaces which mediate interactions between the
    @ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter
    backend.
category:             GHC
exposed:              True
exposed-modules:
    GHCi.BinaryArray GHCi.BreakArray GHCi.CreateBCO GHCi.FFI
    GHCi.InfoTable GHCi.Message GHCi.ObjLink GHCi.RemoteTypes
    GHCi.ResolvedBCO GHCi.Run GHCi.Signals GHCi.StaticPtrTable GHCi.TH
    GHCi.TH.Binary
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSghci-9.2.5
depends:
    array-0.5.4.0 base-4.16.4.0 binary-0.8.9.0 bytestring-0.11.3.1
    containers-0.6.5.1 deepseq-1.4.6.1 filepath-1.4.2.2 ghc-boot-9.2.5
    ghc-heap-9.2.5 ghc-prim-0.8.0 rts template-haskell-2.18.0.0
    transformers-0.5.6.2 unix-2.7.2.2
haddock-interfaces:
haddock-html:
---
name:                 haskeline
version:              0.8.2
visibility:           public
id:                   haskeline-0.8.2
key:                  haskeline-0.8.2
license:              BSD-3-Clause
copyright:            (c) Judah Jacobson
maintainer:           Judah Jacobson <judah.jacobson@gmail.com>
author:               Judah Jacobson
stability:            Stable
homepage:             https://github.com/judah/haskeline
synopsis:
    A command-line interface for user input, written in Haskell.
description:
    Haskeline provides a user interface for line input in command-line
    programs.  This library is similar in purpose to readline, but since
    it is written in Haskell it is (hopefully) more easily used in other
    Haskell programs.
    Haskeline runs both on POSIX-compatible systems and on Windows.
category:             User Interfaces
exposed:              True
exposed-modules:
    System.Console.Haskeline System.Console.Haskeline.Completion
    System.Console.Haskeline.History System.Console.Haskeline.IO
    System.Console.Haskeline.Internal
hidden-modules:
    System.Console.Haskeline.Backend
    System.Console.Haskeline.Backend.WCWidth
    System.Console.Haskeline.Command
    System.Console.Haskeline.Command.Completion
    System.Console.Haskeline.Command.History
    System.Console.Haskeline.Command.KillRing
    System.Console.Haskeline.Directory System.Console.Haskeline.Emacs
    System.Console.Haskeline.InputT System.Console.Haskeline.Key
    System.Console.Haskeline.LineState System.Console.Haskeline.Monads
    System.Console.Haskeline.Prefs System.Console.Haskeline.Recover
    System.Console.Haskeline.RunCommand System.Console.Haskeline.Term
    System.Console.Haskeline.Command.Undo System.Console.Haskeline.Vi
    System.Console.Haskeline.Backend.Posix
    System.Console.Haskeline.Backend.Posix.Encoder
    System.Console.Haskeline.Backend.DumbTerm
    System.Console.Haskeline.Backend.Terminfo
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HShaskeline-0.8.2
depends:
    base-4.16.4.0 bytestring-0.11.3.1 containers-0.6.5.1
    directory-1.3.6.2 exceptions-0.10.4 filepath-1.4.2.2
    process-1.6.16.0 stm-2.5.0.2 terminfo-0.4.1.5 transformers-0.5.6.2
    unix-2.7.2.2
haddock-interfaces:
haddock-html:
---
name:                 hpc
version:              0.6.1.0
visibility:           public
id:                   hpc-0.6.1.0
key:                  hpc-0.6.1.0
license:              BSD-3-Clause
maintainer:           ghc-devs@haskell.org
author:               Andy Gill
synopsis:             Code Coverage Library for Haskell
description:
    This package provides the code coverage library for Haskell.
    See <http://www.haskell.org/haskellwiki/Haskell_program_coverage> for more
    information.
category:             Control
exposed:              True
exposed-modules:
    Trace.Hpc.Mix Trace.Hpc.Reflect Trace.Hpc.Tix Trace.Hpc.Util
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HShpc-0.6.1.0
depends:
    base-4.16.4.0 containers-0.6.5.1 deepseq-1.4.6.1 directory-1.3.6.2
    filepath-1.4.2.2 time-1.11.1.1
haddock-interfaces:
haddock-html:
---
name:                 integer-gmp
version:              1.1
visibility:           public
id:                   integer-gmp-1.1
key:                  integer-gmp-1.1
license:              BSD-3-Clause
maintainer:           hvr@gnu.org
author:               Herbert Valerio Riedel
synopsis:             Integer library based on GMP
description:
    This package used to provide an implementation of the standard 'Integer'
    type based on the
    <http://gmplib.org/ GNU Multiple Precision Arithmetic Library (GMP)>.
    It is now deprecated in favor of the 'ghc-bignum' package.
    Its purpose is to provide backward compatibility for codes directly
    depending on the `integer-gmp` package.
category:             Numeric, Algebra
exposed:              True
exposed-modules:      GHC.Integer.GMP.Internals
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSinteger-gmp-1.1
depends:              base-4.16.4.0 ghc-bignum-1.2 ghc-prim-0.8.0
haddock-interfaces:
haddock-html:
---
name:                 libiserv
version:              9.2.5
visibility:           public
id:                   libiserv-9.2.5
key:                  libiserv-9.2.5
license:              BSD-3-Clause
copyright:            XXX
maintainer:           XXX
author:               XXX
synopsis:
    Provides shared functionality between iserv and iserv-proxy.
description:
    Provides shared functionality between iserv and iserv-proxy.
category:             Development
exposed:              True
exposed-modules:      GHCi.Utils Lib
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSlibiserv-9.2.5
depends:
    base-4.16.4.0 binary-0.8.9.0 bytestring-0.11.3.1 containers-0.6.5.1
    deepseq-1.4.6.1 ghci-9.2.5 unix-2.7.2.2
haddock-interfaces:
haddock-html:
---
name:                 mtl
version:              2.2.2
visibility:           public
id:                   mtl-2.2.2
key:                  mtl-2.2.2
license:              BSD-3-Clause
maintainer:           Edward Kmett <ekmett@gmail.com>
author:               Andy Gill
homepage:             http://github.com/haskell/mtl
synopsis:             Monad classes, using functional dependencies
description:
    Monad classes using functional dependencies, with instances
    for various monad transformers, inspired by the paper
    /Functional Programming with Overloading and Higher-Order Polymorphism/,
    by Mark P Jones, in /Advanced School of Functional Programming/, 1995
    (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).
category:             Control
exposed:              True
exposed-modules:
    Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error
    Control.Monad.Error.Class Control.Monad.Except
    Control.Monad.Identity Control.Monad.List Control.Monad.RWS
    Control.Monad.RWS.Class Control.Monad.RWS.Lazy
    Control.Monad.RWS.Strict Control.Monad.Reader
    Control.Monad.Reader.Class Control.Monad.State
    Control.Monad.State.Class Control.Monad.State.Lazy
    Control.Monad.State.Strict Control.Monad.Trans Control.Monad.Writer
    Control.Monad.Writer.Class Control.Monad.Writer.Lazy
    Control.Monad.Writer.Strict
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSmtl-2.2.2
depends:              base-4.16.4.0 transformers-0.5.6.2
haddock-interfaces:
haddock-html:
---
name:                 parsec
version:              3.1.15.0
visibility:           public
id:                   parsec-3.1.15.0
key:                  parsec-3.1.15.0
license:              BSD-2-Clause
maintainer:
    Oleg Grenrus <oleg.grenrus@iki.fi>, Herbert Valerio Riedel <hvr@gnu.org>
author:
    Daan Leijen <daan@microsoft.com>, Paolo Martini <paolo@nemail.it>, Antoine Latter <aslatter@gmail.com>
homepage:             https://github.com/haskell/parsec
synopsis:             Monadic parser combinators
description:
    Parsec is designed from scratch as an industrial-strength parser
    library.  It is simple, safe, well documented (on the package
    homepage), has extensive libraries, good error messages,
    and is fast.  It is defined as a monad transformer that can be
    stacked on arbitrary monads, and it is also parametric in the
    input stream type.
    The main entry point is the "Text.Parsec" module which provides
    defaults for parsing 'Char'acter data.
    The "Text.ParserCombinators.Parsec" module hierarchy contains
    the legacy @parsec-2@ API and may be removed at some point in
    the future.
category:             Parsing
exposed:              True
exposed-modules:
    Text.Parsec Text.Parsec.ByteString Text.Parsec.ByteString.Lazy
    Text.Parsec.Char Text.Parsec.Combinator Text.Parsec.Error
    Text.Parsec.Expr Text.Parsec.Language Text.Parsec.Perm
    Text.Parsec.Pos Text.Parsec.Prim Text.Parsec.String
    Text.Parsec.Text Text.Parsec.Text.Lazy Text.Parsec.Token
    Text.ParserCombinators.Parsec Text.ParserCombinators.Parsec.Char
    Text.ParserCombinators.Parsec.Combinator
    Text.ParserCombinators.Parsec.Error
    Text.ParserCombinators.Parsec.Expr
    Text.ParserCombinators.Parsec.Language
    Text.ParserCombinators.Parsec.Perm
    Text.ParserCombinators.Parsec.Pos
    Text.ParserCombinators.Parsec.Prim
    Text.ParserCombinators.Parsec.Token
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSparsec-3.1.15.0
depends:
    base-4.16.4.0 bytestring-0.11.3.1 mtl-2.2.2 text-1.2.5.0
haddock-interfaces:
haddock-html:
---
name:                 pretty
version:              1.1.3.6
visibility:           public
id:                   pretty-1.1.3.6
key:                  pretty-1.1.3.6
license:              BSD-3-Clause
maintainer:           David Terei <code@davidterei.com>
stability:            Stable
homepage:             http://github.com/haskell/pretty
synopsis:             Pretty-printing library
description:
    This package contains a pretty-printing library, a set of API's
    that provides a way to easily print out text in a consistent
    format of your choosing. This is useful for compilers and related
    tools.
    This library was originally designed by John Hughes's and has since
    been heavily modified by Simon Peyton Jones.
category:             Text
exposed:              True
exposed-modules:
    Text.PrettyPrint Text.PrettyPrint.Annotated
    Text.PrettyPrint.Annotated.HughesPJ
    Text.PrettyPrint.Annotated.HughesPJClass Text.PrettyPrint.HughesPJ
    Text.PrettyPrint.HughesPJClass
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSpretty-1.1.3.6
depends:              base-4.16.4.0 deepseq-1.4.6.1 ghc-prim-0.8.0
haddock-interfaces:
haddock-html:
---
name:                 process
version:              1.6.16.0
visibility:           public
id:                   process-1.6.16.0
key:                  process-1.6.16.0
license:              BSD-3-Clause
maintainer:           libraries@haskell.org
synopsis:             Process libraries
description:
    This package contains libraries for dealing with system processes.
    The typed-process package is a more recent take on a process API,
    which uses this package internally. It features better binary
    support, easier concurrency, and a more composable API. You can
    read more about it at
    <https://github.com/fpco/typed-process/#readme>.
category:             System
exposed:              True
exposed-modules:      System.Cmd System.Process System.Process.Internals
hidden-modules:       System.Process.Common System.Process.Posix
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSprocess-1.6.16.0
include-dirs:
includes:             runProcess.h
depends:
    base-4.16.4.0 deepseq-1.4.6.1 directory-1.3.6.2 filepath-1.4.2.2
    unix-2.7.2.2
haddock-interfaces:
haddock-html:
---
name:                 stm
version:              2.5.0.2
visibility:           public
id:                   stm-2.5.0.2
key:                  stm-2.5.0.2
license:              BSD-3-Clause
maintainer:           libraries@haskell.org
homepage:             https://wiki.haskell.org/Software_transactional_memory
synopsis:             Software Transactional Memory
description:
    Software Transactional Memory, or STM, is an abstraction for
    concurrent communication. The main benefits of STM are
    /composability/ and /modularity/. That is, using STM you can write
    concurrent abstractions that can be easily composed with any other
    abstraction built using STM, without exposing the details of how
    your abstraction ensures safety. This is typically not the case
    with other forms of concurrent communication, such as locks or
    'MVar's.
category:             Concurrency
exposed:              True
exposed-modules:
    Control.Concurrent.STM Control.Concurrent.STM.TArray
    Control.Concurrent.STM.TBQueue Control.Concurrent.STM.TChan
    Control.Concurrent.STM.TMVar Control.Concurrent.STM.TQueue
    Control.Concurrent.STM.TSem Control.Concurrent.STM.TVar
    Control.Monad.STM
hidden-modules:       Control.Sequential.STM
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSstm-2.5.0.2
depends:              array-0.5.4.0 base-4.16.4.0
haddock-interfaces:
haddock-html:
---
name:                 template-haskell
version:              2.18.0.0
visibility:           public
id:                   template-haskell-2.18.0.0
key:                  template-haskell-2.18.0.0
license:              BSD-3-Clause
maintainer:           libraries@haskell.org
synopsis:             Support library for Template Haskell
description:
    This package provides modules containing facilities for manipulating
    Haskell source code using Template Haskell.
    See <http://www.haskell.org/haskellwiki/Template_Haskell> for more
    information.
category:             Template Haskell
exposed:              True
exposed-modules:
    Language.Haskell.TH Language.Haskell.TH.CodeDo
    Language.Haskell.TH.LanguageExtensions Language.Haskell.TH.Lib
    Language.Haskell.TH.Lib.Internal Language.Haskell.TH.Ppr
    Language.Haskell.TH.PprLib Language.Haskell.TH.Quote
    Language.Haskell.TH.Syntax
hidden-modules:       Language.Haskell.TH.Lib.Map
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HStemplate-haskell-2.18.0.0
depends:
    base-4.16.4.0 ghc-boot-th-9.2.5 ghc-prim-0.8.0 pretty-1.1.3.6
haddock-interfaces:
haddock-html:
---
name:                 terminfo
version:              0.4.1.5
visibility:           public
id:                   terminfo-0.4.1.5
key:                  terminfo-0.4.1.5
license:              BSD-3-Clause
copyright:            (c) Judah Jacobson
maintainer:           Judah Jacobson <judah.jacobson@gmail.com>
author:               Judah Jacobson
stability:            Stable
homepage:             https://github.com/judah/terminfo
synopsis:             Haskell bindings to the terminfo library.
description:
    This library provides an interface to the terminfo database (via bindings to the
    curses library).  <http://en.wikipedia.org/wiki/Terminfo Terminfo> allows POSIX
    systems to interact with a variety of terminals using a standard set of capabilities.
category:             User Interfaces
exposed:              True
exposed-modules:
    System.Console.Terminfo System.Console.Terminfo.Base
    System.Console.Terminfo.Color System.Console.Terminfo.Cursor
    System.Console.Terminfo.Edit System.Console.Terminfo.Effects
    System.Console.Terminfo.Keys
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSterminfo-0.4.1.5
extra-libraries:      tinfo
depends:              base-4.16.4.0
haddock-interfaces:
haddock-html:
---
name:                 text
version:              1.2.5.0
visibility:           public
id:                   text-1.2.5.0
key:                  text-1.2.5.0
license:              BSD-2-Clause
copyright:            2009-2011 Bryan O'Sullivan, 2008-2009 Tom Harper
maintainer:
    Haskell Text Team <andrew.lelechenko@gmail.com>, Core Libraries Committee
author:               Bryan O'Sullivan <bos@serpentine.com>
homepage:             https://github.com/haskell/text
synopsis:             An efficient packed Unicode text type.
description:
    An efficient packed, immutable Unicode text type (both strict and
    lazy), with a powerful loop fusion optimization framework.
    The 'Text' type represents Unicode character strings, in a time and
    space-efficient manner. This package provides text processing
    capabilities that are optimized for performance critical use, both
    in terms of large data quantities and high speed.
    The 'Text' type provides character-encoding, type-safe case
    conversion via whole-string case conversion functions (see "Data.Text").
    It also provides a range of functions for converting 'Text' values to
    and from 'ByteStrings', using several standard encodings
    (see "Data.Text.Encoding").
    Efficient locale-sensitive support for text IO is also supported
    (see "Data.Text.IO").
    These modules are intended to be imported qualified, to avoid name
    clashes with Prelude functions, e.g.
    > import qualified Data.Text as T
    == ICU Support
    To use an extended and very rich family of functions for working
    with Unicode text (including normalization, regular expressions,
    non-standard encodings, text breaking, and locales), see
    the [text-icu package](https://hackage.haskell.org/package/text-icu)
    based on the well-respected and liberally
    licensed [ICU library](http://site.icu-project.org/).
    == Internal Representation: UTF-16 vs. UTF-8
    Currently the @text@ library uses UTF-16 as its internal representation
    which is [neither a fixed-width nor always the most dense representation](http://utf8everywhere.org/)
    for Unicode text. We're currently investigating the feasibility
    of [changing Text's internal representation to UTF-8](https://github.com/text-utf8)
    and if you need such a 'Text' type right now you might be interested in using the spin-off
    packages <https://hackage.haskell.org/package/text-utf8 text-utf8> and
    <https://hackage.haskell.org/package/text-short text-short>.
category:             Data, Text
exposed:              True
exposed-modules:
    Data.Text Data.Text.Array Data.Text.Encoding
    Data.Text.Encoding.Error Data.Text.Foreign Data.Text.IO
    Data.Text.Internal Data.Text.Internal.Builder
    Data.Text.Internal.Builder.Functions
    Data.Text.Internal.Builder.Int.Digits
    Data.Text.Internal.Builder.RealFloat.Functions
    Data.Text.Internal.ByteStringCompat
    Data.Text.Internal.Encoding.Fusion
    Data.Text.Internal.Encoding.Fusion.Common
    Data.Text.Internal.Encoding.Utf16 Data.Text.Internal.Encoding.Utf32
    Data.Text.Internal.Encoding.Utf8 Data.Text.Internal.Functions
    Data.Text.Internal.Fusion Data.Text.Internal.Fusion.CaseMapping
    Data.Text.Internal.Fusion.Common Data.Text.Internal.Fusion.Size
    Data.Text.Internal.Fusion.Types Data.Text.Internal.IO
    Data.Text.Internal.Lazy Data.Text.Internal.Lazy.Encoding.Fusion
    Data.Text.Internal.Lazy.Fusion Data.Text.Internal.Lazy.Search
    Data.Text.Internal.PrimCompat Data.Text.Internal.Private
    Data.Text.Internal.Read Data.Text.Internal.Search
    Data.Text.Internal.Unsafe Data.Text.Internal.Unsafe.Char
    Data.Text.Internal.Unsafe.Shift Data.Text.Lazy
    Data.Text.Lazy.Builder Data.Text.Lazy.Builder.Int
    Data.Text.Lazy.Builder.RealFloat Data.Text.Lazy.Encoding
    Data.Text.Lazy.IO Data.Text.Lazy.Internal Data.Text.Lazy.Read
    Data.Text.Read Data.Text.Unsafe
hidden-modules:       Data.Text.Show
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HStext-1.2.5.0
depends:
    array-0.5.4.0 base-4.16.4.0 binary-0.8.9.0 bytestring-0.11.3.1
    deepseq-1.4.6.1 ghc-prim-0.8.0 template-haskell-2.18.0.0
haddock-interfaces:
haddock-html:
---
name:                 time
version:              1.11.1.1
visibility:           public
id:                   time-1.11.1.1
key:                  time-1.11.1.1
license:              BSD-3-Clause
maintainer:           <ashley@semantic.org>
author:               Ashley Yakeley
stability:            stable
homepage:             https://github.com/haskell/time
synopsis:             A time library
description:          Time, clocks and calendars
category:             Time
exposed:              True
exposed-modules:
    Data.Time Data.Time.Calendar Data.Time.Calendar.Easter
    Data.Time.Calendar.Julian Data.Time.Calendar.Month
    Data.Time.Calendar.MonthDay Data.Time.Calendar.OrdinalDate
    Data.Time.Calendar.Quarter Data.Time.Calendar.WeekDate
    Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.System
    Data.Time.Clock.TAI Data.Time.Format Data.Time.Format.ISO8601
    Data.Time.Format.Internal Data.Time.LocalTime
hidden-modules:
    Data.Format Data.Time.Calendar.Types Data.Time.Calendar.Private
    Data.Time.Calendar.Days Data.Time.Calendar.Gregorian
    Data.Time.Calendar.CalendarDiffDays Data.Time.Calendar.Week
    Data.Time.Calendar.JulianYearDay Data.Time.Clock.Internal.DiffTime
    Data.Time.Clock.Internal.AbsoluteTime
    Data.Time.Clock.Internal.NominalDiffTime
    Data.Time.Clock.Internal.POSIXTime
    Data.Time.Clock.Internal.UniversalTime
    Data.Time.Clock.Internal.SystemTime
    Data.Time.Clock.Internal.UTCTime Data.Time.Clock.Internal.CTimeval
    Data.Time.Clock.Internal.CTimespec Data.Time.Clock.Internal.UTCDiff
    Data.Time.LocalTime.Internal.TimeZone
    Data.Time.LocalTime.Internal.TimeOfDay
    Data.Time.LocalTime.Internal.CalendarDiffTime
    Data.Time.LocalTime.Internal.LocalTime
    Data.Time.LocalTime.Internal.ZonedTime Data.Time.Format.Parse
    Data.Time.Format.Locale Data.Time.Format.Format.Class
    Data.Time.Format.Format.Instances Data.Time.Format.Parse.Class
    Data.Time.Format.Parse.Instances
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HStime-1.11.1.1
include-dirs:
depends:              base-4.16.4.0 deepseq-1.4.6.1
haddock-interfaces:
haddock-html:
---
name:                 transformers
version:              0.5.6.2
visibility:           public
id:                   transformers-0.5.6.2
key:                  transformers-0.5.6.2
license:              BSD-3-Clause
maintainer:           Ross Paterson <R.Paterson@city.ac.uk>
author:               Andy Gill, Ross Paterson
synopsis:             Concrete functor and monad transformers
description:
    A portable library of functor and monad transformers, inspired by
    the paper
    * \"Functional Programming with Overloading and Higher-Order
    Polymorphism\", by Mark P Jones,
    in /Advanced School of Functional Programming/, 1995
    (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).
    This package contains:
    * the monad transformer class (in "Control.Monad.Trans.Class")
    * concrete functor and monad transformers, each with associated
    operations and functions to lift operations associated with other
    transformers.
    The package can be used on its own in portable Haskell code, in
    which case operations need to be manually lifted through transformer
    stacks (see "Control.Monad.Trans.Class" for some examples).
    Alternatively, it can be used with the non-portable monad classes in
    the @mtl@ or @monads-tf@ packages, which automatically lift operations
    introduced by monad transformers through other transformers.
category:             Control
exposed:              True
exposed-modules:
    Control.Applicative.Backwards Control.Applicative.Lift
    Control.Monad.Signatures Control.Monad.Trans.Accum
    Control.Monad.Trans.Class Control.Monad.Trans.Cont
    Control.Monad.Trans.Error Control.Monad.Trans.Except
    Control.Monad.Trans.Identity Control.Monad.Trans.List
    Control.Monad.Trans.Maybe Control.Monad.Trans.RWS
    Control.Monad.Trans.RWS.CPS Control.Monad.Trans.RWS.Lazy
    Control.Monad.Trans.RWS.Strict Control.Monad.Trans.Reader
    Control.Monad.Trans.Select Control.Monad.Trans.State
    Control.Monad.Trans.State.Lazy Control.Monad.Trans.State.Strict
    Control.Monad.Trans.Writer Control.Monad.Trans.Writer.CPS
    Control.Monad.Trans.Writer.Lazy Control.Monad.Trans.Writer.Strict
    Data.Functor.Constant Data.Functor.Reverse
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HStransformers-0.5.6.2
depends:              base-4.16.4.0
haddock-interfaces:
haddock-html:
---
name:                 unix
version:              2.7.2.2
visibility:           public
id:                   unix-2.7.2.2
key:                  unix-2.7.2.2
license:              BSD-3-Clause
maintainer:           libraries@haskell.org
homepage:             https://github.com/haskell/unix
synopsis:             POSIX functionality
description:
    This package gives you access to the set of operating system
    services standardised by
    <http://pubs.opengroup.org/onlinepubs/9699919799/ POSIX.1-2008>
    (or the IEEE Portable Operating System Interface for Computing
    Environments - IEEE Std. 1003.1).
    The package is not supported under Windows.
category:             System
exposed:              True
exposed-modules:
    System.Posix System.Posix.ByteString
    System.Posix.ByteString.FilePath System.Posix.Directory
    System.Posix.Directory.ByteString System.Posix.DynamicLinker
    System.Posix.DynamicLinker.ByteString
    System.Posix.DynamicLinker.Module
    System.Posix.DynamicLinker.Module.ByteString
    System.Posix.DynamicLinker.Prim System.Posix.Env
    System.Posix.Env.ByteString System.Posix.Error System.Posix.Fcntl
    System.Posix.Files System.Posix.Files.ByteString System.Posix.IO
    System.Posix.IO.ByteString System.Posix.Process
    System.Posix.Process.ByteString System.Posix.Process.Internals
    System.Posix.Resource System.Posix.Semaphore System.Posix.SharedMem
    System.Posix.Signals System.Posix.Signals.Exts System.Posix.Temp
    System.Posix.Temp.ByteString System.Posix.Terminal
    System.Posix.Terminal.ByteString System.Posix.Time
    System.Posix.Unistd System.Posix.User
hidden-modules:
    System.Posix.Directory.Common System.Posix.DynamicLinker.Common
    System.Posix.Files.Common System.Posix.IO.Common
    System.Posix.Process.Common System.Posix.Terminal.Common
import-dirs:
library-dirs:
dynamic-library-dirs:
data-dir:
hs-libraries:         HSunix-2.7.2.2
include-dirs:
includes:             HsUnix.h execvpe.h
depends:              base-4.16.4.0 bytestring-0.11.3.1 time-1.11.1.1
haddock-interfaces:
haddock-html:
---
name:            rts
version:         1.0.2
visibility:      public
id:              rts
key:             rts
license:         BSD-3-Clause
maintainer:      glasgow-haskell-users@haskell.org
exposed:         True
library-dirs:
hs-libraries:    HSrts
extra-libraries: m rt dl ffi numa
include-dirs:
includes:        Stg.h
ld-options:
    "-Wl,-u,base_GHCziTopHandler_runIO_closure"
    "-Wl,-u,base_GHCziTopHandler_runNonIO_closure"
    "-Wl,-u,ghczmprim_GHCziTuple_Z0T_closure"
    "-Wl,-u,ghczmprim_GHCziTypes_True_closure"
    "-Wl,-u,ghczmprim_GHCziTypes_False_closure"
    "-Wl,-u,base_GHCziPack_unpackCString_closure"
    "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure"
    "-Wl,-u,base_GHCziIOziException_stackOverflow_closure"
    "-Wl,-u,base_GHCziIOziException_heapOverflow_closure"
    "-Wl,-u,base_GHCziIOziException_allocationLimitExceeded_closure"
    "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure"
    "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure"
    "-Wl,-u,base_GHCziIOziException_cannotCompactFunction_closure"
    "-Wl,-u,base_GHCziIOziException_cannotCompactPinned_closure"
    "-Wl,-u,base_GHCziIOziException_cannotCompactMutable_closure"
    "-Wl,-u,base_GHCziIOPort_doubleReadException_closure"
    "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure"
    "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure"
    "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure"
    "-Wl,-u,base_GHCziExceptionziType_divZZeroException_closure"
    "-Wl,-u,base_GHCziExceptionziType_underflowException_closure"
    "-Wl,-u,base_GHCziExceptionziType_overflowException_closure"
    "-Wl,-u,base_GHCziConcziSync_runSparks_closure"
    "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure"
    "-Wl,-u,base_GHCziConcziIO_interruptIOManager_closure"
    "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure"
    "-Wl,-u,base_GHCziConcziSignal_runHandlersPtr_closure"
    "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure"
    "-Wl,-u,base_GHCziTopHandler_runMainIO_closure"
    "-Wl,-u,ghczmprim_GHCziTypes_Czh_con_info"
    "-Wl,-u,ghczmprim_GHCziTypes_Izh_con_info"
    "-Wl,-u,ghczmprim_GHCziTypes_Fzh_con_info"
    "-Wl,-u,ghczmprim_GHCziTypes_Dzh_con_info"
    "-Wl,-u,ghczmprim_GHCziTypes_Wzh_con_info"
    "-Wl,-u,base_GHCziPtr_Ptr_con_info"
    "-Wl,-u,base_GHCziPtr_FunPtr_con_info"
    "-Wl,-u,base_GHCziInt_I8zh_con_info"
    "-Wl,-u,base_GHCziInt_I16zh_con_info"
    "-Wl,-u,base_GHCziInt_I32zh_con_info"
    "-Wl,-u,base_GHCziInt_I64zh_con_info"
    "-Wl,-u,base_GHCziWord_W8zh_con_info"
    "-Wl,-u,base_GHCziWord_W16zh_con_info"
    "-Wl,-u,base_GHCziWord_W32zh_con_info"
    "-Wl,-u,base_GHCziWord_W64zh_con_info"
    "-Wl,-u,base_GHCziStable_StablePtr_con_info"
    "-Wl,-u,hs_atomic_add8" "-Wl,-u,hs_atomic_add16"
    "-Wl,-u,hs_atomic_add32" "-Wl,-u,hs_atomic_add64"
    "-Wl,-u,hs_atomic_sub8" "-Wl,-u,hs_atomic_sub16"
    "-Wl,-u,hs_atomic_sub32" "-Wl,-u,hs_atomic_sub64"
    "-Wl,-u,hs_atomic_and8" "-Wl,-u,hs_atomic_and16"
    "-Wl,-u,hs_atomic_and32" "-Wl,-u,hs_atomic_and64"
    "-Wl,-u,hs_atomic_nand8" "-Wl,-u,hs_atomic_nand16"
    "-Wl,-u,hs_atomic_nand32" "-Wl,-u,hs_atomic_nand64"
    "-Wl,-u,hs_atomic_or8" "-Wl,-u,hs_atomic_or16"
    "-Wl,-u,hs_atomic_or32" "-Wl,-u,hs_atomic_or64"
    "-Wl,-u,hs_atomic_xor8" "-Wl,-u,hs_atomic_xor16"
    "-Wl,-u,hs_atomic_xor32" "-Wl,-u,hs_atomic_xor64"
    "-Wl,-u,hs_cmpxchg8" "-Wl,-u,hs_cmpxchg16" "-Wl,-u,hs_cmpxchg32"
    "-Wl,-u,hs_cmpxchg64" "-Wl,-u,hs_xchg8" "-Wl,-u,hs_xchg16"
    "-Wl,-u,hs_xchg32" "-Wl,-u,hs_xchg64" "-Wl,-u,hs_atomicread8"
    "-Wl,-u,hs_atomicread16" "-Wl,-u,hs_atomicread32"
    "-Wl,-u,hs_atomicread64" "-Wl,-u,hs_atomicwrite8"
    "-Wl,-u,hs_atomicwrite16" "-Wl,-u,hs_atomicwrite32"
    "-Wl,-u,hs_atomicwrite64"
