#! x = y

will be transformed into

  #! x = _dummyForStrictAlias y

while checking. The new predefined symbol _dummyForStrictAlias has
the type of the identity function. This application will be removed
in the backend conversion phase. In this case x and y will simply get
the same sequence number (see module backendpreprocess). Then the
binding can be ignored.

also STE_Macro. This showed up after a list comprehenshion that matched on
STE_Imported was transformed into a function with that pattern

and the other producers

:: T :== Int

f = { T | f1 = blub }

"PA_BUG" for the same purpose. MW removes his macro _untertaenig_ in favour
of Sjaaks version

Peter's bug removed

function that had the same name as the macro:
//////////
module t5

import t6

Start = f f
/////////
definition module t6

f x :== f x
  where
	f x = x
/////////
caused an abort

that are overloaded

really redundant, but not those which are added automatically by the compiler
to the icl module

with our without layout rule, but not with both)

with synonym types properly.

the compiler would not be able to compile itself.

compiled with Clean 1.3 and Clean 2.0

postparse.icl: Propagation continues with dynamic expression
                      instead of halting

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