<?xml version="1.0" encoding="iso-8859-1"?>
<sect1 id="release-7-4-1">
  <title>Release notes for version 7.4.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.2 branch.
  </para>

  <sect2>
    <title>Highlights</title>

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

    <itemizedlist>
      <listitem>
          <para>
              The <literal>Num</literal> class no longer has
              <literal>Eq</literal> or <literal>Show</literal>
              superclasses. A number of other classes and
              functions have therefore gained explicit
              <literal>Eq</literal> or <literal>Show</literal>
              constraints, rather than relying on a
              <literal>Num</literal> constraint to provide them.
          </para>

          <para>
             You can make code that works with both
             Haskell98/Haskell2010 and GHC by:
             <itemizedlist>
               <listitem>
                 <para>
                   Whenever you make a <literal>Num</literal> instance
                   of a type, also make <literal>Show</literal> and
                   <literal>Eq</literal> instances, and
                 </para>
               </listitem>
               <listitem>
                 <para>
                   Whenever you give a function, instance or class a
                   <literal>Num t</literal> constraint, also give it
                   <literal>Show t</literal> and
                   <literal>Eq t</literal> constraints.
                 </para>
               </listitem>
             </itemizedlist>
           </para>
      </listitem>

      <listitem>
        <para>
          There is a new feature Safe Haskell
          (<literal>-XSafe</literal>,
           <literal>-XTrustworthy</literal>,
           <literal>-XUnsafe</literal>):
          <xref linkend="safe-haskell" />.
          The design has changed since 7.2.
        </para>
      </listitem>

      <listitem>
        <para>
          There is a new feature kind polymorphism
          (<literal>-XPolyKinds</literal>):
          <xref linkend="kind-polymorphism" />.
          A side-effect of this is that, when the extension is not
          enabled, in certain circumstances kinds are now defaulted to
          <literal>*</literal>
          rather than being inferred.
        </para>
      </listitem>

      <listitem>
        <para>
          There is a new feature constraint kinds (-XConstraintKinds):
          <xref linkend="constraint-kind" />.
        </para>
      </listitem>

      <listitem>
        <para>
          It is now possible to give any sort of declaration at the
          ghci prompt:
          <xref linkend="ghci-decls" />.
        </para>
      </listitem>

      <listitem>
        <para>
          The profiling and hpc implementations have been merged and
          overhauled. Visible changes include renaming of profiling
          flags and the cost-centre stacks have a new semantics, which
          should in most cases result in more useful and intuitive
          profiles. The <literal>+RTS -xc</literal> flag now also gives
          a stack trace.
        </para>
      </listitem>

      <listitem>
        <para>
          It is now possible to write compiler plugins:
          <xref linkend="compiler-plugins" />.
        </para>
      </listitem>

      <listitem>
        <para>
          DPH support has been significantly improved.
        </para>
      </listitem>

      <listitem>
        <para>
          There is now preliminary support for registerised
          compilation on the ARM platform, using LLVM.
        </para>
      </listitem>
    </itemizedlist>
  </sect2>

  <sect2>
    <title>Full details</title>
    <sect3>
        <title>Language</title>
        <itemizedlist>
            <listitem>
                <para>
                    GHC previously accepted this code:
                </para>
<programlisting>
data T f = T

class C a where
    t :: f a -> T f
</programlisting>
                <para>
                    inferring the kind of <literal>f</literal> as
                    <literal>* -> *</literal>, but it now (correctly,
                    according to the Haskell 98 and Haskell 2010
                    standards) rejects it. You need to write this
                    instead:
                </para>
<programlisting>
{-# LANGUAGE KindSignatures #-}

data T (f :: * -> *) = T

class C a where
    t :: f a -> T f
</programlisting>
            </listitem>

            <listitem>
                <para>
                    When the new <literal>DataKinds</literal> extension
                    is enabled, suitable user-defined datatypes are
                    automatically "promoted" to kinds, e.g.
                    <literal>Nat</literal> here:
                </para>
<programlisting>
data Nat = Zero | Succ Nat
data Vector :: * -> Nat -> * where
    VNil :: Vector a Zero
    VCons :: a -> Vector a n -> Vector a (Succ n)
</programlisting>
                <para>
                    See <xref linkend="promotion" /> for more
                    information.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new extension
                    <literal>PolyKinds</literal> which make it possible
                    for kinds to be polymorphic. For example, instead of
                </para>
<programlisting>
class Typeable (t :: *) where
  typeOf :: t -> TypeRep

class Typeable1 (t :: * -> *) where
  typeOf1 :: t a -> TypeRep

[...]

instance Typeable  Int  where typeOf _ = TypeRep
instance Typeable1 []   where typeOf _ = TypeRep
</programlisting>
                <para>
                    you can now say
                </para>
<programlisting>
data Proxy t = Proxy

class Typeable t where
  typeOf :: Proxy t -> TypeRep

instance Typeable Int  where typeOf _ = TypeRep
instance Typeable []   where typeOf _ = TypeRep
</programlisting>
                <para>
                    and the kind of <literal>Proxy</literal> is
                    polymorphic:
                    <literal>forall k. k -> *</literal>.
                </para>

                <para>
                    This feature is not yet fully mature, but please
                    do file bug reports if you run into problems.
                    See
                    <xref linkend="kind-polymorphism" />
                    for more information.
                </para>
            </listitem>

            <listitem>
                <para>
                    The Safe Haskell feature, new in GHC 7.2, has been
                    redesigned in GHC 7.4. The motivation was to stop
                    Safe Haskell from causing compilation failures for
                    people not interested in using it.
                </para>

                <para>
                    GHC now tries to infer whether a module is
                    safe, unless the new
                    <literal>-fno-safe-infer</literal> flag is given.
                    Therefore, as well as the old
                    <literal>-XSafe</literal>, there is now a
                    <literal>-XUnsafe</literal>
                    flag to explicitly state that a module should be
                    treated as unsafe. The old
                    <literal>-XSafeImports</literal> has been removed.
                </para>

                <para>
                    The new flags <literal>-fwarn-safe</literal> and
                    <literal>-fwarn-unsafe</literal> give warnings
                    when a module is inferred to be safe or unsafe,
                    respectively.
                </para>

                <para>
                    There is a new flag
                    <literal>-fpackage-trust</literal>. This controls
                    whether packages containing imported trustworthy
                    modules must be marked as
                    <literal>trusted</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is now a <literal>NOUNPACK</literal>
                    pragma, which does the opposite of the existing
                    <literal>PACK</literal> pragma. It is mainly useful
                    when <literal>-funbox-strict-fields</literal> has
                    been used, allowing you to declare that certain
                    fields should not be unpacked.
                </para>
            </listitem>

            <listitem>
                <para>
                    GHC now requires, as per the standard, that
                    if a <literal>newtype</literal> is used in an
                    FFI declaration, then the constructor for that
                    type must be in scope. For now you only get a
                    warning if it is not, but in the future this will
                    be an error.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new extension
                    <literal>ConstraintKind</literal>
                    which adds a new kind, called
                    <literal>Constraint</literal>,
                    to GHC's type system. Then, for example,
                </para>
<programlisting>
Show :: * -> Constraint
(?x::Int) :: Constraint
(Int ~ a) :: Constraint
</programlisting>
                <para>
                    You can now write <em>any</em> type with kind
                    <literal>Constraint</literal> on the left of
                    <literal>=&gt;</literal>, i.e. you can use type
                    synonyms, type variables, indexed types, etc.
                </para>
            </listitem>

            <listitem>
                <para>
                    It is now possible to derive an
                    <literal>Eq</literal> instance for types with no
                    constructors.
                </para>
            </listitem>

            <listitem>
                <para>
                    In the <literal>MonadComprehensions</literal>
                    extension, the
                    <literal>then group by e</literal>
                    form has been removed. You now need to explicitly
                    say
                    <literal>then group by e using groupWith</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new extension
                    <literal>TraditionalRecordSyntax</literal> which is
                    on by default. When turned off, the standard Haskell
                    record syntax cannot be used.
                </para>
            </listitem>

            <listitem>
                <para>
                    In DPH, it is now possible to vectorise things
                    imported from other modules.
                </para>
            </listitem>

            <listitem>
                <para>
                    In DPH, the <literal>VECTORISE</literal> and
                    <literal>VECTORISE SCALAR</literal> pragmas now have
                    <literal>type</literal>, <literal>class</literal>
                    and <literal>instance</literal> variants.
                    See
                    <ulink url="http://hackage.haskell.org/trac/ghc/wiki/DataParallel/VectPragma">VectPragma</ulink> for more details.
                </para>
            </listitem>

            <listitem>
                <para>
                    The <literal>-fdph-seq</literal>,
                    <literal>-fdph-par</literal>,
                    <literal>-fdph-this</literal> and
                    <literal>-fdph-none</literal> flags have been
                    removed. The vectoriser is now controlled by which
                    <literal>Data.Array.Parallel</literal> and
                    <literal>Data.Array.Parallel.Prim</literal>
                    modules are in scope.
                </para>
            </listitem>

            <listitem>
                <para>
                    GHC now warns consistently about unused type
                    variables.
                </para>
            </listitem>

            <listitem>
                <para>
                    GHC now implements the static pattern semantics
                    as clarified by the Haskell' committee, i.e.
                    the binding <literal>p = e</literal> is now
                    equivalent to
                </para>
<programlisting>
t = e
f = case t of p -> f
g = case t of p -> g
</programlisting>
                <para>
                    where <literal>f</literal> and <literal>g</literal>
                    are the variables bound by <literal>p</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    The <literal>MonoPatBinds</literal>
                    extension is now deprecated, and has no effect.
                </para>
            </listitem>

            <listitem>
                <para>
                    GHC will now reject a declaration if it infers a
                    type for it that is impossible to use unambiguously.
                    For example, given
                </para>
<programlisting>
class Wob a b where
    to :: a -> b
    from :: b -> a

foo x = [x, to (from x)]
</programlisting>
                <para>
                    GHC would infer the ambiguous type
                </para>
<programlisting>
foo :: forall a b. Wob a b => b -> [b]
</programlisting>
                <para>
                    but it is impossible to use
                    <literal>foo</literal> as
                    <literal>a</literal> will always be ambiguous,
                    so the declaration is rejected.
                </para>
            </listitem>

            <listitem>
                <para>
                    It is now possible for associated types to have
                    fresh parameters, e.g. this is now allowed:
                </para>
<programlisting>
class C a where
    type T a b :: *

instance C Int
    type T Int b = b -> b
</programlisting>
                <para>
                    where <literal>T</literal> has a type index
                    <literal>b</literal> that is not one of the class
                    variables.
                </para>
            </listitem>

            <listitem>
                <para>
                    It is now possible for multiple associated type
                    declarations to be given in a single instance,
                    e.g.
                </para>
<programlisting>
class C a where
    type T a x :: *

data A
data B

instance C Int where
    type T Int A = Int
    type T Int B = Bool
</programlisting>
            </listitem>

            <listitem>
                <para>
                    The import and export of type family data
                    constructors has been refined. You now need to be
                    more explicit about what should be exported.
                </para>
            </listitem>

            <listitem>
                <para>
                    Associated type default declarations are now
                    fully supported. These allow you to specify
                    a default definition for a type that will be used
                    if an instance doesn't define its own type, e.g.
                </para>
<programlisting>
class Cls a where
    type Typ a
    type Typ a = Maybe a
              
instance Cls Int where
</programlisting>
                <para>
                    See <xref linkend="assoc-decl-defs" /> for more
                    information.
                </para>
            </listitem>

            <listitem>
                <para>
                    You can now specify what simplifier phases
                    <literal>SPECIALISE</literal> pragmas should be
                    applied in, in the same way that you could for
                    <literal>RULE</literal> pragmas, e.g. to specialise
                    <literal>foo</literal> only in phase 1 use:
                </para>
<programlisting>
{-# SPECIALISE [1] foo :: Int -> Int #-}
</programlisting>
            </listitem>

            <listitem>
                <para>
                    The typechecker is now able to do full constraint
                    solving under a for-all, i.e. it can cope with the
                    unification
                    <literal>forall a. t1  ~  forall a. t2</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    The kind <literal>?</literal> has been renamed to
                    <literal>OpenKind</literal>, and
                    <literal>??</literal> to <literal>ArgKind</literal>.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>Compiler</title>
        <itemizedlist>
            <listitem>
                <para>
                    The recompilation checker now takes into account
                    what flags were used when compiling. For example,
                    if you first run <literal>ghc -c Foo.hs</literal>,
                    and then <literal>ghc -DBAR -c Foo.hs</literal>,
                    then GHC will now recompile
                    <literal>Foo.hs</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    The recompilation checker now also tracks files that
                    are <literal>#include</literal>d in Haskell sources.
                </para>
                <para>
                    Note that we still don't get
                    <literal>#include</literal>d files in the
                    <literal>ghc -M</literal> output.
                </para>
            </listitem>

            <listitem>
                <para>
                    The simplifier now maintains a count of how much
                    transformation it does, and prints a warning if
                    that exceeds a limit defined by the new
                    <literal>-fsimpl-tick-factor=N</literal> flag
                    (default is 100). The intention is to detect when
                    it seems likely that GHC has gone into an infinite
                    loop. In the future, GHC may give an error when the
                    limit is exceeded.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new flag
                    <literal>-fpedantic-bottoms</literal> which makes
                    GHC be more precise about its treatment of bottoms.
                    In particular, it stops GHC eta-expanding through
                    case expressions (which means performance can be
                    worse).
                </para>
            </listitem>

            <listitem>
                <para>
                    GHC now knows how to call gcc to compile
                    objective-c++ (<literal>.mm</literal> or
                    <literal>.M</literal> files).
                </para>
            </listitem>

            <listitem>
                <para>
                    The <literal>-optm</literal>
                    flag, which allowed extra arguments to be passed to
                    the mangler, is now deprecated and does nothing.
                    It will be removed in a future release.
                </para>
            </listitem>

            <listitem>
                <para>
                    GHC now works with LLVM version 3.0, and requires at
                    least version 2.8.
                </para>
            </listitem>

            <listitem>
                <para>
                    We now pass gcc
                    <literal>-no_compact_unwind</literal>
                    on OS X x86 (as well as x86_64), in order to avoid
                    the
                </para>
<programlisting>
ld: warning: could not create compact unwind for .LFB3: non-standard register 5 being saved in prolog
</programlisting>
                <para>
                    warning.
                </para>
            </listitem>

            <listitem>
                <para>
                    The context stack depth, which defines how deeply
                    the type constraint solver may reason, has been
                    increased from 20 to 200, as some people were
                    running into the limit.
                </para>
            </listitem>

            <listitem>
                <para>
                    On x86, the new <literal>-msse4.2</literal>
                    flag tells GHC that it may use SSE4.2 instructions.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new flag
                    <literal>-dno-llvm-mangler</literal>
                    which means the LLVM mangler isn't run. It is mainly
                    useful when debugging GHC.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new flag
                    <literal>-dsuppress-var-kinds</literal>
                    which can make the output clearer when
                    <literal>-dppr-debug</literal> is also used.
                </para>
            </listitem>

            <listitem>
                <para>
                    The <literal>-keep-llvm-files</literal>
                    flag now implies <literal>-fllvm</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    The <literal>-split-objs</literal> flag can now be
                    used with the LLVM backend.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new flag <literal>-dumpdir</literal>
                    which allows you to specify the directory in which
                    the output of the <literal>-ddump-*</literal> flags
                    should be put when <literal>-ddump-to-file</literal>
                    is used. The <literal>-outputdir</literal> flag will
                    now also set the dump directory.
                </para>
            </listitem>

            <listitem>
                <para>
                    Bitrotted registerised ports for mips, ia64, alpha,
                    hppa1 and m68k have been removed.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>GHCi</title>
        <itemizedlist>
            <listitem>
                <para>
                    It is now possible to give any top-level
                    declaration at the GHCi prompt, e.g.
                </para>
<programlisting>
Prelude> data D = C Int
Prelude> let f (C i) = i in f (C 5)
5
</programlisting>
                <para>
                    The current set of declarations are shown by
                    the new
                    <literal>:show bindings</literal>
                    command. See
                    <xref linkend="ghci-decls" />.
                    for more information
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new GHCi command
                    <literal>:kind!</literal>
                    which is like
                    <literal>:kind</literal>
                    except it also prints the normalised type; e.g., given
                </para>
<programlisting>
type family F a
type instance F Int = Bool
</programlisting>
                <para>
                    we get
                </para>
<programlisting>
*Main> :kind F Int
F Int :: *
*Main> :kind! F Int
F Int :: *
= Bool
</programlisting>
            </listitem>

            <listitem>
                <para>
                    There is a new flag
                    <literal>-fno-ghci-history</literal>
                    which stops GHCi from loading and saving the GHCi
                    command history from and to
                    <literal>~/.ghc/ghci_history</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    Library loading in GHCi has been improved; in
                    particular, loading
                    <literal>libstdc++.so</literal>
                    now works, and GHCi will use
                    <literal>.a</literal> archives to satisfy
                    <literal>-lfoo</literal> flags on its commandline.
                </para>
            </listitem>

            <listitem>
                <para>
                    When using
                    <literal>:load</literal>, GHCi will not unload
                    the current modules until it has successfully loaded
                    the new ones. This fixes this old problem:
                </para>
<programlisting>
Prelude> :l foo
target `foo' is not a module name or a source file
>
</programlisting>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>Template Haskell</title>
        <itemizedlist>
            <listitem>
                <para>
                    GHC used to treat <literal>\|</literal>
                    and <literal>\]</literal> within quasiquote as
                    escaped characters, parsing them as
                    <literal>|</literal> and <literal>]</literal>
                    respectively. It now does not treat anything
                    specially; if you would like to be able to include
                    sequences such as <literal>|]</literal> inside a
                    quasi-quote then you must define your own escaping
                    mechanism in the quasi-quoter.
                </para>
            </listitem>
            <listitem>
                <para>
                    The interaction between the recompilation checker
                    and Template Haskell has been improved. We now
                    track which modules are used by splices, and if
                    a module is changed then any splices that use it
                    will need to be rerun.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>Profiling</title>
        <itemizedlist>
            <listitem>
                <para>
                    The profiling, coverage (HPC) and breakpoints
                    infrastructure has been overhauled, and the
                    three systems are now much more unified.
                </para>

                <para>
                    As a result of these changes, the cost-centre
                    stacks have a new semantics, which should give
                    more intuitive profiling results. HPC is also
                    slightly improved: In particular, unused derived
                    instances and record field names are now
                    highlighted, and entry counts are more accurate.
                </para>

                <para>
                    The <literal>+RTS -xc</literal> flag now also gives
                    a stack trace.
                </para>

                <para>
                    The
                    <literal>-auto-all</literal> flag has been renamed
                    to <literal>-fprof-auto</literal>,
                    <literal>-auto</literal> renamed to
                    <literal>-fprof-auto-exported</literal>, and
                    <literal>-caf-all</literal> renamed to
                    <literal>-fprof-cafs</literal>. The old names are
                    also still accepted for now.
                </para>

                <para>
                    There are also two new flags.
                    The <literal>-fprof-auto-top</literal> flag
                    annotates all top-level bindings with SCCs, and
                    the <literal>-fprof-auto-calls</literal> flag
                    adds SCCs to all applications. This last flag
                    is particularly useful for stack traces.
                </para>

                <para>
                    Another new flag
                    <literal>-fprof-no-count-entries</literal>
                    indicates that entry counts do not need to be
                    maintained. This makes profiled code faster, and
                    is particularly useful when heap profiling, as
                    heap profiles do not use the entry counts.
                </para>
            </listitem>

            <listitem>
                <para>
                    Cost centre names are now in UTF8 rather than
                    Latin-1.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is now better heap profiling support for
                    pinned objects (e.g. <literal>ByteStrings</literal>).
                    Previously we were completely ignoring them,
                    due to technical difficulties, but now count
                    all the pinned object space (including gaps between
                    pinned objects) as being type
                    <literal>ARR_WORDS</literal>. This isn't ideal, but
                    at least we do now account for the memory, and give
                    it the right type.
                </para>
            </listitem>

            <listitem>
                <para>
                    The quotes in an <literal>SCC</literal> pragma can
                    now be omitted if the SCC name is a valid Haskell
                    variable name, e.g.
                    <literal>{-# SCC  my_function #-} expr</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    It is now possible to use profiling when running on
                    multiple capabilities (i.e. when running with
                    <literal>+RTS -N</literal>). There is a new built-in
                    cost centre called <literal>IDLE</literal>, which
                    records the ticks of idle capabilities.
                </para>

                <para>
                    There are still some rough edges. In particular,
                    it is strongly recommended that you use the
                    <literal>-fno-prof-count-entries</literal> flag
                    or the program will run very slowly.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>Event logging</title>
        <itemizedlist>

            <listitem>
                <para>
                    There are new eventlog events
                    <literal>EVENT_SPARK_COUNTERS</literal>
                    <literal>EVENT_SPARK_CREATE</literal>
                    <literal>EVENT_SPARK_DUD</literal>
                    <literal>EVENT_SPARK_OVERFLOW</literal>
                    <literal>EVENT_SPARK_RUN</literal>
                    <literal>EVENT_SPARK_STEAL</literal>
                    <literal>EVENT_SPARK_FIZZLE</literal> and
                    <literal>EVENT_SPARK_GC</literal> for giving
                    information about sparks.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new eventlog event
                    <literal>EVENT_WALL_CLOCK_TIME</literal>
                    which is used for matching the time of events
                    between different processes.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new eventlog event
                    <literal>EVENT_THREAD_LABEL</literal>
                    which is emitted by the existing
                    <literal>GHC.Conc.labelThread</literal>
                    function. This allows tools such as
                    ThreadScope to use thread labels rather
                    than thread numbers.
                </para>
            </listitem>

            <listitem>
                <para>
                    The eventlog class <literal>g</literal>
                    is no longer ignored, but now controls whether
                    events related to the garbage collector are emitted.
                    There are also new event classes
                    <literal>p</literal> and
                    <literal>f</literal>, which contain sampled
                    (approximate) and full (fully accurate)
                    spark-related events respectively, and
                    <literal>u</literal> which contains user events.
                </para>

                <para>
                    There is also a meta eventlog class
                    <literal>a</literal> which, when enabled or
                    disabled, enables or disables all the classes.
                </para>

                <para>
                    By default, all classes apart from
                    <literal>f</literal> are enabled.
                </para>
            </listitem>

            <listitem>
                <para>
                    On Windows, if the program name ends in
                    <literal>.exe</literal> then the
                    <literal>.exe</literal> is removed when making
                    the eventlog filename.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>Runtime system</title>
        <itemizedlist>
            <listitem>
                <para>
                    The restrictions on what
                    <literal>+RTS</literal>
                    flags are available by default has changed.
                    By default, you can now use the
                    <literal>-t</literal>,
                    <literal>-T</literal>,
                    <literal>-s</literal> and
                    <literal>-S</literal> RTS flags, provided you do not
                    give them a filename argument.
                </para>

                <para>
                    Additionally, when linking with
                    <literal>-threaded</literal>, you can now use the
                    <literal>+RTS -N</literal> flag without having
                    to link with <literal>-rtsopts</literal>.
                    Also, when linking with "developer" ways
                    (<literal>-debug</literal>,
                    <literal>-eventlog</literal> and
                    <literal>-prof</literal>) all the way-specific flags
                    are allowed; for example,
                    <literal>+RTS -h</literal> is allowed when linking
                    with <literal>-prof</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new RTS flag
                    <literal>-T</literal>, which makes the RTS collect
                    statistics (memory usage, etc) but not give any
                    output. The new <literal>GHC.Stats</literal>
                    module in the <literal>base</literal> package
                    provides access to this data.
                </para>
            </listitem>

            <listitem>
                <para>
                    You can now give the RTS flag
                    <literal>-H</literal>
                    (without an argument) and the runtime system
                    will infer a sensible value to use. See
                    <xref linkend="rts-options-gc" /> for more details.
                </para>
            </listitem>

            <listitem>
                <para>
                    When using <literal>-no-hs-main</literal>
                    and starting the runtime system yourself,
                    if you wish to pass RTS flags then you will now
                    need to use the new <literal>hs_init_ghc</literal>
                    function. See <xref linkend="using-own-main" />
                    for details.
                </para>
            </listitem>

            <listitem>
                <para>
                    The runtime system now supports using
                    <literal>forkProcess</literal>
                    when running with multiple capabilities
                    (<literal>+RTS -N</literal>).
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>Build system</title>
        <itemizedlist>
            <listitem>
                <para>
                    You can now build GHC with Alex 3.0.
                </para>
            </listitem>

            <listitem>
                <para>
                    On OS X, with XCode 4.0 and 4.1, GHC will use
                    gcc-4.2 rather than gcc (which is based on LLVM,
                    and currently produces slower code for GHC).
                </para>
            </listitem>

            <listitem>
                <para>
                    There is now preliminary support for registerised
                    compilation on the ARM platform, using LLVM.
                </para>
            </listitem>

            <listitem>
                <para>
                    Dynamic libraries are now supported on OSX x86_64.
                </para>
            </listitem>

            <listitem>
                <para>
                    GHCi is now supported on kfreebsdgnu platforms.
                </para>
            </listitem>

            <listitem>
                <para>
                    GHC now recognises the s390x architecture.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>
  </sect2>

  <sect2>
    <title>Libraries</title>

    <para>
        There have been some changes that have effected multiple
        libraries:
    </para>

    <itemizedlist>
        <listitem>
            <para>
                The <literal>Num</literal> class no longer has
                <literal>Eq</literal> or <literal>Show</literal>
                superclasses. A number of other classes and
                functions have therefore gained explicit
                <literal>Eq</literal> or <literal>Show</literal>
                constraints, rather than relying on a
                <literal>Num</literal> constraint to provide them.
            </para>

            <para>
               You can make code that works with both
               Haskell98/Haskell2010 and GHC by:
               <itemizedlist>
                 <listitem>
                   <para>
                     Whenever you make a <literal>Num</literal> instance
                     of a type, also make <literal>Show</literal> and
                     <literal>Eq</literal> instances, and
                   </para>
                 </listitem>
                 <listitem>
                   <para>
                     Whenever you give a function, instance or class a
                     <literal>Num t</literal> constraint, also give it
                     <literal>Show t</literal> and
                     <literal>Eq t</literal> constraints.
                   </para>
                 </listitem>
               </itemizedlist>
             </para>
        </listitem>

        <listitem>
            <para>
                Many modules have been given Safe Haskell
                <literal>Safe</literal>, <literal>Unsafe</literal> or
                <literal>Trustworthy</literal> annotations.
            </para>
        </listitem>
    </itemizedlist>

    <sect3>
        <title>array</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.4.0.0 (was 0.3.0.3)
                </para>
            </listitem>

            <listitem>
                <para>
                    There are new modules
                    <literal>Data.Array.IO.Safe</literal>,
                    <literal>Data.Array.MArray.Safe</literal>,
                    <literal>Data.Array.ST.Safe</literal> and
                    <literal>Data.Array.Storable.Safe</literal>
                    containing just the safe (in the Safe Haskell sense
                    of the term) parts of their respective APIs, and
                    <literal>Data.Array.Unsafe</literal> containing
                    the unsafe parts of the
                    <literal>Data.Array</literal> API.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new module
                    <literal>Data.Array.Storable.Internals</literal>
                    which exports some internal functions for the
                    <literal>Data.Array.Storable</literal> API.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>Data.Array.IO.castIOUArray</literal>
                    is now deprecated; use
                    <literal>Data.Array.Unsafe.castIOUArray</literal>
                    instead.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>Data.Array.ST.castSTUArray</literal>
                    is now deprecated; use
                    <literal>Data.Array.Unsafe.castSTUArray</literal>
                    instead.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>Data.Array.MArray.unsafeFreeze</literal>
                    and <literal>Data.Array.MArray.unsafeThaw</literal>
                    are now deprecated; use
                    <literal>Data.Array.Unsafe.unsafeFreeze</literal>
                    and <literal>Data.Array.Unsafe.unsafeThaw</literal>
                    instead.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>Data.Array.Storable.unsafeForeignPtrToStorableArray</literal>
                    is now deprecated; use
                    <literal>Data.Array.Unsafe.unsafeForeignPtrToStorableArray</literal>
                    instead.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>base</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 4.5.0.0 (was 4.4.1.0)
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>Data.Monoid</literal> now exports
                    <literal>&lt;&gt;</literal> as an infix synonym for
                    <literal>mappend</literal> It associates to the
                    right, and has precedence 6.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>Data.List</literal> has a new function
                    <literal>dropWhileEnd</literal>, which is similar to
                    <literal>dropWhile</literal> except it removes the
                    suffix of characters matching the predicate, rather
                    than the prefix of characters.
                </para>
            </listitem>

            <listitem>
                <para>
                    The <literal>Data.Bits.Bits</literal>
                    class has two new methods
                    <literal>unsafeShiftL</literal> and
                    <literal>unsafeShiftR</literal> which perform shifts
                    on the assumption that the amount to be shifted by
                    is positive.
                </para>
            </listitem>

            <listitem>
                <para>
                    The <literal>Data.Bits.Bits</literal>
                    class has a new method <literal>popCount</literal>
                    which returns the number of bits that are set in the
                    value.
                </para>
            </listitem>

            <listitem>
                <para>
                    The <literal>C*</literal> types exported by
                    <literal>Foreign.C.Types</literal> and
                    <literal>System.Posix.Types</literal> are now
                    exported non-abstractly, as the FFI now requires
                    that the constructors for newtypes are visible.
                </para>
            </listitem>

            <listitem>
                <para>
                    In <literal>Data.Typeable</literal>,
                    <literal>tyConString</literal> is now deprecated,
                    in favour of the new
                    <literal>tyConPackage</literal>,
                    <literal>tyConModule</literal> and
                    <literal>tyConName</literal> functions.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>GHC.Exts.traceEvent</literal>
                    is now deprecated. You should use the new
                    <literal>Debug.Trace.traceEventIO</literal>
                    instead. There is also a new function
                    <literal>Debug.Trace.traceEvent</literal> that is
                    analogous to <literal>Debug.Trace.trace</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>Debug.Trace.putTraceMsg</literal>
                    is now deprecated in favour of the new function
                    <literal>Debug.Trace.traceIO</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    When a program is compiled with
                    <literal>-prof</literal>, GHC's run-time system now
                    makes a stack trace (based on the SCCs defined)
                    available to the program.
                </para>
                <para>
                    There is a new function
                    <literal>GHC.Exts.currentCallStack</literal> which
                    returns the stack trace as a list of
                    <literal>String</literal>s.
                </para>
                <para>
                    There is also a new function
                    <literal>Debug.Trace.traceStack</literal> which is
                    like <literal>Debug.Trace.trace</literal> but also
                    prints a call stack trace if one is available.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>GHC.Conc</literal> has a new function,
                    <literal>getNumProcessors</literal>, which returns
                    the number of CPUs that the machine has.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>GHC.Conc</literal> has a new function,
                    <literal>setNumCapabilities</literal>, which sets
                    the number of Haskell threads which can run
                    simultaneously. Currently GHC only allows increasing
                    the number of running threads.
                </para>
            </listitem>

            <listitem>
                <para>
                    The encodings used for the filesystem, for foreign
                    calls, and for the locale, are now mutable.
                    In order to alter them you need to use
                    <literal>setLocaleEncoding</literal>,
                    <literal>setFileSystemEncoding</literal> and
                    <literal>setForeignEncoding</literal> from
                    <literal>GHC.IO.Encoding</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    Assertions are now better behaved; if an assertion
                    fails then you will get an assertion error, rather
                    than another <literal>_|_</literal> result from the
                    expression that the assertion guards.
                </para>
            </listitem>

            <listitem>
                <para>
                    A bug in the behaviour of
                    <literal>scaleFloat</literal> on
                    <literal>Float</literal> and
                    <literal>Double</literal> when used with non-finite
                    values has been fixed.
                </para>
            </listitem>

            <listitem>
                <para>
                    A bug which meant that
                    <literal>System.IO.fixIO</literal> was not
                    threadsafe has been fixed.
                </para>
                <para>
                    There is also now a new
                    <literal>System.IO.Unsafe.unsafeFixIO</literal> that
                    may be more efficient, but is not guaranteed to be
                    threadsafe.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new module <literal>GHC.Stats</literal>
                    which exports a function
                    <literal>getGCStats</literal> which gives some info
                    from the runtime system using the
                    <literal>GCStats</literal> type.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new type
                    <literal>GHC.Exts.Constraint</literal> which
                    is used with the <literal>ConstraintKind</literal>
                    extension.
                </para>
            </listitem>

            <listitem>
                <para>
                    The <literal>Control.Monad.Group</literal> module,
                    and the <literal>MonadGroup</literal> class that it
                    defined, have been removed.
                </para>
            </listitem>

            <listitem>
                <para>
                    Support for platforms where word size is less than
                    32bits has been removed.
                </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.5.0.3 (was 0.5.0.2)
                    It is now exposed by default.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>bytestring</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.9.2.1 (was 0.9.2.0)
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>Cabal</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.14.0.0 (was 1.12.0.0)
                </para>
            </listitem>

            <listitem>
                <para>
                    For details of the changes to the Cabal library,
                    plese see the Cabal changelog.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>containers</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.4.2.1 (was 0.4.1.0)
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>Data.Map</literal>
                    now exports
                    <literal>foldr</literal>,
                    <literal>foldr'</literal>,
                    <literal>foldl</literal> and
                    <literal>foldl'</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>Data.Set</literal>
                    now exports
                    <literal>foldr</literal>,
                    <literal>foldr'</literal>,
                    <literal>foldl</literal> and
                    <literal>foldl'</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>Data.IntMap</literal>
                    now exports
                    <literal>foldr</literal>,
                    <literal>foldr'</literal>,
                    <literal>foldl</literal>,
                    <literal>foldl'</literal>,
                    <literal>foldrWithKey</literal>,
                    <literal>foldrWithKey'</literal>,
                    <literal>foldlWithKey</literal> and
                    <literal>foldlWithKey'</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>Data.IntSet</literal>
                    now exports
                    <literal>foldr</literal>,
                    <literal>foldr'</literal>,
                    <literal>foldl</literal> and
                    <literal>foldl'</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>Data.Map.foldWithKey</literal> is no
                    longer deprecated, although it is expected to
                    be deprecated again in the future.
                </para>
            </listitem>

            <listitem>
                <para>
                    There are now
                    <literal>NFData</literal>
                    instance for
                    <literal>Data.Map.Map</literal>,
                    <literal>Data.Set.Set</literal>,
                    <literal>Data.IntMap.IntMap</literal>,
                    <literal>Data.IntSet.IntSet</literal> and
                    <literal>Data.Tree.Tree</literal>.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>deepseq</title>
        <itemizedlist>
            <listitem>
                <para>
                    New package, version 1.3.0.0.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>directory</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.1.0.2 (was 1.1.0.1)
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>extensible-exceptions</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.1.1.4 (was 0.1.1.3)
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>filepath</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.3.0.0 (was 1.2.0.1)
                </para>
            </listitem>

            <listitem>
                <para>
                    A bug, which caused
                    <literal>normalise "/"</literal> to return
                    <literal>"/."</literal> rather than
                    <literal>"/"</literal>, has been fixed.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

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

    <sect3>
        <title>haskell98</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 2.0.0.1 (was 2.0.0.0)
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>haskell2010</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.1.0.1 (was 1.1.0.0)
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>hoopl</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 3.8.7.3 (was 3.8.7.2)
                </para>
            </listitem>

            <listitem>
                <para>
                    A new <literal>liftFuel</literal> method has been
                    added to
                    <literal>Compiler.Hoopl.Fuel.FuelMonadT</literal>.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>hpc</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.5.1.1 (was 0.5.1.0)
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>integer-gmp</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 0.4.0.0 (was 0.3.0.0)
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new module
                    <literal>GHC.Integer.GMP.Prim</literal>
                    that exports the Haskell imports of the GMP
                    functions. They are no longer exported by
                    <literal>GHC.Integer.GMP.Internals</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>GHC.Integer.GMP.Internals</literal>
                    now exports <literal>gcdInteger</literal> and
                    <literal>lcmInteger</literal>. They are no longer
                    exported by <literal>GHC.Integer</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    There is a new function <literal>mkInteger</literal>
                    exported from <literal>GHC.Integer.Type</literal>
                    and <literal>GHC.Integer</literal>. It constructs an
                    <literal>Integer</literal> from a
                    <literal>Bool</literal> (indicating the sign) and a
                    list of <literal>Int</literal>s (which provide the
                    value, in 31-bit chunks, least-significant first).
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>old-locale</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.0.0.4 (was 1.0.0.3)
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>old-time</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.1.0.0 (was 1.0.0.7)
                </para>
            </listitem>

            <listitem>
                <para>
                    A bug which caused
                    <literal>System.Time.formatCalendarTime</literal>
                    to show a value 1 too low for the
                    <literal>%j</literal> format specifier has been fixed.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>pretty</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.1.1.0 (was 1.1.0.0)
                </para>
            </listitem>

            <listitem>
                <para>
                    The recommended module is now
                    <literal>Text.PrettyPrint</literal> rather than
                    <literal>Text.PrettyPrint.HughesPJ</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    Both modules now export <literal>first</literal>,
                    which takes two documents and returns the first
                    provided it is non-empty, and the second otherwise.
                </para>
            </listitem>

            <listitem>
                <para>
                    Both modules now export
                    <literal>reduceDoc</literal>.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>process</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.1.0.1 (was 1.1.0.0)
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

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

            <listitem>
                <para>
                    The
                    <literal>Language.Haskell.TH.Syntax.Quasi</literal>
                    class now has a <literal>qAddDependentFile</literal>
                    method, which splices can use to indicate that the
                    result of the splice depends upon the contents of
                    a file. This tells the compiler that if the file
                    has changed then it will need to recompile the
                    module containing the splice.
                </para>
                <para>
                    There is also a new helper function
                    <literal>addDependentFile</literal> in
                    <literal>Language.Haskell.TH.Syntax</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    The
                    <literal>Language.Haskell.TH.Syntax.Exp</literal>
                    type now has <literal>UInfixE</literal> and
                    <literal>ParensE</literal> constructors, and
                    <literal>Language.Haskell.TH.Syntax.Pat</literal>
                    gains corresponding <literal>UInfixP</literal>
                    and <literal>ParensP</literal> constructors.
                </para>
                <para>
                    There are corresponding helper functions
                    <literal>uInfixE</literal>,
                    <literal>parensE</literal>,
                    <literal>uInfixP</literal> and
                    <literal>parensP</literal> defined in
                    <literal>Language.Haskell.TH.Lib</literal>
                    and re-exported by
                    <literal>Language.Haskell.TH</literal>.
                </para>
                <para>
                    These constructors are used for infix expressions
                    where the fixities of the operators are not known.
                    The compiler will look up the fixities and
                    reassociate the expression as necessary.
                </para>
                <para>
                    There is also a new value
                    <literal>Language.Haskell.TH.Ppr.unopPrec</literal>
                    used when pretty-printing expressions of unknown
                    fixity.
                </para>
            </listitem>

            <listitem>
                <para>
                    The
                    <literal>Language.Haskell.TH.Syntax.Strict</literal>
                    type now has an <literal>Unpacked</literal>
                    constructor, which corresponds to the
                    <literal>{-# UNPACK #-}</literal> pragma.
                    There is a corresponding helper function
                    <literal>Language.Haskell.TH.Lib.unpacked</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    The
                    <literal>Language.Haskell.TH.Syntax.Info</literal>
                    type has a new constructor
                    <literal>FamilyI</literal>, used when reifying a
                    data or type family's name.
                </para>
            </listitem>

            <listitem>
                <para>
                    The
                    <literal>Language.Haskell.TH.Syntax.ClassInstance</literal>
                    type has been removed, and the
                    <literal>ClassI</literal> constructor of
                    <literal>Language.Haskell.TH.Syntax.Info</literal>
                    now contains <literal>[InstanceDec]</literal>
                    rather than <literal>[ClassInstance]</literal>.
                </para>
                <para>
                    <literal>Language.Haskell.TH.Syntax.InstanceDec</literal>
                    is a new type synonym of
                    <literal>Language.Haskell.TH.Syntax.Dec</literal>,
                    but its constructor is guaranteed to be one of
                    <literal>InstanceD</literal> (with empty 
                    <literal>[Dec]</literal>),
                    <literal>DataInstD</literal> or
                    <literal>NewtypeInstD</literal> (with empty derived
                    <literal>[Name]</literal>), or
                    <literal>TySynInstD</literal>.
                </para>
                <para>
                    The <literal>qClassInstances</literal> method of the
                    <literal>Language.Haskell.TH.Syntax.Quasi</literal>
                    class has been replaced with a
                    <literal>qReifyInstances</literal> method.
                </para>
                <para>
                    Likewise, in
                    <literal>Language.Haskell.TH.Syntax</literal>, the
                    <literal>isClassInstance</literal> and
                    <literal>classInstances</literal> functions have
                    been replaced by <literal>isInstance</literal> and
                    <literal>reifyInstances</literal>. They are also
                    re-exported by
                    <literal>Language.Haskell.TH</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    The
                    <literal>Language.Haskell.TH.Syntax.Quasi</literal>
                    class now has a <literal>qLookupName</literal>
                    method, which takes a
                    <literal>Bool</literal>
                    indictaing whether you are looking for a type or a
                    value, and a
                    <literal>String</literal>.
                    It then tries to look up the name, returning a
                    <literal>Maybe Name</literal> in the monad.
                </para>
                <para>
                    There are also new helper functions
                    <literal>lookupTypeName</literal> and
                    <literal>lookupValueName</literal>, which are also
                    re-exported by
                    <literal>Language.Haskell.TH</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    The
                    <literal>Language.Haskell.TH.Syntax.Quasi</literal>
                    class now has an <literal>Applicative</literal>
                    superclass, rather than a <literal>Functor</literal>
                    superclass. There is also now an
                    <literal>Applicative</literal> instance for
                    <literal>Language.Haskell.TH.Syntax.Q</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    The <literal>NameSpace</literal> type is now
                    abstractly re-exported by
                    <literal>Language.Haskell.TH</literal>.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>time</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 1.4 (was 1.2.0.5)
                </para>
            </listitem>

            <listitem>
                <para>
                    A <literal>RealFrac</literal>
                    instance has been added for
                    <literal>Data.Time.Clock.Scale.DiffTime</literal>.
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>NFData</literal>
                    instances have been added for
                    <literal>Data.Time.Calendar.Days.Day</literal>,
                    <literal>Data.Time.Clock.Scale.UniversalTime</literal>,
                    <literal>Data.Time.Clock.Scale.DiffTime</literal>,
                    <literal>Data.Time.Clock.TAI.AbsoluteTime</literal>,
                    <literal>Data.Time.Clock.UTC.UTCTime</literal>,
                    <literal>Data.Time.Clock.UTC.NominalDiffTime</literal>,
                    <literal>Data.Time.LocalTime.LocalTime.LocalTime</literal>,
                    <literal>Data.Time.LocalTime.LocalTime.ZonedTime</literal>,
                    <literal>Data.Time.LocalTime.TimeOfDay.TimeOfDay</literal>
                    and
                    <literal>Data.Time.LocalTime.TimeZone.TimeZone</literal>.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>unix</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 2.5.1.0 (was 2.5.0.0)
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>System.Posix</literal> now re-exports
                    <literal>System.Posix.DynamicLinker</literal>
                    (although it hides the <literal>Default</literal>
                    constructor, as that clashes with the constructor
                    of the same name of the
                    <literal>System.Posix.Signals.Handler</literal>
                    type).
                </para>
            </listitem>

            <listitem>
                <para>
                    There is now a raw bytestring version of the
                    filepath and environment APIs. It uses a
                    <literal>RawFilePath = ByteString</literal>
                    type synonym, and adds a number of new exposed
                    modules:
                    <literal>System.Posix.ByteString</literal>,
                    <literal>System.Posix.ByteString.FilePath</literal>,
                    <literal>System.Posix.Directory.ByteString</literal>,
                    <literal>System.Posix.DynamicLinker.Module.ByteString</literal>,
                    <literal>System.Posix.DynamicLinker.ByteString</literal>,
                    <literal>System.Posix.Files.ByteString</literal>,
                    <literal>System.Posix.IO.ByteString</literal>,
                    <literal>System.Posix.Env.ByteString</literal>,
                    <literal>System.Posix.Process.ByteString</literal>,
                    <literal>System.Posix.Temp.ByteString</literal> and
                    <literal>System.Posix.Terminal.ByteString</literal>.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3>
        <title>Win32</title>
        <itemizedlist>
            <listitem>
                <para>
                    Version number 2.2.2.0 (was 2.2.1.0)
                </para>
            </listitem>

            <listitem>
                <para>
                    <literal>System.Win32.File</literal> now exports
                    <literal>failIfWithRetry</literal>,
                    <literal>failIfWithRetry_</literal> and
                    <literal>failIfFalseWithRetry_</literal>.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>
  </sect2>
</sect1>

