.. _release-9-6-1: Version 9.6.1 ============== Language ~~~~~~~~ - Record updates for GADTs and other existential datatypes are now fully supported. For example: :: data D b where MkD :: { fld1 :: a -> a, fld2 :: a -> (), fld3 :: b } -> D b foo :: D b -> D b foo d = d { fld1 = id, fld2 = const () } In this example, we have an existential variable ``a``, and we update all fields whose type involves ``a`` at once, so the update is valid. A side-effect of this change is that GHC now rejects some record updates involving fields whose types contain type families (these record updates were previously erroneously accepted). Example: :: type family F a where F Int = Char F Float = Char data T b = MkT { x :: [Int], y :: [F b] } emptyT :: forall b. T b emptyT = MkT [] [] bar :: T Int bar = emptyT { x = [3] } In this example, we can't infer the type of ``emptyT`` in ``bar``: it could be ``T Int``, but it could also be ``T Float`` because the type family ``F`` is not injective and ``T Float ~ T Int``. Indeed, the following typechecks :: baz :: T Int baz = case ( emptyT :: T Float ) of { MkT _ y -> MkT [3] y } This means that the type of ``emptyT`` is ambiguous in the definition of ``bar`` above, and thus GHC rejects the record update: :: Couldn't match type `F b0' with `Char' Expected: [F Int] Actual: [F b0] NB: ‘F’ is a non-injective type family The type variable ‘b0’ is ambiguous To fix these issues, add a type signature to the expression that the record update is applied to (``emptyT`` in the example above), or add an injectivity annotation to the type family in the case that the type family is in fact injective. - Error messages are now assigned unique error codes, of the form ``[GHC-12345]``. - GHC Proposal `#106 `_ has been implemented, introducing a new language extension :extension:`TypeData`. This extension permits ``type data`` declarations as a more fine-grained alternative to :extension:`DataKinds`. - GHC now does a better job of solving constraints in the presence of multiple matching quantified constraints. For example, if we want to solve ``C a b Int`` and we have matching quantified constraints: :: forall x y z. (Ord x, Enum y, Num z) => C x y z forall u v. (Enum v, Eq u) => C u v Int Then GHC will use the second quantified constraint to solve ``C a b Int``, as it has a strictly weaker precondition. - GHC proposal `#170 Unrestricted OverloadedLabels `_ has been implemented. This extends the variety syntax for constructing labels under :extension:`OverloadedLabels`. Examples of newly allowed syntax: - Leading capital letters: `#Foo` equivalant to `getLabel @"Foo"` - Numeric characters: `#3.14` equivalent to `getLabel @"3.14"` - Arbitrary strings: `#"Hello, World!"` equivalent to `getLabel @"Hello, World!"` Compiler ~~~~~~~~ - The :extension:`TypeInType` is now marked as deprecated. Its meaning has been included in :extension:`PolyKinds` and :extension:`DataKinds`. - The :ghc-flag:`-Woperator-whitespace` warning no longer ignores constructor symbols (operators starting with ``:``). GHCi ~~~~ - GHCi will now accept any file-header pragmas it finds, such as ``{-# OPTIONS_GHC ... #-}`` and ``{-# LANGUAGE ... #-}`` (see :ref:`pragmas`). For example, instead of using :ghci-cmd:`:set` to enable :ghc-flag:`-Wmissing-signatures`, you could instead write: .. code-block:: none ghci> {-# OPTIONS_GHC -Wmissing-signatures #-} This can be convenient when pasting large multi-line blocks of code into GHCi. Runtime system ~~~~~~~~~~~~~~ - The `Delimited continuation primops `_ proposal has been implemented, adding native support for first-class, delimited continuations to the RTS. For the reasons given in the proposal, no safe API to access this functionality is provided anywhere in ``base``. Instead, the ``prompt#`` and ``control0#`` primops are intended to be consumed by library authors directly, who may wrap them a safe API that maintains the necessary invariants. See the documentation in ``GHC.Prim`` for more details. ``base`` library ~~~~~~~~~~~~~~~~ - Exceptions thrown by weak pointer finalizers are now caught and reported via a global exception handler. By default this handler reports the error to ``stderr`` although this can be changed using ``GHC.Weak.Finalize.setFinalizerExceptionHandler``. - GHC now provides a set of operations for introspecting on the threads of a program, ``GHC.Conc.listThreads``, as well as operations for querying a thread's label (:base-ref:`GHC.Conc.threadLabel`) and status (:base-ref:`GHC.Conc.threadStatus`). - Change default ``Ord`` implementation of ``(>=)``, ``(>)``, and ``(<)`` to use ``(<=)`` instead of ``compare`` per CLC proposal: https://github.com/haskell/core-libraries-committee/issues/24 - Updated to `Unicode 15.0.0 `_. - Add standard Unicode case predicates :base-ref:`Data.Char.isUpperCase` and :base-ref:`Data.Char.isLowerCase`. These predicates use the standard Unicode case properties and are more intuitive than :base-ref:`Data.Char.isUpper` and :base-ref:`Data.Char.isLower`. ``ghc-prim`` library ~~~~~~~~~~~~~~~~~~~~ ``ghc`` library ~~~~~~~~~~~~~~~ ``ghc-heap`` 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/Cabal/Cabal-syntax/Cabal-syntax.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 ``ghc`` and ``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