7.10.1-notes.xml

<?xml version="1.0" encoding="iso-8859-1"?>
<sect1 id="release-7-10-1">
  <title>Release notes for version 7.10.1</title>

  <para>
      The significant changes to the various parts of the compiler are listed
      in the following sections. There have also been numerous bug fixes and
      performance improvements over the 7.8 branch.
  </para>

  <sect2>
    <title>Highlights</title>

    <para>
        The highlights, since the 7.8 branch, are:
    </para>

    <itemizedlist>
        <listitem>
            <para>
                GHC has implemented "The Applicative Monad Proposal",
                meaning the <literal>Applicative</literal> typeclass
                is now a superclass of <literal>Monad</literal>. This
                is a breaking change and your programs will need to be
                updated.
                Please see the <ulink
                url="https://ghc.haskell.org/trac/ghc/wiki/Migration/7.10">GHC
                7.10 Migration Guide</ulink> on the GHC wiki.
           </para>
       </listitem>
        <listitem>
            <para>
                GHC has implemented the "Burning Bridges Proposal",
                meaning that many of the combinators in
                <literal>Prelude</literal> are now re-exported from
                more generic modules (such as
                <literal>Data.Traversable</literal>), rather than exporting
                custom, less-generic versions. This is a change that
                may require updates to your program.
                Please see the <ulink
                url="https://ghc.haskell.org/trac/ghc/wiki/Migration/7.10">GHC
                7.10 Migration Guide</ulink> on the GHC wiki.
           </para>
       </listitem>
        <listitem>
            <para>
                GHC now has support for 'partial type signatures',
                which give you the ability to add 'holes' to a type
                signature that the compiler can later infer. For more,
                see <xref linkend="partial-type-signatures"/>.
           </para>
       </listitem>
        <listitem>
            <para>
                The <literal>integer-gmp</literal> package has been
                completely rewritten from the ground up. The primary
                change in this rewrite is that GHC-compiled programs
                that link to GMP no longer 'hook' GMP allocation
                routines, to create an <literal>Integer</literal> on
                the raw Haskell heap. Instead,
                <literal>integer-gmp</literal> now allocates all
                memory in Haskell code, and talks to GMP via normal
                FFI imports like other C code.
           </para>
            <para>
                The practical side effect of this is that C libraries
                which bind to GMP (such as MPFR or FLINT) no longer
                need careful (or impossible) hacks to be used inside a
                GHC-compiled program via the FFI; GMP is treated just
                like any other C library, with no special
                accomodations.
           </para>
       </listitem>
        <listitem>
            <para>
                GHC now has support for plugins which modify the type
                checker. This allows external users to interface with
                GHC and write type-checking plugins to solve
                constraints and equalities generated by the
                typechecker.
           </para>
            <para>
                This feature is experimental and will likely change in
                the future.
           </para>
       </listitem>
        <listitem>
            <para>
                GHC now has support for a new extension,
                <literal>-XStaticPointers</literal>, that allows you
                to (de)reference and serialize pointers to known,
                closed expressions. This is primarily aimed at making
                distributed programming (via interfaces like Cloud
                Haskell) easier. For more, see <xref
                linkend="static-pointers"/>.
           </para>
            <para>
                This feature is experimental and will likely change in
                the future.
           </para>
       </listitem>
        <listitem>
            <para>
                GHC now has preliminary support for DWARF-based
                debugging, when compiling programs with the new
                <literal>-g</literal> option. This will embed DWARF
                information into the module object files, which can
                then be read by tools like GDB for backtraces or
                single-stepping.
           </para>
            <para>
                This feature is <emphasis>highly</emphasis>
                experimental and will likely change in the future, but
                should still be useful today.
           </para>
       </listitem>
   </itemizedlist>
  </sect2>

  <sect2>
    <title>Full details</title>
    <sect3>
        <title>Language</title>
        <itemizedlist>
            <listitem>
                <para>
                    Implicit parameters of the new base type
                    <literal>GHC.Stack.CallStack</literal> are treated
                    specially, and automatically solved for the current source
                    location. For example
                    <programlisting>
                      f = print (?stk :: CallStack)
                    </programlisting>
                    will print the singleton stack containing the occurrence of
                    <literal>?stk</literal>. If there is another
                    <literal>CallStack</literal> implicit in-scope, the new location
                    will be appended to the existing stack, e.g.
                    <programlisting>
                      f :: (?stk :: CallStack) => IO ()
                      f = print (?stk :: CallStack)
                    </programlisting>
                    will print the occurrence of <literal>?stk</literal> and the
                    call-site of <literal>f</literal>. The name of the implicit
                    parameter does not matter.
               </para>
                <para>
                    See the release notes for base for a description of the
                    <literal>CallStack</literal> type.
               </para>
           </listitem>
            <listitem>
                <para>
                    There is a new extension,
                    <link linkend="static-pointers">StaticPointers</link>,
                    which allows you to create pointers to expressions which
                    remain valid across processes. This is useful for
                    referencing higher-order values in distributed
                    systems. The pointers are created with a new keyword
                    <literal>static</literal> as in
                    <literal>x = static ("abc" ++ "123") :: StaticPtr String</literal>.
                    All processes which dereference <literal>x</literal> get the
                    same result, that is, the body of the static form.
               </para>
           </listitem>
            <listitem>
                <para>
                    Added support for <link linkend="binary-literals">binary integer literals</link>
               </para>
           </listitem>
            <listitem>
                <para>
                    Simplified rules for implicit quantification. In previous versions of GHC,
                    it was possible to use the <literal>=></literal> arrow
                    to quantify over type variables in <literal>data</literal> and
                    <literal>type</literal> declarations without a
                    <literal>forall</literal> quantifier. For example,
                    <literal>data Fun = Fun (Ord a => a -> b)</literal> was identical to
                    <literal>data Fun = Fun (forall a b. Ord a => a -> b)</literal>, while
                    <literal>data Fun = Fun (a -> b)</literal> caused a not-in-scope error.
                    This implicit quantification is now deprecated, and variables
                    in higher-rank constructors should be quantified with <literal>forall</literal>
                    regardless of whether a class context is present or not.
                    GHC 7.10 raises a warning (controlled by
                    <option>-fwarn-context-quantification</option>, enabled by default)
                    and GHC 7.12 will raise an error. See <link linkend="univ">examples</link>
                    in GHC documentation.
                </para>
                <para>
                    The change also applies to Template Haskell splices such as
                    <literal>[t|Ord a => a|]</literal>, which should be written as
                    <literal>[t|forall a. Ord a => a|]</literal>.
                </para>
           </listitem>

           <listitem>
             <para>
               Instance contexts inferred while processing <literal>deriving</literal>
               directives attached to <literal>data</literal> and <literal>newtype</literal>
               declarations now forbid equality constraints. This is a regression in
               obscure cases, but it will yield better error messages in more common
               cases. Users caught by the regression can simply use standalone-deriving,
               where you specify the context yourself.
             </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>Compiler</title>
        <itemizedlist>
            <listitem>
                <para>
                    GHC now checks that all the language extensions required for
                    the inferred type signatures are explicitly enabled. This
                    means that if any of the type signatures inferred in your
                    program requires some language extension you will need to
                    enable it. The motivation is that adding a missing type
                    signature inferred by GHC should yield a program that
                    typechecks. Previously this was not the case.
                </para>
                <para>
                    This is a breaking change. Code that used to compile in the
                    past might fail with an error message requiring some
                    particular language extension (most likely
                    <option>-XTypeFamilies</option>, <option>-XGADTs</option> or
                    <option>-XFlexibleContexts</option>).
                </para>
            </listitem>
	    <listitem>
	      <para>
		The solvers for both type family reductions and
		<literal>Coercible</literal> instances have been improved.
		This should lead to faster compilation of type-family-heavy
		code and more <literal>Coercible</literal> instances to be
		found. However, some bugs remain: see 'Known Bugs' below.
	      </para>
	   </listitem>
           <listitem>
                <para>
                    <option>-fwarn-tabs</option> warning flag is turned on by
                    default with this release of GHC. It can be suppressed
                    either by using <literal>GHC_OPTIONS</literal> pragma or by
                    specifying <option>-fno-warn-tabs</option> flag.
                </para>
           </listitem>
           <listitem>
                <para>
                    The new <option>-fdefer-typed-holes</option> flag turns
                    typed hole errors into typed hole warnings that produce
                    runtime errors when evaluated.

                    The <option>-fno-warn-typed-holes</option> flag was
                    repurposed to silence the warnings produced when
                    <option>-fdefer-typed-holes</option> is used. As a result,
                    it is no longer possible to disable typed holes like it was
                    in GHC 7.8. This only turned a self-explanatory error into
                    a cryptic parse error and was thus not very useful.

                    For more details, consult <xref linkend="typed-holes"/> and
                    <xref linkend="defer-type-errors"/>.
                </para>
           </listitem>
           <listitem>
                <para>
                    A new warning flag, <option>-fwarn-trustworthy-safe</option>
                    has been added and is turned on with
                    <option>-Wall</option>. It warns when a module that is
                    compiled with <option>-XTrustworthy</option> is actually
                    infered as an <option>-XSafe</option> module. This lets the
                    module author know that they can tighten their Safe Haskell
                    bounds if desired.
                </para>
           </listitem>
           <listitem>
                <para>
                    The <option>-fwarn-safe</option> and
                    <option>-fwarn-unsafe</option> that warn if a module was
                    infered as Safe or Unsafe have been improved to work with
                    all Safe Haskell module types. Previously, they only worked
                    for unmarked modules where the compiler was infering the
                    modules Safe Haskell type. They now work even for modules
                    marked as <option>-XTrustworthy</option> or
                    <option>-XUnsafe</option>. This is useful either to have
                    GHC check your assumptions, or to generate a list of
                    reasons easily why a module is regarded as Unsafe.
                </para>
                <para>
                    For many use cases, the new
                    <option>-fwarn-trustworthy-safe</option> flag is better
                    suited than either of these two.
                </para>
           </listitem>
           <listitem>
             <para>
               <option>-ddump-simpl-phases</option> and
               <option>-ddump-core-pipeline</option> flags have been removed.
             </para>
           </listitem>
           <listitem>
                <para>
                    Many more options have learned to respect the <option>-ddump-to-file</option>.
                    For example you can use <option>-ddump-to-file</option> with <option>-ddump-splices</option>
                    to produce a <option>.dump-splices file</option>
                    for each file that uses Template Haskell.
                    This should be much easier to understand on a larger project
                    than having everything being dumped to stdout.
                </para>
           </listitem>
           <listitem>
             <para>
               Compiler plugins (with the <option>-fplugin</option>
               flag) may now modify the behaviour of the constraint
               solver, to add new functionality to GHC's
               typechecker. See <xref linkend="typechecker-plugins"/>
               for more details.
             </para>
           </listitem>
           <listitem>
             <para>
               A new warning flag, <option>-fwarn-missing-exported-sigs</option>
               has been added. The behavior is similar to
               <option>-fwarn-missing-signatures</option> but GHC will only
               flag exported values. This flag takes precedence over
               <option>-fwarn-missing-signatures</option> so it can be used
               in conjunction with <option>-Wall</option>.
             </para>
           </listitem>
           <listitem>
             <para>
               A new warning flag, <option>-fwarn-unticked-promoted-constructors</option>
               has been added. This flag causes GHC to warn when you use a promoted constructor without using a "tick" preceding its name.
             </para>
             <para>For example:
             </para>
<programlisting>
data Nat = Succ Nat | Zero

data Vec n s where
  Nil  :: Vec Zero a
  Cons :: a -> Vec n a -> Vec (Succ n) a
</programlisting>
               <para> Will raise two warnings because <function>Zero</function>
               and <function>Succ</function> are not written as <function>'Zero</function> and
               <function>'Succ</function>.
               </para>
             <para>This warning is enabled by default in <literal>-Wall</literal> mode.</para>
           </listitem>
           <listitem>
             <para>
               Added the option <option>-dth-dec-file</option>.

               This dumps out a .th.hs file of all Template Haskell
               declarations in a corresponding .hs file. The idea is
               that application developers can check this into their
               repository so that they can grep for identifiers used
               elsewhere that were defined in Template Haskell.  This
               is similar to using <option>-ddump-to-file</option>
               with <option>-ddump-splices</option> but it always
               generates a file instead of being coupled to
               <option>-ddump-to-file</option> and only outputs code
               that does not exist in the .hs file and a comment for
               the splice location in the original fi
             </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>GHCi</title>
        <itemizedlist>
            <listitem>
                <para>
                    It's now possible to use <literal>:set
                    -l{foo}</literal> in GHCi to link against a
                    foreign library after startup.
               </para>
           </listitem>
            <listitem>
                <para>
                    Pattern synonyms are now supported in GHCi.
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>Template Haskell</title>
        <itemizedlist>
            <listitem>
                <para>
                    Added support for generating LINE pragma declarations
                    (<xref linkend="line-pragma"/>).
               </para>
            </listitem>

            <listitem>
               <para>
                    The type <literal>Pred</literal> (which stores a type
                    constraint) is now a synonym for <literal>Type</literal>,
                    in order to work with the <literal>ConstraintKinds</literal>
                    extension. This is a breaking change and may require
                    some rewriting of Template Haskell code.
               </para>
            </listitem>

            <listitem>
               <para>
                 Pattern splices now work.
               </para>
            </listitem>

            <listitem>
               <para>
                 <literal>reifyInstances</literal> now treats unbound type
                 variables as univerally quantified, allowing lookup of, say,
                 the instance for <literal>Eq [a]</literal>.
               </para>
            </listitem>

            <listitem>
               <para>
                 More kind annotations appear in reified types, in order to
                 disambiguate types that would otherwise be ambiguous in the
                 presence of <literal>PolyKinds</literal>. In particular, all
                 reified <literal>TyVarBndr</literal>s are now
                 <literal>KindedTV</literal>s. (This does not affect Template
                 Haskell quotations, just calls to <literal>reify</literal>.)
               </para>
            </listitem>

            <listitem>
               <para>
                 Various features unsupported in quotations were previously
                 silently ignored. These now cause errors.
               </para>
            </listitem>

            <listitem>
                <para>
                    <literal>Lift</literal> instances were added for
                    many more types: all of the <literal>IntXX</literal>
                    and <literal>WordXX</literal> types, <literal>Ratio a</literal>,
                    <literal>()</literal>, <literal>Float</literal>, and
                    <literal>Double</literal>.
               </para>
            </listitem>

            <listitem>
               <para>
                 All Template Haskell datatypes now have
                 <literal>Generic</literal> and <literal>Ord</literal> instances.
               </para>
            </listitem>

            <listitem>
               <para>
                 <literal>Ppr</literal> instances were added for <literal>Lit</literal>
                 and <literal>Loc</literal>.
               </para>
            </listitem>

            <listitem>
               <para>
                 Two new declaration forms are now supported:
                 standalone-deriving declarations and generic method
                 signatures (written using <literal>default</literal> in
                 a class). This means an expansion to the <literal>Dec</literal>
                 type.
               </para>
            </listitem>

            <listitem>
               <para>
                 Template Haskell is now more pedantic about splicing in
                 bogus variable names, like those containing whitespace. If you
                 use bogus names in your Template Haskell code, this may break
                 your program.
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>Runtime system</title>
        <itemizedlist>
            <listitem>
                <para>
                    The linker API is now thread-safe.  The main
                    user-facing impact of this change is that you must
                    now call <literal>initLinker</literal> before
                    calling <literal>loadObj</literal> or any of the
                    other linker APIs.
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>Build system</title>
        <itemizedlist>
            <listitem>
                <para>
                    <literal>ghc-pkg</literal> now respects <option>--user</option>
                    and <option>--global</option> when modifying packages (e.g.
                    changing exposed/trust flag or unregistering).  Previously,
                    <literal>ghc-pkg</literal> would ignore these flags and modify
                    whichever package it found first on the database stack.  To
                    recover the old behavior, simply omit these flags.
               </para>
           </listitem>
            <listitem>
                <para>
                    <literal>ghc-pkg</literal> accepts a <option>--user-package-db</option>
                    flag which allows a user to override the location of the user package
                    database.  Unlike databases specified using <option>--package-db</option>,
                    a user package database configured this way respects
                    the <option>--user</option> flag.
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>Package system</title>
        <itemizedlist>
            <listitem>
                <para>
                    ghc-pkg (and ghc) have dropped support for single-file style
                    package databases. Since version 6.12, ghc-pkg has defaulted
                    to a new database format (using a directory of files, one per
                    package plus a binary cache).
               </para>
               <para>
                    This change will not affect programs and scripts that use
                    <literal>ghc-pkg init</literal> to create package databases.
               </para>
               <para>
                    This will affect scripts that create package databases
                    using tricks like
<programlisting>
echo "[]" > package.conf
</programlisting>
                    Such scripts will need to be modified to use
                    <literal>ghc-pkg init</literal>, and to delete databases
                    by directory removal, rather than simple file delete.
               </para>
           </listitem>
       </itemizedlist>
    </sect3>
  </sect2>

  <sect2>
    <title>Libraries</title>

    <sect3>
        <title>array</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.5.1.0 (was 0.5.0.0)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>base</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 4.8.0.0 (was 4.7.0.0)
               </para>
           </listitem>
            <listitem>
                <para>
                    A new module <literal>GHC.SrcLoc</literal> was added,
                    exporting a new type <literal>SrcLoc</literal>. A
                    <literal>SrcLoc</literal> contains package, module,
                    and file names, as well as start and end positions.
               </para>
           </listitem>
            <listitem>
                <para>
                    A new type <literal>CallStack</literal> was added for use
                    with the new implicit callstack parameters. A
                    <literal>CallStack</literal> is a
                    <literal>[(String, SrcLoc)]</literal>, sorted by most-recent
                    call.
               </para>
           </listitem>
            <listitem>
                <para>
                    GHC has had its internal Unicode database for
                    parsing updated to the Unicode 7.0 standard.
                </para>
           </listitem>
            <listitem>
                <para>
                    Attempting to access a portion of the result of
                    <literal>System.IO.hGetContents</literal> that was not yet
                    read when the handle was closed now throws an exception.
                    Previously, a lazy read from a closed handle would simply
                    end the result string, leading to silent or delayed
                    failures.
                </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>bin-package-db</title>
        <itemizedlist>
            <listitem>
                <para>
                    This is an internal package, and should not be used.
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>binary</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.7.3.0 (was 0.7.1.0)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>bytestring</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.10.6.0 (was 0.10.4.0)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>Cabal</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.22.1.0 (was 1.18.1.3)
              </para>
          </listitem>
      </itemizedlist>
    </sect3>

    <sect3>
        <title>containers</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.5.6.2 (was 0.5.4.0)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>deepseq</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.4.1.1 (was 1.3.0.2)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>directory</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.2.2.0 (was 1.2.0.2)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>filepath</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.4.0.0 (was 1.3.0.2)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>ghc</title>
        <itemizedlist>
            <listitem>
                <para>
                    Many internal functions in GHC related to package IDs have been
                    renamed to refer to package keys, e.g. <literal>PackageId</literal>
                    is now <literal>PackageKey</literal>, the wired-in names
                    such as <literal>primPackageId</literal> are now
                    <literal>primPackageKey</literal>, etc.  This reflects a distinction
                    that we are now making: a package ID is, as before, the user-visible
                    ID from Cabal <literal>foo-1.0</literal>; a package key is now
                    a compiler-internal entity used for generating linking symbols, and
                    may not correspond at all to the package ID.  In
                    particular, there may be multiple package keys per
                    package ID.
               </para>
           </listitem>
            <listitem>
                <para>
                    The ghc library no longer depends on the Cabal library. This means
                    that users of the ghc library are no longer forced to use the same
                    version of Cabal as ghc did. It also means that Cabal is freed up
                    to be able to depend on packages that ghc does not want to depend
                    on (which for example may enable improvements to Cabal's parsing
                    infrastructure).
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>ghc-prim</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.4.0.0 (was 0.3.1.0)
               </para>
           </listitem>
            <listitem>
                <para>
                    The low-level prefetch API exported by
                    <literal>GHC.Prim</literal> (added in GHC 7.8) has
                    been overhauled to use <literal>State#</literal>
                    parameters to serialize and thread state around.
               </para>
                <para>
                    This API is still considered experimental, and
                    will be prone to change.
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>haskeline</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.7.2.1 (was 0.7.1.2)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>hoopl</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 3.10.0.2 (was 3.10.0.0)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>hpc</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.6.0.2 (was 0.6.0.1)
               </para>
           </listitem>
            <listitem>
                <para>
                    The <literal>hpc</literal> command supports a new
                    flag, <literal>--verbosity=n</literal>, which
                    controls the verbosity level of subcommands.
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>integer-gmp</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.0.0.0 (was 0.5.1.0)
               </para>
           </listitem>
            <listitem>
                <para>
                    The <literal>integer-gmp</literal> package has
                    been completely rewritten to be more efficient and
                    interoperate more sanely with the GMP
                    library. Specifically, GHC no longer needs to
                    'hook' the GMP memory allocators to make
                    allocations exist on the Haskell heap, a
                    complication which makes GMP-dependent C libraries
                    difficult. This means external libraries that use
                    GMP (such as MPFR or FLINT) can now be trivially
                    FFI'd to without any complication.
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>pretty</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.1.2.0 (was 1.1.1.1)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>process</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.2.3.0 (was 1.2.0.0)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>template-haskell</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 2.10.0.0 (was 2.9.0.0)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>terminfo</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.4.0.1 (was 0.4.0.0)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>time</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.5.0.1 (was 1.4.2)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>transformers</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.4.2.0 (was 0.3.0.0)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>unix</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 2.7.1.0 (was 2.7.0.0)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>Win32</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 2.3.1.0 (was 2.3.0.1)
               </para>
           </listitem>
       </itemizedlist>
    </sect3>

    <sect3>
        <title>xhtml</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number remained at 3000.2.1
               </para>
           </listitem>
       </itemizedlist>
    </sect3>
  </sect2>

  <sect2>
    <title>Known bugs</title>
    <itemizedlist>
        <listitem>
            <para>
                For issues dealing with language changes, please see
                the <ulink
                url="https://ghc.haskell.org/trac/ghc/wiki/Migration/7.10">GHC
                7.10 Migration Guide</ulink> on the GHC wiki.
           </para>
       </listitem>
        <listitem>
            <para>
                GHC's LLVM backend does not support LLVM 3.4 (<ulink
		url="https://ghc.haskell.org/trac/ghc/ticket/9929">issue #9929</ulink>)
           </para>
       </listitem>
        <listitem>
            <para>
                On Mac OS X, the <literal>-threaded</literal> Garbage
                Collector currently suffers from a large performance
                penalty due to a lack of system-specific optimization
                (<ulink
		url="https://ghc.haskell.org/trac/ghc/ticket/7602">issue #7602</ulink>).
           </para>
       </listitem>
        <listitem>
            <para>
                GHC's LLVM backend is currently incompatible with LLVM
                3.4 (<ulink
		url="https://ghc.haskell.org/trac/ghc/ticket/9929">issue #9929</ulink>).
           </para>
       </listitem>
        <listitem>
            <para>
                GHCi fails to appropriately load
                <literal>.dyn_o</literal> files (<ulink
		url="https://ghc.haskell.org/trac/ghc/ticket/8736">issue #8736</ulink>).
           </para>
	</listitem>
	<listitem>
	  <para>
	  Not all cases of non-terminating type-level computation (with both
	  recursive type families and recursive newtypes) are caught. This
	  means that GHC might hang, but it should do so only when the program
	  is ill-typed (due to non-terminating type-level features). The bugs
	  are reported as <ulink
	  url="https://ghc.haskell.org/trac/ghc/ticket/7788">#7788</ulink>
	  and <ulink
	  url="https://ghc.haskell.org/trac/ghc/ticket/10139">#10139</ulink>.
	  There also remain certain obscure scenarios where the solver for
	  <literal>Coercible</literal> instances is known to be still
	  incomplete. See comments in <ulink
	  url="https://ghc.haskell.org/trac/ghc/ticket/10079">#10079</ulink>.
	  </para>
	</listitem>
   </itemizedlist>
  </sect2>
</sect1>