Fix the build on Windows

Add wrappers for [gs]etrlimit
This is for #2038: macros are used in the Linux .h includes to redirect
to a 64-bit version when large file support is enabled.

Add a wrapper for mkstemp
This is for #2038: macros are used in the Linux .h includes to redirect
to a 64-bit version when large file support is enabled.

Avoid calling varargs functions using the FFI
Calling varargs functions is explicitly deprecated according to the
FFI specification.  It used to work, just about, but it broke with the
recent changes to the via-C backend to not use header files.

Add comments about why rotate has an INLINE

Inline Data.Bits.rotate@Int, enables rotate to be constant folded

All other Bits instances seem to inline well enough on their own
to enable constant folding, e.g.

    sumU . mapU (`shift` 3) . replicateU 10000000 $ (7 :: Int)

goes to:

    Main.$wfold =
      \ (ww_sOb :: Int#) (ww1_sOf :: Int#) ->
        case ww1_sOf of wild_XM {
          __DEFAULT -> Main.$wfold (+# ww_sOb 56) (+# wild_XM 1);
          10000000 -> ww_sOb
        }

With this patch, rotate gets inlined and folded too,

    sumU . mapU (`rotate` 3) . replicateU 10000000 $ (7 :: Int)

to:

  Main.$wfold =
    \ (ww_sO7 :: Int#) (ww1_sOb :: Int#) ->
      case ww1_sOb of wild_XM {
        __DEFAULT -> Main.$wfold (+# ww_sO7 56) (+# wild_XM 1);
        10000000 -> ww_sO7

Whereas it was left as a call to $wrotate before.

Moved def. of emptyP

emptyP def to gHC.PArr

Reexport (>>>) and (<<<) from Control.Arrow. Preserves API compatibility

Add realToFrac RULE comments from patch message into the source code

Add RULES for realToFrac from Int.

    {-# RULES
    "realToFrac/Int->Double"    realToFrac   = int2Double
    "realToFrac/Int->Float"     realToFrac   = int2Float
      #-}

Note that this only matters for realToFrac. If you've been using
fromIntegral to promote Int to Doubles, things should be fine as they are.

The following program, using stream fusion to eliminate arrays:

    import Data.Array.Vector

    n = 40000000

    main = do
          let c = replicateU n (2::Double)
              a = mapU realToFrac (enumFromToU 0 (n-1) ) :: UArr Double
          print (sumU (zipWithU (*) c a))

Yields this loop body without the RULE:

    case $wtoRational sc_sY4 of ww_aM7 { (# ww1_aM9, ww2_aMa #) ->
    case $wfromRat ww1_aM9 ww2_aMa of tpl_X1P { D# ipv_sW3 ->
    Main.$s$wfold
      (+# sc_sY4 1)
      (+# wild_X1i 1)
      (+## sc2_sY6 (*## 2.0 ipv_sW3))

And with the rule:

   Main.$s$wfold
      (+# sc_sXT 1)
      (+# wild_X1h 1)
      (+## sc2_sXV (*## 2.0 (int2Double# sc_sXT)))

The running time of the program goes from 120 seconds to 0.198 seconds
with the native backend, and 0.143 seconds with the C backend.

And just so I don't forget, here's the difference in resulting
assembly (x86_64), between the native code generator, and the
C backend.

-fasm

    Main_zdszdwfold_info:
      movq %rdi,%rax
      cmpq $40000000,%rax
      jne .LcZK
      jmp *(%rbp)
    .LcZK:
      cmpq $39999999,%rsi
      jg .LcZN
      cvtsi2sdq %rsi,%xmm0
      mulsd .LnZP(%rip),%xmm0
      movsd %xmm5,%xmm7
      addsd %xmm0,%xmm7
      incq %rax
      incq %rsi
      movq %rax,%rdi
      movsd %xmm7,%xmm5
      jmp Main_zdszdwfold_info

With the C backend we get the even better assembly, (-fvia-C -optc-O3)

    Main_zdszdwfold_info:
        cmpq    $40000000, %rdi
        je  .L9
    .L5:
        cmpq    $39999999, %rsi
        jg  .L9
        cvtsi2sdq   %rsi, %xmm0
        leaq    1(%rdi), %rdi
        addq    $1, %rsi
        addsd   %xmm0, %xmm0
        addsd   %xmm0, %xmm5
        jmp Main_zdszdwfold_info
    .L9:
        jmp *(%rbp)

So might make a useful test once the native codegen project starts up.

Just (-0/1) is now printed as Just (-0.0), not Just -0.0; trac #2036

record libraries@haskell.org as maintainer

Added emptyP def

don't set O_NONBLOCK on FDs passed to fdToHandle

Improve docs for unsafeCoerce
Make it clear that compilers differ.  Point to GHC docs in GHC.Base, and
add a short description of nhc98's representation-safe conversions.

Spelling only

In docs for unsafeCoerce, point to unsafeCoerce#

Turn off the gcd/lcm optimisations for Integer for now
This makes it easier to experiment with other implementations

Ordering has now moved to ghc-prim

fix types for __hscore_st_dev() and __hscore_st_ino()

give an absolute path to 'harch'

Move Word64/Int64/Word32/Int32 primitives into ghc-prim

Update .darcs-boring
GHC/Prim.hs, GHC/PrimopWrappers.hs are no longer generated in this package

Remove GHC.PrimopWrappers from base's exposed modules list

base now uses build-type: Configure

Move Integer out into its own package
We now depend on the new integer package.
We also depend on a new ghc-prim package, which has GHC.Prim,
GHC.PrimopWrappers, and new modules GHC.Bool and GHC.Generics,
containing Bool and Unit/Inl/Inr respectively.

List extensions used rather than using the -fglasgow-exts hammer

Remove a gratuitous pattern type sig

An even better definition for (^) (trac #1687)

Replace (^) with a faster variant (from trac #1687)

Add partitionEithers, lefts, and rights.
Patch from Russell O'Connor, trac proposal #974.

System.Console.GetOpt mistakenly rejects options as ambiguous.
From "Eelis van der Weegen" <haskell-libs@contacts.eelis.net>.
Testcase:

> import System.Console.GetOpt
>
> type Color = String
>
> optsDesc :: [OptDescr Color]
> optsDesc = [Option "" ["color", "colour"]
>                    (ReqArg id "color") "Foreground color"]
>
> main = do
>   let args = ["--col=blue"]
>   case getOpt RequireOrder optsDesc args of
>     (_, _, err:_) -> putStrLn err
>     _ -> return ()

Output:
  option `--col' is ambiguous; could be one of:
      --color=color, --colour=color  Foreground color
      --color=color, --colour=color  Foreground color

This error is silly, because the two alternatives listed are the same
option.  The problem is caused by incorrect use of a generator in a list
comprehension.

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

untabify

export MVar, TVar, and STM non-abstractly
As requested by Sterling Clover on ghc-users

Added Down class and improved groupWith fusion

untabify

untabify

mention explicitly that hIsEOF may block

untabify

untabify

untabify

untabify

untabify

Add exitSuccess :: IO a. For symmetry with exitFailure

untabify

untabify

untabify

FIX dynamic001, dynamic002: further fixes to tuple printing

untabify

untabify only

whitespace only

Whitespace only

FIX dynamic001 dynamic002: isTupleTyCon had rotted
In the patch "Tuple tycons have parens around their names", the names
of the tuple tycons were changed to include parens, but isTupleTyCon
was not updated to match, which made tuple types show as "(,) a b"
rather than "(a,b)"

deforestation rules for enumFromThenTo; based on a patch from Robin Houston

Generalise type of forever :: (Monad m) => m a -> m b

FIX #1936: hGetBufNonBlocking was blocking on stdin/stdout/stderr

The default uncaught exception handler was adding an extra \n

add comment about lack of _chsize_s()

Windows: large file support for hFileSize and hSeek (#1771)

Export topHandler, topHandlerFastExit from GHC.TopHandler
We now use one of these in ghc when running with ghc -e

haddock attributes for haddock-2.0

Data.List.sort: force elements from start to end.
this prevents a stack overflow on  sort (take 10^6 [1..])

Fix comment on GHC.Ptr.minusPtr

Remove redundant imports of GHC.Err

GHC.Base SOURCE-imports GHC.Err, and re-exports 'error'.  So
other modules need only import GHC.Base.

This doesn't change the fact that these other modules are all compiled
before GHC.Err, so they are all part of the module loop that starts with
GHC.Base and finishes with GHC.Err.  But it does reduce the occurrence
of those SOURCE imports.

Tuple tycons have parens around their names

The name of the pair TyCon, in the Typeable instance,
should be "(,)" not ",".

Don't merge to 6.8; it's a minor API change.

Add groupWith, sortWith, the, to support generalised list comprehensions

  This the base-library patch to support the main compiler patch
     Implement generalised list comprehensions

  It just adds three functions to GHC.Exts.

Add GHC.Prim to exposedModules in the Haddock 0.x hook

Please merge to the stable branch

Add GHC.Prim to exposedModules in the Haddock 0.x hook

Please merge to the stable branch

Simplify the GHC.Prim hack in base.cabal/Setup.hs

Implement 'openTempFile' for nhc98.

docs: describe the changes to forkIO, and document forkOnIO

doc only: use realToFrac instead of fromRational.toRational

Add singletonP to GHC.PArr

FIX #1621: bug in Windows code for getCPUTime
We were reading the components of FILETIME as CLong, when they should
be unsigned.  Word32 seems to be the correct type here.

protect console handler against concurrent access (#1922)