Ticket #2271: nextRealFrac.dpatch

1 patch for repository /home/dafis/Haskell/Hacking/ghc/libraries/base:

Mon Oct 18 23:03:37 CEST 2010  Daniel Fischer <daniel.is.fischer@web.de>
  * FIX #2271
  Faster rounding functions for Double and float with Int or Integer results.
  Fixes #2271.
  Since some glibc's have buggy rintf or rint functions and the behaviour of
  these functions depends on the setting of the rounding mode, we provide our
  own implementations which always round ties to even.
  
  Also added rewrite rules and removed trailing whitespace.

New patches:

[FIX #2271
Daniel Fischer <daniel.is.fischer@web.de>**20101018210337
 Ignore-this: ae53a9cc96244741f54aa2c93f577ecc
 Faster rounding functions for Double and float with Int or Integer results.
 Fixes #2271.
 Since some glibc's have buggy rintf or rint functions and the behaviour of
 these functions depends on the setting of the rounding mode, we provide our
 own implementations which always round ties to even.
 
 Also added rewrite rules and removed trailing whitespace.
] {
adddir ./GHC/Float
hunk ./GHC/Float.lhs 24
 #include "ieee-flpt.h"
 
 -- #hide
-module GHC.Float( module GHC.Float, Float(..), Double(..), Float#, Double# )
+module GHC.Float( module GHC.Float, Float(..), Double(..), Float#, Double#
+                , double2Int, int2Double, float2Int, int2Float )
     where
 
 import Data.Maybe
hunk ./GHC/Float.lhs 38
 import GHC.Num
 import GHC.Real
 import GHC.Arr
+import GHC.Float.RealFracMethods
 
 infixr 8  **
 \end{code}
hunk ./GHC/Float.lhs 196
     fromRational x      =  fromRat x
     recip x             =  1.0 / x
 
-{-# RULES "truncate/Float->Int" truncate = float2Int #-}
+-- RULES for Integer and Int
+{-# RULES
+"properFraction/Float->Integer"     properFraction = properFractionFloatInteger
+"truncate/Float->Integer"           truncate = truncateFloatInteger
+"floor/Float->Integer"              floor = floorFloatInteger
+"ceiling/Float->Integer"            ceiling = ceilingFloatInteger
+"round/Float->Integer"              round = roundFloatInteger
+"properFraction/Float->Int"         properFraction = properFractionFloatInt
+"truncate/Float->Int"               truncate = float2Int
+"floor/Float->Int"                  floor = floorFloatInt
+"ceiling/Float->Int"                ceiling = ceilingFloatInt
+"round/Float->Int"                  round = roundFloatInt
+  #-}
 instance  RealFrac Float  where
 
hunk ./GHC/Float.lhs 211
-    {-# SPECIALIZE properFraction :: Float -> (Int, Float) #-}
-    {-# SPECIALIZE round    :: Float -> Int #-}
-
-    {-# SPECIALIZE properFraction :: Float  -> (Integer, Float) #-}
-    {-# SPECIALIZE round    :: Float -> Integer #-}
-
         -- ceiling, floor, and truncate are all small
hunk ./GHC/Float.lhs 212
-    {-# INLINE ceiling #-}
-    {-# INLINE floor #-}
-    {-# INLINE truncate #-}
+    {-# INLINE [1] ceiling #-}
+    {-# INLINE [1] floor #-}
+    {-# INLINE [1] truncate #-}
 
 -- We assume that FLT_RADIX is 2 so that we can use more efficient code
 #if FLT_RADIX != 2
hunk ./GHC/Float.lhs 357
     acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))
     atanh x = 0.5 * log ((1.0+x) / (1.0-x))
 
-{-# RULES "truncate/Double->Int" truncate = double2Int #-}
+-- RULES for Integer and Int
+{-# RULES
+"properFraction/Double->Integer"    properFraction = properFractionDoubleInteger
+"truncate/Double->Integer"          truncate = truncateDoubleInteger
+"floor/Double->Integer"             floor = floorDoubleInteger
+"ceiling/Double->Integer"           ceiling = ceilingDoubleInteger
+"round/Double->Integer"             round = roundDoubleInteger
+"properFraction/Double->Int"        properFraction = properFractionDoubleInt
+"truncate/Double->Int"              truncate = double2Int
+"floor/Double->Int"                 floor = floorDoubleInt
+"ceiling/Double->Int"               ceiling = ceilingDoubleInt
+"round/Double->Int"                 round = roundDoubleInt
+  #-}
 instance  RealFrac Double  where
 
hunk ./GHC/Float.lhs 372
-    {-# SPECIALIZE properFraction :: Double -> (Int, Double) #-}
-    {-# SPECIALIZE round    :: Double -> Int #-}
-
-    {-# SPECIALIZE properFraction :: Double -> (Integer, Double) #-}
-    {-# SPECIALIZE round    :: Double -> Integer #-}
-
         -- ceiling, floor, and truncate are all small
hunk ./GHC/Float.lhs 373
-    {-# INLINE ceiling #-}
-    {-# INLINE floor #-}
-    {-# INLINE truncate #-}
+    {-# INLINE [1] ceiling #-}
+    {-# INLINE [1] floor #-}
+    {-# INLINE [1] truncate #-}
 
     properFraction x
       = case (decodeFloat x)      of { (m,n) ->
hunk ./GHC/Float.lhs 379
-        let  b = floatRadix x     in
         if n >= 0 then
hunk ./GHC/Float.lhs 380
-            (fromInteger m * fromInteger b ^ n, 0.0)
+            (fromInteger m * 2 ^ n, 0.0)
         else
hunk ./GHC/Float.lhs 382
-            case (quotRem m (b^(negate n))) of { (w,r) ->
+            case (quotRem m (2^(negate n))) of { (w,r) ->
             (fromInteger w, encodeFloat r n)
             }
         }
hunk ./GHC/Float.lhs 836
 ltFloat     (F# x) (F# y) = ltFloat# x y
 leFloat     (F# x) (F# y) = leFloat# x y
 
-float2Int :: Float -> Int
-float2Int   (F# x) = I# (float2Int# x)
-
-int2Float :: Int -> Float
-int2Float   (I# x) = F# (int2Float# x)
-
 expFloat, logFloat, sqrtFloat :: Float -> Float
 sinFloat, cosFloat, tanFloat  :: Float -> Float
 asinFloat, acosFloat, atanFloat  :: Float -> Float
hunk ./GHC/Float.lhs 876
 ltDouble    (D# x) (D# y) = x <## y
 leDouble    (D# x) (D# y) = x <=## y
 
-double2Int :: Double -> Int
-double2Int   (D# x) = I# (double2Int#   x)
-
-int2Double :: Int -> Double
-int2Double   (I# x) = D# (int2Double#   x)
-
 double2Float :: Double -> Float
 double2Float (D# x) = F# (double2Float# x)
 
addfile ./GHC/Float/RealFracMethods.hs
hunk ./GHC/Float/RealFracMethods.hs 1
+{-# LANGUAGE CPP, MagicHash, UnboxedTuples, ForeignFunctionInterface,
+    NoImplicitPrelude #-}
+{-# OPTIONS_HADDOCK hide #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  GHC.Float.RealFracMethods
+-- Copyright   :  (c) Daniel Fischer 2010
+-- License     :  see libraries/base/LICENSE
+--
+-- Maintainer  :  cvs-ghc@haskell.org
+-- Stability   :  internal
+-- Portability :  non-portable (GHC Extensions)
+--
+-- Methods for the RealFrac instances for 'Float' and 'Double',
+-- with specialised versions for 'Int'.
+--
+-- Moved to their own module to not bloat GHC.Float further.
+--
+-----------------------------------------------------------------------------
+
+#include "MachDeps.h"
+
+-- #hide
+module GHC.Float.RealFracMethods
+    ( -- * Double methods
+      -- ** Integer results
+      properFractionDoubleInteger
+    , truncateDoubleInteger
+    , floorDoubleInteger
+    , ceilingDoubleInteger
+    , roundDoubleInteger
+      -- ** Int results
+    , properFractionDoubleInt
+    , floorDoubleInt
+    , ceilingDoubleInt
+    , roundDoubleInt
+      -- * Double/Int conversions, wrapped primops
+    , double2Int
+    , int2Double
+      -- * Float methods
+      -- ** Integer results
+    , properFractionFloatInteger
+    , truncateFloatInteger
+    , floorFloatInteger
+    , ceilingFloatInteger
+    , roundFloatInteger
+      -- ** Int results
+    , properFractionFloatInt
+    , floorFloatInt
+    , ceilingFloatInt
+    , roundFloatInt
+      -- * Float/Int conversions, wrapped primops
+    , float2Int
+    , int2Float
+    ) where
+
+import GHC.Integer
+
+import GHC.Base
+import GHC.Num
+
+#if WORD_SIZE_IN_BITS < 64
+
+import GHC.IntWord64
+
+#define TO64 integerToInt64
+#define FROM64 int64ToInteger
+#define MINUS64 minusInt64#
+#define NEGATE64 negateInt64#
+
+#else
+
+#define TO64 toInt#
+#define FROM64 smallInteger
+#define MINUS64 ( -# )
+#define NEGATE64 negateInt#
+
+uncheckedIShiftRA64# :: Int# -> Int# -> Int#
+uncheckedIShiftRA64# = uncheckedIShiftRA#
+
+uncheckedIShiftL64# :: Int# -> Int# -> Int#
+uncheckedIShiftL64# = uncheckedIShiftL#
+
+#endif
+
+default ()
+
+------------------------------------------------------------------------------
+--                              Float Methods                               --
+------------------------------------------------------------------------------
+
+-- Special Functions for Int, nice, easy and fast.
+-- They should be small enough to be inlined automatically.
+
+-- We have to test for ±0.0 to avoid returning -0.0 in the second
+-- component of the pair. Unfortunately the branching costs a lot
+-- of performance.
+properFractionFloatInt :: Float -> (Int, Float)
+properFractionFloatInt (F# x) =
+    if x `eqFloat#` 0.0#
+        then (I# 0#, F# 0.0#)
+        else case float2Int# x of
+                n -> (I# n, F# (x `minusFloat#` int2Float# n))
+
+-- truncateFloatInt = float2Int
+
+floorFloatInt :: Float -> Int
+floorFloatInt (F# x) =
+    case float2Int# x of
+      n | x `ltFloat#` int2Float# n -> I# (n -# 1#)
+        | otherwise                 -> I# n
+
+ceilingFloatInt :: Float -> Int
+ceilingFloatInt (F# x) =
+    case float2Int# x of
+      n | int2Float# n `ltFloat#` x  -> I# (n +# 1#)
+        | otherwise                 -> I# n
+
+roundFloatInt :: Float -> Int
+roundFloatInt x = float2Int (c_rintFloat x)
+
+-- Functions with Integer results
+
+-- With the new code generator in GHC 7, the explicit bit-fiddling is
+-- slower than the old code for values of small modulus, but when the
+-- 'Int' range is left, the bit-fiddling quickly wins big, so we use that.
+-- If the methods are called on smallish values, hopefully people go
+-- through Int and not larger types.
+
+-- Note: For negative exponents, we must check the validity of the shift
+-- distance for the right shifts of the mantissa.
+
+{-# INLINE properFractionFloatInteger #-}
+properFractionFloatInteger :: Float -> (Integer, Float)
+properFractionFloatInteger v@(F# x) =
+    case decodeFloat_Int# x of
+      (# m, e #)
+        | e <# 0#   ->
+          case negateInt# e of
+            s | s ># 23#    -> (0, v)
+              | m <# 0#     ->
+                case negateInt# (negateInt# m `uncheckedIShiftRA#` s) of
+                  k -> (smallInteger k,
+                            case m -# (k `uncheckedIShiftL#` s) of
+                              r -> F# (encodeFloatInteger (smallInteger r) e))
+              | otherwise           ->
+                case m `uncheckedIShiftRL#` s of
+                  k -> (smallInteger k,
+                            case m -# (k `uncheckedIShiftL#` s) of
+                              r -> F# (encodeFloatInteger (smallInteger r) e))
+        | otherwise -> (shiftLInteger (smallInteger m) e, F# 0.0#)
+
+{-# INLINE truncateFloatInteger #-}
+truncateFloatInteger :: Float -> Integer
+truncateFloatInteger x =
+    case properFractionFloatInteger x of
+      (n, _) -> n
+
+-- floor is easier for negative numbers than truncate, so this gets its
+-- own implementation, it's a little faster.
+{-# INLINE floorFloatInteger #-}
+floorFloatInteger :: Float -> Integer
+floorFloatInteger (F# x) =
+    case decodeFloat_Int# x of
+      (# m, e #)
+        | e <# 0#   ->
+          case negateInt# e of
+            s | s ># 23#    -> if m <# 0# then (-1) else 0
+              | otherwise   -> smallInteger (m `uncheckedIShiftRA#` s)
+        | otherwise -> shiftLInteger (smallInteger m) e
+
+-- ceiling x = -floor (-x)
+-- If giving this its own implementation is faster at all,
+-- it's only marginally so, hence we keep it short.
+{-# INLINE ceilingFloatInteger #-}
+ceilingFloatInteger :: Float -> Integer
+ceilingFloatInteger (F# x) =
+    negateInteger (floorFloatInteger (F# (negateFloat# x)))
+
+{-# INLINE roundFloatInteger #-}
+roundFloatInteger :: Float -> Integer
+roundFloatInteger x = float2Integer (c_rintFloat x)
+
+------------------------------------------------------------------------------
+--                              Double Methods                              --
+------------------------------------------------------------------------------
+
+-- Special Functions for Int, nice, easy and fast.
+-- They should be small enough to be inlined automatically.
+
+-- We have to test for ±0.0 to avoid returning -0.0 in the second
+-- component of the pair. Unfortunately the branching costs a lot
+-- of performance.
+properFractionDoubleInt :: Double -> (Int, Double)
+properFractionDoubleInt (D# x) =
+    if x ==## 0.0##
+        then (I# 0#, D# 0.0##)
+        else case double2Int# x of
+                n -> (I# n, D# (x -## int2Double# n))
+
+-- truncateDoubleInt = double2Int
+
+floorDoubleInt :: Double -> Int
+floorDoubleInt (D# x) =
+    case double2Int# x of
+      n | x <## int2Double# n   -> I# (n -# 1#)
+        | otherwise             -> I# n
+
+ceilingDoubleInt :: Double -> Int
+ceilingDoubleInt (D# x) =
+    case double2Int# x of
+      n | int2Double# n <## x   -> I# (n +# 1#)
+        | otherwise             -> I# n
+
+roundDoubleInt :: Double -> Int
+roundDoubleInt x = double2Int (c_rintDouble x)
+
+-- Functions with Integer results
+
+-- The new Code generator isn't quite as good for the old 'Double' code
+-- as for the 'Float' code, so for 'Double' the bit-fiddling also wins
+-- when the values have small modulus.
+
+-- When the exponent is negative, all mantissae have less than 64 bits
+-- and the right shifting of sized types is much faster than that of
+-- 'Integer's, especially when we can
+
+-- Note: For negative exponents, we must check the validity of the shift
+-- distance for the right shifts of the mantissa.
+
+{-# INLINE properFractionDoubleInteger #-}
+properFractionDoubleInteger :: Double -> (Integer, Double)
+properFractionDoubleInteger v@(D# x) =
+    case decodeDoubleInteger x of
+      (# m, e #)
+        | e <# 0#   ->
+          case negateInt# e of
+            s | s ># 52#    -> (0, v)
+              | m < 0       ->
+                case TO64 (negateInteger m) of
+                  n ->
+                    case n `uncheckedIShiftRA64#` s of
+                      k ->
+                        (FROM64 (NEGATE64 k),
+                          case MINUS64 n (k `uncheckedIShiftL64#` s) of
+                            r ->
+                              D# (encodeDoubleInteger (FROM64 (NEGATE64 r)) e))
+              | otherwise           ->
+                case TO64 m of
+                  n ->
+                    case n `uncheckedIShiftRA64#` s of
+                      k -> (FROM64 k,
+                            case MINUS64 n (k `uncheckedIShiftL64#` s) of
+                              r -> D# (encodeDoubleInteger (FROM64 r) e))
+        | otherwise -> (shiftLInteger m e, D# 0.0##)
+
+{-# INLINE truncateDoubleInteger #-}
+truncateDoubleInteger :: Double -> Integer
+truncateDoubleInteger x =
+    case properFractionDoubleInteger x of
+      (n, _) -> n
+
+-- floor is easier for negative numbers than truncate, so this gets its
+-- own implementation, it's a little faster.
+{-# INLINE floorDoubleInteger #-}
+floorDoubleInteger :: Double -> Integer
+floorDoubleInteger (D# x) =
+    case decodeDoubleInteger x of
+      (# m, e #)
+        | e <# 0#   ->
+          case negateInt# e of
+            s | s ># 52#    -> if m < 0 then (-1) else 0
+              | otherwise   ->
+                case TO64 m of
+                  n -> FROM64 (n `uncheckedIShiftRA64#` s)
+        | otherwise -> shiftLInteger m e
+
+{-# INLINE ceilingDoubleInteger #-}
+ceilingDoubleInteger :: Double -> Integer
+ceilingDoubleInteger (D# x) =
+    negateInteger (floorDoubleInteger (D# (negateDouble# x)))
+
+{-# INLINE roundDoubleInteger #-}
+roundDoubleInteger :: Double -> Integer
+roundDoubleInteger x = double2Integer (c_rintDouble x)
+
+-- Wrappers around double2Int#, int2Double#, float2Int# and int2Float#,
+-- we need them here, so we move them from GHC.Float and re-export them
+-- explicitly from there.
+
+double2Int :: Double -> Int
+double2Int (D# x) = I# (double2Int# x)
+
+int2Double :: Int -> Double
+int2Double (I# i) = D# (int2Double# i)
+
+float2Int :: Float -> Int
+float2Int (F# x) = I# (float2Int# x)
+
+int2Float :: Int -> Float
+int2Float (I# i) = F# (int2Float# i)
+
+-- Quicker conversions from 'Double' and 'Float' to 'Integer',
+-- assuming the floating point value is integral.
+--
+-- Note: Since the value is integral, the exponent can't be less than
+-- (-TYP_MANT_DIG), so we need not check the validity of the shift
+-- distance for the right shfts here.
+
+{-# INLINE double2Integer #-}
+double2Integer :: Double -> Integer
+double2Integer (D# x) =
+    case decodeDoubleInteger x of
+      (# m, e #)
+        | e <# 0#   ->
+          case TO64 m of
+            n -> FROM64 (n `uncheckedIShiftRA64#` negateInt# e)
+        | otherwise -> shiftLInteger m e
+
+{-# INLINE float2Integer #-}
+float2Integer :: Float -> Integer
+float2Integer (F# x) =
+    case decodeFloat_Int# x of
+      (# m, e #)
+        | e <# 0#   -> smallInteger (m `uncheckedIShiftRA#` negateInt# e)
+        | otherwise -> shiftLInteger (smallInteger m) e
+
+-- Foreign imports, the rounding is done faster in C when the value
+-- isn't integral, so we call out for rounding. For values of large
+-- modulus, calling out to C is slower than staying in Haskell, but
+-- presumably 'round' is mostly called for values with smaller modulus,
+-- when calling out to C is a major win.
+-- For all other functions, calling out to C gives at most a marginal
+-- speedup for values of small modulus and is much slower than staying
+-- in Haskell for values of large modulus, so those are done in Haskell.
+
+foreign import ccall unsafe "rintDouble"
+    c_rintDouble :: Double -> Double
+
+foreign import ccall unsafe "rintFloat"
+    c_rintFloat :: Float -> Float
hunk ./base.cabal 55
             GHC.Exception,
             GHC.Exts,
             GHC.Float,
+            GHC.Float.RealFracMethods,
             GHC.ForeignPtr,
             GHC.MVar,
             GHC.IO,
hunk ./cbits/primFloat.c 47
 };
 
 /*
- 
+
  To recap, here's the representation of a double precision
  IEEE floating point number:
 
hunk ./cbits/primFloat.c 109
 
 /*
  * Predicates for testing for extreme IEEE fp values.
- */ 
+ */
 
 /* In case you don't suppport IEEE, you'll just get dummy defs.. */
 #ifdef IEEE_FLOATING_POINT
hunk ./cbits/primFloat.c 118
 isDoubleNaN(HsDouble d)
 {
   union stg_ieee754_dbl u;
-  
+
   u.d = d;
 
   return (
hunk ./cbits/primFloat.c 144
 }
 
 HsInt
-isDoubleDenormalized(HsDouble d) 
+isDoubleDenormalized(HsDouble d)
 {
     union stg_ieee754_dbl u;
 
hunk ./cbits/primFloat.c 157
         - (don't care about setting of sign bit.)
 
     */
-    return (  
+    return (
        u.ieee.exponent  == 0 &&
        (u.ieee.mantissa0 != 0 ||
         u.ieee.mantissa1 != 0)
hunk ./cbits/primFloat.c 162
       );
-        
+
 }
 
 HsInt
hunk ./cbits/primFloat.c 166
-isDoubleNegativeZero(HsDouble d) 
+isDoubleNegativeZero(HsDouble d)
 {
     union stg_ieee754_dbl u;
 
hunk ./cbits/primFloat.c 210
 {
     union stg_ieee754_flt u;
     u.f = f;
-  
+
     /* A float is Inf iff exponent is max (all ones),
        and mantissa is min(all zeros.) */
     return (
hunk ./cbits/primFloat.c 237
 }
 
 HsInt
-isFloatNegativeZero(HsFloat f) 
+isFloatNegativeZero(HsFloat f)
 {
     union stg_ieee754_flt u;
     u.f = f;
hunk ./cbits/primFloat.c 249
        u.ieee.mantissa == 0);
 }
 
+/*
+ There are glibc versions around with buggy rintf or rint, hence we
+ provide our own. We always round ties to even, so we can be simpler.
+*/
+
+#define FLT_HIDDEN 0x800000
+#define FLT_POWER2 0x1000000
+
+HsFloat
+rintFloat(HsFloat f)
+{
+    union stg_ieee754_flt u;
+    u.f = f;
+    /* if real exponent > 22, it's already integral, infinite or nan */
+    if (u.ieee.exponent > 149)  /* 22 + 127 */
+    {
+        return u.f;
+    }
+    if (u.ieee.exponent < 126)  /* (-1) + 127, abs(f) < 0.5 */
+    {
+        /* only used for rounding to Integral a, so don't care about -0.0 */
+        return 0.0;
+    }
+    /* 0.5 <= abs(f) < 2^23 */
+    unsigned int half, mask, mant, frac;
+    half = 1 << (149 - u.ieee.exponent);    /* bit for 0.5 */
+    mask = 2*half - 1;                      /* fraction bits */
+    mant = u.ieee.mantissa | FLT_HIDDEN;    /* add hidden bit */
+    frac = mant & mask;                     /* get fraction */
+    mant ^= frac;                           /* truncate mantissa */
+    if ((frac < half) || ((frac == half) && ((mant & (2*half)) == 0)))
+    {
+        /* this means we have to truncate */
+        if (mant == 0)
+        {
+            /* f == ±0.5, return 0.0 */
+            return 0.0;
+        }
+        else
+        {
+            /* remove hidden bit and set mantissa */
+            u.ieee.mantissa = mant ^ FLT_HIDDEN;
+            return u.f;
+        }
+    }
+    else
+    {
+        /* round away from zero, increment mantissa */
+        mant += 2*half;
+        if (mant == FLT_POWER2)
+        {
+            /* next power of 2, increase exponent an set mantissa to 0 */
+            u.ieee.mantissa = 0;
+            u.ieee.exponent += 1;
+            return u.f;
+        }
+        else
+        {
+            /* remove hidden bit and set mantissa */
+            u.ieee.mantissa = mant ^ FLT_HIDDEN;
+            return u.f;
+        }
+    }
+}
+
+#define DBL_HIDDEN 0x100000
+#define DBL_POWER2 0x200000
+#define LTOP_BIT 0x80000000
+
+HsDouble
+rintDouble(HsDouble d)
+{
+    union stg_ieee754_dbl u;
+    u.d = d;
+    /* if real exponent > 51, it's already integral, infinite or nan */
+    if (u.ieee.exponent > 1074) /* 51 + 1023 */
+    {
+        return u.d;
+    }
+    if (u.ieee.exponent < 1022)  /* (-1) + 1023, abs(d) < 0.5 */
+    {
+        /* only used for rounding to Integral a, so don't care about -0.0 */
+        return 0.0;
+    }
+    unsigned int half, mask, mant, frac;
+    if (u.ieee.exponent < 1043) /* 20 + 1023, real exponent < 20 */
+    {
+        /* the fractional part meets the higher part of the mantissa */
+        half = 1 << (1042 - u.ieee.exponent);   /* bit for 0.5 */
+        mask = 2*half - 1;                      /* fraction bits */
+        mant = u.ieee.mantissa0 | DBL_HIDDEN;   /* add hidden bit */
+        frac = mant & mask;                     /* get fraction */
+        mant ^= frac;                           /* truncate mantissa */
+        if ((frac < half) ||
+            ((frac == half) && (u.ieee.mantissa1 == 0)  /* a tie */
+                && ((mant & (2*half)) == 0)))
+        {
+            /* truncate */
+            if (mant == 0)
+            {
+                /* d = ±0.5, return 0.0 */
+                return 0.0;
+            }
+            /* remove hidden bit and set mantissa */
+            u.ieee.mantissa0 = mant ^ DBL_HIDDEN;
+            u.ieee.mantissa1 = 0;
+            return u.d;
+        }
+        else    /* round away from zero */
+        {
+            /* zero low mantissa bits */
+            u.ieee.mantissa1 = 0;
+            /* increment integer part of mantissa */
+            mant += 2*half;
+            if (mant == DBL_POWER2)
+            {
+                /* power of 2, increment exponent and zero mantissa */
+                u.ieee.mantissa0 = 0;
+                u.ieee.exponent += 1;
+                return u.d;
+            }
+            /* remove hidden bit */
+            u.ieee.mantissa0 = mant ^ DBL_HIDDEN;
+            return u.d;
+        }
+    }
+    else
+    {
+        /* 20 <= real exponent < 52, fractional part entirely in mantissa1 */
+        half = 1 << (1074 - u.ieee.exponent);   /* bit for 0.5 */
+        mask = 2*half - 1;                      /* fraction bits */
+        mant = u.ieee.mantissa1;                /* no hidden bit here */
+        frac = mant & mask;                     /* get fraction */
+        mant ^= frac;                           /* truncate mantissa */
+        if ((frac < half) ||
+            ((frac == half) &&                  /* tie */
+            (((half == LTOP_BIT) ? (u.ieee.mantissa0 & 1)  /* yuck */
+                                : (mant & (2*half)))
+                                        == 0)))
+        {
+            /* truncate */
+            u.ieee.mantissa1 = mant;
+            return u.d;
+        }
+        else
+        {
+            /* round away from zero */
+            /* increment mantissa */
+            mant += 2*half;
+            u.ieee.mantissa1 = mant;
+            if (mant == 0)
+            {
+                /* low part of mantissa overflowed */
+                /* increment high part of mantissa */
+                mant = u.ieee.mantissa0 + 1;
+                if (mant == DBL_HIDDEN)
+                {
+                    /* hit power of 2 */
+                    /* zero mantissa */
+                    u.ieee.mantissa0 = 0;
+                    /* and increment exponent */
+                    u.ieee.exponent += 1;
+                    return u.d;
+                }
+                else
+                {
+                    u.ieee.mantissa0 = mant;
+                    return u.d;
+                }
+            }
+            else
+            {
+                return u.d;
+            }
+        }
+    }
+}
+
 #else /* ! IEEE_FLOATING_POINT */
 
 /* Dummy definitions of predicates - they all return false */
hunk ./cbits/primFloat.c 439
 HsInt isFloatDenormalized(f) HsFloat f; { return 0; }
 HsInt isFloatNegativeZero(f) HsFloat f; { return 0; }
 
+
+/* For exotic floating point formats, we can't do much */
+/* We suppose the format has not too many bits */
+/* I hope nobody tries to build GHC where this is wrong */
+
+#define FLT_UPP 536870912.0
+
+HsFloat
+rintFloat(HsFloat f)
+{
+    if ((f > FLT_UPP) || (f < (-FLT_UPP)))
+    {
+        return f;
+    }
+    else
+    {
+        int i = (int)f;
+        float g = i;
+        float d = f - g;
+        if (d > 0.5)
+        {
+            return g + 1.0;
+        }
+        if (d == 0.5)
+        {
+            return (i & 1) ? (g + 1.0) : g;
+        }
+        if (d == -0.5)
+        {
+            return (i & 1) ? (g - 1.0) : g;
+        }
+        if (d < -0.5)
+        {
+            return g - 1.0;
+        }
+        return g;
+    }
+}
+
+#define DBL_UPP 2305843009213693952.0
+
+HsDouble
+rintDouble(HsDouble d)
+{
+    if ((d > DBL_UPP) || (d < (-DBL_UPP)))
+    {
+        return d;
+    }
+    else
+    {
+        HsInt64 i = (HsInt64)d;
+        double e = i;
+        double r = d - e;
+        if (r > 0.5)
+        {
+            return e + 1.0;
+        }
+        if (r == 0.5)
+        {
+            return (i & 1) ? (e + 1.0) : e;
+        }
+        if (r == -0.5)
+        {
+            return (i & 1) ? (e - 1.0) : e;
+        }
+        if (r < -0.5)
+        {
+            return e - 1.0;
+        }
+        return e;
+    }
+}
+
 #endif /* ! IEEE_FLOATING_POINT */
}

Context:

[Define SpecConstrAnnotation in GHC.Exts, and import it from there
simonpj@microsoft.com**20101018135857
 Ignore-this: 8bf81cbc5787dbb5a3875b5622f67732
   
 Reason: avoid having to link the entire ghc package in modules
 that use compile-time annotations:
   
        import GHC.Exts( SpecConstrAnnotation )
        {-# ANN type T ForceSpecConstr #-}
   
 It's a kind of bug that the package exporting SpecConstrAnnotation
 is linked even though it is only needed at compile time, but putting
 the data type declaration in GHC.Exts is a simple way to sidestep
 the problem
   
 See See Note [SpecConstrAnnotation] in SpecConstr
] 
[throwTo: mention interruptible foreign calls
Simon Marlow <marlowsd@gmail.com>**20101014084220
 Ignore-this: dbc53d85f870cf649f87186c7185465a
] 
[remove trailing whitespace
Simon Marlow <marlowsd@gmail.com>**20101013101906
 Ignore-this: b8b424540cacbbb3c6d934242e3af795
] 
[FIX #4381
Simon Marlow <marlowsd@gmail.com>**20101013101849
 Ignore-this: f0daa4845eeb444231451b975b71d055
 Fix scaleFloat by clamping the scaling parameter so that
 exponent + scale doesn't overflow.
 
 Patch by: Daniel Fischer <daniel.is.fischer@web.de>
] 
[Replaced some throws to throwIOs where the type is IO
Bas van Dijk <v.dijk.bas@gmail.com>**20100924221340
 Ignore-this: e74191e4527ae6f7551c95fd41063335
] 
[Added initial .authorspellings
Bas van Dijk <v.dijk.bas@gmail.com>**20101005072701
 Ignore-this: 63628bcabfdd0b7beda4cd37daeccd89
] 
[Lazier intersperse
Daniel Fischer <daniel.is.fischer@web.de>**20101002231201
 Ignore-this: a0fed65930cf19e68b4363381a5ab576
 A lazier implementation of intersperse, and consequentially intercalate, to
 avoid space leaks.
] 
[FIX #4228 (atanh (-1) returns NaN instead of -Infinity)
ghc@cainnorris.net**20100816213654
 Ignore-this: dee89c24493e84a02bea711a1c83a73f
] 
[Make intersectBy lazier
Daniel Fischer <daniel.is.fischer@web.de>**20100930191731
 Ignore-this: ef687bc75923434e85c14b57171576aa
 Add shortcuts to intersectBy for empty list arguments.
 In addition to being faster in that case, more inputs yield defined results.
 Treats ticket #4323
] 
[doc tweak for Directory file type: file names are '\0'-separated
Simon Marlow <marlowsd@gmail.com>**20100922113811
 Ignore-this: 96b7b004bd6e5bc3e958ad55bf238ba1
] 
[documentation for IODeviceType (#4317, edited by me)
Simon Marlow <marlowsd@gmail.com>**20100915131341
 Ignore-this: 21c50ca7a189eebcf299523b6e942bae
] 
[Allow Data.HashTable construction with user-supplied size
**20100722210726
 Ignore-this: bd54880bb16a106a992f03b040dc4164
 
 This avoids some resizing for users who know they will be inserting a
 lot of data.
 
 http://hackage.haskell.org/trac/ghc/ticket/4193
] 
[some fixes for hGetBufSome
Simon Marlow <marlowsd@gmail.com>**20100916113732
 Ignore-this: 3e596a606c180dc4859ea8f4c9132ca1
  - fix one case where it was blocking when it shouldn't
  - a couple of error-message tweaks
] 
[Windows: map ERROR_NO_DATA to EPIPE, rather than EINVAL
Simon Marlow <marlowsd@gmail.com>**20100915142618
 Ignore-this: 9023e5f0542419f225aef26cb6b1d88d
 WriteFile() returns ERROR_NO_DATA when writing to a pipe that is
 "closing", however by default the write() wrapper in the CRT maps this
 to EINVAL so we get confusing things like
 
   hPutChar: invalid argument (Invalid Argumnet)
 
 when piping the output of a Haskell program into something that closes
 the pipe early.  This was happening in the testsuite in a few place.
 
 The solution is to map ERROR_NO_DATA to EPIPE correctly, as we
 explicitly check for EPIPE on stdout (in GHC.TopHandler) so we can
 exit without an error in this case.
] 
[tighten up parsing of numbers (#1579)
Simon Marlow <marlowsd@gmail.com>**20100913214733
 Ignore-this: 3411bf3d2e98cfacb9e0afd11d79e722
] 
[Add absentError.  
simonpj@microsoft.com**20100914134639
 Ignore-this: d0eef5a87e1def4cdbde92a55241c8c4
 
 This patch accompanies the HEAD patch:
 
   Tue Sep 14 12:38:27 BST 2010  simonpj@microsoft.com
     * Make absent-arg wrappers work for unlifted types (fix Trac #4306)
     
     Previously we were simply passing arguments of unlifted
     type to a wrapper, even if they were absent, which was
     stupid.
     
     See Note [Absent error Id] in WwLib.
] 
[Add missing import, fixes build on windows
simonpj@microsoft.com**20100914122750
 Ignore-this: 12ece15ef94982ddfbf5f9f7900619da
] 
[Add a suitable Show instance for TextEncoding (#4273)
Simon Marlow <marlowsd@gmail.com>**20100913154459
 Ignore-this: 77f2235460895debd2827f34c42c3435
] 
[don't fill a finalized handle with an error (see comment)
Simon Marlow <marlowsd@gmail.com>**20100913153350
 Ignore-this: c72cdb6898dffa88eca1d781171b2943
] 
[deriving (Eq, Ord, Read, Show) for Newline and NewlineMode
Simon Marlow <marlowsd@gmail.com>**20100913153031
 Ignore-this: 9b9b29bfb7abf5550cfbfa7788f81bf
] 
[fix warning on Windows
Simon Marlow <marlowsd@gmail.com>**20100913111536
 Ignore-this: dacc5448c452daad60ed37a1a5ed096e
] 
[Put the state-token argument on fill, done, adjust on the RHS
simonpj@microsoft.com**20100913101832
 Ignore-this: d228b492de7d4635c026ed24cbc17e34
 
 This is so that the functions will inline when
 applied to their normal (non-state-token) aguments.
 
 I forget why I did this, but it seems like the right thing anyway.
] 
[avoid Foreign.unsafePerformIO
Ross Paterson <ross@soi.city.ac.uk>**20100909125521
 Ignore-this: b698101119ffd1bc6311cce0736f745d
] 
[Remove debugging code accidentally left in
Simon Marlow <marlowsd@gmail.com>**20100909113331
 Ignore-this: 906a14176dd37030b8203782a687936b
] 
[Fix Windows build; patches frmo ezyang
Ian Lynagh <igloo@earth.li>**20100908123037
 Ignore-this: 2f02986087edd7da8382221012c27cd0
] 
[More accurate isatty test for MinGW.
Edward Z. Yang <ezyang@mit.edu>**20100907154144
 Ignore-this: 93bdc2b2a8e65a7c4c7d3906bdda01db
] 
[Fix the build when HAVE_KQUEUE but not HAVE_KEVENT64
Ian Lynagh <igloo@earth.li>**20100904223703] 
[Fix warnings
benl@ouroborus.net**20100830044741
 Ignore-this: 8397aaec7c36046c9ace403e65f32d32
] 
[fix cache variable name used by FP_SEARCH_LIBS_PROTO
Ross Paterson <ross@soi.city.ac.uk>**20100819204858
 Ignore-this: b8113cb3c6f0e03c507297c99d3d82b7
] 
[Add a missing castPtr (only shows up in -DDEBUG)
simonpj@microsoft.com**20100815145127
 Ignore-this: 30b9c42cd3ce7837bdabd254fe66078d
] 
[Fixed a rounding error in threadDelay
Johan Tibell <johan.tibell@gmail.com>**20100813124043
 Ignore-this: 1cb77d0852233ffffb144b134064ee3c
] 
[export allocaBytesAligned; make allocaArray use the correct alignment (#2917)
Simon Marlow <marlowsd@gmail.com>**20100812105524
 Ignore-this: deb6495f7b7b84deaf02b88927a5ba8c
] 
[deprecate unGetChan and isEmptyChan (see #4154)
Simon Marlow <marlowsd@gmail.com>**20100705125952
 Ignore-this: b4e769959f131b2d0001eb7202bc1b92
] 
[Add type signatures to cope with lack of local generalisation
simonpj@microsoft.com**20100728124847
 Ignore-this: d3af9a47c2821c6081bde05a135a92fb
] 
[Add type signature in local where
simonpj@microsoft.com**20100727151532
 Ignore-this: 1c57063ad32d13e0d1ec8daf968bf055
] 
[Integrated new I/O manager
Simon Marlow <marlowsd@gmail.com>**20100810082248
 Ignore-this: ed70a9066ac9b676a446fe99978fef7a
 (patch originally by Johan Tibell <johan.tibell@gmail.com>, minor merging by me)
] 
[Add mfilter to Control.Monad
jon.fairbairn@cl.cam.ac.uk**20090917145616
 Ignore-this: de4240b60684f3065b29378df3ea98f2
 
 Straightforward MonadPlus version of List.filter. I would
 prefer to call it filter, but the current naming scheme for
 Control.Monad implies mfilter.
 
] 
[move Monad and MonadFix instances for Either from mtl (proposal #4159)
Ross Paterson <ross@soi.city.ac.uk>**20100729122449
 Ignore-this: b0f8cd8643679948d1da43bd7c08c5aa
 
 The Monad and MonadFix instances for Either (formerly in the mtl
 package) are moved to Control.Monad.Instances and Control.Monad.Fix
 respectively.  The Monad instance is still an orphan, to retain Haskell
 98 compatibility, but the MonadFix instance is together with its class.
 The Error constraint is removed from both instances, and the default
 definition of fail is used.
] 
[Remove egregious ghc-ish from Foreign.Marshal
Malcolm.Wallace@me.com**20100722075449] 
[add numSparks :: IO Int (#4167)
Simon Marlow <marlowsd@gmail.com>**20100720153858
 Ignore-this: 4543f57a7f137f8cae1c3efc5c023a9b
] 
[add unsafeLocalState from Haskell 2010, and docs
Simon Marlow <marlowsd@gmail.com>**20100720082819
 Ignore-this: dcd79fb546ebe29ddff4df279ec2f38
] 
[docs: mention that Foreign.unsafePerformIO is deprecated
Simon Marlow <marlowsd@gmail.com>**20100720082804
 Ignore-this: 4cfebb8f2a1cddc7d15e94e31b2befa4
 We can't actually deprecate it without introducing a name clash
 between Foreign.unsafePerformIO and System.IO.Unsafe.unsafePerformIO
] 
[doc formatting fix
Simon Marlow <marlowsd@gmail.com>**20100714151347
 Ignore-this: 255edef607dcd290e198015240b5d125
] 
[add module intro from Haskell 2010
Simon Marlow <marlowsd@gmail.com>**20100714115853
 Ignore-this: 59b5a07507a059ccccdff2dfb6490a27
] 
[document exception-overriding behaviour in withFile
Simon Marlow <marlowsd@gmail.com>**20100714104107
 Ignore-this: f99e641ea2f46d872cb7420a62fa50dc
] 
[doc: use "finalizer" consistently
Simon Marlow <marlowsd@gmail.com>**20100714103649
 Ignore-this: bdfea40f31dc5045fdbc6e12266dda93
] 
[clarify meaning of bit
Simon Marlow <marlowsd@gmail.com>**20100714103310
 Ignore-this: 521b031f1e83ef34ca03d9aa9273df8a
] 
[note shortcutting behaviour of any/all/elem
Simon Marlow <marlowsd@gmail.com>**20100714103304
 Ignore-this: 1605f362ba0712ad1cea1309636f3ea1
] 
[add cast{C,U}CharToChar and castCharTo{C,U}Char, from Haskell 2010
Simon Marlow <marlowsd@gmail.com>**20100713132515
 Ignore-this: 9b1da827016c7b08668078b45964e9de
] 
[mention that IntPtr and WordPtr can be marshalled to/from intptr_t and uintptr_t
Simon Marlow <marlowsd@gmail.com>**20100713132403
 Ignore-this: dcc112a72746ba117a84fa29e71b6800
] 
[Partial fix for Trac #4136
simonpj@microsoft.com**20100707135725
 Ignore-this: 9548eeb3187d9779d4e5c858a0f35354
 
 In 'choose' (which is a library function designed specifically
 to support derived instances of Read), we must match Symbol
 as well as Ident, for nullary constructors that (wierdly) are
 symbols.
] 
[Fix typo in documentation
Simon Hengel <simon.hengel@wiktory.org>**20100711141648
 Ignore-this: c052dd8a681832ef598a323ad55eae3a
] 
[Remove duplicated word in documentation
Simon Hengel <simon.hengel@wiktory.org>**20100711072703
 Ignore-this: fb3732dc57be55f14168792f923433
] 
[Allow nhc98 to cope with recent changes to Control.Exception.
Malcolm.Wallace@me.com**20100710170940] 
[ New asynchronous exception control API (base parts)
Simon Marlow <marlowsd@gmail.com>**20100708152735
 Ignore-this: 71a4811804f04259f1fe739f8863beaf
   
 As discussed on the libraries/haskell-cafe mailing lists
   http://www.haskell.org/pipermail/libraries/2010-April/013420.html
 
 This is a replacement for block/unblock in the asychronous exceptions
 API to fix a problem whereby a function could unblock asynchronous
 exceptions even if called within a blocked context.
 
 The new terminology is "mask" rather than "block" (to avoid confusion
 due to overloaded meanings of the latter).
 
 The following is the new API; the old API is deprecated but still
 available for the time being.
 
 Control.Exception
 -----------------
 
 mask  :: ((forall a. IO a -> IO a) -> IO b) -> IO b
 mask_ :: IO a -> IO a
 
 uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b
 uninterruptibleMask_ :: IO a -> IO 
 
 getMaskingState :: IO MaskingState
 
 data MaskingState
   = Unmasked
   | MaskedInterruptible 
   | MaskedUninterruptible
 
 
 Control.Concurrent
 ------------------
 
 forkIOUnmasked :: IO () -> IO ThreadId
] 
[Async-exception safety, and avoid space leaks
Simon Marlow <marlowsd@gmail.com>**20100708145819
 Ignore-this: dbfd0e61551e9e7b4fc1c6fe9b9a83de
 Patch submitted by: Bas van Dijk <v.dijk.bas@gmail.com>
 Modified slightly by me to remove non-functional changes.
] 
[Async-exception safety, and avoid space leaks
Simon Marlow <marlowsd@gmail.com>**20100708103154
 Ignore-this: 190c3ac8f6633231624da8cf1316588
 Patch submitted by: Bas van Dijk <v.dijk.bas@gmail.com>
 Modified slightly by me to remove non-functional changes.
] 
[Fix a few places where we forgot to close the text codecs (#4029)
Simon Marlow <marlowsd@gmail.com>**20100702130210
 Ignore-this: 2e81a4b4cb343181cef34b0f9e2ded47
 Each time you invoke :load in GHCi it resets the CAFs, including
 stdin/stdout/stderr, and each of these was allocating a new iconv_t.
] 
[remove docs from Monad that belonged on the instance for MonadPlus IO
Simon Marlow <marlowsd@gmail.com>**20100701154203
 Ignore-this: 59df02542a7ac9421552a2155d848d27
] 
[docs: unqualify Prelude.IO
Simon Marlow <marlowsd@gmail.com>**20100701153817
 Ignore-this: 73b0202876c827e7a5b4a5ce74e724c4
] 
[unqualify Float and Double
Simon Marlow <marlowsd@gmail.com>**20100701142727
 Ignore-this: cbe89d31a00bf49996a33933324fca17
] 
[extract information about Data.Time from docs for CTime
Simon Marlow <marlowsd@gmail.com>**20100701142415
 Ignore-this: c48c9609b8d36e43e033a7bea81d6f17
] 
[doc typo
Simon Marlow <marlowsd@gmail.com>**20100701142354
 Ignore-this: 17a1fd703831c888975ff63fbfa3a9b2
] 
[peekArray docs: remove mentions of "this version" and "previous version"
Simon Marlow <marlowsd@gmail.com>**20100701125333
 Ignore-this: 39a744874258670bd935ba9e38390939
] 
[doc typo
Simon Marlow <marlowsd@gmail.com>**20100701124154
 Ignore-this: 98f5c286e38c2c34c96b05d5e8bc5ad9
] 
[doc typo
Simon Marlow <marlowsd@gmail.com>**20100701124128
 Ignore-this: 10a4314ec7aed336701fc616fb574ebc
] 
[doc typo
Simon Marlow <marlowsd@gmail.com>**20100701123715
 Ignore-this: c4909a7bf7163460ee5d32f58812041e
] 
[doc wibble: Haskell 98 I/O Error -> 'IOError'
Simon Marlow <marlowsd@gmail.com>**20100701123612
 Ignore-this: bf373df781acbc575e4ffe3b7e6059ae
] 
[doc typo
Simon Marlow <marlowsd@gmail.com>**20100701123014
 Ignore-this: 16aaccae48ef3101adf78ea5b0d5a8fd
] 
[Haddock hacks to fix whitespace consistency
Simon Marlow <marlowsd@gmail.com>**20100701121631
 Ignore-this: 61c58dec52a31fd2d3f331a87d2f903f
] 
[use '==' consistently rather than '->' in examples
Simon Marlow <marlowsd@gmail.com>**20100701121616
 Ignore-this: 472b0a05a85d34d9712186040e1636d9
] 
[doc wibble: remove confusing mention of "Prelude"
Simon Marlow <marlowsd@gmail.com>**20100701113308
 Ignore-this: 232283d0096d01cd45e9b3c5c1e63a6d
] 
[doc wibble: nonstrict -> non-strict
Simon Marlow <marlowsd@gmail.com>**20100701113253
 Ignore-this: 4264f0ab23a0835fc13c6e8601d6b743
] 
[doc whitespace
Simon Marlow <marlowsd@gmail.com>**20100701112242
 Ignore-this: 777a95b1d1140c61d3ab95d5eb5809e7
] 
[move the doc for 'Char' to its new home in ghc-prim:GHC.Types
Simon Marlow <marlowsd@gmail.com>**20100629134150
 Ignore-this: 7687db0077a29498349bfb4b44983985
] 
[doc wibble
Simon Marlow <marlowsd@gmail.com>**20100629122608
 Ignore-this: 9a909e5d015332dc445bd9592e6e386d
] 
[doc updates in System.IO
Simon Marlow <marlowsd@gmail.com>**20100629122118
 Ignore-this: 2257ec1cc4cdb8b7804cfa1f3cf32753
] 
[doc wibble
Simon Marlow <marlowsd@gmail.com>**20100625134858
 Ignore-this: 64c50f29df6c389273b818918fe7033a
] 
[doc wibbles
Simon Marlow <marlowsd@gmail.com>**20100624154614
 Ignore-this: b364aad53beea6e741fee2824459b6e8
] 
[Fix haddock formatting
Ian Lynagh <igloo@earth.li>**20100625222623] 
[Give nub's complexity in the haddock docs; fixes #4086
Ian Lynagh <igloo@earth.li>**20100625222059] 
[correct docs for exitWith: only stdout/stderr are flushed, not all Handles
Simon Marlow <marlowsd@gmail.com>**20100624130506
 Ignore-this: 33a938dad8f0bc061572e2ec571cacc7
] 
[fix docs for isSpace
Simon Marlow <marlowsd@gmail.com>**20100624130444
 Ignore-this: b35ff080dbb9833176f08e39dbd9ff6d
] 
[make the hGetBuf/hPutBuf family work with non-FD Handles (#4144)
Simon Marlow <marlowsd@gmail.com>**20100624130425
 Ignore-this: 8200f0208a9b1b1cf4824f343d75819a
] 
[nit in docs for accumArray
Simon Marlow <marlowsd@gmail.com>**20100622121131
 Ignore-this: c066a456c40907e767df10c3990f35ff
] 
[add doc for the ExitCode type
Simon Marlow <marlowsd@gmail.com>**20100622120930
 Ignore-this: 99c34332be7f3565da844528b470054a
] 
[remove extraneous info from docs for Array
Simon Marlow <marlowsd@gmail.com>**20100622120921
 Ignore-this: e2a3f5e84fc23eb7bae911f0680e805e
] 
[add an INLINE to the list version of traverse, to enable fusion
Simon Marlow <marlowsd@gmail.com>**20100608082531
 Ignore-this: ea98cdc3308b406bb04c0f7a38c4424b
] 
[Don't define the C localeEncoding on Windows
Ian Lynagh <igloo@earth.li>**20100620202342
 Ignore-this: c4992f6832a391b0cccc5a9b7d643976
 (it causes warnings, and isn't used)
] 
[add Applicative instance for Either (proposal #4095)
Ross Paterson <ross@soi.city.ac.uk>**20100617225110
 Ignore-this: 50262ec4700dc16efec5755be5b308c5
 
 This is not the only possible instance for Either, but this one is
 compatible with the usual Monad instance.
] 
[Use libcharset instead of nl_langinfo(CODESET) if possible.
pho@cielonegro.org**20100519013112
 Ignore-this: 4c1e278e022a3d276848afc1dcba4425
 
 nl_langinfo(CODESET) doesn't always return standardized variations of the encoding names. Use libcharset if possible, which is shipped together with GNU libiconv.
] 
[Add a note about the interruptibility of throwTo.
Simon Marlow <marlowsd@gmail.com>**20100615112720
 Ignore-this: ae9fabe95310d7c364e95f7784793485
] 
[docs: note that hGetBufNonBlocking isn't non-blocking on Windows
Simon Marlow <marlowsd@gmail.com>**20100615112547
 Ignore-this: 4f3e5213e142149affe08c5123d6efea
] 
[don't depend on Prelude (#4122)
Simon Marlow <marlowsd@gmail.com>**20100615105631
 Ignore-this: 1a3fd49b103fe31cbb453f302c18767f
] 
[Don't depend on Prelude (#4123)
Simon Marlow <marlowsd@gmail.com>**20100615105401
 Ignore-this: cc7616d85a1637bc7621b4f2bc181c0e
] 
[bump version to 4.3.0.0, added instance MonadPlus STM
Simon Marlow <marlowsd@gmail.com>**20100601144831
 Ignore-this: 7c3cf7574499c4267372493f2636dc0
] 
[Moved MonadPlus instance for STM from Control.Monad.STM to GHC.Conc to avoid an orphaned instance
Bas van Dijk <v.dijk.bas@gmail.com>**20100516160651
 Ignore-this: 651b852942b2fae2b93f996e39239b8f
] 
[Added Applicative and Alternative instances for STM
Bas van Dijk <v.dijk.bas@gmail.com>**20100516171756
 Ignore-this: 567003bc4040bc97105cda4d31ebf04a
] 
[expand Foldable instance for Array
Ross Paterson <ross@soi.city.ac.uk>**20100602212154
 Ignore-this: 9bd9e9666a9400431eb92352244fe7e7
] 
[doc comment illustrating Foldable(foldr)
Ross Paterson <ross@soi.city.ac.uk>**20100527150833
 Ignore-this: 8f27d889379803f3ba86d6e928428f3c
] 
[fix syntax in doc comments
Ross Paterson <ross@soi.city.ac.uk>**20100527150757
 Ignore-this: cb78da51d60ff6863dc395f1a892c103
] 
[export hGetBufSome (#4046)
Simon Marlow <marlowsd@gmail.com>**20100520093538
 Ignore-this: f467fad9722e27edfad6b3dd75290e7b
] 
[hWaitForInput: don't try to read from the device (#4078)
Simon Marlow <marlowsd@gmail.com>**20100517133741
 Ignore-this: 55ec33b03397380259b91e4ca62207a6
 readTextDeviceNonBlocking is not non-blocking on Windows
] 
[hSetEncoding: change the encoding on both read and write sides (#4066)
Simon Marlow <marlowsd@gmail.com>**20100514124628
 Ignore-this: 5b9e9caef06356d0296c584159709ebb
] 
[Correct haddock formatting.
Adam Vogt <vogt.adam@gmail.com>**20100423022103
 Ignore-this: d2622339302048fda48080f7d5ce4a2f
] 
[Fix for hGetBufSome
Simon Marlow <marlowsd@gmail.com>**20100505135637
 Ignore-this: 2019680f8fb223956cacfcf0d046f133
] 
[improve the documentation for throwTo and killThread (#3884)
Simon Marlow <marlowsd@gmail.com>**20100505135600
 Ignore-this: ce881d96ddb729acb6ca09c779975e7d
] 
[elaborate the docs for unsafePerformIO a bit
Simon Marlow <marlowsd@gmail.com>**20100505101249
 Ignore-this: 1cec3f67560b672c64c5a0dcf9a79eb7
] 
[add Typeable instance
Simon Marlow <marlowsd@gmail.com>**20100504152815
 Ignore-this: 6d9cf9d62f0ef17fa459bf213a04098
] 
[Add hGetBufSome, like hGetBuf but can return short reads
Simon Marlow <marlowsd@gmail.com>**20100504152759
 Ignore-this: 195c905b43f8d9505029364e2c5b18e
] 
[Add swap (#3298)
Simon Marlow <marlowsd@gmail.com>**20100504095339
 Ignore-this: 13b007dc4594ce252997ec6fa0bbd976
] 
[inline allocaArray0, to fix withCString benchmark
Simon Marlow <marlowsd@gmail.com>**20100423124729
 Ignore-this: 35c96816acc2f3aaf9dd29f7995fa6f0
] 
[raise asynchronous exceptions asynchronously (#3997)
Simon Marlow <marlowsd@gmail.com>**20100421094932
 Ignore-this: 6d987d93d382c0f69c68c326312abd6b
] 
[add NOINLINE pragmas for stdin/stdout/stderr
Simon Marlow <marlowsd@gmail.com>**20100421082041
 Ignore-this: 3fc130268ec786f28d945858d6690986
] 
[INLINE alloca and malloc
Simon Marlow <marlowsd@gmail.com>**20100419135333
 Ignore-this: b218bd611f18721b1505a8c0b9e6a16a
 See discussion on glasgow-haskell-users:
   http://www.haskell.org/pipermail/glasgow-haskell-users/2010-April/018740.html
] 
[Move comment closer to the offending line
Matthias Kilian <kili@outback.escape.de>**20100419155421
 Ignore-this: b34a1d7affd66f67d210df2377b585d9
] 
[Ignore the return code of c_fcntl_write again
Matthias Kilian <kili@outback.escape.de>**20100415140452
 Ignore-this: 266d8ba02cc3cb79c85629b3528261c9
 
 The return code has been ignored in the past on purpose, because
 O_NONBLOCK will fail on BSDs for some special files. This fixes the
 problem mentioned in
 http://www.haskell.org/pipermail/glasgow-haskell-users/2010-April/018698.html
 
] 
[Fix bitrot in IO debugging code
Ian Lynagh <igloo@earth.li>**20100413134339
 Also switched to using Haskell Bools (rather than CPP) to en/disable it,
 so it shouldn't break again in the future.
] 
[Tiny code tidy-up
Ian Lynagh <igloo@earth.li>**20100413011147] 
[remove old/wrong comment
Simon Marlow <marlowsd@gmail.com>**20100325161403
 Ignore-this: e6e377d44af48c4162d17d55bdf3f821
] 
[withThread: block asynchronous exceptions before installing exception handler.
Bas van Dijk <v.dijk.bas@gmail.com>**20100329131624
 Ignore-this: be5aeb47dbd73807b5f94df11afbb81c
 Note that I don't unblock the given io computation. Because AFAICS
 withThread is only called with 'waitFd' which only performs an FFI
 call which can't receive asynchronous exceptions anyway.
] 
[runInUnboundThread: block asynchronous exceptions before installing exception handler
Bas van Dijk <v.dijk.bas@gmail.com>**20100329131549
 Ignore-this: a00c5e32fe3981ff87bedd367a69051e
] 
[fix the deprecation message (GHC.IO.Handle.Base -> GHC.IO.Handle)
Simon Marlow <marlowsd@gmail.com>**20100330121137
 Ignore-this: 4ca8500a01ac93454507aa8f9dd001f9
] 
[Make SampleVar an abstract newtype
Bas van Dijk <v.dijk.bas@gmail.com>**20100318200349
 Ignore-this: 27939e2a064b75e71cb146117346be30
] 
[Fix bugs regarding asynchronous exceptions and laziness in Control.Concurrent.SampleVar
Bas van Dijk <v.dijk.bas@gmail.com>**20100318200104
 Ignore-this: 7376b2a3afe155daf233a8f1ddc0a7a
  - Block asynchronous exceptions at the right places
  - Force thunks before putting them in a MVar
] 
[Write the thunk 'next' to the MVar
Bas van Dijk <v.dijk.bas@gmail.com>**20100319125951
 Ignore-this: dd25636cf220131385ff2fd32493d456
] 
[change to use STM, fixing 4 things
Simon Marlow <marlowsd@gmail.com>**20100318104436
 Ignore-this: 551d30280a7941c08f5c3b14576bdd70
   1. there was no async exception protection
   2. there was a space leak (now new value is strict)
   3. using atomicModifyIORef would be slightly quicker, but can
      suffer from adverse scheduling issues (see #3838)
   4. also, the STM version is faster.
] 
[Tweak docs
Ian Lynagh <igloo@earth.li>**20100312214129] 
[Fixed dead links in documentation of forkIO
Bas van Dijk <v.dijk.bas@gmail.com>**20100308222415
 Ignore-this: 7deb8fd064c867fbede2a6b2e9da4f15
] 
[Documentation fixes in Control.Exception
Bas van Dijk <v.dijk.bas@gmail.com>**20100301220442
 Ignore-this: 761fcba401cbd1f47276ddfc9b5b80f2
] 
[Plug two race conditions that could lead to deadlocks in the IO manager
Simon Marlow <marlowsd@gmail.com>**20100225120255
 Ignore-this: e6983d6b953104d370278ab3e4617e8b
] 
[FIX #3866: improve documentation of Data.Data.Constr
jpm@cs.uu.nl**20100224125506
 Ignore-this: 3818c5d8fee012a3cf322fb455b6e5dc
] 
[UNDO: Handle NaN, -Infinity and Infinity in the toRational for Float/Double (#3676)
Simon Marlow <marlowsd@gmail.com>**20100223101603
 Ignore-this: 78becb2d39b3cd9a1a473a5811ca7d92
] 
[Put the complexity in the length docs. Fixes trac #3680
Ian Lynagh <igloo@earth.li>**20100221191425] 
[nhc98 should build Data.Functor.
Malcolm.Wallace@cs.york.ac.uk**20100221163218] 
[Update the exitWith docs
Ian Lynagh <igloo@earth.li>**20100213140004
 Error pointed out by Volker Wysk <vw@volker-wysk.de>
] 
[Handle NaN, -Infinity and Infinity in the toRational for Float/Double (#3676)
Simon Marlow <marlowsd@gmail.com>**20100211101955
 Ignore-this: 261415363303efca265e80290eac5f28
] 
[For nhc98, import unsafeInterleaveIO rather than defining it here.
Malcolm.Wallace@cs.york.ac.uk**20100204171021] 
[Stifle warning about unused return value
benl@cse.unsw.edu.au**20100203025537] 
[fix #3832: use the locale encoding in openTempFile
Simon Marlow <marlowsd@gmail.com>**20100120211830
 Ignore-this: df4f778cc5fefb32290c798db722632c
 Also while I was here fix an XXX: the Handle contained an
 uninformative string like <fd: 4> for error messages rather than the
 real file path.
] 
[Fix the build: export void, so it doesn't give an unused binding warning
Ian Lynagh <igloo@earth.li>**20100116174451] 
[hIsEOF: don't do any decoding (#3808)
Simon Marlow <marlowsd@gmail.com>**20100112230317
 Ignore-this: 6a384dd2d547ffe3ad3762920e5c1671
] 
[Control.Monad: +void :: f a -> f ()
gwern0@gmail.com**20100108214455
 Ignore-this: 4dc07452315f2d1b4941903ff42fc45f
 See http://hackage.haskell.org/trac/ghc/ticket/3292
 Turns m a -> m (). Lets one call functions for their side-effects without
 having to get rid of their return values with '>> return ()'. Very useful
 in many contexts (parsing, IO etc.); particularly good for 'forkIO' and 'forM_',
 as they demand return types of 'IO ()' though most interesting IO functions
 return non-().
] 
[Replace the implementation of mergesort with a 2x faster one.
Malcolm.Wallace@cs.york.ac.uk**20091224152014
 See ticket http://hackage.haskell.org/trac/ghc/ticket/2143.
] 
[Restore previous Data.Typeable.typeOf*Default implementations for non-ghc.
Malcolm.Wallace@cs.york.ac.uk**20091223142625
 Not all compilers have ScopedTypeVariables.
] 
[Add comments about double bounds-checking, and fast paths for rectangular arrays
simonpj@microsoft.com**20091218165655
 Ignore-this: ea0849419dc00927aba4bd410b1cc58d
 
 See Note [Double bounds-checking of index values] for the details.
 
 The fast paths omit the doubled checks for cases we know about
] 
[Fix Trac #3245: memoising typeOf
simonpj@microsoft.com**20091218155117
 Ignore-this: 5a178a7f2222293c5ee0c3c43bd1b625
 
 The performance bug in #3245 was caused by computing the typeRep
 once for each call of typeOf, rather than once for each dictionary
 contruction.  (Computing TypeReps is reasonably expensive, because
 of the hash-consing machinery.)
 
 This is readily fixed by putting the TypeRep construction outside
 the lambda.  (Arguably GHC might have worked that out itself,
 but it involves floating something between a type lambda and a
 value lambda, which GHC doesn't currently do. If it happens a lot
 we could fix that.)
] 
[Mark 'index' as INLINE in GHC.Arr
simonpj@microsoft.com**20091216170441
 Ignore-this: a4df9d8acf496c8e0e9ce5a520509a2a
 
 This makes indexing much faster. See Trac #1216
] 
[Comment the remaining orphan instance modules
Ian Lynagh <igloo@earth.li>**20091206125021] 
[De-orphan Eq/Ord Float/Double
Ian Lynagh <igloo@earth.li>**20091205181238] 
[Add comments to "OPTIONS_GHC -fno-warn-orphans" pragmas
Ian Lynagh <igloo@earth.li>**20091205165854] 
[Data.Either.partitionEithers was insufficiently lazy.
Malcolm.Wallace@cs.york.ac.uk**20091202032807
 Ignore-this: 77e1b3288f66608c71458d8a91bcbe12
 Spotted by Daniel Fischer.
] 
[fix the docs regarding finalizer guarantees
Simon Marlow <marlowsd@gmail.com>**20091130144409
 Ignore-this: d1ab9532c74a002b8075ff60febcbe2d
] 
[x86_64 requires more stack
Malcolm.Wallace@cs.york.ac.uk**20091201033745] 
[check for size < 0 in mallocForeignPtrBytes and friends (#3514)
Simon Marlow <marlowsd@gmail.com>**20091125143822
 Ignore-this: 91077d01da2bbe1dfed5155e8b40da9
] 
[hGetContents: close the handle properly on error
Simon Marlow <marlowsd@gmail.com>**20091125123435
 Ignore-this: bc37ff678acc6e547dc390285e056eb9
 
 When hGetContents caught an error it was closing the handle and then
 throwing the exception, without updating the handle with the new
 closed state.  This lead to a double-closed, which was the cause of
 
 *** glibc detected *** ./Setup: double free or corruption 
 
 when iconv_close was called twice on the decoder.
 
 See http://hackage.haskell.org/trac/hackage/ticket/609
] 
[Fix arities of mapFB and zipFB
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20091126232219
 Ignore-this: c4e14cd0a92622549c86e67237a40865
] 
[Remove an unnecessary -fno-warn-orphans flag
Ian Lynagh <igloo@earth.li>**20091126123404] 
[Tweak layout to work with alternative layout rule
Ian Lynagh <igloo@earth.li>**20091125232349] 
[Tweak layout to be accepted by the alternative layout rul
Ian Lynagh <igloo@earth.li>**20091125194147] 
[Make sure zipWithFB has arity 2
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20091125010003
 Ignore-this: 4cf60c55666f03d22a9f5a6e07f52d36
 
 It gets 2 arguments in the "zipWith" rule but its arity was higher and the new
 inliner didn't inline it sometimes, for instance here:
 
 mpp ::  [Double] -> [Double] -> [Double] -> [Double] -> [Double]
 mpp as bs cs ds = zipWith (*) (zipWith (+) as bs) (zipWith (+) cs ds)
  
 This was a regression vs. 6.10.
] 
[Remove an old comment
Ian Lynagh <igloo@earth.li>**20091124134647] 
[De-orphan the Eq/Ord Integer instances
Ian Lynagh <igloo@earth.li>**20091124133639] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20091124133421] 
[Derive some more instances, rather than writing them by hand
Ian Lynagh <igloo@earth.li>**20091124011747] 
[We can now derive Ord ()
Ian Lynagh <igloo@earth.li>**20091124011416] 
[De-orphan tuple Eq/Ord instances
Ian Lynagh <igloo@earth.li>**20091123233343] 
[Control.Exception.Base no longer has any orphans
Ian Lynagh <igloo@earth.li>**20091123224905] 
[De-orphan the MonadFix ST instance for GHC
Ian Lynagh <igloo@earth.li>**20091123223544] 
[Rearrange the contents of Control.Monad.ST; no functionality changes
Ian Lynagh <igloo@earth.li>**20091123222702] 
[De-orphan the Eq/Ord [a] instances
Ian Lynagh <igloo@earth.li>**20091123215635] 
[De-orphan the Eq/Ord Char instances
Ian Lynagh <igloo@earth.li>**20091123202253] 
[De-orphan the Eq/Ord Bool instances
Ian Lynagh <igloo@earth.li>**20091123201817] 
[Move Eq/Ord Ordering instances to de-orphan them
Ian Lynagh <igloo@earth.li>**20091123194310] 
[Remove ffi warnings for nhc98.
Malcolm.Wallace@cs.york.ac.uk**20091123063743] 
[Second attempt to fix #1185 (forkProcess and -threaded)
Simon Marlow <marlowsd@gmail.com>**20091111151915
 Ignore-this: fa5f5d5e4e080d4b612a37244f937f9c
 
 Patch 2/2: first patch is to ghc
 
 This time without dynamic linker hacks, instead I've expanded the
 existing rts/Globals.c to cache more CAFs, specifically those in
 GHC.Conc.  We were already using this trick for signal handlers, I
 should have realised before.
 
 It's still quite unsavoury, but we can do away with rts/Globals.c in
 the future when we switch to a dynamically-linked GHCi.
] 
[Rollback #1185 fix
Simon Marlow <marlowsd@gmail.com>**20091106140629
 Ignore-this: cd5667e8474e37e01ba26a1984274811
 
 rolling back:
 
 Tue Nov  3 16:05:40 GMT 2009  Simon Marlow <marlowsd@gmail.com>
   * Fix #1185: restart the IO manager after fork()
   
   This is the libraries/base part of the patch; there is a corresponding
   patch to GHC itself.
   
   The main change is that we now keep track of the IO manager's ThreadId
   in a top-level MVar, and ensureIOManagerIsRunning checks whether a
   previous IO manager thread is alive before starting one.  In the child
   of fork(), we can hence call ensureIOManagerIsRunning to restart the
   IO manager.
 
     M ./GHC/Conc.lhs -46 +44
 
 Wed Nov  4 17:49:45 GMT 2009  Ian Lynagh <igloo@earth.li>
   * Fix the build on Windows
 
     M ./GHC/Conc.lhs -6 +4
] 
[Fix the build on Windows
Ian Lynagh <igloo@earth.li>**20091104174945] 
[Fix #1185: restart the IO manager after fork()
Simon Marlow <marlowsd@gmail.com>**20091103160540
 Ignore-this: 6dc05464f1500104554637f4759738cc
 
 This is the libraries/base part of the patch; there is a corresponding
 patch to GHC itself.
 
 The main change is that we now keep track of the IO manager's ThreadId
 in a top-level MVar, and ensureIOManagerIsRunning checks whether a
 previous IO manager thread is alive before starting one.  In the child
 of fork(), we can hence call ensureIOManagerIsRunning to restart the
 IO manager.
] 
[improve the documentation for throwErrnoIfRetry
Simon Marlow <marlowsd@gmail.com>**20091016112404
 Ignore-this: b77275cacf730e15757946027168f63e
] 
[Don't inline unpackFoldrCString ever
simonpj@microsoft.com**20091029135350
 Ignore-this: 85d672649b1b776efc7e97500b05d4f9
] 
[Inline more default methods
simonpj@microsoft.com**20091029135330
 Ignore-this: 289c44b0afd6d5631c2a4e0664275ca9
 
 Namely Monad: (>>)
        Eq:    (==), (/=)
        Num:   (-), negate
        Real:  quot, rem, div, mod, recip, (/), truncate
        Float: (**), logBase, sqrt, tan, tanh
] 
[Move error messages out of INLINEd default methods
simonpj@microsoft.com**20091029135118
 Ignore-this: 9e35dc947f94827a3529eb53a41575fd
 
 No need to duplicate the error generation!
] 
[Exploit now-working default-method INLINE pragmas for Data.Bits
simonpj@microsoft.com**20091029135041
 Ignore-this: 8adf225f31ca7a3181ee087e9e4fe535
 
 * Add INLINE pragmas to default methods for class Bits
 
 * Remove redundant instance methods elsewhere, now that
   the default method will do the job
] 
[Tidy up and comment imports
simonpj@microsoft.com**20091029134414
 Ignore-this: bf2be31035de975d8995e988933cc940
] 
[Inline foldr and (.) when applied to two arguments not three
simonpj@microsoft.com**20091029134335
 Ignore-this: fccb6f3e90e15f44cb465814be85ede2
 
 The new INLINE story is (by design) arity-sensitive, so we must
 put fewer argument on the LHS for foldr and (.)
] 
[dirUtils.c no longer available
Malcolm.Wallace@cs.york.ac.uk**20091013093833] 
[Make hGetContents throw an exception if an error is encountered
Simon Marlow <marlowsd@gmail.com>**20091012152955
 Ignore-this: 9f7a7176193eab25c9daaacd9261f2de
 
 Strictly speaking this breaks Haskell 98 compatibility, which requires
 hGetContents to just end the lazy stream silently if an error is
 encountered.  However, for a few reasons we think it will make
 everyone's life a bit easier if we make this change
 
  1. Errors will be a lot more common in GHC 6.12.1, in the form
     of Unicode decoding errors.
 
  2. When Haskell 98 was designed, we didn't know how to throw
     exceptions from inside lazy I/O, but now we do.
 
  3. If anyone is actually relying on the previous behaviour, their
     code is arguably broken.
] 
[Re-instate System.Console.Getopt for nhc98 builds.
Malcolm.Wallace@cs.york.ac.uk**20091013092843
 Although it was split out of base a while back, that change was
 reverted for ghc soon afterwards, but nhc98 never noticed.
] 
[Roll back "Another instance of nhc98's strange import semantics."
Ian Lynagh <igloo@earth.li>**20091009185618
 Fri Oct  9 14:50:51 BST 2009  Malcolm.Wallace@cs.york.ac.uk
 GHC (correctly) warns about the unused import, which breaks the validate
 build.
] 
[Roll back "Cope with nhc98's (occasionally-strange) import semantics"
Ian Lynagh <igloo@earth.li>**20091009184704
 Fri Oct  9 14:43:51 BST 2009  Malcolm.Wallace@cs.york.ac.uk
 GHC (correctly) warns about the unused import, which breaks the validate
 build.
] 
[It seems that nhc98 needs defaulting in Data.Fixed.
Malcolm.Wallace@cs.york.ac.uk**20091009135242] 
[Another instance of nhc98's strange import semantics.
Malcolm.Wallace@cs.york.ac.uk**20091009135051] 
[Make Data.Functor compatible with non-GHC compilers.
Malcolm.Wallace@cs.york.ac.uk**20091009134821] 
[Cope with nhc98's (occasionally-strange) import semantics.
Malcolm.Wallace@cs.york.ac.uk**20091009134351] 
[Fix gratuitous breakage of nhc98 in System.IO.
Malcolm.Wallace@cs.york.ac.uk**20091009134001] 
[Fix gratuitous breakage of nhc98 in Control.Exception.Base.
Malcolm.Wallace@cs.york.ac.uk**20091009133615] 
[Fix gratuitous breakage of non-GHC in Data.Fixed.
Malcolm.Wallace@cs.york.ac.uk**20091009133330] 
[Fix gratuitous breakage for non-GHC in Data.Bits.
Malcolm.Wallace@cs.york.ac.uk**20091009133257] 
[Use UTF-32LE instead of UTF32LE
Simon Marlow <marlowsd@gmail.com>**20091006100207
 Ignore-this: 7f881e36543d250ef848c9f60d67655a
 The latter is not recognised by some iconv implementations.
] 
[Strip any Byte Order Mark (BOM) from the front of decoded streams.
Ben.Lippmeier@anu.edu.au*-20090930084229
 Ignore-this: d0d0c3ae87b31d71ef1627c8e1786445
 When decoding to UTF-32, Solaris iconv inserts a BOM at the front
 of the stream, but Linux iconv doesn't. 
] 
[use UTF32BE/UTF32LE instead of UCS-4/UCS-4LE
Simon Marlow <marlowsd@gmail.com>**20091005101554
 Ignore-this: 2aef5e9bec421e714953b7aa1bdfc1b3
] 
[Strip any Byte Order Mark (BOM) from the front of decoded streams.
Ben.Lippmeier@anu.edu.au**20090930084229
 Ignore-this: d0d0c3ae87b31d71ef1627c8e1786445
 When decoding to UTF-32, Solaris iconv inserts a BOM at the front
 of the stream, but Linux iconv doesn't. 
] 
[Add traceEvent :: String -> IO ()
Simon Marlow <marlowsd@gmail.com>**20090925141257
 Ignore-this: 8b1888bbf9682ffba13f815b6000e4b1
 For emitting an event via the RTS tracing framework
] 
[Fix the error message when flushing the read buffer of a non-seekable Handle
Simon Marlow <marlowsd@gmail.com>**20090923090536
 Ignore-this: 4342026df93759d99480f4e13f80a492
] 
[Fix #3534: No need to flush the byte buffer when setting binary mode
Simon Marlow <marlowsd@gmail.com>**20090923090445
 Ignore-this: 625817ed7ae2c12291eb993a99dc640a
] 
[Use let !y = x in .. x .. instead of seq in $! and evaluate (#2273)
Simon Marlow <marlowsd@gmail.com>**20090916140454] 
[make some Applicative functions into methods, and split off Data.Functor (proposal #3335)
Ross Paterson <ross@soi.city.ac.uk>**20090915173109
 Ignore-this: a0cff4de6dfdbcbd56a66101bc4855a9
 
 The following functions
 
     (<$) :: Functor f => a -> f b -> f a
     (*>) :: Applicative f => f a -> f b -> f b
     (<*) :: Applicative f => f a -> f b -> f a
     some :: Alternative f => f a -> f [a]
     many :: Alternative f => f a -> f [a]
 
 are moved into the corresponding classes, with the existing implementations
 as default definitions.  This gives people creating instances the option of
 defining specialized implementations of these functions, though they should
 be equivalent to the default definitions.
 
 Although (<$) is now a method of the Functor class, it is hidden in the
 re-export by the Prelude, Control.Monad and Monad.  The new module
 Data.Functor exposes the full class, plus the function (<$>).  These are
 also re-exported by Control.Applicative.
] 
[On Windows, use the console code page for text file encoding/decoding.
Judah Jacobson <judah.jacobson@gmail.com>**20090913022126
 Ignore-this: 86c2f2db8ef92b751599795d3195187b
 
 We keep all of the code page tables in the module
 GHC.IO.Encoding.CodePage.Table.  That file was generated automatically
 by running codepages/MakeTable.hs; more details are in the comments at the
 start of that script.
 
 Storing the lookup tables adds about 40KB to each statically linked executable;
 this only increases the size of a "hello world" program by about 7%.
 
 Currently we do not support double-byte encodings (Chinese/Japanese/Korean), since
 including those codepages would increase the table size to 400KB.  It will be
 straightforward to implement them once the work on library DLLs is finished.
] 
[Fix "init" docs: the input list need not be finite. Fixes trac #3465
Ian Lynagh <igloo@earth.li>**20090911210437] 
[Bump base version to 4.2.0.0
Ian Lynagh <igloo@earth.li>**20090911153913] 
[Address #3310
Simon Marlow <marlowsd@gmail.com>**20090830152850
 Ignore-this: 40c7f7c171ee299a83092fd360a952b7
 
  - Rename BlockedOnDeadMVar   -> BlockedIndefinitelyOnMVar
  - Rename BlockedIndefinitely -> BlockedIndefinitelyOnSTM
  - instance Show BlockedIndefinitelyOnMVar is now
      "blocked indefinitely in an MVar operation"
  - instance Show BlockedIndefinitelyOnSTM is now
      "blocked indefinitely in an STM transaction"
 
 clients using Control.OldException will be unaffected (the new
 exceptions are mapped to the old names).  However, for base4-compat
 we'll need to make a version of catch/try that does a similar
 mapping.
] 
[Fix unicode conversion for MSB architectures
Ben.Lippmeier@anu.edu.au**20090830130028
 This fixes the SPARC/Solaris build.
] 
[Fix #3441: detect errors in partial sequences
Simon Marlow <marlowsd@gmail.com>**20090830075909
 Ignore-this: d12a75d95e0cae5eb1555266810ec281
] 
[Fix hWaitForInput
Simon Marlow <marlowsd@gmail.com>**20090827152116
 Ignore-this: 2550e911f1a4d4357a5aa8d1764238ce
 It was erroneously waiting when there were bytes to decode waiting in
 the byte buffer.
] 
[fix debugging code
Simon Marlow <marlowsd@gmail.com>**20090827150628
 Ignore-this: e1c82fdc19a22e247cd69ff6fa11921d
] 
[Allow for configurable iconv include and library locations.
Matthias Kilian <kili@outback.escape.de>**20090826154406
 Ignore-this: be95fab611a5534cf184b508964ed498
 This should help to fix the build on OpenBSD.
] 
[typo in comment
Simon Marlow <marlowsd@gmail.com>**20090826085252
 Ignore-this: 1903ee0f354157a6ed3871c100f6b1b9
] 
[un-hide some modules from the Haddock docs
Simon Marlow <marlowsd@gmail.com>**20090825152457
 Ignore-this: dce6606f93cf977fb24ebe99082dfa62
] 
[Apply fix for #1548, from squadette@gmail.com
Simon Marlow <marlowsd@gmail.com>**20090819120700
 Ignore-this: 31c237c46a6445f588ed4b8c51bb6231
] 
[improvements to Data.Fixed: instances for Typeable and Data, more predefined types
Ashley Yakeley <ashley@semantic.org>**20090812055058
 Ignore-this: feeece36d5632f02a05d137d2a39ab78
] 
[Fix "Cabal check" warnings
Ian Lynagh <igloo@earth.li>**20090811215856] 
[Add a GHC.Constants module; fixes trac #3094
Ian Lynagh <igloo@earth.li>**20090809183252] 
[Apply proposal #3393
Ian Lynagh <igloo@earth.li>**20090809134717
 Add openTempFileWithDefaultPermissions and
 openBinaryTempFileWithDefaultPermissions.
] 
[Add some more C wrappers; patch from Krister Walfridsson
Ian Lynagh <igloo@earth.li>**20090807200631
 Fixes 21 testsuite errors on NetBSD 5.99.
] 
[Fixing configure for autoconf 2.64
Alexander Dunlap <alexander.dunlap@gmail.com>**20090805060748
 Ignore-this: 992ab91ae3d68c12dbb265776e33e243
] 
[add INLINE toList
Ross Paterson <ross@soi.city.ac.uk>**20090806142853
 Ignore-this: aba16aabb17d5dca44f15d188945680e
 
 In anticipation of the fixing of #2353.
] 
[fix a copyright
Simon Marlow <marlowsd@gmail.com>**20090805134045
 Ignore-this: b0ffbdd38fbba121e8bcba37c4082a60
] 
[Tweak the BufferedIO class to enable a memory-mapped file implementation
Simon Marlow <marlowsd@gmail.com>**20090805134036
 Ignore-this: ec67d7a0a6d977438deaa342503f77e0
 We have to eliminate the assumption that an empty write buffer can be
 constructed by setting the buffer pointers to zero: this isn't
 necessarily the case when the buffer corresponds to a memory-mapped
 file, or other in-memory device implementation.
] 
[Deprecate Control.OldException
Ian Lynagh <igloo@earth.li>**20090804143910] 
[Windows build fix, following RTS tidyup
Simon Marlow <marlowsd@gmail.com>**20090803131121
 Ignore-this: ce862fb91c2b234211a8757f98690778
] 
[Updates to follow the RTS tidyup
Simon Marlow <marlowsd@gmail.com>**20090801220743
 Ignore-this: 6e92412df93a66c12d75344053d5634
 C functions like isDoubleNaN moved here (primFloat.c)
] 
[Add integer-simple as a build option
Ian Lynagh <igloo@earth.li>**20090722013151] 
[Use shift[LR]Integer in the Bits Integer instance
Ian Lynagh <igloo@earth.li>**20090721222440] 
[depend directly on integer-gmp, rather than indirecting through integer
Ian Lynagh <igloo@earth.li>**20090721185228] 
[Move the instances of Functor and Monad IO to GHC.Base, to avoid orphans
Simon Marlow <marlowsd@gmail.com>**20090722102130
 Ignore-this: a7d85ac0025d559674249de0108dbcf4
] 
[move "instance Exception Dynamic" so it isn't an orphan
Simon Marlow <marlowsd@gmail.com>**20090721093854
 Ignore-this: 5ede91ecfec2112c91b699d4de87cd02
] 
[Improve the index checking for array accesses; fixes #2120 #2669
Ian Lynagh <igloo@earth.li>**20090719153228
 As well as checking that offset we are reading is actually inside the
 array, we now also check that it is "in range" as defined by the Ix
 instance. This fixes confusing behaviour (#2120) and improves some error
 messages (#2669).
] 
[Make chr say what its argument was, if it's a bad argument
Ian Lynagh <igloo@earth.li>**20090718151049] 
[remove unused warning
Simon Marlow <marlowsd@gmail.com>**20090715124416
 Ignore-this: 31f613654089d0f4a44363946087b41e
] 
[warning fix: -fno-implicit-prelude -> -XNoImplicitPrelude
Simon Marlow <marlowsd@gmail.com>**20090715122839
 Ignore-this: dc8957249731d5bcb71c01899e5adf2b
] 
[Add hGetEncoding :: Handle -> IO (Maybe TextEncoding)
Simon Marlow <marlowsd@gmail.com>**20090715122519
 Ignore-this: 14c3eff996db062da1199739781e4708
 as suggested during the discussion on the libraries list
] 
[Add more documentation to mkTextEncoding
Simon Marlow <marlowsd@gmail.com>**20090715122414
 Ignore-this: 97253b2624267df3a246a18121e8ea81
 noting that "//IGNORE" and "//TRANSLIT" suffixes can be used with GNU
 iconv.
] 
[Add the utf8_bom codec
Simon Marlow <marlowsd@gmail.com>**20090715122257
 Ignore-this: 1c9396cd805201fe873a39382ced79c7
 as suggested during the discussion on the libraries list.
] 
[Export Unicode and newline functionality from System.IO; update Haddock docs
Simon Marlow <marlowsd@gmail.com>**20090713113104
 Ignore-this: c3f017a555335aa55d106253393f72e2
] 
[add a comment about the non-workingness of CHARBUF_UTF16
Simon Marlow <marlowsd@gmail.com>**20090707124406
 Ignore-this: 98d00411b68d688b3b4cffc9507b1f35
] 
[Fix build on Windows
Ian Lynagh <igloo@earth.li>**20090711004351] 
[Fix some "warn-unused-do-bind" warnings where we want to ignore the value
Ian Lynagh <igloo@earth.li>**20090710204513] 
[Use throwErrnoIfMinus1_ when calling getrusage
Ian Lynagh <igloo@earth.li>**20090710204221] 
[Remove an unused import
Ian Lynagh <igloo@earth.li>**20090710153345] 
[reportStackOverflow now returns IO ()
Ian Lynagh <igloo@earth.li>**20090710153257
 It used to do "return undefined" to return IO a.
] 
[GHC.Conc.reportError now returns IO ()
Ian Lynagh <igloo@earth.li>**20090710152646
 It used to return IO a, by "return undefined".
] 
[Fix some "warn-unused-do-bind" warnings where we want to ignore the value
Ian Lynagh <igloo@earth.li>**20090710152526] 
[Minor SampleVar refactoring
Ian Lynagh <igloo@earth.li>**20090710151438] 
[Fix "warn-unused-do-bind" warnings in GHC/IO/Handle/Text.hs
Ian Lynagh <igloo@earth.li>**20090710122905] 
[Fix some "warn-unused-do-bind" warnings where we just want to ignore the result
Ian Lynagh <igloo@earth.li>**20090710005638] 
[Use the result of writeCharBuf in GHC/IO/Encoding/Latin1.hs too
Ian Lynagh <igloo@earth.li>**20090710004032] 
[Minor code tidyups in GHC.Conc
Ian Lynagh <igloo@earth.li>**20090710003801] 
[Fix "warn-unused-do-bind" warning in GHC.Conc
Ian Lynagh <igloo@earth.li>**20090710003530
 If we fail to communicate with the IO manager then we print a warning
 using debugErrLn from the ghc-prim package.
] 
[Fix "warn-unused-do-bind" warnings in System.Posix.Internals
Ian Lynagh <igloo@earth.li>**20090709164546] 
[Fix "warn-unused-do-bind" warnings where we really do want to ignore the result
Ian Lynagh <igloo@earth.li>**20090709163912] 
[Add back imports needed on Windows
Ian Lynagh <igloo@earth.li>**20090707181924] 
[Remove unused imports
Ian Lynagh <igloo@earth.li>**20090707115810] 
[Remove unused imports from base
simonpj@microsoft.com**20090706111842
 Ignore-this: f9b5f353e3bb820f787c56d615b28765
 
 These unused imports are detected by the new unused-import code
 
] 
[Use the result of writeCharBuf
Simon Marlow <marlowsd@gmail.com>**20090706133303
 Ignore-this: 52288dd559bf4c4f313df6197091d935
   
 This only makes a difference when CHARBUF_UTF16 is in use, which it
 normally isn't.  I suspect CHARBUF_UTF16 doesn't currently work for
 other reasons (CHARBUF_UTF16 was an experiment before I wrote the
 GHC.IO.Encoding.UTF* codecs), but this patch at least makes it
 slightly closer to working.
] 
[Remove some cruft from Data.HashTable
Ian Lynagh <igloo@earth.li>**20090706181630] 
[Add 'eof' to Text.ParserCombinators.ReadP
simonpj@microsoft.com**20090706111801
 Ignore-this: 2aea7b848e00c894761bc4011adaa95d
 
 Add a ReadP parser that succeeds at the end of input. Very useful!
 
] 
[Don't export CLDouble for GHC; fixes trac #2793
Ian Lynagh <igloo@earth.li>**20090705155120
 We never really supported CLDouble (it was a plain old double underneath),
 and pretending that we do does more harm than good.
] 
[a byte between 0x80 and 0xBF is illegal immediately (#3341)
Simon Marlow <marlowsd@gmail.com>**20090702081415
 Ignore-this: dc19ef59a1a21118d5a7dd38aa2f611c
] 
[avoid a warning
Simon Marlow <marlowsd@gmail.com>**20090630084134
 Ignore-this: c92a45ee216faf01327feae9fe06d6e2
] 
[Add a wrapper for libiconv.
Matthias Kilian <kili@outback.escape.de>**20090629183634
 Ignore-this: 23c6047c0d71b745b495cc223574a47f
] 
[#include <sys/times.h> if we have it (should fix build problems)
Simon Marlow <marlowsd@gmail.com>**20090629085351
 Ignore-this: a35e93b37ca9595c73460243180f4b9d
] 
[set binary mode for existing FDs on Windows (fixes some GHCi test failures)
Simon Marlow <marlowsd@gmail.com>**20090626120522
 Ignore-this: 580cf636e9c77d8427aff6861d089481
] 
[Move directory-related stuff to the unix package
Simon Marlow <marlowsd@gmail.com>**20090625120325
 Ignore-this: b997b3cbce0a46ca87ad825bbdc0a411
 now that it isn't used on Windows any more.
] 
[TAG 2009-06-25
Ian Lynagh <igloo@earth.li>**20090625160056] 
Patch bundle hash:
bc878d1d4a0032b0cfa08b790a7be97e7ce51590