diff options
| -rw-r--r-- | docs/users_guide/8.10.1-notes.rst | 388 | ||||
| -rw-r--r-- | docs/users_guide/8.8.1-notes.rst | 273 | ||||
| -rw-r--r-- | docs/users_guide/release-notes.rst | 2 |
3 files changed, 0 insertions, 663 deletions
diff --git a/docs/users_guide/8.10.1-notes.rst b/docs/users_guide/8.10.1-notes.rst deleted file mode 100644 index a1bf31519b..0000000000 --- a/docs/users_guide/8.10.1-notes.rst +++ /dev/null @@ -1,388 +0,0 @@ -.. _release-8-10-1: - -Version 8.10.1 -============== - -The significant changes to the various parts of the compiler are listed in the -following sections. - - -Highlights ----------- - -- The :extension:`UnliftedNewtypes` extension. - -Full details ------------- - -Language -~~~~~~~~ - -- Kind variables are no longer implicitly quantified when an explicit ``forall`` is used, see - `GHC proposal #24 - <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0024-no-kind-vars.rst>`__. - :ghc-flag:`-Wimplicit-kind-vars` is now obsolete. - -- Kind variables are no longer implicitly quantified in constructor declarations: :: - - data T a = T1 (S (a :: k)) | forall (b::k). T2 (S b) -- no longer accepted - data T (a :: k) = T1 (S (a :: k)) | forall (b::k). T2 (S b) -- still accepted - -- Implicitly quantified kind variables are no longer put in front of other variables: :: - - f :: Proxy (a :: k) -> Proxy (b :: j) - - ghci> :t +v f -- old order: - f :: forall k j (a :: k) (b :: j). Proxy a -> Proxy b - - ghci> :t +v f -- new order: - f :: forall k (a :: k) j (b :: j). Proxy a -> Proxy b - - This is a breaking change for users of :extension:`TypeApplications`. - -- In type synonyms and type family equations, free variables on the RHS are no longer - implicitly quantified unless used in an outermost kind annotation: :: - - type T = Just (Nothing :: Maybe a) -- no longer accepted - type T = Just Nothing :: Maybe (Maybe a) -- still accepted - -- A new extension :extension:`StandaloneKindSignatures` allows one to explicitly - specify the kind of a type constructor, as proposed in `GHC proposal #54 - <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0054-kind-signatures.rst>`__: :: - - type TypeRep :: forall k. k -> Type - data TypeRep a where - TyInt :: TypeRep Int - TyMaybe :: TypeRep Maybe - TyApp :: TypeRep a -> TypeRep b -> TypeRep (a b) - - Analogous to function type signatures, a :ref:`standalone kind signature - <standalone-kind-signatures>` enables polymorphic recursion. This feature is - a replacement for :extension:`CUSKs`. - -- GHC now parses visible, dependent quantifiers (as proposed in - `GHC proposal 35 - <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0035-forall-arrow.rst>`__), - such as the following: :: - - data Proxy :: forall k -> k -> Type - - See the :ref:`section on explicit kind quantification - <explicit-kind-quantification>` for more details. - -- Type variables in associated type family default declarations can now be - explicitly bound with a ``forall`` when :extension:`ExplicitForAll` is - enabled, as in the following example: :: - - class C a where - type T a b - type forall a b. T a b = Either a b - - This has a couple of knock-on consequences: - - - Wildcard patterns are now permitted on the left-hand sides of default - declarations, whereas they were rejected by previous versions of GHC. - - - It used to be the case that default declarations supported occurrences of - left-hand side arguments with higher-rank kinds, such as in the following - example: :: - - class C a where - type T a (f :: forall k. k -> Type) - type T a (f :: forall k. k -> Type) = f Int - - This will no longer work unless ``f`` is explicitly quantified with a - ``forall``, like so: :: - - class C a where - type T a (f :: forall k. k -> Type) - type forall a (f :: forall k. k -> Type). - T a f = f Int - -- A new extension :extension:`UnliftedNewtypes` that relaxes restrictions - around what kinds of types can appear inside of the data constructor - for a ``newtype``. This was proposed in - `GHC proposal #13 <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0013-unlifted-newtypes.rst>`__. - -- A new extension :extension:`ImportQualifiedPost` allows the syntax - ``import M qualified``, that is, to annotate a module as qualified by - writing ``qualified`` after the module name. - This was proposed in `GHC proposal #49 <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0049-module-qualified-syntax.rst>`__. - -- New flag :ghc-flag:`-Wderiving-defaults` that controls a warning - message when both :extension:`DeriveAnyClass` and - :extension:`GeneralizedNewtypeDeriving` are enabled and no explicit - deriving strategy is in use. The warning is enabled by default and - has been present in earlier GHC versions but without the option of - disabling it. For example, this code would trigger the warning: :: - - class C a - newtype T a = MkT a deriving C - -- GHC now performs more validity checks on inferred type signatures. One - consequence of this change is that some programs that used to be accepted - will no longer compile without enabling the required language extensions. - For example, in these two modules: :: - - {-# LANGUAGE RankNTypes #-} - module A where - - foo :: (forall a. a -> a) -> b -> b - foo f x = f x - - module B where - - import A - - bar = foo - - Notice that ``A`` enables :ghc-flag:`-XRankNTypes`, but ``B`` does not. - Previous versions of GHC would allow ``bar`` to typecheck, even though its - inferred type is higher-rank. GHC 8.10 will now reject this, as one must now - enable :ghc-flag:`-XRankNTypes` in ``B`` to accept the inferred type signature. - -- Type family dependencies (also known as injective type families) - sometimes now need ``-XUndecidableInstances`` in order to be - accepted. Here is an example:: - - type family F1 a = r | r -> a - type family F2 a = r | r -> a - type instance F2 [a] = Maybe (F1 a) - - Because GHC needs to look under a type family to see that ``a`` is determined - by the right-hand side of ``F2``\'s equation, this now needs ``-XUndecidableInstances``. - The problem is very much akin to its need to detect some functional dependencies. - -- The pattern-match coverage checker received a number of improvements wrt. - correctness and performance. - - Checking against user-defined COMPLETE pragmas - "just works" now, so that we could move away from the - `complicated procedure for disambiguation <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#disambiguating-between-multiple-complete-pragmas>`__ - we had in place before. - - Previously, the checker performed really badly on some inputs and had no - good story for graceful degradation in these situations. These situations - should occur much less frequently now and degradation happens much more - smoothly, while still producing useful, sound results (see - :ghc-flag:`-fmax-pmcheck-models=⟨n⟩`). - -Compiler -~~~~~~~~ - -- Add new flags :ghc-flag:`-Wunused-record-wildcards` and - :ghc-flag:`-Wredundant-record-wildcards` which warn users when they have - redundant or unused uses of a record wildcard match. - -- Calls to ``memset`` and ``memcpy`` are now unrolled more aggressively - and the produced code is more efficient on `x86_64` with added - support for 64-bit ``MOV``\s. In particular, ``setByteArray#`` and - ``copyByteArray#`` calls that were not optimized before, now will - be. See :ghc-ticket:`16052`. -- GHC's runtime linker no longer uses global state. This allows programs - that use the GHC API to safely use multiple GHC sessions in a single - process, as long as there are no native dependencies that rely on - global state. - -- When loading modules that use :extension:`UnboxedTuples` or - :extension:`UnboxedSums` into GHCi, it will now automatically enable - :ghc-flag:`-fobject-code` for these modules and all modules they depend on. - Before this change, attempting to load these modules into the interpreter - would just fail, and the only convenient workaround was to enable - :ghc-flag:`-fobject-code` for all modules. See the - :ref:`GHCi FAQ <ghci-faq>` for further details. - -- The eventlog now contains events for biographical and retainer profiling. - The biographical profiling events all appear at the end of the eventlog but - the sample start event contains a timestamp of when the census occurred. - The retainer profiling events are emitted using the standard events. - -- The eventlog now logs the cost centre stack on each sample. This enables - the ``.prof`` file to be partially reconstructed from the eventlog. - -- Add new flag :ghc-flag:`-fkeep-going` which makes the compiler - continue as far as it can despite errors. - -- Deprecated flag ``-fwarn-hi-shadowing`` because it was not - implemented correctly, and appears to be largely unused. This flag - will be removed in a later version of GHC. - -- Windows bindist has been updated to GCC 9.2 and binutils 2.32. These binaries have - been patched to no longer have have the MAX_PATH limit. Windows users should no longer - have any issues with long path names. - -- Introduce ``DynFlags`` plugins, that allow users to modidy the ``DynFlags`` - that GHC is going to use when processing a set of files, from plugins. - They can be used for applying tiny configuration changes, registering hooks - and much more. See the :ref:`user guide <dynflags_plugins>` for - more details as well as an example. - -- Deprecated flag ``-fmax-pmcheck-iterations`` in favor of - :ghc-flag:`-fmax-pmcheck-models=⟨n⟩`, which uses a completely different mechanism. - -- GHC now writes ``.o`` files atomically, resulting in reduced chances - of truncated files when a build is cancelled or the computer crashes. - - This fixes numerous bug reports in Stack and Cabal where GHC was not - able to recover from such situations by itself and users reported having - to clean the build directory. - - Other file types are not yet written atomically. - Users that observe related problems should report them on - `GHC issue #14533 <https://gitlab.haskell.org/ghc/ghc/issues/14533>`__. - This fix is part of the - `Stack initiative to get rid of persistent build errors due to non-atomic - file writes across the Haskell tooling ecosystem - <https://github.com/commercialhaskell/stack/issues/4559>`__. - - -GHCi -~~~~ - -- Added a command :ghci-cmd:`:instances` to show the class instances available for a type. - -- Added new debugger commands :ghci-cmd:`:disable` and :ghci-cmd:`:enable` to - disable and re-enable breakpoints. - -- Improved command name resolution with option ``!``. For example, ``:k!`` - resolves to ``:kind!``. - -Runtime system -~~~~~~~~~~~~~~ - -- The runtime system linker now marks loaded code as non-writable (see - :ghc-ticket:`14069`) on all tier-1 platforms. This is necesaary for - out-of-the-box compatibility with OpenBSD and macOS Catalina (see - :ghc-ticket:`17353`) - -- The RTS API now exposes :ref:`an interface <event_log_output_api>` to - configure ``EventLogWriters``, allowing eventlog data to fed to sinks other - than ``.eventlog`` files. - -- A new ``+RTS`` flag ``--disable-delayed-os-memory-return`` was added to make - for accurate resident memory usage of the program as shown in memory - usage reporting tools (e.g. the ``RSS`` column in ``top`` and ``htop``). - - This makes it easier to check the real memory usage of Haskell programs. - - Using this new flag is expected to make the program slightly slower. - - Without this flag, the (Linux) RTS returns unused memory "lazily" to the OS. - This has making the memory available to other processes while also allowing - the RTS to re-use the memory very efficiently (without zeroing pages) in case - it needs it again, but common tools will incorrectly show such memory as - occupied by the RTS (because they do not process the ``LazyFree`` field in - ``/proc/PID/smaps``). - -Template Haskell -~~~~~~~~~~~~~~~~ - -- The ``Lift`` typeclass is now levity-polymorphic and has a ``liftTyped`` - method. Previously disallowed instances for unboxed tuples, unboxed sums, an - primitive unboxed types have also been added. Finally, the code generated by - :extension:`DeriveLift` has been simplified to take advantage of expression - quotations. - -- Using ``TupleT 1``, ``TupE [exp]``, or ``TupP [pat]`` will now produce unary - tuples (i.e., involving the ``Unit`` type from ``GHC.Tuple``) instead of - silently dropping the parentheses. This brings Template Haskell's treatment - of boxed tuples in line with that of unboxed tuples, as ``UnboxedTupleT`, - ``UnboxedTupE``, and ``UnboxedTupP`` also produce unary unboxed tuples - (i.e., ``Unit#``) when applied to only one argument. - -- GHC's constraint solver now solves constraints in each top-level group - sooner. This has practical consequences for Template Haskell, as TH splices - necessarily separate top-level groups. For example, the following program - would compile in previous versions of GHC, but not in GHC 8.10: :: - - data T = MkT - - tStr :: String - tStr = show MkT - - $(return []) - - instance Show T where - show MkT = "MkT" - - This is because each top-level group's constraints are solved before moving - on to the next, and since the top-level group for ``tStr`` appears before the - top-level group that defines a ``Show T`` instance, GHC 8.10 will throw an - error about a missing ``Show T`` instance in the expression ``show MkT``. The - issue can be fixed by rearranging the order of declarations. For instance, - the following will compile: :: - - data T = MkT - - instance Show T where - show MkT = "MkT" - - $(return []) - - tStr :: String - tStr = show MkT - -- TH splices by default don't generate warnings anymore. For example, - ``$([d| f :: Int -> void; f x = case x of {} |])`` used to generate a - pattern-match exhaustivity warning, which now it doesn't. The user can - activate warnings for TH splices with :ghc-flag:`-fenable-th-splice-warnings`. - The reason for opt-in is that the offending code might not have been generated - by code the user has control over, for example the ``singletons`` or ``lens`` - library. - -``ghc-prim`` library -~~~~~~~~~~~~~~~~~~~~ - -- Add new ``bitReverse#`` primops that, for a ``Word`` of 8, 16, 32 or 64 bits, - reverse the order of its bits e.g. ``0b110001`` becomes ``0b100011``. - These primitives use optimized machine instructions when available. - -``ghc`` library -~~~~~~~~~~~~~~~ - -``base`` library -~~~~~~~~~~~~~~~~ - -Included libraries ------------------- - -The package database provided with this distribution also contains a number of -packages other than GHC itself. See the changelogs provided with these packages -for further change information. - -.. ghc-package-list:: - - libraries/array/array.cabal: Dependency of ``ghc`` library - libraries/base/base.cabal: Core library - libraries/binary/binary.cabal: Dependency of ``ghc`` library - libraries/bytestring/bytestring.cabal: Dependency of ``ghc`` library - libraries/Cabal/Cabal/Cabal.cabal: Dependency of ``ghc-pkg`` utility - libraries/containers/containers/containers.cabal: Dependency of ``ghc`` library - libraries/deepseq/deepseq.cabal: Dependency of ``ghc`` library - libraries/directory/directory.cabal: Dependency of ``ghc`` library - libraries/exceptions/exceptions.cabal: Dependency of ``haskeline`` library - libraries/filepath/filepath.cabal: Dependency of ``ghc`` library - compiler/ghc.cabal: The compiler itself - libraries/ghci/ghci.cabal: The REPL interface - libraries/ghc-boot/ghc-boot.cabal: Internal compiler library - libraries/ghc-boot-th/ghc-boot-th.cabal: Internal compiler library - libraries/ghc-compact/ghc-compact.cabal: Core library - libraries/ghc-heap/ghc-heap.cabal: GHC heap-walking library - libraries/ghc-prim/ghc-prim.cabal: Core library - libraries/haskeline/haskeline.cabal: Dependency of ``ghci`` executable - libraries/hpc/hpc.cabal: Dependency of ``hpc`` executable - libraries/integer-gmp/integer-gmp.cabal: Core library - libraries/libiserv/libiserv.cabal: Internal compiler library - libraries/mtl/mtl.cabal: Dependency of ``Cabal`` library - libraries/parsec/parsec.cabal: Dependency of ``Cabal`` library - libraries/pretty/pretty.cabal: Dependency of ``ghc`` library - libraries/process/process.cabal: Dependency of ``ghc`` library - libraries/stm/stm.cabal: Dependency of ``haskeline`` library - libraries/template-haskell/template-haskell.cabal: Core library - libraries/terminfo/terminfo.cabal: Dependency of ``haskeline`` library - libraries/text/text.cabal: Dependency of ``Cabal`` library - libraries/time/time.cabal: Dependency of ``ghc`` library - libraries/transformers/transformers.cabal: Dependency of ``ghc`` library - libraries/unix/unix.cabal: Dependency of ``ghc`` library - libraries/Win32/Win32.cabal: Dependency of ``ghc`` library - libraries/xhtml/xhtml.cabal: Dependency of ``haddock`` executable diff --git a/docs/users_guide/8.8.1-notes.rst b/docs/users_guide/8.8.1-notes.rst deleted file mode 100644 index 4dd7ff1b0f..0000000000 --- a/docs/users_guide/8.8.1-notes.rst +++ /dev/null @@ -1,273 +0,0 @@ -.. _release-8-8-1: - -Version 8.8.1 -============= - -The significant changes to the various parts of the compiler are listed in the -following sections. There have also been numerous bug fixes and performance -improvements over the 8.6.1 release. - - -Highlights ----------- - -The highlights, since the 8.6.1 release, are: - -- Many, many bug fixes. -- A new code layout algorithm for x86. - - -Full details ------------- - -Language -~~~~~~~~ - -- GHC now supports visible kind applications, as described in - `GHC proposal #15 <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0015-type-level-type-applications.rst>`__. This extends the existing - :ref:`visible type applications <visible-type-application>` feature to permit - type applications at the type level (e.g., ``f :: Proxy ('Just @Bool 'True)``) in - addition to the term level (e.g., ``g = Just @Bool True``). - -- GHC now allows explicitly binding type variables in type family instances and - rewrite rules, as described in - `GHC proposal #7 <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0007-instance-foralls.rst>`__. For instance: :: - - type family G a b where - forall x y. G [x] (Proxy y) = Double - forall z. G z z = Bool - {-# RULES "example" forall a. forall (x :: a). id x = x #-} - -- :extension:`ScopedTypeVariables`: The type variable that a type signature on - a pattern can bring into scope can now stand for arbitrary types. Previously, - they could only stand in for other type variables, but this restriction was deemed - unnecessary in `GHC proposal #29 <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0029-scoped-type-variables-types.rst>`__. Also see :ghc-ticket:`15050`. - -- The pattern-match coverage checker now checks for cases that are unreachable - due to constructors have strict argument types. For instance, in the - following example: :: - - data K = K1 | K2 !Void - - f :: K -> () - f K1 = () - - ``K2`` cannot be matched on in ``f``, since it is impossible to construct a - terminating value of type ``Void``. Accordingly, GHC will not warn about - ``K2`` (whereas previous versions of GHC would). - -- ``(!)`` and ``(.)`` are now valid type operators: :: - - type family a ! b - type family a . b - -- ``forall`` is now always a keyword in types to provide more helpful - error messages when ``-XExplicitForall`` is off. - -- An existential context no longer requires parenthesization: :: - - class a + b - data D1 = forall a b. (a + b) => D1 a b - data D2 = forall a b. a + b => D2 a b -- now allowed - -- ``{-# UNPACK #-}`` annotation no longer requires parenthesization: :: - - data T = MkT1 { a :: {-# UNPACK #-} (Maybe Int && Bool) } - | MkT2 { a :: {-# UNPACK #-} Maybe Int && Bool } -- now allowed - - data G where - MkG1 :: {-# UNPACK #-} (Maybe Int && Bool) -> G - MkG2 :: {-# UNPACK #-} Maybe Int && Bool -> G -- now allowed - -- The requirement that kind signatures always be parenthesized has been relaxed. - For instance, it is now permissible to write ``Proxy '(a :: A, b :: B)`` - (previous GHC versions required extra parens: ``Proxy '((a :: A), (b :: B))``). - -- :ghc-flag:`-Woverflowed-literals` checks all literals. Previously, it would - only inspect boxed expression literals. - -- :ghc-flag:`-Wempty-enumerations` now also works for ``Numeric.Natural``. - -Compiler -~~~~~~~~ - -- The final phase of the ``MonadFail`` proposal has been implemented. - Accordingly, the ``MonadFailDesugaring`` language extension is now - deprecated, as its effects are always enabled. Similarly, the - ``-Wnoncanonical-monadfail-instances`` flag is also deprecated, as there is - no longer any way to define a "non-canonical" ``Monad`` or ``MonadFail`` - instance. - -- New :ghc-flag:`-keep-hscpp-files` to keep the output of the CPP pre-processor. - -- The :ghc-flag:`-Wcompat` warning group now includes :ghc-flag:`-Wstar-is-type`. - -- New :ghc-flag:`-Wunused-packages` warning reports unused packages. - -- The :ghc-flag:`-fllvm-pass-vectors-in-regs` flag is now deprecated as vector - arguments are now passed in registers by default. - -- The :ghc-flag:`-fblock-layout-cfg` flag enables a new code layout algorithm on x86. - This is enabled by default at :ghc-flag:`-O` and :ghc-flag:`-O2`. - -- The deprecated ghc-flag ``-Wamp`` has been removed. - -- Add new :ghc-flag:`-Wmissing-deriving-strategies` flag that warns users when they are not - taking advantage of :extension:`DerivingStrategies`. The warning is supplied at each - ``deriving`` site. - -- Support for object splitting with the flag ``-split-objs`` is removed. Using - this flag now results in a warning and does nothing. Use - :ghc-flag:`-split-sections` instead. - - -Runtime system -~~~~~~~~~~~~~~ - -- Add and document new FFI functions ``hs_lock_stable_ptr_table`` - and ``hs_unlock_stable_ptr_table``. These replace the undocumented - functions ``hs_lock_stable_tables`` and ``hs_unlock_stable_tables``, - respectively. The latter should now be considered deprecated. - -- Document the heretofore undocumented FFI function - ``hs_free_stable_ptr_unsafe``, used in conjunction with manual - locking and unlocking. - -- The runtime linker on Windows has been overhauled to properly handle section - alignment, lower the amount of wasted memory and lower the amount of in use memory. - See :ghc-ticket:`13617`. Note that committed memory may be slightly higher. - -- The output filename used for :ref:`eventlog output <rts-eventlog>` can now be - specified with the :rts-flag:`-ol ⟨filename⟩` flag. - -- Add support for generating a new type of output: extended interfaces files. - Generation of these files, which sport a ``.hie`` suffix, is enabled via the - ``-fwrite-ide-info`` flag. See :ref:`hie-options` for more information. - -- A new flag ``-xp`` is added on x86_64. When it is passed, the runtime linker - can load object files compiled with ``-fPIC -fexternal-dynamic-refs`` - anywhere in the address space. This used to be restricted to the low 2Gb. - -Template Haskell -~~~~~~~~~~~~~~~~ - -- Reifying type classes no longer shows redundant class type variables and - contexts in the type signature of each class method. For instance, - reifying the following class: :: - - class C a where - method :: a - - Used to produce the following: :: - - class C a where - method :: forall a. C a => a - - Where the ``forall a. C a =>`` part is entirely redundant. This part is no - longer included when reifying ``C``. It's possible that this may break some - code which assumes the existence of ``forall a. C a =>``. - -- Template Haskell has been updated to support visible kind applications and - explicit ``foralls`` in type family instances and ``RULES``. These required - a couple of backwards-incompatible changes to the ``template-haskell`` API. - Please refer to the - `GHC 8.8 Migration Guide <https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.8#template-haskell-21500>`__ - for more details. - -- Template Haskell now supports implicit parameters and recursive do. - -- Template Haskell splices can now embed assembler source (:ghc-ticket:`16180`) - -``ghc-prim`` library -~~~~~~~~~~~~~~~~~~~~ - -- GHC now exposes a new primop, ``traceBinaryEvent#``. This primop writes - eventlog events similar to ``traceEvent#`` but allows the user to pass - the event payload as a binary blob instead of a zero-terminated - ``ByteString``. - -- The ``StableName#`` type parameter now has a phantom role instead of - a representational one. There is really no reason to care about the - type of the underlying object. - -``ghc`` library -~~~~~~~~~~~~~~~ - - -``base`` library -~~~~~~~~~~~~~~~~ - -- The final phase of the ``MonadFail`` proposal has been implemented. As a - result of this change: - - - The ``fail`` method of ``Monad`` has been removed in favor of the method of - the same name in the ``MonadFail`` class. - - - ``MonadFail(fail)`` is now re-exported from the ``Prelude`` and - ``Control.Monad`` modules. - - These are breaking changes that may require you to update your code. Please - refer to the - `GHC 8.8 Migration Guide <https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.8#base-41300>`__ - for more details. - -- Support the characters from recent versions of Unicode (up to v. 12) in literals - (see :ghc-ticket:`5518`). - -- The ``StableName`` type parameter now has a phantom role instead of - a representational one. There is really no reason to care about the - type of the underlying object. - -- The functions ``zipWith3`` and ``zip3`` in ``Prelude`` can now fuse, - together with ``zipWith4`` to ``zipWith7`` as well as their - tuple counterparts in ``Data.List``. - -Build system -~~~~~~~~~~~~ - -- Configure: Add ALEX and HAPPY variables to explicitly set the alex and happy - programs to use. -- Configure: Deprecate --with-ghc=ARG in favour of the GHC variable. - -Included libraries ------------------- - -The package database provided with this distribution also contains a number of -packages other than GHC itself. See the changelogs provided with these packages -for further change information. - -.. ghc-package-list:: - - libraries/array/array.cabal: Dependency of ``ghc`` library - libraries/base/base.cabal: Core library - libraries/binary/binary.cabal: Dependency of ``ghc`` library - libraries/bytestring/bytestring.cabal: Dependency of ``ghc`` library - libraries/Cabal/Cabal/Cabal.cabal: Dependency of ``ghc-pkg`` utility - libraries/containers/containers/containers.cabal: Dependency of ``ghc`` library - libraries/deepseq/deepseq.cabal: Dependency of ``ghc`` library - libraries/directory/directory.cabal: Dependency of ``ghc`` library - libraries/filepath/filepath.cabal: Dependency of ``ghc`` library - compiler/ghc.cabal: The compiler itself - libraries/ghci/ghci.cabal: The REPL interface - libraries/ghc-boot/ghc-boot.cabal: Internal compiler library - libraries/ghc-boot-th/ghc-boot-th.cabal: Internal compiler library - libraries/ghc-compact/ghc-compact.cabal: Core library - libraries/ghc-heap/ghc-heap.cabal: GHC heap-walking library - libraries/ghc-prim/ghc-prim.cabal: Core library - libraries/haskeline/haskeline.cabal: Dependency of ``ghci`` executable - libraries/hpc/hpc.cabal: Dependency of ``hpc`` executable - libraries/integer-gmp/integer-gmp.cabal: Core library - libraries/libiserv/libiserv.cabal: Internal compiler library - libraries/mtl/mtl.cabal: Dependency of ``Cabal`` library - libraries/parsec/parsec.cabal: Dependency of ``Cabal`` library - libraries/pretty/pretty.cabal: Dependency of ``ghc`` library - libraries/process/process.cabal: Dependency of ``ghc`` library - libraries/stm/stm.cabal: Dependency of ``haskeline`` library - libraries/template-haskell/template-haskell.cabal: Core library - libraries/terminfo/terminfo.cabal: Dependency of ``haskeline`` library - libraries/text/text.cabal: Dependency of ``Cabal`` library - libraries/time/time.cabal: Dependency of ``ghc`` library - libraries/transformers/transformers.cabal: Dependency of ``ghc`` library - libraries/unix/unix.cabal: Dependency of ``ghc`` library - libraries/Win32/Win32.cabal: Dependency of ``ghc`` library - libraries/xhtml/xhtml.cabal: Dependency of ``haddock`` executable diff --git a/docs/users_guide/release-notes.rst b/docs/users_guide/release-notes.rst index 179402e238..3fce057729 100644 --- a/docs/users_guide/release-notes.rst +++ b/docs/users_guide/release-notes.rst @@ -5,5 +5,3 @@ Release notes :maxdepth: 1 8.12.1-notes - 8.10.1-notes - 8.8.1-notes |