GitLab

add some more warnings about unsafeThaw

improve documentation for takeMVar/putMVar

Use a type sig rather than a pattern signature, to avoid
depending on GHC's precise impl of scoped type variables.
(Which I'm about to change.)

Eta-expand some higher-rank functions.  GHC is about to
move to *invariant* rather than *contra-variant* in function
arguments, so far as type subsumption is concerned. These
eta-expansions are simple, and allow type inference to
go through with invariance.

Fix one-char typo in scanl1P

* Left-bias restored
* Minor documentation improvements

deriving Data

Add dataCast1/dataCast2 methods to Data class, as per ticket #633.

Raise the (new) exception NestedAtomically when atomically is nested
(using unsafePerformIO).  This is a small improvement over crashing.

Only Streams can be DuplexHandles, not RawDevices.

Add IO versions of the STM primitives that allocate new transactional variables:

  newTVarIO :: a -> IO (TVar a)
  newTChanIO :: IO (TChan a)
  newTMVarIO :: a -> IO (TMVar a)

These can be used inside unsafePerformIO, unlike the STM versions.

Removed spurious constraint for Monoid (IntMap a) instance

avoid recursive module trap with Haddock

Apply rev 1.24 from FreeBSD's copy of this file.  Commit message from
FreeBSD:

   The algorithm that computes the tables used in the BM search
   algorithm sometimes access an array beyond it's length. This only
   happens in the last iteration of a loop, and the value fetched is
   not used then, so the bug is a relatively innocent one. Fix this by
   not fetching any value on the last iteration of said loop.

   Submitted by:	MKI <mki@mozone.net>

This is the cause of bug #1194393 (crash in darcs on Windows).

oops, forgot to remove forkIO from here

export childHandler

- move forkIO into GHC.Conc, so that the I/O manager can use proper forkIO
  with an exception handler.  This required TopHandler.lhs-boot.  It's the
  right thing, though, since the forkIO implementation is GHC-specific.

- check for out-of-range file descriptors in the I/O manager, rather than
  just exploding.  The I/O manager will exit ungracefully, but at least
  there will be an error message.

Add

  registerDelay :: Int -> IO (TVar Bool)

for implementing delays and timeouts in STM.  The delay is implemented
in the same way as threadDelay.  Currently doesn't work on Windows or
without -threaded (I do intend to make it work on Windows, though).

As foreshadowed on the libraries list, introduce new classes:

Applicative (formerly known as Idiom): generalizes (but does not replace)
both Monad and Monoid.

Traversable: containers that can be traversed, executing actions and
re-assembling the results.  This class generalizes and replaces FunctorM,
because it requires Applicative instead of Monad.

Foldable: containers that can be folded over a Monoid.  Traversable
supplies a default definition, but some structures, e.g. Set, are Foldable
but not Traversable.

add a couple of Boolean instances

ProcessHandle is now an MVar, in which we cache the ExitCode of the
process when we know it.

Additionally, waitForProcess and getProcessExitCode now close the
handle eagerly on Windows, this avoids a problem with hsc2hs which
wants to remove the executable it just ran, and it can't if the handle
is still open.

Correct handling of negative numbers in split and splitMember in IntMap and IntSet.
Better documentation for insert and insertWith in Maps.

waitForProcess: if the process died with a signal, just return the
exit status rather than EINTR.

This means a segfault shows up as (ExitFailure 139) rather than
an exception complaining about system call interruption.  If the
client wants a more unix-ish interpretation, they probably should be
using System.Posix.Process anyway.

On Windows, attach a finalizer to the ProcessHandle so that we can
call CloseHandle() when the handle is no longer in use.  Previously we
were calling CloseHandle() in waitForProcess and terminateProcess,
which prevented making multiple calls to these functions on the same
handle.

Fix bugs in new signal handling machinery

Some docs for System.Posix, from Bj?rn Bringert

add GHC notes to mallocForeignPtr

[mingw/msys only]
Undo long-standing workaround for buggy GNU ld's on mingw/msys; i.e.,
the linker wasn't correctly generating relocatable object files when
the number of relocs exceeded 2^16. Worked around the issue by
hackily splitting up the GHCi object file for the larger packages
('base', 'ObjectIO' and 'win32') into a handful of object files,
each with a manageable number of relocs. Tiresome and error-prone
(but the hack has served us well!)

This commit imposes a restriction on the 'ld' you use to compile
up GHC with; it now has to be ld-2.15.x or later (something GHC
binary dists have shipped with since 6.2.2)

missing part of rev. 1.13: in unfoldForestM_BF, the output sequence is
now in the right order, so don't reverse it.

FPTOOLS_CHECK_HTYPE: correctly scope the resetting of CPPFLAGS; as was,
it got blown away if the value was cached.

Merge to STABLE.

fix findExecutable (I hope; don't have an up to date Windows build to
test on).

forkIO the signal handlers directly from the IO manager thread, rather
than calling an RTS function to do the same thing.

add Monoid instance

Now that Data.Monoid is portable, move Monoid instances for sets and
maps back to where the data types are defined.

Change the Monoid instance for functions (as proposed on the libraries
list, and interpreting silence as assent) from composition to pointwise
combination.

Rationale: The new instance is consistent with the instances for tuples,
it's compositional, in that it builds instances for complex types out
of instances for simpler ones, and it makes this module Haskell 98.

Downside: the old instance was easy to use with Writer monads, and ShowS
was a special case.  You can get that effect using the new Endo type,
but you have to wrap and unwrap the newtype.

Also added a few other simple monoids: dual, sum and product.

Note that throwTo blocks if the target thread is in a foreign call.

docs (readListDefault seems pretty useless)

define readListPrec too.

oops

Data and FunctorM instances for View[LR].