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
|
.. _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
<https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0106-type-data.rst>`_
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
<https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0170-unrestricted-overloadedlabels.rst>`_
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: `#1728` equivalent to `getLabel @"1728"`
- Arbitrary strings: `#"Hello, World!"` equivalent to `getLabel @"Hello, World!"`
Compiler
~~~~~~~~
- The `WebAssembly backend
<https://www.tweag.io/blog/2022-11-22-wasm-backend-merged-in-ghc>`_
has been merged. This allows GHC to be built as a cross-compiler
that targets ``wasm32-wasi`` and compiles Haskell code to
self-contained WebAssembly modules that can be executed on a variety
of different runtimes. There are a few caveats to be aware of:
- To use the WebAssembly backend, one would need to follow the
instructions on `ghc-wasm-meta
<https://gitlab.haskell.org/ghc/ghc-wasm-meta>`_. The WebAssembly
backend is not included in the GHC release bindists for the time
being, nor is it supported by ``ghcup`` or ``stack`` yet.
- The WebAssembly backend is still under active development. It's
presented in this GHC version as a technology preview, bugs and
missing features are expected.
- 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 ``:``).
- The :ghc-flag:`-Wstar-is-type` warning is now enabled by default, continuing
the implementation of GHC proposal `#143
<https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0143-remove-star-kind.rst>`_.
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 <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0313-delimited-continuation-primops.rst>`_
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.
- The behaviour of the ``-M`` flag has been made more strict. It will now trigger
a heap overflow if the total amount of memory used by the Haskell heap exceeds the limit.
Previously only live blocks were taken into account.
This makes it more likely to trigger promptly when the heap is highly fragmented.
- Fixed a bug that sometimes caused live sparks to be GC'ed too early either during
minor GC or major GC with workstealing disabled. See #22528.
``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 <https://www.unicode.org/versions/Unicode15.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
~~~~~~~~~~~~~~~
- Add `Foreign.C.Types.ConstPtr` was added to encode ``const``-qualified pointer return
types in foreign declarations when using ``CApiFFI`` extension.
``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
|
