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