Add release note about flexible RebindableSyntax
[ghc.git] / docs / users_guide / 8.0.1-notes.rst
1 .. _release-8-0-1:
2
3 Release notes for version 8.0.1
4 ===============================
5
6 The significant changes to the various parts of the compiler are listed
7 in the following sections. There have also been numerous bug fixes and
8 performance improvements over the 7.10 branch.
9
10 .. warning::
11
12     Only Cabal versions 1.24 and newer will function properly with this release.
13     Consequently it will likely be necessary to recompile ``cabal-install``
14     before installing new packages.
15
16     The reason for this is a change in how packages are identified in GHC
17     8.0. While previous versions of Cabal identified packages to GHC with a
18     package key (with GHC's :ghc-flag:`-this-package-key` argument), GHC 8.0 and
19     later uses installed package IDs in place of package keys.
20
21
22 Highlights
23 ----------
24
25 The highlights, since the 7.10 branch, are:
26
27 - TODO FIXME
28
29 - nokinds
30
31 - Support for :ref:`record pattern synonyms <record-patsyn>`
32
33 - The :ghc-flag:`-XDeriveAnyClass` extension learned to derive instances for
34   classes with associated types (see :ref:`derive-any-class`)
35
36 - More reliable DWARF debugging information
37
38 - Support for :ref:`injective type families <injective-ty-fams>`
39
40 - Applicative ``do`` notation (see :ref:`applicative-do`)
41
42 - Support for wildcards in data and type family instances
43
44 - :ghc-flag:`-XStrict` and :ghc-flag:`-XStrictData` extensions, allowing modules
45   to be compiled with strict-by-default bindings (see :ref:`strict-haskell`)
46
47 - :ghc-flag:`-XDuplicateRecordFields`, allowing multiple datatypes to declare the same
48   record field names provided they are used unambiguously (see :ref:`duplicate-record-fields`)
49
50 - Support for implicit parameters providing light-weight
51   :ref:`callstacks and source locations <implicit-callstacks>`
52
53 - User-defined error messages for type errors
54
55 - A rewritten (and greatly improved) pattern exhaustiveness checker
56
57 - More flexible rebindable syntax
58
59 - GHC can run the interpreter in a separate process (see
60   :ref:`external-interpreter`), and the interpreter can now run profiled
61   code.
62
63 - GHCi now provides access to stack traces when used with
64   :ghc-flag:`-fexternal-interpreter` and :ghc-flag:`-prof` (see
65   :ref:`ghci-stack-traces`).
66
67 - A native code generator for powerpc64 and powerpc64le architectures
68
69 - The reworked users guide you are now reading
70
71 - Support for Windows XP and earlier has been dropped.
72
73 Full details
74 ------------
75
76 Language
77 ~~~~~~~~
78
79 -  TODO FIXME.
80
81 -  The parser now supports Haddock comments on GADT data constructors.
82    For example ::
83
84         data Expr a where
85             -- | Just a normal sum
86             Sum :: Int -> Int -> Expr Int
87
88 -  Implicit parameters of the new ``base`` type :base-ref:`GHC.Stack.CallStack <GHC-Stack.html>`
89    are treated specially in function calls, the solver automatically
90    appends the source location of the call to the ``CallStack`` in
91    the environment. For example ::
92
93         myerror :: (?callStack :: CallStack) => String -> a
94         myerror msg = error (msg ++ "\n" ++ prettyCallStack ?callStack)
95
96         ghci> myerror "die"
97         *** Exception: die
98         CallStack (from ImplicitParams):
99           myerror, called at <interactive>:2:1 in interactive:Ghci1
100
101    prints the call-site of ``myerror``. The name of the implicit
102    parameter does not matter, but within ``base`` we call it
103    ``?callStack``.
104
105    See :ref:`lib-base` for a description of the ``CallStack`` type.
106
107 -  GHC now supports visible type application, allowing
108    programmers to easily specify how type parameters should be
109    instantiated when calling a function. See
110    :ref:`visible-type-application` for the details.
111
112 -  To conform to the common case, the default role assigned to
113    parameters of datatypes declared in ``hs-boot`` files is
114    ``representational``. However, if the constructor(s) for the datatype
115    are given, it makes sense to do normal role inference. This is now
116    implemented, effectively making the default role for non-abstract
117    datatypes in ``hs-boot`` files to be ``phantom``, like it is in
118    regular Haskell code.
119
120 -  Wildcards can be used in the type arguments of type/data family
121    instance declarations to indicate that the name of a type variable
122    doesn't matter. They will be replaced with new unique type variables.
123    See :ref:`data-instance-declarations` for more details.
124
125 -  GHC now allows to declare type families as injective. Injectivity
126    information can then be used by the typechecker. See
127    :ref:`injective-ty-fams` for details.
128
129 -  Due to a :ghc-ticket:`security issue <10826>`, Safe Haskell now forbids
130    annotations in programs marked as :ghc-flag:`-XSafe`.
131
132 -  Generic instances can be derived for data types whose constructors have
133    arguments with certain unlifted types. See :ref:`generic-programming` for
134    more details.
135
136 -  GHC generics can now provide strictness information for fields in a data
137    constructor via the ``Selector`` type class.
138
139 -  The :ghc-flag:`-XDeriveAnyClass` extension now fills in associated type family
140    default instances when deriving a class that contains them.
141
142 -  The :ghc-flag:`-XRebindableSyntax` feature is now much more flexible, imposing
143    fewer restrictions on the types of the rebindable syntax elements. For example,
144    your ``negate`` function may now return a different type than it accepts.
145    Rebindable syntax also supports higher-rank types fully, allowing types
146    like ``(>>=) :: m a -> (forall x. a x -> m b) -> m b``.
147
148 -  Users can now define record pattern synonyms. This allows pattern synonyms
149    to behave more like normal data constructors. For example, ::
150
151       pattern P :: a -> b -> (a, b)
152       pattern P{x,y} = (x,y)
153
154    will allow ``P`` to be used like a record data constructor and also defines
155    selector functions ``x :: (a, b) -> a`` and ``y :: (a, b) -> b``.
156
157 -  Pattern synonyms can now be bundled with type constructors. For a pattern
158    synonym ``P`` and a type constructor ``T``, ``P`` can be bundled with ``T``
159    so that when ``T`` is imported ``P`` is also imported. With this change
160    a library author can provide either real data constructors or pattern
161    synonyms in an opaque manner. See :ref:`pattern-synonyms` for details. ::
162
163       -- Foo.hs
164       module Foo ( T(P) ) where
165
166       data T = T
167
168       pattern P = T
169
170       -- Baz.hs
171       module Baz where
172
173       -- P is imported
174       import Foo (T(..))
175
176 -  Whenever a data instance is exported, the corresponding data family
177    is exported, too. This allows one to write ::
178
179      -- Foo.hs
180      module Foo where
181
182      data family T a
183
184      -- Bar.hs
185      module Bar where
186
187      import Foo
188
189      data instance T Int = MkT
190
191      -- Baz.hs
192      module Baz where
193
194      import Bar (T(MkT))
195
196    In previous versions of GHC, this required a workaround via an
197    explicit export list in ``Bar``.
198
199
200
201 Compiler
202 ~~~~~~~~
203
204 -  Warnings can now be controlled with ``-W(no-)...`` flags in addition to
205    the old ``-f(no-)warn...`` ones. This was done as the first part of a
206    rewrite of the warning system to provide better control over warnings,
207    better warning messages, and more common syntax compared to other
208    compilers. The old ``-f``-based warning flags will remain functional for
209    the forseeable future.
210
211 -  Added the option :ghc-flag:`-dth-dec-file`. This dumps out a ``.th.hs`` file of
212    all Template Haskell declarations in a corresponding .hs file. The
213    idea is that application developers can check this into their
214    repository so that they can grep for identifiers used elsewhere that
215    were defined in Template Haskell. This is similar to using
216    :ghc-flag:`-ddump-to-file` with :ghc-flag:`-ddump-splices` but it always generates a
217    file instead of being coupled to :ghc-flag:`-ddump-to-file` and only outputs
218    code that does not exist in the .hs file and a comment for the splice
219    location in the original file.
220
221 -  After a long hiatus (see :ghc-ticket:`10935`) the
222    :ghc-flag:`-Wmonomorphism-restriction` (formerly
223    :ghc-flag:`-fwarn-monomorphism-restriction`) flag has returned.
224    The functionality of this flag was inadvertently removed by a commit in 2010;
225    this has been fixed and the flag should now issue warnings as it
226    previously did.
227
228 -  Added the option :ghc-flag:`-fprint-expanded-types`. When enabled, GHC also
229    prints type-synonym-expanded types in type errors.
230
231 -  Added the option :ghc-flag:`-fcpr-anal`. When enabled, the demand analyser
232    performs CPR analysis. It is implied by :ghc-flag:`-O`. Consequently,
233    :ghc-flag:`-fcpr-off` is now removed, run with :ghc-flag:`-fno-cpr-anal` to get the
234    old :ghc-flag:`-fcpr-off` behaviour.
235
236 -  Added the option :ghc-flag:`-fworker-wrapper`. When enabled, the worker-wrapper
237    transformation is performed after a strictness analysis pass. It is implied
238    by :ghc-flag:`-O` and by :ghc-flag:`-fstrictness`. It is disabled by :ghc-flag:`-fno-strictness`.
239    Enabling :ghc-flag:`-fworker-wrapper` while strictness analysis is disabled (by
240    :ghc-flag:`-fno-strictness`) has no effect.
241
242 -  Added the options :ghc-flag:`-Wmissed-specialisations` and
243    :ghc-flag:`-Wall-missed-specialisations`. When enabled, the simplifier will
244    produce a warning when a overloaded imported function cannot be
245    specialised (typically due to a missing ``INLINEABLE`` pragma). This
246    is intended to alert users to cases where they apply ``INLINEABLE`` but
247    may not get the speed-up they expect.
248
249 -  Added the option :ghc-flag:`-Wnoncanonical-monad-instances` and
250    :ghc-flag:`-Wnoncanonical-monadfail-instances` which help detect noncanonical
251    ``Applicative``/``Monad``/``MonadFail`` instance definitions.
252    See flag description in :ref:`options-sanity` for more details.
253
254 -  When printing an out-of-scope error message, GHC will give helpful advice if
255    the error might be caused by too restrictive imports.
256
257 -  Added the :ghc-flag:`-Wcompat` warning group, along with its opposite
258    :ghc-flag:`-Wno-compat`. Turns on warnings that will be enabled by default in the
259    future, but remain off in normal compilations for the time being. This
260    allows library authors eager to make their code future compatible to adapt
261    to new features before they even generate warnings.
262
263 -  Added the :ghc-flag:`-Wmissing-monadfail-instances` flag. When enabled, this
264    will issue a warning if a failable pattern is used in a context that does
265    not have a ``MonadFail`` constraint. This flag represents phase 1 of the
266    `MonadFail Proposal (MFP)
267    <https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail>`__.
268
269 -  Added the :ghc-flag:`-Wsemigroup` flag. When enabled, this
270    will issue a warning if a type is an instance of ``Monoid`` but not
271    ``Semigroup``, and when a custom definition ``(<>)`` is made. Fixing these
272    warnings makes sure the definition of ``Semigroup`` as a superclass of
273    ``Monoid`` does not break any code.
274
275 -  Added the :ghc-flag:`-Wmissing-pat-syn-sigs` flag. When enabled, this will issue
276    a warning when a pattern synonym definition doesn't have a type signature.
277    It is turned off by default but enabled by :ghc-flag:`-Wall`.
278
279 -  Added the :ghc-flag:`-Wunused-type-patterns` flag to report unused
280    type variables in data and type family instances. This flag is not implied
281    by :ghc-flag:`-Wall`, since :ghc-flag:`-Wunused-type-patterns` will
282    warn about unused type variables even if the types themselves are intended
283    to be used as documentation. If :ghc-flag:`-Wunused-type-patterns` is
284    enabled, one can prefix or replace unused type variables with underscores to
285    avoid warnings.
286
287 -  Split off the new flag :ghc-flag:`-Wunused-foralls` from the previously
288    existing flag :ghc-flag:`-Wunused-matches`. :ghc-flag:`-Wunused-foralls`
289    emits a warning in the specific case that a user writes explicit ``forall``
290    syntax with unused type variables, while :ghc-flag:`-Wunused-matches` only
291    warns in the case of unused term-level patterns. Both flags are implied by
292    :ghc-flag:`-W`.
293
294 -  Added the :ghc-flag:`-Wtoo-many-guards` flag. When enabled, this will issue a
295    warning if a pattern match contains too many guards (over 20 at the
296    moment). Makes a difference only if pattern match checking is also enabled.
297
298 -  Added the :ghc-flag:`-ffull-guard-reasoning` flag. When enabled, pattern match
299    checking tries its best to reason about guards. Since the additional
300    expressivity may come with a high price in terms of compilation time and
301    memory consumption, it is turned off by default.
302
303 -  :ghc-flag:`-this-package-key` has been renamed again (hopefully for the last time!)
304    to :ghc-flag:`-this-unit-id`.  The renaming was motivated by the fact that
305    the identifier you pass to GHC here doesn't have much to do with packages:
306    you may provide different unit IDs for libraries which are in the same
307    package.  :ghc-flag:`-this-package-key` is deprecated; you should use
308    :ghc-flag:`-this-unit-id` or, if you need compatibility over multiple
309    versions of GHC, :ghc-flag:`-package-name`.
310
311 GHCi
312 ~~~~
313
314 -  ``Main`` with an explicit module header but without ``main`` is now
315    an error (:ghc-ticket:`7765`).
316
317 -  The :ghci-cmd:`:back` and :ghci-cmd:`:forward` commands now take an optional count
318    allowing the user to move forward or backward in history several
319    steps at a time.
320
321 -  Added commands :ghci-cmd:`:load! <:load>` and :ghci-cmd:`:reload! <:reload>`,
322    effectively setting :ghc-flag:`-fdefer-type-errors` before loading a module and
323    unsetting it after loading if it has not been set before (:ghc-ticket:`8353`).
324
325 -  ``ghci -e`` now behaves like :ghc-flag:`ghc -e <-e>` (:ghc-ticket:`9360`).
326
327 -  Added support for top-level function declarations (:ghc-ticket:`7253`).
328
329 -  The new commands :ghci-cmd:`:all-types`, :ghci-cmd:`:loc-at`, :ghci-cmd:`:type-at`, and
330    :ghci-cmd:`:uses` designed for editor-integration
331    (such as Emacs' ``haskell-mode``) originally premiered by ``ghci-ng``
332    have been integrated into GHCi (:ghc-ticket:`10874`).
333
334 -  GHCi now supports decoupled operation between the interpreter and the
335    shell. While this is largely an implementation detail, it opens up a few
336    interesting possibilities in the future. See :ghc-wiki:`RemoteGHCi` for
337    details.
338
339 Template Haskell
340 ~~~~~~~~~~~~~~~~
341
342 -  The new :ghc-flag:`-XTemplateHaskellQuotes` flag allows to use the
343    quotes (not quasi-quotes) subset of ``TemplateHaskell``.  This is
344    particularly useful for use with a stage 1 compiler (i.e. GHC
345    without interpreter support). Also, :ghc-flag:`-XTemplateHaskellQuotes` is
346    considered safe under Safe Haskell.
347
348 -  The ``__GLASGOW_HASKELL_TH__`` CPP constant denoting support for
349    :ghc-flag:`-XTemplateHaskell` introduced in GHC 7.10.1 has been changed to
350    use the values ``1``/``0`` instead of the previous ``YES``/``NO``
351    values.
352
353 -  Partial type signatures can now be used in splices, see
354    :ref:`pts-where`.
355
356 -  Template Haskell now fully supports typed holes and quoting unbound
357    variables.  This means it is now possible to use pattern splices nested
358    inside quotation brackets.
359
360 -  Template Haskell now supports the use of ``UInfixT`` in types to
361    resolve infix operator fixities, in the same vein as ``UInfixP`` and
362    ``UInfixE`` in patterns and expressions. ``ParensT`` and ``InfixT``
363    have also been introduced, serving the same functions as their
364    pattern and expression counterparts.
365
366 - Template Haskell has now explicit support for representing GADTs.  Until
367   now GADTs were encoded using ``NormalC``, ``RecC`` (record syntax) and
368   ``ForallC`` constructors.  Two new constructors - ``GadtC`` and ``RecGadtC`` -
369   are now supported during quoting, splicing and reification.
370
371 -  Primitive chars (e.g., ``[| 'a'# |]``) and primitive strings (e.g.,
372    ``[| "abc"# |]``) can now be quoted with Template Haskell. The
373    ``Lit`` data type also has a new constructor, ``CharPrimL``, for
374    primitive char literals.
375
376 -  ``addTopDecls`` now accepts annotation pragmas.
377
378 -  Internally, the implementation of quasi-quotes has been unified with
379    that of normal Template Haskell splices. Under the previous
380    implementation, top-level declaration quasi-quotes did not cause a
381    break in the declaration groups, unlike splices of the form
382    ``$(...)``. This behavior has been preserved under the new
383    implementation, and is now recognized and documented in
384    :ref:`th-syntax`.
385
386 -  The ``Lift`` class is now derivable via the :ghc-flag:`-XDeriveLift` extension. See
387    :ref:`deriving-lift` for more information.
388
389 -  The ``FamilyD`` data constructor and ``FamFlavour`` data type have
390    been removed. Data families are now represented by ``DataFamilyD`` and
391    open type families are now represented by ``OpenTypeFamilyD`` instead
392    of ``FamilyD``. Common elements of ``OpenTypeFamilyD`` and
393    ``ClosedTypeFamilyD`` have been moved to ``TypeFamilyHead``.
394
395 -  The representation of ``data``, ``newtype``, ``data instance``, and
396    ``newtype instance`` declarations has been changed to allow for
397    multi-parameter type classes in the ``deriving`` clause. In particular,
398    ``dataD`` and ``newtypeD`` now take a ``CxtQ`` instead of a ``[Name]``
399    for the list of derived classes.
400
401 -  ``isExtEnabled`` can now be used to determine whether a language extension
402    is enabled in the ``Q`` monad. Similarly, ``extsEnabled`` can be used to list
403    all enabled language extensions.
404
405 -  One can now reify the strictness information of a constructors' fields using
406    Template Haskell's ``reifyConStrictness`` function, which takes into account
407    whether flags such as :ghc-flag:`-XStrictData` or
408    :ghc-flag:`-funbox-strict-fields` are enabled.
409
410 Runtime system
411 ~~~~~~~~~~~~~~
412
413 - Support for performance monitoring with PAPI has been dropped.
414
415 - :rts-flag:`-maxN⟨x⟩ <-maxN>` flag added to complement :rts-flag:`-N`. It will
416   choose to use at most ⟨x⟩ capabilities, limited by the number of processors
417   as :rts-flag:`-N` is.
418
419 Build system
420 ~~~~~~~~~~~~
421
422 -  TODO FIXME.
423
424 Package system
425 ~~~~~~~~~~~~~~
426
427 -  TODO FIXME.
428
429 hsc2hs
430 ~~~~~~
431
432 - :command:`hsc2hs` now supports the ``#alignment`` macro, which can be used to
433   calculate the alignment of a struct in bytes. Previously, ``#alignment``
434   had to be implemented manually via a ``#let`` directive, e.g., ::
435
436       #let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
437
438   As a result, if you have the above directive in your code, it will now emit
439   a warning when compiled with GHC 8.0.
440
441   .. code-block:: none
442
443       Module.hsc:24:0: warning: "hsc_alignment" redefined [enabled by default]
444       In file included from dist/build/Module_hsc_make.c:1:0:
445       /path/to/ghc/lib/template-hsc.h:88:0: note: this is the location of the previous definition
446        #define hsc_alignment(t...) \
447        ^
448
449   To make your code free of warnings on GHC 8.0 and still support earlier
450   versions, surround the directive with a pragma checking for the right GHC
451   version. ::
452
453       #if __GLASGOW_HASKELL__ < 800
454       #let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
455       #endif
456
457 Libraries
458 ---------
459
460 array
461 ~~~~~
462
463 -  Version number XXXXX (was 0.5.0.0)
464
465
466 .. _lib-base:
467
468 base
469 ~~~~
470
471 See ``changelog.md`` in the ``base`` package for full release notes.
472
473 -  Version number 4.9.0.0 (was 4.7.0.0)
474
475 -  :base-ref:`GHC.Stack <GHC-Stack.html>` exports two new types ``SrcLoc`` and ``CallStack``. A
476    ``SrcLoc`` contains package, module, and file names, as well as start
477    and end positions. A ``CallStack`` is essentially a ``[(String, SrcLoc)]``,
478    sorted by most-recent call.
479
480 -  ``error`` and ``undefined`` will now report a partial stack-trace
481    using the new ``CallStack`` feature (and the :ghc-flag:`-prof` stack if
482    available).
483
484 -  A new function, ``interruptible``, was added to ``GHC.IO`` allowing
485    an ``IO`` action to be run such that it can be interrupted by an
486    asynchronous exception, even if exceptions are masked (except if
487    masked with ``interruptibleMask``).
488
489    This was introduced to fix the behavior of ``allowInterrupt``, which
490    would previously incorrectly allow exceptions in uninterruptible
491    regions (see :ghc-ticket:`9516`).
492
493 -  Per-thread allocation counters (``setAllocationCounter`` and
494    ``getAllocationCounter``) and limits (``enableAllocationLimit``,
495    ``disableAllocationLimit`` are now available from ``System.Mem``. Previously
496    this functionality was only available from :base-ref:`GHC.Conc <GHC-Stack.html>`.
497
498 - ``forever``, ``filterM``, ``mapAndUnzipM``, ``zipWithM``, ``zipWithM_``,
499   ``replicateM``, and ``replicateM`` were generalized from ``Monad`` to
500   ``Applicative``. If this causes performance regressions, try to make the
501   implementation of ``(*>)`` match that of ``(>>)``.
502
503 - Add ``URec``, ``UAddr``, ``UChar``, ``UDouble``, ``UFloat``, ``UInt``, and ``UWord`` to
504   :base-ref:`GHC.Generics <GHC-Generics.html>` as part of making GHC generics
505   capable of handling unlifted types (:ghc-ticket:`10868`)
506
507 - Expand ``Floating`` class to include operations that allow for better
508   precision: ``log1p``, ``expm1``, ``log1pexp`` and ``log1mexp``. These are not
509   available from ``Prelude``, but the full class is exported from ``Numeric``.
510
511 - Add ``Data.List.NonEmpty`` and ``Data.Semigroup`` (to become
512   super-class of ``Monoid`` in the future). These modules were
513   provided by the ``semigroups`` package previously. (:ghc-ticket:`10365`)
514
515 - The constraints of various functions in ``Control.Monad`` have been
516   generalized from ``Monad`` to ``Applicative`` including ``filterM``,
517   ``zipWithM`` and ``replicateM_`` (see :ghc-ticket:`10168`).
518
519 - Add ``GHC.TypeLits.TypeError`` and ``ErrorMessage`` to allow users
520   to define custom compile-time error messages. (see :ref:`custom-errors` and
521   the original :ghc-wiki:`proposal <Proposal/CustomTypeErrors>`).
522
523 - The ``Generic`` instance for ``Proxy`` is now poly-kinded (see :ghc-ticket:`10775`)
524
525 - The ``IsString`` instance for ``[Char]`` has been modified to eliminate
526   ambiguity arising from overloaded strings and functions like ``(++)``.
527
528 - Move ``Const`` from ``Control.Applicative`` to its own module in
529   ``Data.Functor.Const``. (see :ghc-ticket:`11135`)
530
531 - Enable ``PolyKinds`` in the ``Data.Functor.Const`` module to give ``Const``
532   the kind ``* -> k -> *`` (see :ghc-ticket:`10039`).
533
534 binary
535 ~~~~~~
536
537 -  Version number XXXXX (was 0.7.1.0)
538
539 bytestring
540 ~~~~~~~~~~
541
542 -  Version number XXXXX (was 0.10.4.0)
543
544 Cabal
545 ~~~~~
546
547 -  Version number XXXXX (was 1.18.1.3)
548
549 containers
550 ~~~~~~~~~~
551
552 -  Version number XXXXX (was 0.5.4.0)
553
554 deepseq
555 ~~~~~~~
556
557 -  Version number XXXXX (was 1.3.0.2)
558
559 directory
560 ~~~~~~~~~
561
562 -  Version number XXXXX (was 1.2.0.2)
563
564 filepath
565 ~~~~~~~~
566
567 -  Version number XXXXX (was 1.3.0.2)
568
569 ghc
570 ~~~
571
572 -  TODO FIXME.
573
574 -  The ``HsBang`` type has been removed in favour of ``HsSrcBang`` and
575    ``HsImplBang``. Data constructors now always carry around their
576    strictness annotations as the user wrote them, whether from an
577    imported module or not.
578
579 -  Moved ``startsVarSym``, ``startsVarId``, ``startsConSym``, ``startsConId``,
580    ``startsVarSymASCII``, and ``isVarSymChar`` from ``Lexeme`` to the
581    ``GHC.Lemexe`` module of the ``ghc-boot`` library.
582
583 -  Add ``isImport``, ``isDecl``, and ``isStmt`` functions.
584
585 -  The `mi_fix_fn` field of `ModIface` had its type changed from
586    ``OccName -> Fixity`` to ``OccName -> Maybe Fixity``, where a returned value
587    of ``Nothing`` indicates a cache miss. As a result, the types of
588    ``mkIfaceFixCache`` and ``emptyIfaceFixCache`` were also changed to have a
589    return type of ``Maybe Fixity``, and a new ``mi_fix :: OccName -> Fixity``
590    function was introduced which invokes ``mi_fix_fn`` but returns
591    ``defaultFixity`` upon a cache miss.
592
593 ghc-boot
594 ~~~~~~~~
595
596 -  This is an internal package. Use with caution.
597
598 -  This package was renamed from ``bin-package-db`` to reflect its new purpose
599    of containing intra-GHC functionality that needs to be shared across
600    multiple GHC boot libraries.
601
602 -  Added ``GHC.Lexeme``, which contains functions for determining if a
603    character can be the first letter of a variable or data constructor in
604    Haskell, as defined by GHC. (These functions were moved from ``Lexeme``
605    in ``ghc``.)
606
607 -  Added ``GHC.LanguageExtensions`` which contains a type listing all
608    supported language extensions.
609
610 ghc-prim
611 ~~~~~~~~
612
613 -  Version number XXXXX (was 0.3.1.0)
614
615 haskell98
616 ~~~~~~~~~
617
618 -  Version number XXXXX (was 2.0.0.3)
619
620 haskell2010
621 ~~~~~~~~~~~
622
623 -  Version number XXXXX (was 1.1.1.1)
624
625 hoopl
626 ~~~~~
627
628 -  Version number XXXXX (was 3.10.0.0)
629
630 hpc
631 ~~~
632
633 -  Version number XXXXX (was 0.6.0.1)
634
635 integer-gmp
636 ~~~~~~~~~~~
637
638 -  Version number XXXXX (was 0.5.1.0)
639
640 old-locale
641 ~~~~~~~~~~
642
643 -  Version number XXXXX (was 1.0.0.6)
644
645 old-time
646 ~~~~~~~~
647
648 -  Version number XXXXX (was 1.1.0.2)
649
650 process
651 ~~~~~~~
652
653 -  Version number XXXXX (was 1.2.0.0)
654
655 template-haskell
656 ~~~~~~~~~~~~~~~~
657
658 -  Version number XXXXX (was 2.9.0.0)
659
660 -  The ``Lift`` type class for lifting values into Template Haskell
661    splices now has a default signature ``lift :: Data a => a -> Q Exp``,
662    which means that you do not have to provide an explicit
663    implementation of ``lift`` for types which have a ``Data`` instance.
664    To manually use this default implementation, you can use the
665    ``liftData`` function which is now exported from
666    ``Language.Haskell.TH.Syntax``.
667
668 -  ``Info``'s constructors no longer have ``Fixity`` fields. A
669    ``qReifyFixity`` function was added to the ``Quasi`` type class (as
670    well as the ``reifyFixity`` function, specialized for ``Q``) to allow
671    lookup of fixity information for any given ``Name``.
672
673 time
674 ~~~~
675
676 -  Version number XXXXX (was 1.4.1)
677
678 unix
679 ~~~~
680
681 -  Version number XXXXX (was 2.7.0.0)
682
683 Win32
684 ~~~~~
685
686 -  Version number XXXXX (was 2.3.0.1)
687
688 Known bugs
689 ----------
690
691 -  TODO FIXME