remove Text.Regex(.Posix) from nhc98 build

add Data.Foldable.{msum,asum}, plus tweaks to comments

fix doc typo

add Data.Foldable.{for_,forM_} and Data.Traversable.{for,forM}

generalizing Control.Monad.{forM_,forM}

Make length a good consumer

Make length into a good consumer.  Fixes Trac bug #707.

(Before length simply didn't use foldr.)

Add Control.Monad.forM and forM_

flip mapM_ is more and more common, I find. Several suggestions have
been made to add this, as foreach or something similar. This patch
does just that:

    forM  :: (Monad m) => [a] -> (a -> m b) -> m [b]
    forM_ :: (Monad m) => [a] -> (a -> m b) -> m ()

So we can write:

    Prelude Control.Monad> forM_ [1..4] $ \x -> print x
    1
    2
    3
    4

Hide internal module from haddock in Data.ByteString

add advice on avoiding import ambiguities

expand advice on importing these modules

add Haddock marker

Clarify how one hides Prelude.catch

User feedback indicated that an example was required, of how to hide
Prelude.catch, so add such an example to the docs

Workaround for OSes that don't have intmax_t and uintmax_t
OpenBSD (and possibly others) do not have intmax_t and uintmax_t types:
    http://www.mail-archive.com/haskell-prime@haskell.org/msg01548.html
so substitute (unsigned) long long if we have them, otherwise
(unsigned) long.

add docs for par

document minimal complete definition for Bits

C regex library bits have moved to the regex-posix package

Add shared Typeable support (ghc only)

this should have been removed with the previous patch

remove Text.Regx & Text.Regex.Posix
These are subsumed by the new regex-base, regex-posix and regex-compat
packages.

explicitly tag Data.ByteString rules with the FPS prefix.

Add spec rules for sections in Data.ByteString

Sync Data.ByteString with current stable branch, 0.7

add notes about why copyFile doesn't remove the target

copyFile: try removing the target file before opening it for writing

copyFile: try removing the target file before opening it for writing

add alternative functors and extra instances

* Alternative class, for functors with a monoid
* instances for Const
* instances for arrows

generate Haddock docs on all platforms

remove extra comma from import

fix docs for withC(A)StringLen

use Haskell'98 compliant indentation in do blocks

use correct names of IOArray operations for nhc98

add mapMaybe and mapEither, plus WithKey variants

remove Text.Html from nhc98 build

eliminate more HOST_OS tests

Hugs only: disable unused process primitives

These were the cause of Hugs bug #30, I think, and weren't used by Hugs anyway.

markup fix to Data.HashTable

revert removal of ghcconfig.h from package.conf.in

as it's preprocessed with -undef (pointed out by Esa Ilari Vuokko)

fix Data.HashTable for non-GHC

remove deprecated 'withObject'

Jan-Willem Maessen's improved implementation of Data.HashTable
Rather than incrementally enlarging the hash table, this version
just does it in one go when the table gets too full.

Warning police: Make some prototypes from the RTS known

Warning police: Removed useless catch-all clause

reduce dependency on ghcconfig.h

The only remaining use is in cbits/dirUtils.h, which tests solaris2_HOST_OS

(Also System.Info uses ghcplatform.h and several modules import MachDeps.h
to get SIZEOF_* and ALIGNMENT_* from ghcautoconf.h)

(non-GHC only) track MArray interface change

move Text.Html to a separate package

bump version to 2.0

Remove deprecated Data.FiniteMap and Data.Set interfaces

move altzone test from ghc to base package

remove unnecessary #include "ghcconfig.h"

Change the API of MArray to allow resizable arrays
See #704

The MArray class doesn't currently allow a mutable array to change its
size, because of the pure function

  bounds :: (HasBounds a, Ix i) => a i e -> (i,i)

This patch removes the HasBounds class, and adds

  getBounds :: (MArray a e m, Ix i) => a i e -> m (i,i)

to the MArray class, and

  bounds :: (IArray a e, Ix i) => a i e -> (i,i)

to the IArray class.

The reason that bounds had to be incorporated into the IArray class is
because I couldn't make DiffArray work without doing this.  DiffArray
acts as a layer converting an MArray into an IArray, and there was no
way (that I could find) to define an instance of HasBounds for
DiffArray.

deprecate this module.

add traceShow (see #474)

remove spurious 'extern "C" {'

Fix unsafeIndex for large ranges

Improve documentation of atomically

Add missing method genRange for StdGen (fixes #794)

MERGE TO STABLE

Trac #794 reports (correctly) that the implementation of StdGen
only returns numbers in the range (0..something) rather than
(minBound, maxBound), which is what StdGen's genRange claims.

This commit fixes the problem, by implementing genRange for StdGen
(previously it just used the default method).

disambiguate uses of foldr for nhc98 to compile without errors

make Control.Monad.Instances compilable by nhc98

breakpointCond

UNDO: Merge "unrecognized long opt" fix from 6.4.2
This patch undid the previous patch, "RequireOrder: do not collect
unrecognised options after a non-opt".  I asked Sven to revert it, but
didn't get an answer.

See bug #473.

Avoid strictness in accumulator for unpackFoldr

The seq on the accumulator for unpackFoldr will break in the presence of
head/build rewrite rules. The empty list case will be forced, producing
an exception. This is a known issue with seq and rewrite rules that we
just stumbled on to.

Disable unpack/build fusion

unpack/build on bytestrings seems to trigger a bug when interacting with
head/build fusion in GHC.List. The bytestring001 testcase catches it.

I'll investigate further, but best to disable this for now (its not
often used anyway).

Note that with -frules-off or ghc 6.4.2 things are fine. It seems to
have emerged with the recent rules changes.

Import Data.ByteString.Lazy, improve ByteString Fusion, and resync with FPS head

This patch imports the Data.ByteString.Lazy module, and its helpers,
providing a ByteString implemented as a lazy list of strict cache-sized
chunks. This type allows the usual lazy operations to be written on
bytestrings, including lazy IO, with much improved space and time over
the [Char] equivalents.

Wibble in docs for new ForeignPtr functionsn

comments for Applicative and Traversable

default to NoBuffering on Windows for a read/write text file
Fixes (works around) #679

remove dead code

clarify and expand docs

Add minView and maxView to Map and Set

add signature for registerDelay

a few doc comments

Optimised foreign pointer representation, for heap-allocated objects

Add the inline function, and many comments

This commit adds the 'inline' function described in the
related patch in the compiler.

I've also added comments about the 'lazy' function.

small intro to exceptions

export breakpoint

Merge in changes from fps head. Highlights:

    Wed May 24 15:49:38 EST 2006  sjanssen@cse.unl.edu
      * instance Monoid ByteString

    Wed May 24 15:04:04 EST 2006  Duncan Coutts <duncan.coutts@worc.ox.ac.uk>
      * Rearange export lists for the .Char8 modules

    Wed May 24 14:59:56 EST 2006  Duncan Coutts <duncan.coutts@worc.ox.ac.uk>
      * Implement mapAccumL and reimplement mapIndexed using loopU

    Wed May 24 14:47:32 EST 2006  Duncan Coutts <duncan.coutts@worc.ox.ac.uk>
      * Change the implementation of the unfoldr(N) functions.
      Use a more compact implementation for unfoldrN and change it's behaviour
      to only return Just in the case that it actually 'overflowed' the N, so
      the boundary case of unfolding exactly N gives Nothing.
      Implement unfoldr and Lazy.unfoldr in terms of unfoldrN. Use fibonacci
      growth for the chunk size in unfoldr

    Wed May 24 08:32:29 EST 2006  sjanssen@cse.unl.edu
      * Add unfoldr to ByteString and .Char8
      A preliminary implementation of unfoldr.

    Wed May 24 01:39:41 EST 2006  Duncan Coutts <duncan.coutts@worc.ox.ac.uk>
      * Reorder the export lists to better match the Data.List api

    Tue May 23 14:04:32 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
      * pack{Byte,Char} -> singleton. As per fptools convention

    Tue May 23 14:00:51 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
      * elemIndexLast -> elemIndexEnd

    Tue May 23 13:57:34 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
      * In the search for a more orthogonal api, we kill breakFirst/breakLast,
        which were of dubious value

    Tue May 23 12:24:09 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
      * Abolish elems. It's name implied it was unpack, but its type didn't. it made no sense

    Tue May 23 10:42:09 EST 2006  Duncan Coutts <duncan.coutts@worc.ox.ac.uk>
      * Minor doc tidyup. Use haddock markup better.

    Tue May 23 11:00:31 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
      * Simplify the join() implementation. Spotted by Duncan.

add a way to ask the IO manager thread to exit

Sync with FPS head, including the following patches:

    Thu May 18 15:45:46 EST 2006  sjanssen@cse.unl.edu
      * Export unsafeTake and unsafeDrop

    Fri May 19 11:53:08 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
      * Add foldl1'

    Fri May 19 13:41:24 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
      * Add fuseable scanl, scanl1 + properties

    Fri May 19 18:20:40 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
      * Spotted another chance to use unsafeTake,Drop (in groupBy)

    Thu May 18 09:24:25 EST 2006  Duncan Coutts <duncan.coutts@worc.ox.ac.uk>
      * More effecient findIndexOrEnd based on the impl of findIndex

    Thu May 18 09:22:49 EST 2006  Duncan Coutts <duncan.coutts@worc.ox.ac.uk>
      * Eliminate special case in findIndex since it's handled anyway.

    Thu May 18 09:19:08 EST 2006  Duncan Coutts <duncan.coutts@worc.ox.ac.uk>
      * Add unsafeTake and unsafeDrop
      These versions assume the n is in the bounds of the bytestring, saving
      two comparison tests. Then use them in varous places where we think this
      holds. These cases need double checking (and there are a few remaining
      internal uses of take / drop that might be possible to convert).
      Not exported for the moment.

    Tue May 16 23:15:11 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
      * Handle n < 0 in drop and splitAt. Spotted by QC.

    Tue May 16 22:46:22 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
      * Handle n <= 0 cases for unfoldr and replicate. Spotted by QC

    Tue May 16 21:34:11 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
      * mapF -> map', filterF -> filter'

haddock fix

simplify indexing in Data.Sequence

Move Eq, Ord, Show instances for ThreadId to GHC.Conc
Eliminates orphans.

Better error handling in the IO manager thread
In particular, handle EBADF just like rts/posix/Select.c, by waking up
all the waiting threads.  Other errors are thrown, instead of just
being ignored.

#define _REENTRANT 1  (needed to get the right errno on some OSs)
Part 2 of the fix for threaded RTS problems on Solaris and possibly
*BSD (Part 1 was the same change in ghc/includes/Rts.h).

copyCString* should be in IO. Spotted by Tomasz Zielonka

add import Prelude to get dependencies right for Data/Fixed.hs
Hopefully this fixes parallel builds.

Fix negative index handling in splitAt, replicate and unfoldrN. Move mapF, filterF -> map', filter' while we're here

Use our own realloc. Thus reduction functions (like filter) allocate on the Haskell heap. Makes around 10% difference.

Last two CInt fixes for 64 bit, and bracket writeFile while we're here

Some small optimisations, generalise the type of unfold

    Tue May  9 22:36:29 EST 2006  Duncan Coutts <duncan.coutts@worc.ox.ac.uk>
      * Surely the error function should not be inlined.

    Tue May  9 22:35:53 EST 2006  Duncan Coutts <duncan.coutts@worc.ox.ac.uk>
      * Reorder memory writes for better cache locality.

    Tue May  9 23:28:09 EST 2006  Duncan Coutts <duncan.coutts@worc.ox.ac.uk>
      * Generalise the type of unfoldrN

      The type of unfoldrN was overly constrained:
      unfoldrN :: Int -> (Word8 -> Maybe (Word8, Word8)) -> Word8 -> ByteString

      if we compare that to unfoldr:
      unfoldr :: (b -> Maybe (a, b)) -> b -> [a]

      So we can generalise unfoldrN to this type:
      unfoldrN :: Int -> (a -> Maybe (Word8, a)) -> a -> ByteString

      and something similar for the .Char8 version. If people really do want to
      use it a lot with Word8/Char then perhaps we should add a specialise pragma.

    Wed May 10 13:26:40 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
      * Add foldl', and thus a fusion rule for length . {map,filter,fold},
      that avoids creating an array at all if the end of the pipeline is a 'length' reduction

**END OF DESCRIPTION***

Place the long patch description above the ***END OF DESCRIPTION*** marker.
The first line of this file will be the patch name.

This patch contains the following changes:

M ./Data/ByteString.hs -8 +38
M ./Data/ByteString/Char8.hs -6 +12

portable implementation of WordPtr/IntPtr for non-GHC

plus much tweaking of imports to avoid cycles

add WordPtr and IntPtr types to Foreign.Ptr, with associated conversions

As suggested by John Meacham.

I had to move the Show instance for Ptr into GHC.ForeignPtr to avoid
recursive dependencies.

add CIntPtr, CUIntPtr, CIntMax, CUIntMax types

add GHC.Dynamic

Two things. #if defined(__GLASGOW_HASKELL__) on INLINE [n] pragmas (for jhc). And careful use of INLINE on words/unwords halves runtime for those functions

Make length a good consumer

Make length into a good consumer.  Fixes Trac bug #707.

(Before length simply didn't use foldr.)

Trim imports

Make unsafePerformIO lazy

The stricteness analyser used to have a HACK which ensured that NOINLNE things
were not strictness-analysed.  The reason was unsafePerformIO. Left to itself,
the strictness analyser would discover this strictness for unsafePerformIO:
unsafePerformIO:  C(U(AV))
But then consider this sub-expression
unsafePerformIO (\s -> let r = f x in
       case writeIORef v r s of (# s1, _ #) ->
       (# s1, r #)
The strictness analyser will now find that r is sure to be eval'd,
and may then hoist it out.  This makes tests/lib/should_run/memo002
deadlock.

Solving this by making all NOINLINE things have no strictness info is overkill.
In particular, it's overkill for runST, which is perfectly respectable.
Consider
f x = runST (return x)
This should be strict in x.

So the new plan is to define unsafePerformIO using the 'lazy' combinator:

unsafePerformIO (IO m) = lazy (case m realWorld# of (# _, r #) -> r)

Remember, 'lazy' is a wired-in identity-function Id, of type a->a, which is
magically NON-STRICT, and is inlined after strictness analysis.  So
unsafePerformIO will look non-strict, and that's what we want.

Sync with FPS head.

Mon May  8 10:40:14 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
  * Fix all uses for Int that should be CInt or CSize in ffi imports.
  Spotted by Igloo, dcoutts

Mon May  8 16:09:41 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
  * Import nicer loop/loop fusion rule from ghc-ndp

Mon May  8 17:36:07 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
  * Fix stack leak in split on > 60M strings

Mon May  8 17:50:13 EST 2006  Don Stewart <dons@cse.unsw.edu.au>
  * Try same fix for stack overflow in elemIndices

Fix all uses for Int that should be CInt or CSize in ffi imports. Spotted by Duncan and Ian

Fixed import list syntax

Faster filterF, filterNotByte