1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
.. _release-8-10-1:
Release notes for 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>`__.
- 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
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` 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.
- 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.
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.
Runtime system
~~~~~~~~~~~~~~
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.
- Explicit boxed 1-tuples from `HsSyn` are now treated as actual 1-tuples,
without flattening. In most of the cases these will be obtained using
Template Haskell since it is uncommon to deal with 1-tuples in the source.
``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
~~~~~~~~~~~~~~~~
Build system
~~~~~~~~~~~~
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
|
