GitLab

Very little parameter passing is needed without it, so there was no real
benefit to it.

This fixes part of trac #856

Otherwise "$(A) $(B)" will not be equal to "" even if A and B are empty.
Trac #856.

We were doing lots of cons'ing and tail'ing without forcing the tails,
so were building up lots of thunks.

Fixes trac #1893, based on a patch from Daniel Franke.

This optimisation actually make things a bit slower on average, as
measured by nofib. The example in #1136 in particular suffers from high
memory usage. Therefore we no longer do the optimisation.

1. We weren't squeezing two frames if one of them was a marked update
   frame.  This is easy to fix.

2. The heuristic to decide whether to squeeze was a little
   conservative.  It's worth copying 3 words to save an update frame.
 

- Makes this horrid function a bit better - and shorter!
- Also gets rid of another API function of TcTyFuns

- Another chapter in the never-ending TcSimplify.reduceContext saga: after
  context reduction of wanted dicts it is not sufficient to normalise them
  wrt to the wanted equalities.  We also need to take top-level equalities
  into account.  (In fact, we probably also have to normalise wrt to given
  equalities, but I have left that open for the moment - but added a TODO
  note.)
- This finally eliminates substEqInDictInsts from TcTyFuns interface and
  suggest some further possible clean up (which will be in a separate patch).

Thanks to Roman for the intricate example that uncovered this bug.

Modified version of Judah's patch

I updated the External Core AST to be somewhat closer to reality (where reality is defined by the HEAD), and got all the code to compile under GHC 6.8.1. (That means it works, right?)

Major changes:

- Added a Makefile.

- Core AST:
    - Represented package names and qualified module names.
    - Added type annotation on Case exps.
    - Changed Coerce to Cast.
    - Cleaned up representation of qualified/unqualified names.
    - Fixed up wired-in module names (no more "PrelGHC", etc.)

- Updated parser/interpreter/typechecker/prep for the new AST.

- Typechecker:
    - Used a Reader monad to pass around the global environment and top module name.
    - Added an entry point to check a single expression.

- Prep:
    - Got rid of typeofExp; it's now defined in terms of the typechecker.

This patch removes the ndpFlatten directory and the -fflatten static flag.
This code has never worked and has now been superceded by vectorisation.

When compiling without -O we were getting code like this

	f x = case GHC.Base.$f20 of
		  :DEq eq neq -> eq x x

But because of the -O the $f20 dictionary is not available, so exposing
the dictionary selector was useless.  Yet it makes the code bigger!
Better to get
	f x = GHC.Base.== GHC.Bsae.$f20 x x

This patch suppresses the implicit unfolding for dictionary selectors
when compiling without -O.  We could do the same for other implicit
Ids, but this will do for now.

There should be no effect when compiling with -O.  Programs should
be smaller without -O and may run a tiny bit slower.

The Inst.shortCutIntLit mechanism in the type checker was missing cases
where a floating-point literal was given without an explicit decimal point.

As a result, programs with lots of floating-point literals (without decimals)
ended up with massive Static Reference Tables.  This is not cool.  See
comments with Trac #783 for details.

This patch makes a significant improvement to SpecConstr, based on
Roman's experience with using it for stream fusion.  The main change is
this:

  * For local (not-top-level) declarations, seed the specialisation 
    loop from the calls in the body of the 'let'.

See Note [Local recursive groups] for discussion and example.  Top-level
declarations are treated just as before.

Other changes in this patch:

  * New flag -fspec-constr-count=N sets the maximum number of specialisations
    for any single function to N.  -fno-spec-constr-count removes the limit.

  * Refactoring in specLoop and friends; new algebraic data types 
    OneSpec and SpecInfo instead of the tuples that were there before

  * Be less keen to specialise on variables that are simply in scope.
    Example
      f p q = letrec g a y = ...g....  in g q p
    We probably do not want to specialise 'g' for calls with exactly
    the arguments 'q' and 'p', since we know nothing about them.

The occurrence analyer is now really rather subtle when dealing
with recursive groups; see Note [Loop breaking and RULES] especially.

This patch refactors this code a bit, notably 
  * Introduces a new data type Details instead of a tuple

  * More clearly breaks up a recursive group into its SCCs
	before processing it in a separate function occAnalRec

  * As a result, does better dead-code elimination, becuause it's
   	done per SCC rather than for the whole Rec


  

Instead of
   Warning: Definition but no type signature for `.+.'
            Inferred type: .+. :: forall a. a
we now say
    Warning: Definition but no type signature for `.+.'
             Inferred type: (.+.) :: forall a. a

Fixes trac #1971: unjustified warning about documentation

This roughly halves memory usage when compiling
    module Foo where

    foo :: Double -> Int
    foo x | x == 1 = 1
    ...
    foo x | x == 500 = 500
without optimisation.