allow integers and strings as consumer for generic functions (to optimize use of generic info).
use PR_CurriedFunction instead of PR_Curried for local macro functions that are good producers.
check the arity of the function to be generated already in determineProducer,
if too large, don't yield a producer which will be rejected later,
to allow optimization of producers in subsequent arguments.
optimize trivial function calls (with arguments) before optimizing arguments,
treat constant function as trivial function.
if a function call has two identical arguments,
generate a specialized function that shares these parameters.
specialize functions with zero arity constructor arguments,
if the function is a generic function, or the constructor is a generic constructor.

add type constraints in constructors and function arguments with universal quantifier (from iTask branch)

because the new functions in ti_new_functions must be in the right order.

										-

instead of only the FI_IsMacroFun bit,
this will be used in future versions, for example to recognize generic functions

replace function NewAttrVarId by NewAttrVar, improve caching of uniqueness attribute variable identifiers

before copying the producer, the type variables are modified
to use the type of the producer when updating the types in cases and lets,
otherwise a polymorphic type may be specialized, possibly causing a type error later

to local function n_args_before_producer_and_n_producer_args

add constructors PE_Matches and IsConstructor in module syntax

because the case expression is not identical to the consumer anymore after adding arguments,
don't fold in local function possiblyFoldOuterCase if aci_opt_unfolder is No

remove some unused local variables and functions,
replace field tfi_geni by tfi_n_args_before_producer and tfi_n_producer_args

to reduce memory usage of the compiler

adjust imports

(to have fewer differences with the haskell frontend branch)

because function pointers for generated functions are stored in the Component,
they can be found without searching the new functions list

No commit message

because it is always []

call of an expanded function with too many arguments

is used in a curried application of a case expression, to prevent
case's with applications that are be optimized.
Whether the producer is treated as a curried or normal producer is
determined during unfolding, PR_CurriedProducer is
used to mark producers for which this is allowed.

an application that can be fused,
a function is created of the case, without the application (producer),
and the new function and the application (producer) are fused later (if possible)

may be copied (without duplicating work),
this is intended to optimize generic bimaps

arguments or a basic value