From dec81155e04ec0b55882b5437cd395507a1d0ba4 Mon Sep 17 00:00:00 2001 From: Travis Whitaker Date: Wed, 20 May 2020 03:29:49 +0000 Subject: [PATCH 1/2] native aarch64 support --- compiler/ghc/default.nix | 5 +- compiler/old-ghc-nix/old-ghc-nix.json | 7 +- lib/call-cabal-project-to-nix.nix | 2 + .../ghc-pkg/dump-global | 1591 +++++++++++++++++ .../ghc-8.8.3-aarch64-linux/ghc-pkg/version | 1 + .../ghc-8.8.3-aarch64-linux/ghc/info | 58 + .../ghc/numeric-version | 1 + .../ghc/supported-languages | 247 +++ nix-tools/regenerate.nix | 6 +- overlays/bootstrap.nix | 33 +- overlays/haskell.nix | 5 +- overlays/patches/Cabal/fix-data-dir.patch | 2 +- snapshots.nix | 5 +- 13 files changed, 1947 insertions(+), 16 deletions(-) create mode 100644 materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc-pkg/dump-global create mode 100644 materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc-pkg/version create mode 100644 materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/info create mode 100644 materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/numeric-version create mode 100644 materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/supported-languages diff --git a/compiler/ghc/default.nix b/compiler/ghc/default.nix index de752bdc51..68d5409809 100644 --- a/compiler/ghc/default.nix +++ b/compiler/ghc/default.nix @@ -7,7 +7,7 @@ # build-tools , bootPkgs -, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx +, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx, numactl , autoreconfHook , bash @@ -116,7 +116,8 @@ let libDeps = platform: stdenv.lib.optional enableTerminfo [ ncurses ] ++ [targetLibffi] ++ stdenv.lib.optional (!enableIntegerSimple) gmp - ++ stdenv.lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv; + ++ stdenv.lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv + ++ stdenv.lib.optional platform.isLinux numactl; toolsForTarget = if hostPlatform == buildPlatform then diff --git a/compiler/old-ghc-nix/old-ghc-nix.json b/compiler/old-ghc-nix/old-ghc-nix.json index e4088814ef..9467ec06d0 100644 --- a/compiler/old-ghc-nix/old-ghc-nix.json +++ b/compiler/old-ghc-nix/old-ghc-nix.json @@ -1,7 +1,6 @@ { - "url": "https://github.com/angerman/old-ghc-nix", - "rev": "bf640c1a3f55203bb7492a366c6492ff3c211332", - "date": "2020-02-27T19:53:36+08:00", - "sha256": "050g06911rpmvn66y5lmnszswz17flw3b979imdchc2apji6a1sm", + "url": "https://github.com/traviswhitaker/old-ghc-nix", + "rev": "0d136da6e48de6d1256c8aa2b281662e93f9e486", + "sha256": "1cp6aksb6ldgjb5zyqikyjrjij79n9z7wd86migph0wp19vmszkf", "fetchSubmodules": false } diff --git a/lib/call-cabal-project-to-nix.nix b/lib/call-cabal-project-to-nix.nix index 04a2b2049f..7fd5f4de37 100644 --- a/lib/call-cabal-project-to-nix.nix +++ b/lib/call-cabal-project-to-nix.nix @@ -266,6 +266,7 @@ let executable = true; destination = "/bin/${ghc.targetPrefix}ghc"; text = '' + #!${pkgs.buildPackages.runtimeShell} if [ "'$*'" == "'--numeric-version'" ]; then cat ${dummy-ghc-data}/ghc/numeric-version; elif [ "'$*'" == "'--supported-languages'" ]; then cat ${dummy-ghc-data}/ghc/supported-languages; elif [ "'$*'" == "'--print-global-package-db'" ]; then echo $out/dumby-db; @@ -283,6 +284,7 @@ let executable = true; destination = "/bin/${ghc.targetPrefix}ghc-pkg"; text = '' + #!${pkgs.buildPackages.runtimeShell} if [ "'$*'" == "'--version'" ]; then cat ${dummy-ghc-data}/ghc-pkg/version; elif [ "'$*'" == "'dump --global -v0'" ]; then cat ${dummy-ghc-data}/ghc-pkg/dump-global; else diff --git a/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc-pkg/dump-global b/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc-pkg/dump-global new file mode 100644 index 0000000000..fb295bb748 --- /dev/null +++ b/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc-pkg/dump-global @@ -0,0 +1,1591 @@ +name: Cabal +version: 3.0.1.0 +visibility: public +id: Cabal-3.0.1.0 +key: Cabal-3.0.1.0 +license: BSD-3-Clause +copyright: 2003-2019, Cabal Development Team (see AUTHORS file) +maintainer: cabal-devel@haskell.org +author: Cabal Development Team +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.Parsing Distribution.Compat.Prelude.Internal + Distribution.Compat.ResponseFile Distribution.Compat.Semigroup + Distribution.Compat.Stack Distribution.Compat.Time + Distribution.Compiler Distribution.FieldGrammar + Distribution.FieldGrammar.Class + Distribution.FieldGrammar.FieldDescrs + 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.Newtypes 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.Doctest + 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.Dependency Distribution.Types.DependencyMap + Distribution.Types.ExeDependency Distribution.Types.Executable + Distribution.Types.Executable.Lens + Distribution.Types.ExecutableScope Distribution.Types.ExposedModule + 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.VersionRange + Distribution.Types.VersionRange.Internal Distribution.Utils.Generic + Distribution.Utils.IOData Distribution.Utils.LogProgress + Distribution.Utils.MapAccum Distribution.Utils.NubList + Distribution.Utils.Progress Distribution.Utils.ShortText + 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.CopyFile + Distribution.Compat.GetShortPathName Distribution.Compat.MonadFail + Distribution.Compat.Prelude Distribution.Compat.SnocList + Distribution.GetOpt Distribution.Lex Distribution.Utils.String + Distribution.Simple.GHC.EnvironmentParser + Distribution.Simple.GHC.Internal Distribution.Simple.GHC.ImplInfo + Distribution.Simple.Utils.Json Paths_Cabal +import-dirs: +library-dirs: +dynamic-library-dirs: +data-dir: +hs-libraries: HSCabal-3.0.1.0 +depends: + array-0.5.4.0 base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.0 + containers-0.6.2.1 deepseq-1.4.4.0 directory-1.3.6.0 + filepath-1.4.2.1 mtl-2.2.2 parsec-3.1.14.0 pretty-1.1.3.6 + process-1.6.8.0 text-1.2.4.0 time-1.9.3 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 + , + 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.13.0.0 +haddock-interfaces: +haddock-html: +--- +name: base +version: 4.13.0.0 +visibility: public +id: base-4.13.0.0 +key: base-4.13.0.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.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.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.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.Unsafe GHC.IOArray + GHC.IORef GHC.Int GHC.List GHC.MVar GHC.Maybe GHC.Natural GHC.Num + 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.TypeNats 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.StaticPtr.Internal + System.Environment.ExecutablePath System.CPUTime.Utils + GHC.Event.Arr GHC.Event.Array GHC.Event.Control GHC.Event.EPoll + GHC.Event.IntTable GHC.Event.Internal GHC.Event.KQueue + GHC.Event.Manager GHC.Event.PSQ GHC.Event.Poll GHC.Event.Thread + GHC.Event.TimerManager GHC.Event.Unique + 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.13.0.0 +include-dirs: +includes: HsBase.h +depends: ghc-prim-0.5.3 integer-gmp-1.0.2.0 rts +haddock-interfaces: +haddock-html: +--- +name: binary +version: 0.8.7.0 +visibility: public +id: binary-0.8.7.0 +key: binary-0.8.7.0 +license: BSD-3-Clause +maintainer: Lennart Kolmodin, Don Stewart +author: Lennart Kolmodin +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.7.0 +depends: + array-0.5.4.0 base-4.13.0.0 bytestring-0.10.10.0 containers-0.6.2.1 +haddock-interfaces: +haddock-html: +--- +name: bytestring +version: 0.10.10.0 +visibility: public +id: bytestring-0.10.10.0 +key: bytestring-0.10.10.0 +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: Duncan Coutts +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 can be converted to or from a 'ByteString', but supports very few + other operations. 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.Char8 Data.ByteString.Internal Data.ByteString.Lazy + Data.ByteString.Lazy.Builder Data.ByteString.Lazy.Builder.ASCII + Data.ByteString.Lazy.Builder.Extras 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.Binary + Data.ByteString.Builder.Prim.ASCII + Data.ByteString.Builder.Prim.Internal.Floating + Data.ByteString.Builder.Prim.Internal.UncheckedShifts + Data.ByteString.Builder.Prim.Internal.Base16 +import-dirs: +library-dirs: +dynamic-library-dirs: +data-dir: +hs-libraries: HSbytestring-0.10.10.0 +include-dirs: +includes: fpstring.h +depends: + base-4.13.0.0 deepseq-1.4.4.0 ghc-prim-0.5.3 integer-gmp-1.0.2.0 +haddock-interfaces: +haddock-html: +--- +name: containers +version: 0.6.2.1 +visibility: public +id: containers-0.6.2.1 +key: containers-0.6.2.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.2.1 +depends: array-0.5.4.0 base-4.13.0.0 deepseq-1.4.4.0 +haddock-interfaces: +haddock-html: +--- +name: deepseq +version: 1.4.4.0 +visibility: public +id: deepseq-1.4.4.0 +key: deepseq-1.4.4.0 +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.4.0 +depends: array-0.5.4.0 base-4.13.0.0 +haddock-interfaces: +haddock-html: +--- +name: directory +version: 1.3.6.0 +visibility: public +id: directory-1.3.6.0 +key: directory-1.3.6.0 +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.0 +depends: + base-4.13.0.0 filepath-1.4.2.1 time-1.9.3 unix-2.7.2.2 +haddock-interfaces: +haddock-html: +--- +name: filepath +version: 1.4.2.1 +visibility: public +id: filepath-1.4.2.1 +key: filepath-1.4.2.1 +license: BSD-3-Clause +copyright: Neil Mitchell 2005-2018 +maintainer: Neil Mitchell +author: Neil Mitchell +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 and the . 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.1 +depends: base-4.13.0.0 +haddock-interfaces: +haddock-html: +--- +name: ghc +version: 8.8.3 +visibility: public +id: ghc-8.8.3 +key: ghc-8.8.3 +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. +category: Development +exposed-modules: + Annotations ApiAnnotation Ar AsmCodeGen AsmUtils Avail Bag + BasicTypes BinFingerprint BinIface Binary Bitmap BkpSyn BlockId + BlockLayout BooleanFormula BufWrite BuildTyCl ByteCodeAsm + ByteCodeGen ByteCodeInstr ByteCodeItbls ByteCodeLink ByteCodeTypes + CFG CLabel CPrim CSE CallArity CgUtils Check Class ClsInst + CmdLineParser Cmm CmmBuildInfoTables CmmCallConv CmmCommonBlockElim + CmmContFlowOpt CmmExpr CmmImplementSwitchPlans CmmInfo + CmmLayoutStack CmmLex CmmLint CmmLive CmmMachOp CmmMonad CmmNode + CmmOpt CmmParse CmmPipeline CmmProcPoint CmmSink CmmSwitch CmmType + CmmUtils CoAxiom CodeGen.Platform CodeGen.Platform.ARM + CodeGen.Platform.ARM64 CodeGen.Platform.NoRegs CodeGen.Platform.PPC + CodeGen.Platform.SPARC CodeGen.Platform.X86 CodeGen.Platform.X86_64 + CodeOutput Coercion ConLike Config Constants Convert CoreArity + CoreFVs CoreLint CoreMap CoreMonad CoreOpt CorePrep CoreSeq + CoreStats CoreSubst CoreSyn CoreTidy CoreToStg CoreUnfold CoreUtils + CostCentre CostCentreState Coverage Ctype DataCon Debug Debugger + Demand Desugar Digraph DmdAnal DriverBkp DriverMkDepend + DriverPhases DriverPipeline DsArrows DsBinds DsCCall DsExpr + DsForeign DsGRHSs DsListComp DsMeta DsMonad DsUsage DsUtils Dwarf + Dwarf.Constants Dwarf.Types DynFlags DynamicLoading Elf Encoding + EnumSet ErrUtils Exception Exitify ExtractDocs FV FamInst + FamInstEnv FastFunctions FastMutInt FastString FastStringEnv + FieldLabel FileCleanup Finder Fingerprint FiniteMap FlagChecker + FloatIn FloatOut ForeignCall Format FunDeps GHC GHCi GhcMake + GhcMonad GhcPlugins GraphBase GraphColor GraphOps GraphPpr + HaddockUtils HeaderInfo HieAst HieBin HieDebug HieTypes HieUtils + Hooks Hoopl.Block Hoopl.Collections Hoopl.Dataflow Hoopl.Graph + Hoopl.Label HsBinds HsDecls HsDoc HsDumpAst HsExpr HsExtension + HsImpExp HsInstances HsLit HsPat HsSyn HsTypes HsUtils HscMain + HscStats HscTypes IOEnv Id IdInfo IfaceEnv IfaceSyn IfaceType Inst + InstEnv Instruction InteractiveEval InteractiveEvalTypes Json Kind + KnownUniques Lexeme Lexer LiberateCase Linker ListSetOps ListT + Literal Llvm Llvm.AbsSyn Llvm.MetaData Llvm.PpLlvm Llvm.Types + LlvmCodeGen LlvmCodeGen.Base LlvmCodeGen.CodeGen LlvmCodeGen.Data + LlvmCodeGen.Ppr LlvmCodeGen.Regs LlvmMangler LoadIface Match + MatchCon MatchLit Maybes MkCore MkGraph MkId MkIface Module + MonadUtils NCGMonad Name NameCache NameEnv NameSet NameShape + OccName OccurAnal OptCoercion OrdList Outputable PIC PPC.CodeGen + PPC.Cond PPC.Instr PPC.Ppr PPC.RegInfo PPC.Regs PackageConfig + Packages Pair Panic Parser PatSyn PipelineMonad PlaceHolder + PlainPanic Platform PlatformConstants Plugins PmExpr PprBase PprC + PprCmm PprCmmDecl PprCmmExpr PprColour PprCore PprTyThing PrelInfo + PrelNames PrelRules Pretty PrimOp ProfInit RdrHsSyn RdrName Reg + RegAlloc.Graph.ArchBase RegAlloc.Graph.ArchX86 + RegAlloc.Graph.Coalesce RegAlloc.Graph.Main RegAlloc.Graph.Spill + RegAlloc.Graph.SpillClean RegAlloc.Graph.SpillCost + RegAlloc.Graph.Stats RegAlloc.Graph.TrivColorable + RegAlloc.Linear.Base RegAlloc.Linear.FreeRegs + RegAlloc.Linear.JoinToTargets RegAlloc.Linear.Main + RegAlloc.Linear.PPC.FreeRegs RegAlloc.Linear.SPARC.FreeRegs + RegAlloc.Linear.StackMap RegAlloc.Linear.State + RegAlloc.Linear.Stats RegAlloc.Linear.X86.FreeRegs + RegAlloc.Linear.X86_64.FreeRegs RegAlloc.Liveness RegClass RepType + RnBinds RnEnv RnExpr RnFixity RnHsDoc RnModIface RnNames RnPat + RnSource RnSplice RnTypes RnUnbound RnUtils RtClosureInspect Rules + SAT SMRep SPARC.AddrMode SPARC.Base SPARC.CodeGen + SPARC.CodeGen.Amode SPARC.CodeGen.Base SPARC.CodeGen.CondCode + SPARC.CodeGen.Expand SPARC.CodeGen.Gen32 SPARC.CodeGen.Gen64 + SPARC.CodeGen.Sanity SPARC.Cond SPARC.Imm SPARC.Instr SPARC.Ppr + SPARC.Regs SPARC.ShortcutJump SPARC.Stack SetLevels SimplCore + SimplEnv SimplMonad SimplStg SimplUtils Simplify SpecConstr + Specialise SrcLoc State StaticPtrTable StgCmm StgCmmArgRep + StgCmmBind StgCmmClosure StgCmmCon StgCmmEnv StgCmmExpr + StgCmmExtCode StgCmmForeign StgCmmHeap StgCmmHpc StgCmmLayout + StgCmmMonad StgCmmPrim StgCmmProf StgCmmTicky StgCmmUtils StgCse + StgFVs StgLiftLams StgLiftLams.Analysis StgLiftLams.LiftM + StgLiftLams.Transformation StgLint StgStats StgSubst StgSyn Stream + StringBuffer SysTools SysTools.BaseDir SysTools.ExtraObj + SysTools.Info SysTools.Process SysTools.Tasks SysTools.Terminal + THNames TargetReg TcAnnotations TcArrows TcBackpack TcBinds + TcCanonical TcClassDcl TcDefaults TcDeriv TcDerivInfer TcDerivUtils + TcEnv TcErrors TcEvTerm TcEvidence TcExpr TcFlatten TcForeign + TcGenDeriv TcGenFunctor TcGenGenerics TcHoleErrors TcHsSyn TcHsType + TcIface TcInstDcls TcInteract TcMType TcMatches TcPat TcPatSyn + TcPluginM TcRnDriver TcRnExports TcRnMonad TcRnTypes TcRules + TcSMonad TcSigs TcSimplify TcSplice TcTyClsDecls TcTyDecls TcType + TcTypeNats TcTypeable TcTypeableValidity TcUnify TcValidity TidyPgm + TmOracle ToIface TrieMap TyCoRep TyCon Type TysPrim TysWiredIn + UnVarGraph UnariseStg Unify UniqDFM UniqDSet UniqFM UniqMap UniqSet + UniqSupply Unique Util Var VarEnv VarSet WorkWrap WwLib X86.CodeGen + X86.Cond X86.Instr X86.Ppr X86.RegInfo X86.Regs +hidden-modules: GhcPrelude +import-dirs: +library-dirs: +dynamic-library-dirs: +data-dir: +hs-libraries: HSghc-8.8.3 +include-dirs: +depends: + array-0.5.4.0 base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.0 + containers-0.6.2.1 deepseq-1.4.4.0 directory-1.3.6.0 + filepath-1.4.2.1 ghc-boot-8.8.3 ghc-boot-th-8.8.3 ghc-heap-8.8.3 + ghci-8.8.3 hpc-0.6.0.3 integer-gmp-1.0.2.0 process-1.6.8.0 + template-haskell-2.15.0.0 terminfo-0.4.1.4 time-1.9.3 + transformers-0.5.6.2 unix-2.7.2.2 +haddock-interfaces: +haddock-html: +--- +name: ghc-boot +version: 8.8.3 +visibility: public +id: ghc-boot-8.8.3 +key: ghc-boot-8.8.3 +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.PackageDb": 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.ForeignSrcLang GHC.HandleEncoding GHC.LanguageExtensions + GHC.PackageDb GHC.Serialized +import-dirs: +library-dirs: +dynamic-library-dirs: +data-dir: +hs-libraries: HSghc-boot-8.8.3 +depends: + base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.0 directory-1.3.6.0 + filepath-1.4.2.1 ghc-boot-th-8.8.3 +haddock-interfaces: +haddock-html: +--- +name: ghc-boot-th +version: 8.8.3 +visibility: public +id: ghc-boot-th-8.8.3 +key: ghc-boot-th-8.8.3 +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-8.8.3 +depends: base-4.13.0.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. +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.13.0.0 bytestring-0.10.10.0 ghc-prim-0.5.3 +haddock-interfaces: +haddock-html: +--- +name: ghc-heap +version: 8.8.3 +visibility: public +id: ghc-heap-8.8.3 +key: ghc-heap-8.8.3 +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.InfoTable + GHC.Exts.Heap.InfoTable.Types GHC.Exts.Heap.InfoTableProf + GHC.Exts.Heap.Utils +import-dirs: +library-dirs: +dynamic-library-dirs: +data-dir: +hs-libraries: HSghc-heap-8.8.3 +depends: base-4.13.0.0 ghc-prim-0.5.3 rts +haddock-interfaces: +haddock-html: +--- +name: ghc-prim +version: 0.5.3 +visibility: public +id: ghc-prim-0.5.3 +key: ghc-prim-0.5.3 +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.IntWord64 GHC.Magic + GHC.PrimopWrappers GHC.Tuple GHC.Types GHC.Prim +import-dirs: +library-dirs: +dynamic-library-dirs: +data-dir: +hs-libraries: HSghc-prim-0.5.3 +include-dirs: +depends: rts +haddock-interfaces: +haddock-html: +--- +name: ghci +version: 8.8.3 +visibility: public +id: ghci-8.8.3 +key: ghci-8.8.3 +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 SizedSeq +import-dirs: +library-dirs: +dynamic-library-dirs: +data-dir: +hs-libraries: HSghci-8.8.3 +include-dirs: +depends: + array-0.5.4.0 base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.0 + containers-0.6.2.1 deepseq-1.4.4.0 filepath-1.4.2.1 ghc-boot-8.8.3 + ghc-boot-th-8.8.3 ghc-heap-8.8.3 template-haskell-2.15.0.0 + transformers-0.5.6.2 unix-2.7.2.2 +haddock-interfaces: +haddock-html: +--- +name: haskeline +version: 0.7.5.0 +visibility: public +id: haskeline-0.7.5.0 +key: haskeline-0.7.5.0 +license: BSD-3-Clause +copyright: (c) Judah Jacobson +maintainer: Judah Jacobson +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.MonadException +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.7.5.0 +depends: + base-4.13.0.0 bytestring-0.10.10.0 containers-0.6.2.1 + directory-1.3.6.0 filepath-1.4.2.1 process-1.6.8.0 stm-2.5.0.0 + terminfo-0.4.1.4 transformers-0.5.6.2 unix-2.7.2.2 +haddock-interfaces: +haddock-html: +--- +name: hpc +version: 0.6.0.3 +visibility: public +id: hpc-0.6.0.3 +key: hpc-0.6.0.3 +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 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.0.3 +depends: + base-4.13.0.0 containers-0.6.2.1 directory-1.3.6.0 filepath-1.4.2.1 + time-1.9.3 +haddock-interfaces: +haddock-html: +--- +name: integer-gmp +version: 1.0.2.0 +visibility: public +id: integer-gmp-1.0.2.0 +key: integer-gmp-1.0.2.0 +license: BSD-3-Clause +maintainer: hvr@gnu.org +author: Herbert Valerio Riedel +synopsis: Integer library based on GMP +description: + This package provides the low-level implementation of the standard + 'Integer' type based on the + . + This package provides access to the internal representation of + 'Integer' as well as primitive operations with no proper error + handling, and should only be used directly with the utmost care. +category: Numeric, Algebra +exposed: True +exposed-modules: + GHC.Integer GHC.Integer.GMP.Internals GHC.Integer.Logarithms + GHC.Integer.Logarithms.Internals +hidden-modules: GHC.Integer.Type +import-dirs: +library-dirs: +dynamic-library-dirs: +data-dir: +hs-libraries: HSinteger-gmp-1.0.2.0 +extra-libraries: gmp +include-dirs: +depends: ghc-prim-0.5.3 +haddock-interfaces: +haddock-html: +--- +name: libiserv +version: 8.8.3 +visibility: public +id: libiserv-8.8.3 +key: libiserv-8.8.3 +license: BSD-3-Clause +copyright: XXX +maintainer: XXX +author: XXX +synopsis: 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-8.8.3 +depends: + base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.0 + containers-0.6.2.1 deepseq-1.4.4.0 ghci-8.8.3 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 +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 + (). +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.13.0.0 transformers-0.5.6.2 +haddock-interfaces: +haddock-html: +--- +name: parsec +version: 3.1.14.0 +visibility: public +id: parsec-3.1.14.0 +key: parsec-3.1.14.0 +license: BSD-3-Clause +maintainer: Herbert Valerio Riedel +author: + Daan Leijen , Paolo Martini , Antoine Latter +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.14.0 +depends: + base-4.13.0.0 bytestring-0.10.10.0 mtl-2.2.2 text-1.2.4.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 +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.13.0.0 deepseq-1.4.4.0 ghc-prim-0.5.3 +haddock-interfaces: +haddock-html: +--- +name: process +version: 1.6.8.0 +visibility: public +id: process-1.6.8.0 +key: process-1.6.8.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 + . +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.8.0 +include-dirs: +includes: runProcess.h +depends: + base-4.13.0.0 deepseq-1.4.4.0 directory-1.3.6.0 filepath-1.4.2.1 + unix-2.7.2.2 +haddock-interfaces: +haddock-html: +--- +name: stm +version: 2.5.0.0 +visibility: public +id: stm-2.5.0.0 +key: stm-2.5.0.0 +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.0 +depends: array-0.5.4.0 base-4.13.0.0 +haddock-interfaces: +haddock-html: +--- +name: template-haskell +version: 2.15.0.0 +visibility: public +id: template-haskell-2.15.0.0 +key: template-haskell-2.15.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 for more + information. +category: Template Haskell +exposed: True +exposed-modules: + Language.Haskell.TH 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.15.0.0 +depends: base-4.13.0.0 ghc-boot-th-8.8.3 pretty-1.1.3.6 +haddock-interfaces: +haddock-html: +--- +name: terminfo +version: 0.4.1.4 +visibility: public +id: terminfo-0.4.1.4 +key: terminfo-0.4.1.4 +license: BSD-3-Clause +copyright: (c) Judah Jacobson +maintainer: Judah Jacobson +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). 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.4 +extra-libraries: tinfo +depends: base-4.13.0.0 +haddock-interfaces: +haddock-html: +--- +name: text +version: 1.2.4.0 +visibility: public +id: text-1.2.4.0 +key: text-1.2.4.0 +license: BSD-2-Clause +copyright: 2009-2011 Bryan O'Sullivan, 2008-2009 Tom Harper +maintainer: + Bryan O'Sullivan , Herbert Valerio Riedel +author: Bryan O'Sullivan +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 and + . +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.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.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.4.0 +depends: + array-0.5.4.0 base-4.13.0.0 binary-0.8.7.0 bytestring-0.10.10.0 + deepseq-1.4.4.0 ghc-prim-0.5.3 integer-gmp-1.0.2.0 + template-haskell-2.15.0.0 +haddock-interfaces: +haddock-html: +--- +name: time +version: 1.9.3 +visibility: public +id: time-1.9.3 +key: time-1.9.3 +license: BSD-3-Clause +maintainer: +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.MonthDay + Data.Time.Calendar.OrdinalDate 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.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.9.3 +include-dirs: +depends: base-4.13.0.0 deepseq-1.4.4.0 +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 +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 + (). + 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.13.0.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 + + (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 +extra-libraries: rt util dl pthread +include-dirs: +includes: HsUnix.h execvpe.h +depends: base-4.13.0.0 bytestring-0.10.10.0 time-1.9.3 +haddock-interfaces: +haddock-html: +--- +name: xhtml +version: 3000.2.2.1 +visibility: public +id: xhtml-3000.2.2.1 +key: xhtml-3000.2.2.1 +license: BSD-3-Clause +copyright: + Bjorn Bringert 2004-2006, Andy Gill and the Oregon + Graduate Institute of Science and Technology, 1999-2001 +maintainer: Chris Dornan +author: Bjorn Bringert +stability: Stable +homepage: https://github.com/haskell/xhtml +synopsis: An XHTML combinator library +description: + This package provides combinators for producing + XHTML 1.0, including the Strict, Transitional and + Frameset variants. +category: Web, XML, Pretty Printer +exposed: True +exposed-modules: + Text.XHtml Text.XHtml.Debug Text.XHtml.Frameset Text.XHtml.Strict + Text.XHtml.Table Text.XHtml.Transitional +hidden-modules: + Text.XHtml.Strict.Attributes Text.XHtml.Strict.Elements + Text.XHtml.Frameset.Attributes Text.XHtml.Frameset.Elements + Text.XHtml.Transitional.Attributes Text.XHtml.Transitional.Elements + Text.XHtml.BlockTable Text.XHtml.Extras Text.XHtml.Internals +import-dirs: +library-dirs: +dynamic-library-dirs: +data-dir: +hs-libraries: HSxhtml-3000.2.2.1 +depends: base-4.13.0.0 +haddock-interfaces: +haddock-html: +--- +name: rts +version: 1.0 +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 pthread +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_ControlziExceptionziBase_absentSumFieldError_closure" + "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure" + "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure" + "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure" + "-Wl,-u,base_GHCziConcziSync_runSparks_closure" + "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_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_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" diff --git a/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc-pkg/version b/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc-pkg/version new file mode 100644 index 0000000000..17d542dbee --- /dev/null +++ b/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc-pkg/version @@ -0,0 +1 @@ +GHC package manager version 8.8.3 diff --git a/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/info b/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/info new file mode 100644 index 0000000000..f5e3a27135 --- /dev/null +++ b/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/info @@ -0,0 +1,58 @@ + [("Project name","The Glorious Glasgow Haskell Compilation System") + ,("GCC extra via C opts"," -fwrapv -fno-builtin") + ,("C compiler flags","") + ,("C compiler link flags"," -Wl,-z,noexecstack") + ,("C compiler supports -no-pie","YES") + ,("Haskell CPP flags","-E -undef -traditional") + ,("ld flags"," -z noexecstack") + ,("ld supports compact unwind","YES") + ,("ld supports build-id","YES") + ,("ld supports filelist","NO") + ,("ld is GNU ld","YES") + ,("ar command","ar") + ,("ar flags","q") + ,("ar supports at file","YES") + ,("touch command","touch") + ,("dllwrap command","/bin/false") + ,("windres command","/bin/false") + ,("libtool command","libtool") + ,("cross compiling","NO") + ,("target os","OSLinux") + ,("target arch","ArchARM64") + ,("target word size","8") + ,("target has GNU nonexec stack","True") + ,("target has .ident directive","True") + ,("target has subsections via symbols","False") + ,("target has RTS linker","YES") + ,("Unregisterised","NO") + ,("LLVM llc command","llc") + ,("LLVM opt command","opt") + ,("LLVM clang command","clang") + ,("Project version","8.8.3") + ,("Project Git commit id","d0bab2e3419e49cdbb1201d4650572b57f33420c") + ,("Booter version","8.8.2") + ,("Stage","2") + ,("Build platform","aarch64-unknown-linux") + ,("Host platform","aarch64-unknown-linux") + ,("Target platform","aarch64-unknown-linux") + ,("Have interpreter","YES") + ,("Object splitting supported","NO") + ,("Have native code generator","NO") + ,("Support SMP","YES") + ,("Tables next to code","YES") + ,("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") + ,("RTS expects libdw","NO") + ,("Support dynamic-too","YES") + ,("Support parallel --make","YES") + ,("Support reexported-modules","YES") + ,("Support thinning and renaming package flags","YES") + ,("Support Backpack","YES") + ,("Requires unified installed package IDs","YES") + ,("Uses package keys","YES") + ,("Uses unit IDs","YES") + ,("Dynamic by default","NO") + ,("GHC Dynamic","YES") + ,("GHC Profiled","NO") + ,("Leading underscore","NO") + ,("Debug on","False") + ] diff --git a/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/numeric-version b/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/numeric-version new file mode 100644 index 0000000000..ce7520b2ac --- /dev/null +++ b/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/numeric-version @@ -0,0 +1 @@ +8.8.3 diff --git a/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/supported-languages b/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/supported-languages new file mode 100644 index 0000000000..50a0383159 --- /dev/null +++ b/materialized/dummy-ghc/ghc-8.8.3-aarch64-linux/ghc/supported-languages @@ -0,0 +1,247 @@ +Haskell98 +Haskell2010 +Unsafe +Trustworthy +Safe +AllowAmbiguousTypes +NoAllowAmbiguousTypes +AlternativeLayoutRule +NoAlternativeLayoutRule +AlternativeLayoutRuleTransitional +NoAlternativeLayoutRuleTransitional +Arrows +NoArrows +AutoDeriveTypeable +NoAutoDeriveTypeable +BangPatterns +NoBangPatterns +BinaryLiterals +NoBinaryLiterals +CApiFFI +NoCApiFFI +CPP +NoCPP +ConstrainedClassMethods +NoConstrainedClassMethods +ConstraintKinds +NoConstraintKinds +DataKinds +NoDataKinds +DatatypeContexts +NoDatatypeContexts +DefaultSignatures +NoDefaultSignatures +DeriveAnyClass +NoDeriveAnyClass +DeriveDataTypeable +NoDeriveDataTypeable +DeriveFoldable +NoDeriveFoldable +DeriveFunctor +NoDeriveFunctor +DeriveGeneric +NoDeriveGeneric +DeriveLift +NoDeriveLift +DeriveTraversable +NoDeriveTraversable +DerivingStrategies +NoDerivingStrategies +DerivingVia +NoDerivingVia +DisambiguateRecordFields +NoDisambiguateRecordFields +DoAndIfThenElse +NoDoAndIfThenElse +BlockArguments +NoBlockArguments +DoRec +NoDoRec +DuplicateRecordFields +NoDuplicateRecordFields +EmptyCase +NoEmptyCase +EmptyDataDecls +NoEmptyDataDecls +EmptyDataDeriving +NoEmptyDataDeriving +ExistentialQuantification +NoExistentialQuantification +ExplicitForAll +NoExplicitForAll +ExplicitNamespaces +NoExplicitNamespaces +ExtendedDefaultRules +NoExtendedDefaultRules +FlexibleContexts +NoFlexibleContexts +FlexibleInstances +NoFlexibleInstances +ForeignFunctionInterface +NoForeignFunctionInterface +FunctionalDependencies +NoFunctionalDependencies +GADTSyntax +NoGADTSyntax +GADTs +NoGADTs +GHCForeignImportPrim +NoGHCForeignImportPrim +GeneralizedNewtypeDeriving +NoGeneralizedNewtypeDeriving +GeneralisedNewtypeDeriving +NoGeneralisedNewtypeDeriving +ImplicitParams +NoImplicitParams +ImplicitPrelude +NoImplicitPrelude +ImpredicativeTypes +NoImpredicativeTypes +IncoherentInstances +NoIncoherentInstances +TypeFamilyDependencies +NoTypeFamilyDependencies +InstanceSigs +NoInstanceSigs +ApplicativeDo +NoApplicativeDo +InterruptibleFFI +NoInterruptibleFFI +JavaScriptFFI +NoJavaScriptFFI +KindSignatures +NoKindSignatures +LambdaCase +NoLambdaCase +LiberalTypeSynonyms +NoLiberalTypeSynonyms +MagicHash +NoMagicHash +MonadComprehensions +NoMonadComprehensions +MonadFailDesugaring +NoMonadFailDesugaring +MonoLocalBinds +NoMonoLocalBinds +MonoPatBinds +NoMonoPatBinds +MonomorphismRestriction +NoMonomorphismRestriction +MultiParamTypeClasses +NoMultiParamTypeClasses +MultiWayIf +NoMultiWayIf +NumericUnderscores +NoNumericUnderscores +NPlusKPatterns +NoNPlusKPatterns +NamedFieldPuns +NoNamedFieldPuns +NamedWildCards +NoNamedWildCards +NegativeLiterals +NoNegativeLiterals +HexFloatLiterals +NoHexFloatLiterals +NondecreasingIndentation +NoNondecreasingIndentation +NullaryTypeClasses +NoNullaryTypeClasses +NumDecimals +NoNumDecimals +OverlappingInstances +NoOverlappingInstances +OverloadedLabels +NoOverloadedLabels +OverloadedLists +NoOverloadedLists +OverloadedStrings +NoOverloadedStrings +PackageImports +NoPackageImports +ParallelArrays +NoParallelArrays +ParallelListComp +NoParallelListComp +PartialTypeSignatures +NoPartialTypeSignatures +PatternGuards +NoPatternGuards +PatternSignatures +NoPatternSignatures +PatternSynonyms +NoPatternSynonyms +PolyKinds +NoPolyKinds +PolymorphicComponents +NoPolymorphicComponents +QuantifiedConstraints +NoQuantifiedConstraints +PostfixOperators +NoPostfixOperators +QuasiQuotes +NoQuasiQuotes +Rank2Types +NoRank2Types +RankNTypes +NoRankNTypes +RebindableSyntax +NoRebindableSyntax +RecordPuns +NoRecordPuns +RecordWildCards +NoRecordWildCards +RecursiveDo +NoRecursiveDo +RelaxedLayout +NoRelaxedLayout +RelaxedPolyRec +NoRelaxedPolyRec +RoleAnnotations +NoRoleAnnotations +ScopedTypeVariables +NoScopedTypeVariables +StandaloneDeriving +NoStandaloneDeriving +StarIsType +NoStarIsType +StaticPointers +NoStaticPointers +Strict +NoStrict +StrictData +NoStrictData +TemplateHaskell +NoTemplateHaskell +TemplateHaskellQuotes +NoTemplateHaskellQuotes +TraditionalRecordSyntax +NoTraditionalRecordSyntax +TransformListComp +NoTransformListComp +TupleSections +NoTupleSections +TypeApplications +NoTypeApplications +TypeInType +NoTypeInType +TypeFamilies +NoTypeFamilies +TypeOperators +NoTypeOperators +TypeSynonymInstances +NoTypeSynonymInstances +UnboxedTuples +NoUnboxedTuples +UnboxedSums +NoUnboxedSums +UndecidableInstances +NoUndecidableInstances +UndecidableSuperClasses +NoUndecidableSuperClasses +UnicodeSyntax +NoUnicodeSyntax +UnliftedFFITypes +NoUnliftedFFITypes +ViewPatterns +NoViewPatterns diff --git a/nix-tools/regenerate.nix b/nix-tools/regenerate.nix index 231b92ed9e..58a868ff5c 100644 --- a/nix-tools/regenerate.nix +++ b/nix-tools/regenerate.nix @@ -54,7 +54,11 @@ in # "stm" "terminfo" ]; }]; - }).nix-tools.components.exes.plan-to-nix; in + }).nix-tools.components.exes.plan-to-nix; + bootstrap = if pkgs.targetPlatform.isAarch64 + then haskell-nix.bootstrap.compiler.ghc882 + else haskell-nix.bootstrap.compiler.ghc844; + in with builtins; with stdenv.lib; writeShellScriptBin "update-nix-tools" '' diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index 971f9e423e..fcea2cb721 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -28,12 +28,30 @@ let fi done ''; + # For each architecture, we need to know two (somewhat ad-hoc) things: + # - What GHC version we should use for bootstrapping. + # - What Happy version we should use for bootstrapping. + buildBootstrapper = + if final.targetPlatform.isAarch64 + then { + ghc = final.buildPackages.haskell-nix.bootstrap.compiler.ghc882; + happyVersion = "1.19.12"; + } + else { + ghc = final.buildPackages.haskell-nix.bootstrap.compiler.ghc844; + happyVersion = "1.19.11"; + }; + # For buildPackages.buildPackages, we just care about the GHC version: + buildBuildBootstrapper = + if final.targetPlatform.isAarch64 + then final.buildPackages.buildPackages.haskell-nix.bootstrap.compiler.ghc882 + else final.buildPackages.buildPackages.haskell-nix.bootstrap.compiler.ghc844; in { haskell-nix = prev.haskell-nix // { # Use this to disable the existing haskell infra structure for testing purposes compiler = let bootPkgs = with final.buildPackages; { - ghc = buildPackages.haskell-nix.bootstrap.compiler.ghc844; + ghc = buildBuildBootstrapper; alex = final.haskell-nix.bootstrap.packages.alex-tool { checkMaterialization = false; }; @@ -320,7 +338,11 @@ in { '' + installDeps targetPrefix); }))); - defaultCompilerNixName = "ghc865"; + # Need to use something from 8.8.x as the default on aarch64: + defaultCompilerNixName = + if final.targetPlatform.isAarch64 + then "ghc883" + else "ghc865"; ghc = final.haskell-nix.compiler."${final.haskell-nix.defaultCompilerNixName}"; # Both `cabal-install` and `nix-tools` are needed for `cabalProject` # to check materialized results. We need to take care that when @@ -404,7 +426,7 @@ in { } // args); alex = final.buildPackages.haskell-nix.alex-tool {}; happy-tool = args: final.haskell-nix.tool "happy" ({ - version = "1.19.12"; + version = buildBootstrapper.happyVersion; index-state = final.haskell-nix.internalHackageIndexState; materialized = ../materialized + "/${ args.compiler-nix-name or final.haskell-nix.defaultCompilerNixName @@ -438,7 +460,7 @@ in { # the bootstrap infra structure (pre-compiled ghc; bootstrapped cabal-install, ...) - bootstrap = with final.haskell-nix; let ghc = final.buildPackages.haskell-nix.bootstrap.compiler.ghc844; in { + bootstrap = with final.haskell-nix; let ghc = buildBootstrapper.ghc; in { # XXX: import ../. will throw away all other overlays, config values, ... # this is not ideal! # get binary compilers for bootstrapping. We'll put the eventual proper @@ -474,9 +496,10 @@ in { } // args); alex = bootstrap.packages.alex-tool {}; happy-tool = args: tool "happy" ({ - version = "1.19.11"; + version = buildBootstrapper.happyVersion; # Only a boot compiler is suitable here ghcOverride = ghc // { isHaskellNixCompiler = ghc.isHaskellNixBootCompiler; }; + inherit (bootstrap.packages) cabal-install nix-tools hpack; index-state = final.haskell-nix.internalHackageIndexState; materialized = ../materialized/bootstrap/happy; } // args); diff --git a/overlays/haskell.nix b/overlays/haskell.nix index c267163669..9f683644da 100644 --- a/overlays/haskell.nix +++ b/overlays/haskell.nix @@ -172,7 +172,10 @@ final: prev: { # Package sets for all stackage snapshots. snapshots = import ../snapshots.nix { inherit (final) lib ghc-boot-packages; inherit mkPkgSet stackage excludeBootPackages; }; # Pick a recent LTS snapshot to be our "default" package set. - haskellPackages = snapshots."lts-14.13"; + haskellPackages = + if final.targetPlatform.isAarch64 + then snapshots."lts-15.13" + else snapshots."lts-14.13"; # Produce a fixed output derivation from a moving target (hackage index tarball) # Takes desired index-state and sha256 and produces a set { name, index }, where diff --git a/overlays/patches/Cabal/fix-data-dir.patch b/overlays/patches/Cabal/fix-data-dir.patch index 45fef75b1b..2579c5385a 100644 --- a/overlays/patches/Cabal/fix-data-dir.patch +++ b/overlays/patches/Cabal/fix-data-dir.patch @@ -17,4 +17,4 @@ index f6a203874..2aa406f74 100644 + InstallDirs { bindir = flat_bindirrel, - libdir = flat_libdirrel, \ No newline at end of file + libdir = flat_libdirrel, diff --git a/snapshots.nix b/snapshots.nix index c66f2d5ddf..bf687e39be 100644 --- a/snapshots.nix +++ b/snapshots.nix @@ -19,10 +19,11 @@ let ++ [(hackage: ghc-boot-packages.${(pkg-def hackage).compiler.nix-name})]; modules = [ { reinstallableLibGhc = true; } # Allow ghc library to be installed for packages that need it - { packages.Cabal.patches = [ ./overlays/patches/Cabal/fix-data-dir.patch ]; } { packages.alex.package.setup-depends = [pkgSet.config.hsPkgs.Cabal]; } { packages.happy.package.setup-depends = [pkgSet.config.hsPkgs.Cabal]; } - ]; + ] ++ optional (ltsInRange "1" "15" name) { + packages.Cabal.patches = [ ./overlays/patches/Cabal/fix-data-dir.patch ]; + }; }; in pkgSet).config.hsPkgs; # Tests whether snapshot name is an LTS within From 40397a38f61c35c575743ca6664d68fa780954ae Mon Sep 17 00:00:00 2001 From: Moritz Angermann Date: Wed, 3 Jun 2020 12:53:51 +0800 Subject: [PATCH 2/2] Update old-ghc-nix.json reduce external dependencies --- compiler/old-ghc-nix/old-ghc-nix.json | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/compiler/old-ghc-nix/old-ghc-nix.json b/compiler/old-ghc-nix/old-ghc-nix.json index 9467ec06d0..ac31221f58 100644 --- a/compiler/old-ghc-nix/old-ghc-nix.json +++ b/compiler/old-ghc-nix/old-ghc-nix.json @@ -1,6 +1,7 @@ { - "url": "https://github.com/traviswhitaker/old-ghc-nix", - "rev": "0d136da6e48de6d1256c8aa2b281662e93f9e486", + "url": "https://github.com/angerman/old-ghc-nix", + "rev": "2a41a09127f6dc7a6384823d1acd51ba257f95bd", + "date": "2020-06-03T12:50:09+08:00", "sha256": "1cp6aksb6ldgjb5zyqikyjrjij79n9z7wd86migph0wp19vmszkf", "fetchSubmodules": false }