4ed70280eb9158d40337ab5d9d4c421001e46894
[ghc.git] / docs / users_guide / 8.4.1-notes.rst
1 .. _release-8-4-1:
2
3 Release notes for version 8.4.1
4 ===============================
5
6 The significant changes to the various parts of the compiler are listed in the
7 following sections. There have also been numerous bug fixes and performance
8 improvements over the 8.2.1 release.
9
10
11 Highlights
12 ----------
13
14 The highlights, since the 8.2.1 release, are:
15
16 -  Many, many bug fixes.
17
18 Full details
19 ------------
20
21 Language
22 ~~~~~~~~
23
24 - Data families have been generalised a bit: a data family declaration can now
25   end with a kind variable ``k`` instead of ``Type``. Additionally, data/newtype
26   instance no longer need to list all the patterns of the family if they don't
27   wish to; this is quite like how regular datatypes with a kind signature can omit
28   some type variables.
29
30 - There are now fewer restrictions regarding whether kind variables can appear
31   on the right-hand sides of type and data family instances. Before, there was
32   a strict requirements that all kind variables on the RHS had to be explicitly
33   bound by type patterns on the LHS. Now, kind variables can be *implicitly*
34   bound, which allows constructions like these: ::
35
36     data family Nat :: k -> k -> *
37     -- k is implicitly bound by an invisible kind pattern
38     newtype instance Nat :: (k -> *) -> (k -> *) -> * where
39       Nat :: (forall xx. f xx -> g xx) -> Nat f g
40
41     class Funct f where
42       type Codomain f :: *
43     instance Funct ('KProxy :: KProxy o) where
44       -- o is implicitly bound by the kind signature
45       -- of the LHS type pattern ('KProxy)
46       type Codomain 'KProxy = NatTr (Proxy :: o -> *)
47
48 - Implicitly bidirectional pattern synonyms no longer allow bang patterns
49   (``!``) or irrefutable patterns (``~``) on the right-hand side. Previously,
50   this was allowed, although the bang patterns and irrefutable patterns would
51   be silently ignored when used in an expression context. This is now a proper
52   error, and explicitly bidirectional pattern synonyms should be used in their
53   stead. That is, instead of using this (which is an error): ::
54
55       data StrictJust a = Just !a
56
57   Use this: ::
58
59       data StrictJust a <- Just !a where
60         StrictJust !a = Just a
61
62 - GADTs with kind-polymorphic type arguments now require :ghc-flag:`TypeInType`.
63   For instance, consider the following, ::
64
65       data G :: k -> * where
66         GInt   :: G Int
67         GMaybe :: G Maybe
68
69   In previous releases this would compile with :ghc-flag:`PolyKinds` alone due
70   to bug :ghc-ticket:`13391`. As of GHC 8.4, however, this requires
71   :ghc-flag:`TypeInType`. Note that since GADT kind signatures aren't generalized,
72   this will also require that you provide a :ref:`CUSK
73   <complete-kind-signatures>` by explicitly quantifying over the kind argument,
74   ``k``, ::
75
76       data G :: forall k. k -> * where
77         GInt   :: G Int
78         GMaybe :: G Maybe
79
80 - The order in which type variables are quantified in GADT constructor type
81   signatures has changed. Before, if you had ``MkT`` as below: ::
82
83       data T a where
84         MkT :: forall b a. b -> T a
85
86   Then the type of ``MkT`` would (counterintuitively) be
87   ``forall a b. b -> T a``! Now, GHC quantifies the type variables in the
88   order that the users writes them, so the type of ``MkT`` is now
89   ``forall b a. b -> T a`` (this matters for :ghc-flag:`-XTypeApplications`).
90
91 Compiler
92 ~~~~~~~~
93
94 - The ``configure`` script now no longer accepts ``--with-TOOL`` flags (e.g.
95   ``--with-nm``, ``--with-ld``, etc.). Instead, these are taken from environment
96   variables, as is typical in ``autoconf`` scripts. For instance,
97   ``./configure --with-nm=/usr/local/bin/nm`` turns into
98   ``./configure NM=/usr/local/bin/nm``.
99
100 - Derived ``Functor``, ``Foldable``, and ``Traversable`` instances are now
101   optimized when their last type parameters have phantom roles.
102   Specifically, ::
103
104     fmap _ = coerce
105     traverse _ x = pure (coerce x)
106     foldMap _ _ = mempty
107
108   These definitions of ``foldMap`` and ``traverse`` are lazier than the ones we
109   would otherwise derive, as they may produce results without inspecting their
110   arguments at all.
111
112   See also :ref:`deriving-functor`, :ref:`deriving-foldable`, and
113   :ref:`deriving-traversable`.
114
115 - Derived ``Functor``, ``Foldable``, ``Traversable``, ``Generic``, and
116   ``Generic1`` instances now have better, and generally better-documented,
117   behaviors for types with no constructors. In particular, ::
118
119       fmap _ x = case x of
120       foldMap _ _ = mempty
121       traverse _ x = pure (case x of)
122       to x = case x of
123       to1 x = case x of
124       from x = case x of
125       from1 x = case x of
126
127   The new behavior generally leads to more useful error messages than the
128   old did, and lazier semantics for ``foldMap`` and ``traverse``.
129
130 - Derived ``Foldable`` instances now derive custom definitions for ``null``
131   instead of using the default one. This leads to asymptotically better
132   performance for recursive types not shaped like cons-lists, and allows ``null``
133   to terminate for more (but not all) infinitely large structures.
134
135 - Derived instances for types with no constructors now have appropriate
136   arities: they take all their arguments before producing errors. This may not
137   be terribly important in practice, but it seems like the right thing to do.
138   Previously, we generated ::
139
140       (==) = error ...
141
142 Now we generate ::
143
144       _ == _ = error ...
145
146 - `-fsplit-sections` is now supported on x86_64 Windows and is on by default.
147   See :ghc-ticket:`12913`.
148
149 - Configure on Windows now supports ``--enable-distro-toolchain`` which can be
150   used to build a GHC using compilers on your ``PATH`` instead of using the
151   bundled bindist. See :ghc-ticket:`13792`
152
153 - The optional ``instance`` keyword is now usable in type family instance
154   declarations. See :ghc-ticket:`13747`
155
156 - Lots of other bugs. See `Trac <https://ghc.haskell.org/trac/ghc/query?status=closed&milestone=8.4.1&col=id&col=summary&col=status&col=type&col=priority&col=milestone&col=component&order=priority>`_
157   for a complete list.
158
159 Runtime system
160 ~~~~~~~~~~~~~~
161
162 - Function ``hs_add_root()`` was removed. It was a no-op since GHC-7.2.1
163   where module initialisation stopped requiring a call to ``hs_add_root()``.
164
165 - Proper import library support added to GHC which can handle all of the libraries produced
166   by ``dlltool``. The limitation of them needing to be named with the suffix .dll.a is also removed.
167   See :ghc-ticket:`13606`, :ghc-ticket:`12499`, :ghc-ticket:`12498`
168
169 - The GHCi runtime linker on Windows now supports the ``big-obj`` file format.
170
171 - The runtime system's :ref:`native stack backtrace <backtrace-signal>` support
172   on POSIX platforms is now triggered by ``SIGQUIT`` instead of ``SIGUSR2`` as
173   it was in previous releases. This change is to bring GHC's behavior into
174   compliance with the model set by the most Java virtual machine
175   implementations.
176
177 - The GHC runtime on Windows now uses Continue handlers instead of Vectorized
178   handlers to trap exceptions. This change gives other exception handlers a chance
179   to handle the exception before the runtime does. Furthermore The RTS flag
180   :rts-flag:`--install-seh-handlers=<yes|no>` Can be used on Wndows to
181   completely disable the runtime's handling of exceptions. See
182   :ghc-ticket:`13911`, :ghc-ticket:`12110`.
183
184 - The GHC runtime on Windows can now generate crash dumps on unhandled exceptions
185   using the RTS flag :rts-flag:`--generate-crash-dumps`.
186
187 - The GHCi runtime linker now avoid calling GCC to find libraries as much as possible by caching
188   the list of search directories of GCC and querying the file system directly. This results in
189   much better performance, especially on Windows.
190
191 - The GHC runtime on Windows can now generate stack traces on unhandled exceptions.
192   When running in GHCi more information is displayed about the symbols if available.
193   This behavior can be controlled with the RTS flag `--generate-stack-traces=<yes|no>`.
194
195 Template Haskell
196 ~~~~~~~~~~~~~~~~
197
198 - Template Haskell now reifies data types with GADT syntax accurately.
199   Previously, TH used heuristics to determine whether a data type
200   should be reified using GADT syntax, which could lead to incorrect results,
201   such as ``data T1 a = (a ~ Int) => MkT1`` being reified as a GADT and
202   ``data T2 a where MkT2 :: Show a => T2 a`` *not* being reified as a GADT.
203
204   In addition, reified GADT constructors now more accurately track the order in
205   which users write type variables. Before, if you reified ``MkT`` as below: ::
206
207       data T a where
208         MkT :: forall b a. b -> T a
209
210   Then the reified type signature of ``MkT`` would have been headed by
211   ``ForallC [PlainTV a, PlainTV b]``. Now, reifying ``MkT`` will give a type
212   headed by ``ForallC [PlainTV b, PlainTV a]``, as one would expect.
213
214 ``ghc`` library
215 ~~~~~~~~~~~~~~~
216
217 - hsSyn Abstract Syntax Tree (AST) is now extensible via the mechanism described in `Trees that Grow <http://www.jucs.org/jucs_23_1/trees_that_grow/jucs_23_01_0042_0062_najd.pdf>`_
218
219   The main change for users of the GHC API is that the AST is no longer indexed
220   by the type used as the identifier, but by a specific index type, ::
221
222       type GhcPs   = GhcPass 'Parsed      -- Old 'RdrName' type param
223       type GhcRn   = GhcPass 'Renamed     -- Old 'Name' type param
224       type GhcTc   = GhcPass 'Typechecked -- Old 'Id' type para,
225       type GhcTcId = GhcTc                -- Old 'TcId' type param
226
227   The simplest way to support the current GHC as well as earlier ones is to define ::
228
229       #if MIN_VERSION_ghc(8,3,0)
230       type ParseI     = GhcPs
231       type RenameI    = GhcRn
232       type TypecheckI = GhcTc
233       #else
234       type ParseI     = RdrName
235       type RenameI    = Name
236       type TypecheckI = Var
237       #endif
238
239   and then replace all hardcoded index types accordingly. For polymorphic types,
240   the constraint ::
241
242       #if MIN_VERSION_ghc(8,3,0)
243       -- |bundle up the constraints required for a trees that grow pass
244       type IsPass pass = (DataId pass, OutputableBndrId pass, SourceTextX pass)
245       else
246       type IsPass pass = (DataId pass, OutputableBndrId pass)
247       #endif
248
249   can be used.
250
251 ``base`` library
252 ~~~~~~~~~~~~~~~~
253
254 - Blank strings can now be used as values for environment variables using the
255   System.Environment.Blank module. See :ghc-ticket:`12494`
256
257 - ``Data.Type.Equality.==`` is now a closed type family. It works for all kinds
258   out of the box. Any modules that previously declared instances of this family
259   will need to remove them. Whereas the previous definition was somewhat ad
260   hoc, the behavior is now completely uniform. As a result, some applications
261   that used to reduce no longer do, and conversely. Most notably, ``(==)`` no
262   longer treats the ``*``, ``j -> k``, or ``()`` kinds specially; equality is
263   tested structurally in all cases.
264
265 Build system
266 ~~~~~~~~~~~~
267
268 - ``dll-split`` has been removed and replaced with an automatic partitioning utility ``gen-dll``.
269   This utility can transparently split and compile any DLLs that require this. Note that the ``rts`` and
270   ``base`` can not be split at this point because of the mutual recursion between ``base`` and ``rts``.
271   There is currently no explicit dependency between the two in the build system and such there is no way
272   to notify ``base`` that the ``rts`` has been split, or vice versa.
273   (see :ghc-ticket:`5987`).