module t
/*2.0
from m import :: T(C1)
0.2*/
//1.3
from m import T, C1
//3.1

will be transformed into

module t
/***/
from m import :: T(C1)
/***/
/*1.3
from m import T, C1
3.1*/

before scanning. In this way we achieve that the upper source can be
compiled with the 2.0 compiler as well as with the 1.3 compiler

The comments _must_ begin the line (no leading whitespaces are allowed).

that are imported

to solve the following bug:

f
  # x = undef
  #! y = x
  | True
    = 2
  = y

After checking this will be like

f
  # x = undef
  | True
    = 2
  = x

To really solve this bug we have to invent something new, because aliases
like (#! y = x) are _not_ allowed. We could either introduce a dummy identity function:

f
  # x = undef
  #! y = dummy_id x
  | True
    = 2
  = y

or we could introduce constructs like

f
  # x = undef
  #! y
  | True
    = 2
  = y

follows: In a first phase bind type variables to their instantiation for all producers. In the
second phase apply the substitution. This didn't work for consumers that are fused with multiple
producers, e.g:
  cons :: (a->b) (b->c) a -> c
  prod1 :: Int -> Int
  prod2 :: d->e
During producer-wise binding a and b were first bound to Int and Int. _Then_ b and c were bound
to d and e (b was overwritten)

Solution:
Apply the one substitution for each producer

 #! (a, b) = f

was originally translated into

 #! _x = f
 #! a = _x.0
 #! b = _x.1

which is wrong. Now a an b are in a lazy context

did not recognise a dynamic.

funny constructors in algebraic typedefs

this into account)

   in "convertCasesOfFunctionsIntoPatterns" and "collectVariables")
 - new switch "SwitchUniquenessBug" in module checksupport
 - several bugfixes

fixed bug in arity check for local functions