(changes are commented with "MW0")

  #! 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.

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

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

did not recognise a dynamic.

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

bugfix

    (new module: comparedefimp)
- implemented array patterns. Further work: arrays are in lazy context (should be strict),
    currently only one dimensional arrays
- optimised memory usage for explicit imports

completing Sjaak's changes in module trans caused by exchanging the transform and convertcases phases

 - dictionary arguments added properly
 - coercion of function types