feature, in types of local functions with free variables that are added as function arguments by lifting
add specifying type and attribute variables that occur in the types of these free variables/lifted arguments
so that the (partial) type of functions that use these variables and attributes can be specified
with syntax:

function_name :: E.^ type_and_attribute_variables : function_type

type_and_attributes_variables is a list of at least one of:

type_var *type_var .type_var (attribute_var:type_var) (attribute_var:)

these type and attribute variables are still polymorphic, but for recursive calls no new variables are created,
so polymorpic recursion is not supported for these variables

a local function type can still not be specified if:
an attribute inequality contains one attribute variable that occurs only in types of free variables/lifted arguments
(and the other attribute variable occurs only in the rest of the function type)
or a class constraint that contains both a type variable that occurs only in types of free variables/lifted arguments
and a type variable that occurs in the rest of the function type

refactor, make some local functions global, remove some function arguments that always have the same constant value

refactor, change type of field fun_type from Optional SymbolType to new algebraic type FunDefType (so a new constructor can be added later)

optimise cleanup in module typesupport, use cleanup only for top level types (= function types), add clean_up_expression_types for non top level types

bug fix in comparing type contexts of specified and derived types of local functions with specified type constraints and derived constraints using type variables in the types of lifted arguments

fix previous commit, add code to makefile to remove carriage returns from shell script add_dllexports.sh so it can be executed

in the strictness analyser, add code for caching previous results of ExtLtExp2 to prevent exponential time, not yet enabled

in the strictness analyser, add code for caching previous results of LtExp2 to prevent exponential time, not yet enabled

bug fix for macosx, in make.macosx64.sh set the stack size to 2M, make the heap size the same as for 64 bit linux (60M instead of 48M), compile module backendconvert with -fusion

optimisation, don't call _normalise for dynamic expressions of type type_var^, if there were no dynamic pattern matches before

optimisation, use _unify_tcs instead of _unify_ to match dynamic patterns of type type_var^, if there are no other dynamic pattern matches before and no dynamic pattern matches and expressions after this match

small optimisations in generated code for dynamic types, call _unify_ instead of _unify if only the boolean result is used, use _bind_global_type_pattern_var_n with int type_var_n instead of_bind_global_type_pattern_var with (TypeVar type_var_n)

refactor in module convertDynamics, function newVariable always creates the var_info_ptr with VI_Empty, add function case_unify that creates a case of a unify application expression, remove unused function fatal

optimisation, if a function contains type(s) (a e) and an Array a e constraint use type {e} instead in the backend, this changes the calling convention for strict arguments and results, no ARRAY node is passed in those cases

refactor. in module backendconvert remove functions beautifyAttributes, convertSymbolTypeArgs and remove_first_arg_type and some unused code

refactor, remove function backEndPreprocess, move constructors VI_SequenceNumber and VI_AliasSequenceNumber from module syntax to backendconvert, remove imports of module backendpreprocess

refactor, assign sequence numbers (VI_SequenceNumber and VI_AliasSequenceNumber) in declareVars in module backendconvert instead of sequence in module backendpreprocess, remove preprocess and sequence from module backendpreprocess

refactor, convertCasesOfFunctions created SK_GeneratedFunction's with FunDef Ptr's to a different heap, these FunDef Ptr's were not used, instead remove cs_fun_heap from ConvertState, use SK_LocalMacroFunction for case functions instead of SK_GeneratedFunction, store the FunDefs and indices in cs_new_functions instead of FunctionInfoPtr's

don't replace an explicit case by the only alternative that may match if the result is a strict let that is not a root expression

don't restrict case_expr of an explicit Case to Var expressions, this restriction has been removed by using mergeExplicitCasePatterns and variable aliases introduced by simplifications of cases in module trans will now be removed in module partition

always recompute components of functions after fusion pass (module trans), ignore -strip, remove function stripStrictLets

refactor, add a specialised version of collectVariables to module partition (from transform), that only removes aliases and computes the refcounts (to be combined with find_calls next)

refactor collectVariables for Let in module transform, don't combine and split strict and lazy binds, use unzip instead of map fst and map snd

refactor, add function mergeExplicitCasePatterns, use it to merge explicit case expressions in module transform, note that cases with a case_expr that is not a variable can also be merged now, so function share_case_expr in module checkFunctionBodies is probably not necessary anymore

refactor, replace type StringPos and function stringPosition by type StringPosition, add function for 'cannot unify demanded type with offered type' error

refactor, replace function uniquenessError, that was always called with a CP_Expression with a FreeVar, by function uniquenessErrorFreeVar

refactor, remove some unused functions and record, use =: instead of == to compare annotations and attributes in the parser

rename label _Nothing as _None in the generated code, and _!Nothing,_#Nothing and _|Nothing in the compiler to _!None,_#None and _|None