GitLab

Ganesh wanted to update records that involve existentials.  That 
seems reasonable to me, and this patch covers existentials, GADTs,
and data type families.

The restriction is that 
  The types of the updated fields may mention only the
  universally-quantified type variables of the data constructor

This doesn't allow everything in #2595 (it allows 'g' but not 'f' in
the ticket), but it gets a lot closer.

Lots of the new lines are comments!

The idea here is that with -XNamedFieldPuns and -XRecordWildCards we don't
want to report shadowing errors for
	let fld = <blah> in C { .. }
But to suppress such shadowing errors, the renamer needs to know that
'fld' *is* a record selector.  Hence the new NameSet in 
TcRnFypes.RecFieldEnv

In fixing #2713, this patch also eliminates two almost-unused
functions from RnEnv (lookupBndr and lookupBndr_maybe).  The
net lines of code is prety much unchanged, but more of them
are comments!

Getting the automatic deriving mechanism to work really smoothly
is surprisingly hard.  I keep finding myself in TcDeriv!

Anyway, this is a nice clean fix to Trac #2701.

The Windows builder is having problems running ps2pdf, so this works
aroudn the problem.

If the current thread blocks, we should yield the Capability
immediately, because the thread and hence possibly the current Task
are now owned by someone else.  This worked in the old scheduler, but
we moved where the yield happens in the new scheduler which broke it.

Change the way we look for work in the scheduler.  Previously,
checking to see whether there was anything to do was a
non-side-effecting operation, but this has changed now that we do
work-stealing.  This lead to a refactoring of the inner loop of the
scheduler.

Also, lots of cleanup in the new work-stealing code, but no functional
changes.

One new statistic is added to the +RTS -s output:

  SPARKS: 1430 (2 converted, 1427 pruned)

lets you know something about the use of `par` in the program.

   Spark stealing support for PARALLEL_HASKELL and THREADED_RTS versions of the RTS.
  
  Spark pools are per capability, separately allocated and held in the Capability 
  structure. The implementation uses Double-Ended Queues (deque) and cas-protected 
  access.
  
  The write end of the queue (position bottom) can only be used with
  mutual exclusion, i.e. by exactly one caller at a time.
  Multiple readers can steal()/findSpark() from the read end
  (position top), and are synchronised without a lock, based on a cas
  of the top position. One reader wins, the others return NULL for a
  failure.
  
  Work stealing is called when Capabilities find no other work (inside yieldCapability),
  and tries all capabilities 0..n-1 twice, unless a theft succeeds.
  
  Inside schedulePushWork, all considered cap.s (those which were idle and could 
  be grabbed) are woken up. Future versions should wake up capabilities immediately when 
  putting a new spark in the local pool, from newSpark().

Patch has been re-recorded due to conflicting bugfixes in the sparks.c, also fixing a 
(strange) conflict in the scheduler.

In boxy_match (which is a pure function used by preSubType) we can
encounter TyVars not just TcTyVars; this patch takes account of that.

- The current implementation of type families cannot properly deal
  with superclass equalities.  Instead of making a half-hearted attempt at
  supporting them, which mostly ends in cryptic error message, rejecting
  right away with an appropriate message.

  MERGE TO 6.10

The README file talks about getting and building the sources, which
doesn't make sense for the installer.

See Note [Freshen type variables] in WwLib.  We need to clone type
variables when building a worker/wrapper split, else we simply get
bogus code, admittedly in rather obscure situations.  I can't quite
remember what program showed this up, unfortunately, but there 
definitely *was* one!  (You get a Lint error.)

There is no point in floating out an expression wrapped in a coercion;
If we do we'll transform  
	lvl = e |> co [_$_]
to  	
	lvl' = e; lvl = lvl' |> co
and then inline lvl.  Better just to float out the payload (e).

TcDeriv deals with both standalone and ordinary 'deriving';
and with both data types and 'newtype deriving'.  The result
is really rather compilcated and ad hoc.  Ryan discovered
#2668; this patch fixes that bug, and makes the internal interfces
#more uniform.  Specifically, the business of knocking off 
type arguments from the instance type until it matches the kind of the
class, is now done by derivTyData, not mkNewTypeEqn, because the
latter is shared with standalone derriving, whree the trimmed
type application is what the user wrote.

We've always intended to allow you to use GADT syntax for
data families:
	data instance T [a] where
	  T1 :: a -> T [a]
and indeed to allow data instances to *be* GADTs
	data intsance T [a] where
	  T1 :: Int -> T [Int]
	  T2 :: a -> b -> T [(a,b)]

This patch fixes the renamer and type checker to allow this.
	

- As long as the first reduceContext in tcSimplifyRestricted potentially
  performs improvement, we need to zonk again before the second reduceContext.
  It would be better to prevent the improvement in the first place, but given
  the current situation zonking is definitely the right thing to do.

  MERGE TO 6.10

- Change in TcSimplify.reduceContext:

     We do *not* go around for new extra_eqs.  Morally, we should,
     but we can't without risking non-termination (see #2688).  By
     not going around, we miss some legal programs mixing FDs and
     TFs, but we never claimed to support such programs in the
     current implementation anyway.

  MERGE TO 6.10