8.12.1-notes.rst 13.6 KB
Newer Older
1 2
.. _release-8-12-1:

3 4
Version 8.12.1
==============
5 6 7 8 9 10 11 12

The significant changes to the various parts of the compiler are listed in the
following sections.


Highlights
----------

Krzysztof Gogolewski's avatar
Krzysztof Gogolewski committed
13 14 15 16 17 18 19 20 21
* The :extension:`LinearTypes` extension enables linear function syntax
  ``a #-> b``, as described in the `Linear Types GHC proposal
  <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0111-linear-types.rst>`__.

  The GADT syntax can be used to define data types with linear and nonlinear fields.

  This extension is considered experimental: it doesn't implement the full proposal yet and the details
  are subject to change.

22 23 24 25 26 27 28
* NCG

  - The linear register allocator saw improvements reducing the number
    of redundant move instructions. Rare edge cases can see double
    digit improvements in runtime for inner loops.

    In the mean this improved runtime by about 0.8%. For details
29
    see ticket :ghc-ticket:`17823`.
30

31 32
* Pattern-Match Coverage Checking

33
  - The revamp of the pattern-match coverage checker that started in 8.10 concludes with this release and implements the
34
    novel `*Lower Your Guards* <https://www.microsoft.com/en-us/research/uploads/prod/2020/03/lyg.pdf>`_ algorithm.
35
  - Compared to 8.10, end users might notice improvements to "long-distance information": ::
36 37 38 39 40 41 42

      f True = 1
      f x    = ... case x of { False -> 2; True -> 3 } ...

    GHC is now able to detect the case alt returning 3 as redundant.
  - Some more performance improvements in edge cases.

43 44 45 46 47
* Windows: Use the larg address space allocator.

  This improves runtime but causes increased memory usage on Windows versions
  older than Win 8.1/Server 2012.

48 49 50 51 52 53
Full details
------------

Language
~~~~~~~~

54 55
* Record field selectors are now given type signatures that preserve the
  user-written order of quantified type variables. Moreover, field selector
56
  type signatures no longer make inferred type variables available for explicit
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
  type application. See :ref:`field-selectors-and-type-applications` for more
  details.

  In certain situations, this will constitute a breaking change as this can
  affect :extension:`TypeApplications`. For instance, given the following
  definitions: ::

    {-# LANGUAGE PolyKinds #-}

    newtype P a = MkP { unP :: Proxy a }

    newtype N :: Type -> Type -> Type where
      MkN :: forall b a. { unN :: Either a b } -> N a b

  Previous versions of GHC would give the following types to ``unP`` and
  ``unN``: ::

    unP :: forall k (a :: k). P a -> Proxy a
    unN :: forall a b. N a b -> Either a b

  GHC will now give them the following types instead: ::

    unP :: forall {k} (a :: k). P a -> Proxy a
    unN :: forall b a. N a b -> Either a b

82 83 84 85 86 87
* In obscure scenarios, GHC now rejects programs it previously accepted, but
  with unhelpful types. For example, if (with ``-XPartialTypeSignatures``) you
  were to write ``x :: forall (f :: forall a (b :: a -> Type). b _). f _``, GHC previously
  would have accepted ``x``, but its type would have involved the mysterious ``Any``
  internal type family. Now, GHC rejects, explaining the situation.

88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
* GHC now more faithfully implements the instance-lookup scheme described with
  :extension:`QuantifiedConstraints`. Previous bugs meant that programs like this
  were accepted::

    data T (c :: Type -> Constraint)
    instance (forall h. c h => Functor h) => Functor (T c)
    instance (forall h. c h => Applicative h) => Applicative (T c)

  Note that in the instance declaration for ``Applicative (T c)``, we cannot prove
  ``Functor (T c)``, because the quantified constraint shadows the global instance.
  There is an easy workaround, though: just include ``Functor (T c)`` as an assumption. ::

    instance (forall h. c h => Applicative h, Functor (T c)) => Applicative (T c)

  There is a chance we will tweak the lookup scheme in the future, to make this
  workaround unnecessary.
104

105 106 107
* GHC now consistently does eager instantiation during type inference.
  As a consequence, visible type application (VTA) now only works when
  the head of the application is:
108

109 110 111
  * A variable
  * An expression with a type signature

112 113 114 115 116
  For example ``(let x = blah in id) @Bool True`` no longer typechecks.
  You should write ``let x = blah in id @Bool True`` instead.

  This change prepares the way for `Quick Look impredicativity
  <https://gitlab.haskell.org/ghc/ghc/issues/18126>`_.
117

Simon Peyton Jones's avatar
Simon Peyton Jones committed
118
* GHC now implements simplified subsumption, as described in `GHC Proposal #287 <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0287-simplify-subsumption.rst>`__.
119
  This change simplifies the type system, and prevents the possibility of GHC
Simon Peyton Jones's avatar
Simon Peyton Jones committed
120 121 122 123 124
  silently changing the semantics of user programs, but it does mean that some libraries
  may need eta-expansion to typecheck.  More info here: :ref:`simple-subsumption`.

  This change also prepares the way for Quick Look impredicativity.

Gert-Jan Bottu's avatar
Gert-Jan Bottu committed
125 126 127 128 129 130
* GHC now allows users to manually define the specificity of type variable
  binders. By marking a variable with braces ``{tyvar}`` or ``{tyvar :: kind}``,
  it becomes inferred despite appearing in a type signature. This feature
  effectively allows users to choose which variables can or can't be
  instantiated through visible type application. More information can be found
  here: :ref:`Manually-defining-inferred-variables`.
131

132 133 134 135 136 137 138 139 140
* GADT constructor types now properly adhere to :ref:`forall-or-nothing`. As
  a result, GHC will now reject some GADT constructors that previous versions
  of GHC would accept, such as the following: ::

    data T where
      MkT1 :: (forall a. a -> b -> T)
      MkT2 :: (forall a. a -> T)

  ``MkT1`` and ``MkT2`` are rejected because the lack of an outermost
141
  ``forall`` triggers implicit quantification, making the explicit ``forall``\ s
142
  nested. Furthermore, GADT constructors do not permit the use of nested
143
  ``forall``\ s, as explained in :ref:`formal-gadt-syntax`.
144

145
  In addition to rejecting nested ``forall``\ s, GHC is now more stringent about
146 147
  rejecting uses of nested *contexts* in GADT constructors. For example, the
  following example, which previous versions of GHC would accept, is now
148
  rejected: ::
149 150 151 152

    data U a where
      MkU :: (Show a => U a)

153 154 155 156 157 158 159
Compiler
~~~~~~~~


GHCi
~~~~

160 161
- The ``:script`` command now allows for file names that contain spaces to
  passed as arguments: either by enclosing the file names in double quotes or by
162
  escaping spaces in file names with a backslash. (:ghc-ticket:`18027`)
163

164 165 166 167 168
- The GHCi debugger syntax ``:break <qualified.name>`` now allows to set
  breakpoints on all functions. The restrictions ``top-Level`` and ``exported``
  have been removed. Hence it's now possible to use this syntax to set
  breakpoints on functions defined in nested ``where`` or ``let`` clauses.

169 170 171
Runtime system
~~~~~~~~~~~~~~

172 173 174 175
- :rts-flag:`-N` without a count now tries to respect the number of processors
  in the process's affinity mask, making GHC's behavior more predictable in
  containerized settings (:ghc-ticket:`14781`).

176 177 178
- Support for Windows Vista has been dropped. GHC-compiled programs now require
  Windows 7 or later.

179 180 181 182 183 184
- Windows now uses the large address space allocator by default.
  In extreme cases we saw improvements by up to 3% decreased runtime.

  The downside is that haskell apps run on older (Pre Win-8.1/Server 2012)
  systems will have higher memory footprints.

185 186 187
Template Haskell
~~~~~~~~~~~~~~~~

188 189 190 191
- Implement the `Overloaded Quotations proposal (#246) <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0246-overloaded-bracket.rst>`_.
  The type of all quotation forms have now been generalised in terms of a
  minimal interface necessary (the ``Quote`` type class) for the
  implementation rather than the overapproximation of the ``Q`` monad.
192

193 194 195
- Template Haskell quotes now handle fixity declarations in ``let`` and
  ``where`` bindings properly. Previously, such fixity declarations would
  be dropped when quoted due to a Template Haskell bug.
196

197 198 199
- The ``-XTemplateHaskellQuotes`` extension now allows nested splices as nested
  splices do not lead directly to compile-time evaluation. (Merge request
  `!2288 <https://gitlab.haskell.org/ghc/ghc/-/merge_requests/2288>`_)
200

201 202 203
Arrow notation
~~~~~~~~~~~~~~

204 205 206
- When combined with :extension:`Arrows`, the :extension:`LambdaCase` extension
  now additionally allows ``\case`` syntax to be used as a command in ``proc``
  notation.
207

208 209 210
- When combined with :extension:`Arrows`, the effects of the
  :extension:`BlockArguments` extension now also apply to applications of
  arrow control operators in ``(|`` banana brackets ``|)``: ::
211

212 213 214
    (| untilA (increment -< x + y) do
         within 0.5 -< x
         ... |)
215

216 217 218
``ghc-prim`` library
~~~~~~~~~~~~~~~~~~~~

219 220 221
- Add a known-key ``cstringLength#`` to ``GHC.CString`` that is eligible
  for constant folding by a built-in rule.

222 223 224
``ghc`` library
~~~~~~~~~~~~~~~

225 226 227
- The type of the ``getAnnotations`` function has changed to better reflect
  the fact that it returns two different kinds of annotations, those on
  names and those on modules: ::
228

229 230 231
     getAnnotations :: Typeable a
                    => ([Word8] -> a) -> ModGuts
                    -> CoreM (ModuleEnv [a], NameEnv [a])
232

233 234 235 236 237 238
- The meaning of the ``hs_fixds`` field of ``HsGroup`` has changed slightly.
  It now only contains fixity signatures defined for top-level declarations
  and class methods defined *outside* of the class itself. Previously,
  ``hs_fixds`` would also contain fixity signatures for class methods defined
  *inside* the class, such as the fixity signature for ``m`` in the following
  example: ::
239

240 241 242
    class C a where
      infixl 4 `m`
      m :: a -> a -> a
243

244 245 246
  If you wish to attain the previous behavior of ``hs_fixds``, use the new
  ``hsGroupTopLevelFixitySigs`` function, which collects all top-level fixity
  signatures, including those for class methods defined inside classes.
247

248
- The ``Exception`` module was boiled down acknowledging the existence of
249 250
  the ``exceptions`` dependency. In particular, the ``ExceptionMonad``
  class is not a proper class anymore, but a mere synonym for ``MonadThrow``,
251 252
  ``MonadCatch``, ``MonadMask`` (all from ``exceptions``) and ``MonadIO``.
  All of ``g*``-functions from the module (``gtry``, ``gcatch``, etc.) are
253 254 255
  erased, and their ``exceptions``-alternatives are meant to be used in the
  GHC code instead.

256 257 258
``base`` library
~~~~~~~~~~~~~~~~

259 260 261 262 263 264 265 266 267
- ``ForeignPtrContents`` has a new nullary data constructor ``FinalPtr``.
  ``FinalPtr`` is intended for turning a primitive string literal into a
  ``ForeignPtr``.  Unlike ``PlainForeignPtr``, ``FinalPtr`` does not have
  a finalizer. Replacing ``PlainForeignPtr`` that has ``NoFinalizers`` with
  ``FinalPtr`` reduces allocations, reduces the size of compiled binaries,
  and unlocks important Core-to-Core optimizations. ``FinalPtr`` will be used
  in an upcoming ``bytestring`` release to improve the performance of
  ``ByteString`` literals created with ``OverloadedStrings``.

268 269 270
Build system
~~~~~~~~~~~~

271 272 273 274 275 276
Bootstrapping requirements
--------------------------

- GHC now requires a C compiler which supports
  ``__atomic_op_n`` builtins. This raises the requirement for GCC to 4.7.

277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
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
294
    libraries/exceptions/exceptions.cabal:   Dependency of ``ghc`` and ``haskeline`` library
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
    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