Generics are added, but are disabled.

Tested with compiling Object IO and butstrapping.


git-svn-id: https://svn.cs.ru.nl/repos/clean-compiler/trunk@329 1f8540f1-abd5-4d5b-9d24-4c5ce8603e2d

25 files changed, 3157 insertions, 234 deletions

diff --git a/frontend/analtypes.dcl b/frontend/analtypes.dcl
index 5203a68..9fa9735 100644
--- a/frontend/analtypes.dcl
+++ b/frontend/analtypes.dcl
@@ -4,4 +4,3 @@ import checksupport, typesupport
 
 analTypeDefs :: !{#CommonDefs} !NumberSet !*TypeHeaps !*ErrorAdmin -> (!*TypeDefInfos, !*TypeHeaps, !*ErrorAdmin)
 
-instance <<< TypeKind
diff --git a/frontend/analtypes.icl b/frontend/analtypes.icl
index 2dd5715..ac1f79b 100644
--- a/frontend/analtypes.icl
+++ b/frontend/analtypes.icl
@@ -10,21 +10,6 @@ import syntax, checksupport, checktypes, check, typesupport, utilities, analunit
 	
 AS_NotChecked :== -1
 
-instance <<< TypeKind
-where
-	(<<<) file tk = file <<< toString (toKindInfo tk)
-
-instance toString KindInfo
-where
-	toString (KI_Var ptr) 		= "*" +++ toString (ptrToInt ptr)
-	toString (KI_Const) 		= "*"
-	toString (KI_Arrow kinds)	= kind_list_to_string kinds
-	where
-		kind_list_to_string [] = " ?????? "
-		kind_list_to_string [k] = "* -> *"
-		kind_list_to_string [k:ks] = "* -> " +++ kind_list_to_string ks
-
-
 kindError kind1 kind2 error
 	= checkError "conflicting kinds: " (toString kind1 +++ " and " +++ toString kind2) error
 
@@ -70,8 +55,8 @@ where
 		= KI_Var info_ptr
 	toKindInfo KindConst
 		= KI_Const
-	toKindInfo (KindArrow arity)
-		= KI_Arrow [ KI_Const \\ i <- [1 .. arity]]
+	toKindInfo (KindArrow ks)
+		= KI_Arrow [ toKindInfo k \\ k <- ks]
 //			---> ("toKindInfo", arity)
 
 
@@ -373,7 +358,8 @@ where
 			determine_kind (KI_Indirection kind) 
 				= determine_kind kind
 			determine_kind (KI_Arrow kinds)
-				= KindArrow (length kinds)
+				//AA: = KindArrow (length kinds)
+				= KindArrow [determine_kind k \\ k <- kinds]
 			determine_kind kind
 				= KindConst
 			   
diff --git a/frontend/check.dcl b/frontend/check.dcl
index c28d7c7..77fb153 100644
--- a/frontend/check.dcl
+++ b/frontend/check.dcl
@@ -14,3 +14,5 @@ determineTypeOfMemberInstance :: !SymbolType ![TypeVar] !InstanceType !Specials
 arrayFunOffsetToPD_IndexTable :: !w:{# MemberDef} !v:{# PredefinedSymbol} -> (!{# Index}, !x:{#MemberDef}, !v:{#PredefinedSymbol}) , [w<=x]
 
 makeElemTypeOfArrayFunctionStrict :: !SymbolType !Index !{# Index} -> SymbolType
+
+initializeContextVariables :: ![TypeContext] !*VarHeap ->  (![TypeContext], !*VarHeap)
diff --git a/frontend/check.icl b/frontend/check.icl
index f9b1f9d..f9789e7 100644
--- a/frontend/check.icl
+++ b/frontend/check.icl
@@ -13,7 +13,47 @@ isMainModule :: ModuleKind -> Bool
 isMainModule MK_Main	= True
 isMainModule _ 			= False
 
+// AA..
+checkGenerics :: !Index !Index !*{#GenericDef} !*{#ClassDef} !*{#CheckedTypeDef} !*{#DclModule} !*TypeHeaps !*CheckState
+	-> (!*{#GenericDef}, !*{#ClassDef}, !*{#CheckedTypeDef}, !*{#DclModule}, !*TypeHeaps, !*CheckState)
+checkGenerics 
+		gen_index module_index generic_defs class_defs type_defs modules 
+		type_heaps=:{th_vars} 
+		cs=:{cs_symbol_table, cs_error}
+	| gen_index == size generic_defs
+		= (generic_defs, class_defs, type_defs, modules, type_heaps, cs)
+	// otherwise
+		# (gen_def=:{gen_name, gen_args, gen_type,gen_pos}, generic_defs) = generic_defs![gen_index]
+		# position = newPosition gen_name gen_pos
+		# cs_error = setErrorAdmin position cs_error
+
+		# (gen_args, cs_symbol_table, th_vars, cs_error)
+		  	= add_vars_to_symbol_table gen_args cs_symbol_table th_vars cs_error
+		
+		# cs = {cs & cs_error = cs_error, cs_symbol_table = cs_symbol_table }
+		# type_heaps = {type_heaps & th_vars = th_vars}
+		# (gen_type, specials, type_defs, class_defs, modules, type_heaps, cs) =
+			checkSymbolType module_index gen_type SP_None type_defs class_defs modules type_heaps cs
 
+		# cs = {cs & cs_symbol_table = removeVariablesFromSymbolTable cGlobalScope gen_args cs.cs_symbol_table}
+
+		# generic_defs = {generic_defs & [gen_index] = {gen_def & gen_type = gen_type, gen_args = gen_args}}		
+		= checkGenerics (inc gen_index) module_index generic_defs class_defs type_defs modules type_heaps cs
+where	
+	add_vars_to_symbol_table [] symbol_table th_vars error = ([], symbol_table, th_vars, error)	
+	add_vars_to_symbol_table [var=:{tv_name={id_name,id_info}} : vars] symbol_table th_vars error
+	  	# (entry, symbol_table) = readPtr id_info symbol_table
+		| entry.ste_kind == STE_Empty || entry.ste_def_level < cGlobalScope
+			# (new_var_ptr, th_vars) = newPtr TVI_Empty th_vars
+			# symbol_table = NewEntry symbol_table id_info (STE_TypeVariable new_var_ptr) NoIndex cGlobalScope entry
+			# var = { var & tv_info_ptr = new_var_ptr}
+			# (vars, symbol_table, th_vars, error) = add_vars_to_symbol_table vars  symbol_table th_vars error
+			= ([var:vars], symbol_table, th_vars, error)
+		// otherwise
+			= add_vars_to_symbol_table vars symbol_table th_vars (checkError id_name "(variable) already defined" error)
+		
+				  
+// ..AA
 
 checkTypeClasses :: !Index !Index !*{#ClassDef} !*{#MemberDef} !*{#CheckedTypeDef} !*{#DclModule} !*TypeHeaps !*CheckState
 	-> (!*{#ClassDef}, !*{#MemberDef}, !*{#CheckedTypeDef}, !*{#DclModule}, !*TypeHeaps, !*CheckState)
@@ -169,9 +209,124 @@ where
 	{	is_type_defs		:: !.{# CheckedTypeDef}
 	,	is_class_defs		:: !.{# ClassDef}
 	,	is_member_defs		:: !.{# MemberDef}
+	, 	is_generic_defs		:: !.{# GenericDef} // AA
 	,	is_modules			:: !.{# DclModule}
 	}
 
+// AA..
+checkInstanceDefs :: !Index !*{#ClassInstance} !u:{#CheckedTypeDef} !u:{#ClassDef} !u:{#MemberDef} /*AA*/!u:{#GenericDef} !u:{#DclModule} !*TypeHeaps !*CheckState
+	-> (!.{#ClassInstance},!u:{#CheckedTypeDef},!u:{#ClassDef},!u:{#MemberDef}, /*AA*/!u:{#GenericDef}, !u:{#DclModule},!.TypeHeaps,!.CheckState)
+checkInstanceDefs mod_index instance_defs type_defs class_defs member_defs generic_defs modules type_heaps cs
+	# is = { is_type_defs = type_defs, is_class_defs = class_defs, is_member_defs = member_defs, /*AA*/is_generic_defs = generic_defs, is_modules = modules }
+	  (instance_defs, is, type_heaps, cs) = check_instance_defs 0 mod_index instance_defs is type_heaps cs
+	= (instance_defs, is.is_type_defs, is.is_class_defs, is.is_member_defs, /*AA*/is.is_generic_defs, is.is_modules, type_heaps, cs)
+where
+	check_instance_defs :: !Index !Index !*{# ClassInstance} !u:InstanceSymbols !*TypeHeaps !*CheckState
+		-> (!*{# ClassInstance},!u:InstanceSymbols,!*TypeHeaps,!*CheckState)
+	check_instance_defs inst_index mod_index instance_defs is type_heaps cs
+		| inst_index < size instance_defs
+			# (instance_def, instance_defs) = instance_defs![inst_index]
+			  (instance_def, is, type_heaps, cs) = check_instance mod_index instance_def is type_heaps cs
+			= check_instance_defs (inc inst_index) mod_index { instance_defs & [inst_index] = instance_def } is type_heaps cs
+			= (instance_defs, is, type_heaps, cs)
+			
+	check_instance :: !Index !ClassInstance !u:InstanceSymbols !*TypeHeaps !*CheckState -> (!ClassInstance, !u:InstanceSymbols, !*TypeHeaps, !*CheckState)
+	check_instance module_index
+			ins=:{ins_members,ins_class={glob_object = class_name =: {ds_ident = {id_name,id_info},ds_arity}},ins_type,ins_specials,ins_pos,ins_ident}
+			is=:{is_class_defs,is_generic_defs, is_modules} type_heaps cs=:{cs_symbol_table}
+		#  	(entry, cs_symbol_table) = readPtr id_info cs_symbol_table
+		# 	cs = pushErrorAdmin (newPosition ins_ident ins_pos) { cs & cs_symbol_table = cs_symbol_table }
+		#   (ins, is, type_heaps, cs) = case entry.ste_kind of
+				STE_Class				
+					# (class_def, is) = class_by_index entry.ste_index is
+					-> check_class_instance	class_def module_index entry.ste_index module_index ins is type_heaps cs 
+				STE_Imported STE_Class dcl_index	
+					# (class_def, is) = class_by_module_index dcl_index entry.ste_index is
+					-> check_class_instance class_def module_index entry.ste_index dcl_index ins is type_heaps cs
+				STE_Generic 
+					# (generic_def, is) = generic_by_index entry.ste_index is
+					-> check_generic_instance generic_def module_index entry.ste_index module_index ins is type_heaps cs
+				STE_Imported STE_Generic dcl_index	
+					# (gen_def, is) = generic_by_module_index dcl_index entry.ste_index is
+					-> check_generic_instance gen_def module_index entry.ste_index dcl_index ins is type_heaps cs
+				ste -> (ins, is, type_heaps, { cs & cs_error = checkError id_name "class or generic undefined" cs.cs_error })
+		= (ins, is, type_heaps, popErrorAdmin cs)
+
+	where
+			class_by_index class_index is=:{is_class_defs}
+				#	(class_def, is_class_defs) = is_class_defs![class_index]
+ 				= (class_def, {is & is_class_defs = is_class_defs})
+			class_by_module_index dcl_index class_index is=:{is_modules}
+ 				# 	(dcl_mod, is_modules) = is_modules![dcl_index]
+					class_def = dcl_mod.dcl_common.com_class_defs.[class_index]
+				= (class_def, {is & is_modules = is_modules })
+			generic_by_index gen_index is=:{is_generic_defs}
+				# 	(gen_def, is_generic_defs) = is_generic_defs![gen_index]
+				= (gen_def, {is & is_generic_defs = is_generic_defs})
+			generic_by_module_index dcl_index gen_index is=:{is_modules}	
+ 				# 	(dcl_mod, is_modules) = is_modules![dcl_index]
+					gen_def = dcl_mod.dcl_common.com_generic_defs.[gen_index]
+				= (gen_def, {is & is_modules = is_modules })
+				
+	check_class_instance :: ClassDef !Index !Index !Index !ClassInstance !u:InstanceSymbols !*TypeHeaps !*CheckState 
+		-> (!ClassInstance, !u:InstanceSymbols, !*TypeHeaps, !*CheckState)
+	check_class_instance class_def module_index class_index class_mod_index
+			ins=:{ins_members,ins_class={glob_object = class_name =: {ds_ident = {id_name,id_info},ds_arity}},ins_type,ins_specials,ins_pos,ins_ident,ins_generate}
+			is=:{is_class_defs,is_modules} type_heaps cs=:{cs_symbol_table}	
+		| ins_generate
+			= ( ins
+			  , is
+			  , type_heaps
+			  , { cs & cs_error = checkError id_name "cannot generate class instance" cs.cs_error }
+			  )
+		| class_def.class_arity == ds_arity
+			# ins_class = { glob_object = { class_name & ds_index = class_index }, glob_module = class_mod_index}
+			  (ins_type, ins_specials, is_type_defs, is_class_defs, is_modules, type_heaps, cs)
+			  		= checkInstanceType module_index ins_class ins_type ins_specials
+							is.is_type_defs is.is_class_defs is.is_modules type_heaps cs
+			  is = { is & is_type_defs = is_type_defs, is_class_defs = is_class_defs, is_modules = is_modules }
+			= ({ins & ins_class = ins_class, ins_type = ins_type, ins_specials = ins_specials}, is, type_heaps, cs)
+		// otherwise
+			= ( ins
+			  , is
+			  , type_heaps
+			  , { cs & cs_error = checkError id_name ("wrong arity: expected "+++toString class_def.class_arity+++" found "+++toString ds_arity) cs.cs_error }
+			  )
+	check_generic_instance :: GenericDef !Index !Index !Index !ClassInstance !u:InstanceSymbols !*TypeHeaps !*CheckState -> (!ClassInstance, !u:InstanceSymbols, !*TypeHeaps, !*CheckState)
+	check_generic_instance 
+			class_def module_index generic_index generic_module_index
+			ins=:{
+				ins_members,
+				ins_class={glob_object = class_name =: {ds_ident = {id_name,id_info},ds_arity, ds_index} },
+				ins_type,
+				ins_specials,
+				ins_pos,
+				ins_ident, 
+				ins_is_generic}
+			is=:{is_class_defs,is_modules} 
+			type_heaps 
+			cs=:{cs_symbol_table, cs_error}
+		# class_name = {class_name & ds_index = generic_index}	
+		# ins_class = { glob_object = class_name, glob_module = generic_module_index}
+		| ds_arity == 1
+			# (ins_type, ins_specials, is_type_defs, is_class_defs, is_modules, type_heaps, cs)
+			  = checkInstanceType module_index ins_class ins_type ins_specials
+							is.is_type_defs is.is_class_defs is.is_modules type_heaps cs
+			# is = { is & is_type_defs = is_type_defs, is_class_defs = is_class_defs, is_modules = is_modules }		 
+			# ins = { ins & 
+				ins_is_generic = True,
+				ins_generic = {glob_module = module_index, glob_object = generic_index}, 
+				ins_class = ins_class, 
+				ins_type = ins_type, 
+				ins_specials = ins_specials 
+				}  
+			= (ins, is, type_heaps, cs)
+		// otherwise
+			# cs_error = checkError id_name "arity of generic instance must be 1" cs_error 
+			# cs = {cs & cs_error = cs_error}
+			= (ins, is, type_heaps, cs)
+						 
+/*
 checkInstanceDefs :: !Index !*{#ClassInstance} !u:{#CheckedTypeDef} !u:{#ClassDef} !u:{#MemberDef} !u:{#DclModule} !*TypeHeaps !*CheckState
 	-> (!.{#ClassInstance},!u:{#CheckedTypeDef},!u:{#ClassDef},!u:{#MemberDef},!u:{#DclModule},!.TypeHeaps,!.CheckState)
 checkInstanceDefs mod_index instance_defs type_defs class_defs member_defs modules type_heaps cs
@@ -221,32 +376,70 @@ where
 		= (ste_index, dcl_index, class_def, class_defs, modules)
 	get_class_def _ mod_index class_defs modules
 		= (NotFound, -1/*cIclModIndex*/, abort "no class definition", class_defs, modules)
-	
+*/
+
 checkInstances :: !Index !*CommonDefs !u:{# DclModule} !*VarHeap !*TypeHeaps !*CheckState
 	-> (![(Index,SymbolType)], !*CommonDefs, !u:{# DclModule}, !*VarHeap , !*TypeHeaps, !*CheckState)
-checkInstances mod_index icl_common=:{com_instance_defs,com_class_defs,com_member_defs} modules var_heap type_heaps cs=:{cs_error}
+checkInstances mod_index icl_common=:{com_instance_defs,com_class_defs,com_member_defs,/*AA*/com_generic_defs} modules var_heap type_heaps cs=:{cs_error}
 	| cs_error.ea_ok
-		# (instance_types, com_instance_defs, com_class_defs, com_member_defs, modules, var_heap, type_heaps, cs)
-				= check_instances 0 mod_index [] com_instance_defs com_class_defs com_member_defs modules var_heap type_heaps cs
-		= (instance_types, { icl_common & com_instance_defs = com_instance_defs,com_class_defs = com_class_defs,com_member_defs = com_member_defs },
+		# (instance_types, com_instance_defs, com_class_defs, com_member_defs, com_generic_defs, modules, var_heap, type_heaps, cs)
+				= check_instances 0 mod_index [] com_instance_defs com_class_defs com_member_defs /*AA*/com_generic_defs modules var_heap type_heaps cs
+		= (instance_types, { icl_common & com_instance_defs = com_instance_defs,com_class_defs = com_class_defs,com_member_defs = com_member_defs, /*AA*/com_generic_defs = com_generic_defs },
 			 	modules, var_heap, type_heaps, cs)
 		= ([], icl_common, modules, var_heap, type_heaps, cs)
 where
-	check_instances :: !Index !Index ![(Index,SymbolType)] !x:{# ClassInstance} !w:{# ClassDef} !v:{# MemberDef} !u:{# DclModule}
+	check_instances :: !Index !Index ![(Index,SymbolType)] !x:{# ClassInstance} !w:{# ClassDef} !v:{# MemberDef} /*AA*/!w:{# GenericDef} !u:{# DclModule}
 		!*VarHeap !*TypeHeaps !*CheckState
-			-> (![(Index,SymbolType)], !x:{# ClassInstance}, !w:{# ClassDef}, !v:{# MemberDef}, !u:{# DclModule}, !*VarHeap, !*TypeHeaps, !*CheckState)
-	check_instances inst_index mod_index instance_types instance_defs class_defs member_defs modules var_heap type_heaps cs
+			-> (![(Index,SymbolType)], !x:{# ClassInstance}, !w:{# ClassDef}, !v:{# MemberDef}, /*AA*/!w:{# GenericDef}, !u:{# DclModule}, !*VarHeap, !*TypeHeaps, !*CheckState)
+	check_instances inst_index mod_index instance_types instance_defs class_defs member_defs generic_defs modules var_heap type_heaps cs
+/*
 		| inst_index < size instance_defs
-			# ({ins_class,ins_members,ins_type}, instance_defs) = instance_defs![inst_index]
+			# ({ins_class,ins_members,ins_type, /*AA*/ins_generic}, instance_defs) = instance_defs![inst_index]
 			# ({class_members,class_name}, class_defs, modules) = getClassDef ins_class mod_index class_defs modules
 			  class_size = size class_members
 			| class_size == size ins_members
 				# (instance_types, member_defs, modules, var_heap, type_heaps, cs) = check_member_instances mod_index ins_class.glob_module
 			  	         0 class_size ins_members class_members ins_type instance_types member_defs modules var_heap type_heaps cs
-				= check_instances (inc inst_index) mod_index instance_types instance_defs class_defs member_defs modules var_heap type_heaps cs
-				= check_instances (inc inst_index) mod_index instance_types instance_defs class_defs member_defs modules var_heap type_heaps
+				= check_instances (inc inst_index) mod_index instance_types instance_defs class_defs member_defs /*AA*/generic_defs modules var_heap type_heaps cs
+				= check_instances (inc inst_index) mod_index instance_types instance_defs class_defs member_defs /*AA*/generic_defs modules var_heap type_heaps
 						{ cs & cs_error = checkError class_name "different number of members specified" cs.cs_error }
-			= (instance_types, instance_defs, class_defs, member_defs, modules, var_heap, type_heaps, cs)
+			= (instance_types, instance_defs, class_defs, member_defs, /*AA*/generic_defs, modules, var_heap, type_heaps, cs)
+*/
+// AA..
+		| inst_index < size instance_defs
+			# (instance_def=:{ins_is_generic}, instance_defs) = instance_defs![inst_index]
+			# (instance_types, class_defs, member_defs, generic_defs, modules, var_heap, type_heaps, cs) =
+				(if ins_is_generic check_generic_instance check_class_instance)  
+					instance_def mod_index instance_types class_defs member_defs generic_defs modules var_heap type_heaps cs				 
+			= check_instances (inc inst_index) mod_index instance_types instance_defs class_defs member_defs generic_defs modules var_heap type_heaps cs 
+		// otherwise
+			= (instance_types, instance_defs, class_defs, member_defs, generic_defs, modules, var_heap, type_heaps, cs)
+													
+	check_class_instance {ins_class,ins_members,ins_type} mod_index instance_types class_defs member_defs generic_defs modules var_heap type_heaps cs
+			# ({class_members,class_name}, class_defs, modules) = getClassDef ins_class mod_index class_defs modules
+			  class_size = size class_members
+			| class_size == size ins_members
+				# (instance_types, member_defs, modules, var_heap, type_heaps, cs) = check_member_instances mod_index ins_class.glob_module
+			  	         0 class_size ins_members class_members ins_type instance_types member_defs modules var_heap type_heaps cs
+				= (instance_types, class_defs, member_defs, generic_defs, modules, var_heap, type_heaps, cs)
+			// otherwise
+				# cs = { cs & cs_error = checkError class_name "different number of members specified" cs.cs_error }
+				= (instance_types, class_defs, member_defs, generic_defs, modules, var_heap, type_heaps, cs)
+	
+	check_generic_instance {ins_class, ins_members, ins_generate} mod_index instance_types class_defs member_defs generic_defs modules var_heap type_heaps cs
+			# ({gen_name, gen_member_name}, generic_defs, modules) = getGenericDef ins_class mod_index generic_defs modules		
+			| ins_generate 
+				= (instance_types, class_defs, member_defs, generic_defs, modules, var_heap, type_heaps, cs)				
+			| size ins_members <> 1 				
+				# cs = { cs & cs_error = checkError gen_name "generic instance must have one memeber" cs.cs_error }
+				= (instance_types, class_defs, member_defs, generic_defs, modules, var_heap, type_heaps, cs)
+			# member_name = ins_members.[0].ds_ident
+			| member_name <> gen_member_name
+				# cs = { cs & cs_error = checkError member_name "wrong member name" cs.cs_error }
+				= (instance_types, class_defs, member_defs, generic_defs, modules, var_heap, type_heaps, cs)				
+			// otherwise
+				= (instance_types, class_defs, member_defs, generic_defs, modules, var_heap, type_heaps, cs)
+// ..AA
 
 	check_member_instances :: !Index !Index !Int !Int !{#DefinedSymbol} !{#DefinedSymbol} !InstanceType ![(Index,SymbolType)]
 		!v:{# MemberDef} !u:{# DclModule} !*VarHeap !*TypeHeaps !*CheckState
@@ -272,6 +465,7 @@ where
 				= check_member_instances module_index member_mod_index (inc mem_offset) class_size ins_members class_members ins_type
 						[ (ins_member.ds_index, { instance_type & st_context = st_context }) : instance_types ] member_defs modules var_heap type_heaps cs
 
+
 getClassDef :: !(Global DefinedSymbol) !Int !u:{#ClassDef} !v:{#DclModule} -> (!ClassDef,!u:{#ClassDef},!v:{#DclModule})
 getClassDef {glob_module, glob_object={ds_ident, ds_index}} mod_index class_defs modules
 	| glob_module == mod_index
@@ -288,6 +482,16 @@ getMemberDef mem_mod mem_index mod_index member_defs modules
 		# (dcl_mod,modules) = modules![mem_mod]
 		= (dcl_mod.dcl_common.com_member_defs.[mem_index], member_defs, modules)
 
+// AA..
+getGenericDef :: !(Global DefinedSymbol) !Int !u:{#GenericDef} !v:{#DclModule} -> (!GenericDef,!u:{#GenericDef},!v:{#DclModule})
+getGenericDef {glob_module, glob_object={ds_ident, ds_index}} mod_index generic_defs modules
+	| glob_module == mod_index
+		# (generic_def, generic_defs) = generic_defs![ds_index]
+		= (generic_def, generic_defs, modules)
+		# (dcl_mod, modules) = modules![glob_module]
+		= (dcl_mod.dcl_common.com_generic_defs.[ds_index], generic_defs, modules)
+// ..AA
+
 instantiateTypes :: ![TypeVar] ![AttributeVar] !types ![TypeContext] ![AttrInequality] !SpecialSubstitution ![SpecialSubstitution] !*TypeHeaps
 	-> (![TypeVar], ![AttributeVar], !types , ![TypeContext], ![AttrInequality], ![SpecialSubstitution], !*TypeHeaps) | substitute types
 instantiateTypes old_type_vars old_attr_vars types type_contexts attr_env {ss_environ, ss_vars, ss_attrs, ss_context} special_subst_list type_heaps=:{th_vars, th_attrs}
@@ -563,13 +767,14 @@ instance < FunDef
 where
 	(<) fd1 fd2 = fd1.fun_symb.id_name < fd2.fun_symb.id_name
 
-createCommonDefinitions {def_types,def_constructors,def_selectors,def_macros,def_classes,def_members,def_instances}
+createCommonDefinitions {def_types,def_constructors,def_selectors,def_macros,def_classes,def_members,def_instances, def_generics}
 	=	{	com_type_defs		= { type \\ type <- def_types }
 		,	com_cons_defs		= { cons \\ cons <- def_constructors }
 		,	com_selector_defs	= { sel \\ sel <- def_selectors }
 		,	com_class_defs		= { class_def \\ class_def <- def_classes }
 		,	com_member_defs		= { member \\ member <- def_members }
 		,	com_instance_defs	= { next_instance \\ next_instance <- def_instances }
+		,	com_generic_defs	= { gen \\ gen <- def_generics }		
 		}
 
 array_plus_list a [] = a
@@ -586,9 +791,13 @@ checkCommonDefinitions is_dcl module_index common modules type_heaps var_heap cs
 	  		= checkTypeClasses 0 module_index common.com_class_defs common.com_member_defs com_type_defs modules type_heaps cs
 	  (com_member_defs, com_type_defs, com_class_defs, modules, type_heaps, var_heap, cs)
 	  		= checkMemberTypes module_index com_member_defs com_type_defs com_class_defs modules type_heaps var_heap cs
-	  (com_instance_defs, com_type_defs, com_class_defs, com_member_defs, modules, type_heaps, cs)
-	  		= checkInstanceDefs module_index common.com_instance_defs com_type_defs com_class_defs com_member_defs modules type_heaps cs
-
+// AA..
+	  (com_generic_defs, com_class_defs, com_type_defs, modules, type_heaps, cs)
+			= checkGenerics 0 module_index common.com_generic_defs com_class_defs com_type_defs modules type_heaps cs
+// ..AA
+	  (com_instance_defs, com_type_defs, com_class_defs, com_member_defs, /*AA*/com_generic_defs, modules, type_heaps, cs)
+	  		= checkInstanceDefs module_index common.com_instance_defs com_type_defs com_class_defs com_member_defs /*AA*/com_generic_defs modules type_heaps cs
+	
 	  (size_com_type_defs,com_type_defs) = usize com_type_defs
 	  (size_com_selector_defs,com_selector_defs) = usize com_selector_defs
 	  (size_com_cons_defs,com_cons_defs) = usize com_cons_defs
@@ -602,10 +811,10 @@ checkCommonDefinitions is_dcl module_index common modules type_heaps var_heap cs
 	  com_cons_defs = array_plus_list com_cons_defs new_cons_defs
 
 	= ({common & com_type_defs = com_type_defs, com_cons_defs = com_cons_defs, com_selector_defs = com_selector_defs, com_class_defs = com_class_defs,
-			com_member_defs = com_member_defs,  com_instance_defs = com_instance_defs }, modules, { type_heaps & th_vars = th_vars }, var_heap, cs)
+			com_member_defs = com_member_defs,  com_instance_defs = com_instance_defs, /* AA */ com_generic_defs = com_generic_defs }, modules, { type_heaps & th_vars = th_vars }, var_heap, cs)
 
 collectCommonfinitions :: !(CollectedDefinitions ClassInstance a) -> (!*{# Int}, ![Declaration])
-collectCommonfinitions {def_types,def_constructors,def_selectors,def_macros,def_classes,def_members,def_instances} 
+collectCommonfinitions {def_types,def_constructors,def_selectors,def_macros,def_classes,def_members,def_instances, def_generics} 
 	// MW: the order in which the declarations appear in the returned list is essential (explicit imports)
 	# sizes = createArray cConversionTableSize 0
 	  (size, defs) = foldSt cons_def_to_dcl def_constructors (0, [])
@@ -620,6 +829,10 @@ collectCommonfinitions {def_types,def_constructors,def_selectors,def_macros,def_
 	  sizes = { sizes & [cClassDefs] = size }
 	  (size, defs) = foldSt instance_def_to_dcl def_instances (0, defs)
 	  sizes = { sizes & [cInstanceDefs] = size }
+// AA..
+	  (size, defs) = foldSt generic_def_to_dcl def_generics (0, defs)
+	  sizes = { sizes & [cGenericDefs] = size }
+// ..AA
 	= (sizes, defs)
 where
 	type_def_to_dcl {td_name, td_pos} (dcl_index, decls)
@@ -635,6 +848,13 @@ where
 	instance_def_to_dcl {ins_class, ins_ident, ins_pos} (dcl_index, decls)
 		= (inc dcl_index, [{ dcl_ident = ins_ident, dcl_pos = ins_pos, dcl_kind = STE_Instance ins_class.glob_object.ds_ident, dcl_index = dcl_index } : decls]) 
 
+// AA..
+	generic_def_to_dcl {gen_name, gen_member_name, gen_type, gen_pos} (dcl_index, decls)
+		# generic_decl = { dcl_ident = gen_name, dcl_pos = gen_pos, dcl_kind = STE_Generic, dcl_index = dcl_index }
+		# member_decl = { dcl_ident = gen_member_name, dcl_pos = gen_pos, dcl_kind = STE_Generic, dcl_index = dcl_index }
+		= (inc dcl_index, [generic_decl, member_decl : decls]) 
+// ..AA
+
 collectMacros {ir_from,ir_to} macro_defs sizes_defs
 	= collectGlobalFunctions cMacroDefs ir_from ir_to macro_defs sizes_defs
 
@@ -720,17 +940,25 @@ renumber_icl_definitions_as_dcl_definitions _ icl_decl_symbols modules cdefs icl
 						# class_def = {class_def & class_members=class_members}
 						# cdefs = {cdefs & com_class_defs.[dcl_index] =class_def}
 						= ({icl_decl_symbol & dcl_index=icl_to_dcl_index_table.[cClassDefs,dcl_index]},cdefs)
+// AA..
+					renumber_icl_decl_symbol icl_decl_symbol=:{dcl_kind = STE_Generic, dcl_index} cdefs
+						= ({icl_decl_symbol & dcl_index=icl_to_dcl_index_table.[cGenericDefs,dcl_index]},cdefs)
+							---> ("renumber_icl_decl_symbol: " +++ icl_decl_symbol.dcl_ident.id_name)
+// ..AA
 					renumber_icl_decl_symbol icl_decl_symbol cdefs
 						= (icl_decl_symbol,cdefs)
 	# cdefs=reorder_common_definitions cdefs
 		with
-			reorder_common_definitions {com_type_defs,com_cons_defs,com_selector_defs,com_class_defs,com_member_defs,com_instance_defs}
+			reorder_common_definitions {com_type_defs,com_cons_defs,com_selector_defs,com_class_defs,com_member_defs,com_instance_defs, /* AA */ com_generic_defs}
 				# com_type_defs=reorder_array com_type_defs icl_to_dcl_index_table.[cTypeDefs]
 				# com_cons_defs=reorder_array com_cons_defs icl_to_dcl_index_table.[cConstructorDefs]
 				# com_selector_defs=reorder_array com_selector_defs icl_to_dcl_index_table.[cSelectorDefs]
 				# com_class_defs=reorder_array com_class_defs icl_to_dcl_index_table.[cClassDefs]
 				# com_member_defs=reorder_array com_member_defs icl_to_dcl_index_table.[cMemberDefs]
-				= {com_type_defs=com_type_defs,com_cons_defs=com_cons_defs,com_selector_defs=com_selector_defs,com_class_defs=com_class_defs,com_member_defs=com_member_defs,com_instance_defs=com_instance_defs}
+				# com_generic_defs=reorder_array com_generic_defs icl_to_dcl_index_table.[cGenericDefs] // AA				
+				= {	com_type_defs=com_type_defs,com_cons_defs=com_cons_defs,com_selector_defs=com_selector_defs,
+					com_class_defs=com_class_defs,com_member_defs=com_member_defs,com_instance_defs=com_instance_defs, 
+					com_generic_defs = com_generic_defs/*AA*/}
 					where
 						reorder_array array index_array
 							# new_array={e\\e<-:array}
@@ -753,8 +981,8 @@ combineDclAndIclModule _ modules icl_decl_symbols icl_definitions icl_sizes cs
 	  (moved_dcl_defs, conversion_table, icl_sizes, icl_decl_symbols, cs)
 			= foldSt (add_to_conversion_table dcl_macros.ir_from dcl_common) dcls_local ([], { createArray size NoIndex \\ size <-: dcl_sizes }, icl_sizes, icl_decl_symbols, cs)
             
-	  (new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, cs)
-			= foldSt (add_dcl_definition dcl_common) moved_dcl_defs ([], [], [], [], [], cs)
+	  (new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, /*AA*/new_generic_defs, cs)
+			= foldSt (add_dcl_definition dcl_common) moved_dcl_defs ([], [], [], [], [], /*AA*/[],cs)
 	  cs_symbol_table
 	  		= removeDeclarationsFromSymbolTable icl_decl_symbols cGlobalScope cs.cs_symbol_table
 
@@ -766,6 +994,7 @@ combineDclAndIclModule _ modules icl_decl_symbols icl_definitions icl_sizes cs
 				, def_selectors		= my_append icl_definitions.def_selectors new_selector_defs
 				, def_classes		= my_append icl_definitions.def_classes new_class_defs
 				, def_members		= my_append icl_definitions.def_members new_member_defs
+				, def_generics		= my_append icl_definitions.def_generics new_generic_defs // AA
 		  }
 		,  icl_sizes
 		, { cs & cs_symbol_table = cs_symbol_table }
@@ -799,7 +1028,7 @@ where
 
 	can_be_only_in_dcl def_kind
 		=	def_kind == cTypeDefs	|| def_kind == cConstructorDefs || def_kind == cSelectorDefs
-		||	def_kind == cClassDefs	|| def_kind == cMemberDefs
+		||	def_kind == cClassDefs	|| def_kind == cMemberDefs /*AA*/ || def_kind == cGenericDefs 
 
  	is_abstract_type com_type_defs dcl_index
  		= case com_type_defs.[dcl_index].td_rhs of (AbstractType _) -> True ; _ -> False
@@ -819,10 +1048,10 @@ where
 			)
 	
 	add_dcl_definition {com_type_defs} dcl=:{dcl_kind = STE_Type, dcl_index}
-			(new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, cs)
+			(new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, new_generic_defs, cs)
 		# type_def = com_type_defs.[dcl_index]
 		  (new_type_defs, cs) = add_type_def type_def new_type_defs cs
-		= (new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, cs)
+		= (new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, new_generic_defs, cs)
 	where
 		add_type_def td=:{td_pos, td_rhs = AlgType conses} new_type_defs cs
 			# (conses, cs) = mapSt (redirect_defined_symbol STE_Constructor td_pos) conses cs
@@ -855,27 +1084,34 @@ where
 			is_field _				= False
 
 	add_dcl_definition {com_cons_defs} dcl=:{dcl_kind = STE_Constructor, dcl_index} 
-			(new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, cs)
-		= (new_type_defs, new_class_defs, [ com_cons_defs.[dcl_index] : new_cons_defs ], new_selector_defs, new_member_defs, cs)
+			(new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, new_generic_defs, cs)
+		= (new_type_defs, new_class_defs, [ com_cons_defs.[dcl_index] : new_cons_defs ], new_selector_defs, new_member_defs, new_generic_defs, cs)
 	add_dcl_definition {com_selector_defs} dcl=:{dcl_kind = STE_Field _, dcl_index} 
-			(new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, cs)
-		= (new_type_defs, new_class_defs, new_cons_defs, [ com_selector_defs.[dcl_index] : new_selector_defs ], new_member_defs, cs)
+			(new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, new_generic_defs, cs)
+		= (new_type_defs, new_class_defs, new_cons_defs, [ com_selector_defs.[dcl_index] : new_selector_defs ], new_member_defs, new_generic_defs, cs)
 	add_dcl_definition {com_class_defs} dcl=:{dcl_kind = STE_Class, dcl_index, dcl_pos} 
-			(new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, cs)
+			(new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, new_generic_defs, cs)
 		# class_def = com_class_defs.[dcl_index]
 		  (new_class_defs, cs) = add_class_def dcl_pos class_def new_class_defs cs
-		= (new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, cs)
+		= (new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, new_generic_defs, cs)
 	  where
 		add_class_def dcl_pos cd=:{class_members} new_class_defs cs
 			# (new_class_members, cs) = mapSt (redirect_defined_symbol STE_Member dcl_pos) [ cm \\ cm<-:class_members ] cs
 			= ([{cd & class_members={cm \\ cm<-new_class_members}}:new_class_defs], cs)
 	add_dcl_definition {com_member_defs} dcl=:{dcl_kind = STE_Member, dcl_index, dcl_pos} 
-			(new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, cs)
+			(new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, new_generic_defs, cs)
 		# member_def = com_member_defs.[dcl_index]
-		= (new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, [member_def:new_member_defs], cs)
+		= (new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, [member_def:new_member_defs], new_generic_defs, cs)
+// AA..
+	add_dcl_definition {com_generic_defs} dcl=:{dcl_kind = STE_Generic, dcl_index, dcl_pos} 
+			(new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, new_generic_defs, cs)
+		# generic_def = com_generic_defs.[dcl_index]
+		= (new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, [generic_def:new_generic_defs], cs)	
+// ..AA
+
 	add_dcl_definition _ _ 
-			(new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, cs)
-		= (new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, cs)
+			(new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, new_generic_defs, cs)
+		= (new_type_defs, new_class_defs, new_cons_defs, new_selector_defs, new_member_defs, new_generic_defs, cs)
 
 	redirect_defined_symbol req_kind pos ds=:{ds_ident} cs
 		# ({ste_kind,ste_index}, cs_symbol_table) = readPtr ds_ident.id_info cs.cs_symbol_table
@@ -1309,6 +1545,8 @@ check_module1 {mod_type,mod_name,mod_imports,mod_imported_objects,mod_defs = cde
 					<=< adjust_predefined_module_symbol PD_StdEnum
 					<=< adjust_predefined_module_symbol PD_StdBool
 					<=< adjust_predefined_module_symbol PD_StdDynamics
+					<=< adjust_predefined_module_symbol PD_StdGeneric	// AA
+					<=< adjust_predefined_module_symbol PD_StdMisc		// AA										
 					<=< adjust_predefined_module_symbol PD_PredefinedModule
 			= ([], macro_and_fun_defs, { cs & cs_predef_symbols = cs_predef_symbols, cs_symbol_table = cs_symbol_table})
 		where
@@ -1507,8 +1745,9 @@ check_module2 mod_name mod_imported_objects mod_imports mod_type icl_global_func
 	  heaps = { heaps & hp_type_heaps = hp_type_heaps, hp_var_heap = hp_var_heap }
 
 	  e_info = { ef_type_defs = icl_common.com_type_defs, ef_selector_defs = icl_common.com_selector_defs, ef_class_defs = icl_common.com_class_defs, 
-	  			  ef_cons_defs = icl_common.com_cons_defs, ef_member_defs = icl_common.com_member_defs, ef_modules = dcl_modules,
-					ef_is_macro_fun = False }
+	  			  ef_cons_defs = icl_common.com_cons_defs, ef_member_defs = icl_common.com_member_defs,
+	  			  ef_generic_defs = icl_common.com_generic_defs, //AA 
+	  			  ef_modules = dcl_modules, ef_is_macro_fun = False }
 
 	  (icl_functions, e_info, heaps, cs) = checkMacros main_dcl_module_n cdefs.def_macros icl_functions e_info heaps cs
 	  (icl_functions, e_info, heaps, cs) = checkFunctions main_dcl_module_n cGlobalScope icl_global_function_range.ir_from icl_global_function_range.ir_to icl_functions e_info heaps cs
@@ -1548,7 +1787,9 @@ check_module2 mod_name mod_imported_objects mod_imports mod_type icl_global_func
 		  		= partitionateAndLiftFunctions [icl_global_function_range, icl_instances] main_dcl_module_n pds_alias_dummy icl_functions
 		  			dcl_modules var_heap expr_heap cs_symbol_table cs_error
 		  icl_common	= { icl_common & com_type_defs = e_info.ef_type_defs, com_selector_defs = e_info.ef_selector_defs, com_class_defs = e_info.ef_class_defs,
-			  	 			  com_cons_defs = e_info.ef_cons_defs, com_member_defs = e_info.ef_member_defs, com_instance_defs = class_instances }	  			  
+			  	 			  com_cons_defs = e_info.ef_cons_defs, com_member_defs = e_info.ef_member_defs,
+			  	 			  com_generic_defs = e_info.ef_generic_defs, // AA	 
+			  	 			  com_instance_defs = class_instances }	  			  
 		  icl_mod		= { icl_name = mod_name, icl_functions = icl_functions, icl_common = icl_common, icl_instances = icl_instances, icl_specials = icl_specials,
 								icl_imported_objects = mod_imported_objects, icl_used_module_numbers = imported_module_numbers,
 	  			  				icl_import = icl_imported }
@@ -1563,7 +1804,8 @@ check_module2 mod_name mod_imported_objects mod_imports mod_type icl_global_func
 
 		= (cs_error.ea_ok, icl_mod, dcl_modules, groups, dcl_icl_conversions, cached_functions_and_macros, cs_x.x_main_dcl_module_n, heaps, cs_predef_symbols, cs_symbol_table, cs_error.ea_file /* TD */, cs_x.directly_imported_dcl_modules)
 		# icl_common	= { icl_common & com_type_defs = e_info.ef_type_defs, com_selector_defs = e_info.ef_selector_defs, com_class_defs = e_info.ef_class_defs,
-			  	 			  com_cons_defs = e_info.ef_cons_defs, com_member_defs = e_info.ef_member_defs }	  			  
+			  	 			  com_cons_defs = e_info.ef_cons_defs, com_member_defs = e_info.ef_member_defs,
+			  	 			  com_generic_defs = e_info.ef_generic_defs/*AA*/ }	  			  
 		  icl_mod		= { icl_name = mod_name, icl_functions = icl_functions, icl_common = icl_common,
 		  					icl_instances = icl_instance_range,
 		  					icl_specials = {ir_from = nr_of_functions, ir_to = nr_of_functions},
@@ -1732,6 +1974,11 @@ check_module2 mod_name mod_imported_objects mod_imports mod_type icl_global_func
 			= (com_type_defs`, { icl_common & com_type_defs = com_type_defs })
 
 check_needed_modules_are_imported mod_name extension cs=:{cs_x={x_needed_modules}}
+//AA..
+	# cs = case x_needed_modules bitand cNeedStdGeneric of
+			0 -> cs
+			_ -> check_it PD_StdGeneric mod_name "" extension cs
+//..AA
 	# cs = case x_needed_modules bitand cNeedStdDynamics of
 			0 -> cs
 			_ -> check_it PD_StdDynamics mod_name "" extension cs
@@ -2170,8 +2417,9 @@ checkDclModule dcl_imported_module_numbers super_components imports_ikh componen
 
 	  com_member_defs = dcl_common.com_member_defs
 	  e_info = { ef_type_defs = com_type_defs, ef_selector_defs = dcl_common.com_selector_defs, ef_class_defs = com_class_defs,
-	  			 ef_cons_defs = dcl_common.com_cons_defs, ef_member_defs = com_member_defs, ef_modules = modules,
-				 ef_is_macro_fun = False }
+	  			 ef_cons_defs = dcl_common.com_cons_defs, ef_member_defs = com_member_defs,
+	  			 ef_generic_defs = dcl_common.com_generic_defs, // AA
+	  			 ef_modules = modules, ef_is_macro_fun = False }
 
 	  (icl_functions, e_info=:{ef_modules=modules}, heaps=:{hp_expression_heap}, cs)
 			= checkMacros mod_index dcl_macros icl_functions e_info heaps cs
@@ -2191,7 +2439,9 @@ checkDclModule dcl_imported_module_numbers super_components imports_ikh componen
 	  heaps = { heaps & hp_expression_heap = hp_expression_heap }
 
 	  dcl_common = { dcl_common & com_type_defs = e_info.ef_type_defs, com_selector_defs = e_info.ef_selector_defs, com_class_defs = e_info.ef_class_defs,
-			  	 		com_instance_defs = com_instance_defs, com_cons_defs = e_info.ef_cons_defs, com_member_defs = e_info.ef_member_defs }
+			  	 		com_instance_defs = com_instance_defs, com_cons_defs = e_info.ef_cons_defs,
+			  	 		com_generic_defs = e_info.ef_generic_defs, //AA  
+			  	 		com_member_defs = e_info.ef_member_defs }
 
 	  (modules, expl_imp_info, cs_symbol_table)
 	  		= updateExplImpInfo super_components mod_index dcls_import dcl_mod.dcl_declared.dcls_local_for_import
@@ -2245,7 +2495,34 @@ where
 				<=< adjust_predef_symbol PD_DynamicValue		mod_index (STE_Field unused))
 
 // ... MV
+// AA..			
+		# (pre_mod, cs_predef_symbols) = cs_predef_symbols![PD_StdGeneric]
+		# (pd_type_iso, cs_predef_symbols) = cs_predef_symbols![PD_TypeISO]	
+		| pre_mod.pds_def == mod_index
+			= (class_members, class_instances, fun_types, { cs & cs_predef_symbols = cs_predef_symbols}
+				<=< adjust_predef_symbol PD_TypeISO				mod_index STE_Type
+				<=< adjust_predef_symbol PD_ConsISO				mod_index STE_Constructor				
+				<=< adjust_predef_symbol PD_iso_from			mod_index (STE_Field pd_type_iso.pds_ident)
+				<=< adjust_predef_symbol PD_iso_to				mod_index (STE_Field pd_type_iso.pds_ident)				
+				<=< adjust_predef_symbol PD_TypeUNIT			mod_index STE_Type
+				<=< adjust_predef_symbol PD_ConsUNIT			mod_index STE_Constructor
+				<=< adjust_predef_symbol PD_TypePAIR			mod_index STE_Type
+				<=< adjust_predef_symbol PD_ConsPAIR			mod_index STE_Constructor
+				<=< adjust_predef_symbol PD_TypeEITHER			mod_index STE_Type
+				<=< adjust_predef_symbol PD_ConsLEFT			mod_index STE_Constructor
+				<=< adjust_predef_symbol PD_ConsRIGHT			mod_index STE_Constructor
+				<=< adjust_predef_symbol PD_TypeARROW			mod_index STE_Type
+				<=< adjust_predef_symbol PD_ConsARROW			mod_index STE_Constructor
+				<=< adjust_predef_symbol PD_isomap_ARROW_		mod_index STE_DclFunction				
+				<=< adjust_predef_symbol PD_isomap_ID			mod_index STE_DclFunction)				
+		# (pre_mod, cs_predef_symbols) = cs_predef_symbols![PD_StdMisc]	
+		| pre_mod.pds_def == mod_index
+			= (class_members, class_instances, fun_types, { cs & cs_predef_symbols = cs_predef_symbols}
+				<=< adjust_predef_symbol PD_abort				mod_index STE_DclFunction
+				<=< adjust_predef_symbol PD_undef				mod_index STE_DclFunction)
+// ..AA
 			= (class_members, class_instances, fun_types, { cs & cs_predef_symbols = cs_predef_symbols})
+		
 	where
 // MV ...
 		unused
@@ -2430,3 +2707,182 @@ possibly_write_expl_imports_of_main_dcl_mod_to_file imports_ikh dcl_modules cs
 		Yes {si_explicit}
 			-> writeExplImportsToFile "dcl.txt" si_explicit dcl_modules cs
 
+write_expl_imports_to_file file_name si_explicit dcl_modules cs
+	| switch_port_to_new_syntax False True
+		= abort "write_expl_imports_to_file is only used for portToNewSyntax"
+	# (file, cs)
+			= openFile file_name cs
+	  (dcl_modules, file)
+	  		= foldSt (write_expl_import (flatten (map fst si_explicit))) (reverse si_explicit) (dcl_modules, file)
+	= (dcl_modules, closeFile file cs)
+	
+write_expl_import all_expl_imp_decls (declarations, _) (dcl_modules, file)
+	# (declaration_strings, dcl_modules)
+			= mapFilterYesSt (decl_to_opt_string all_expl_imp_decls) (reverse declarations) dcl_modules
+	= (dcl_modules, fwriteNewSyntax declaration_strings file)
+
+// only for portToNewSyntax
+decl_to_opt_string all_expl_imp_decls decl=:{dcl_ident, dcl_index, dcl_kind=STE_Imported ste_kind def_mod_index}
+			dcl_modules
+	= imported_decl_to_opt_string all_expl_imp_decls dcl_ident dcl_index ste_kind def_mod_index
+			dcl_modules
+decl_to_opt_string _ {dcl_ident, dcl_kind=STE_FunctionOrMacro _} dcl_modules
+	= (Yes dcl_ident.id_name, dcl_modules)
+decl_to_opt_string all_expl_imp_decls decl dcl_modules
+	= abort ("decl_to_opt_string failed"--->decl)
+	
+// only for portToNewSyntax
+imported_decl_to_opt_string all_expl_imp_decls dcl_ident dcl_index STE_Constructor def_mod_index
+		dcl_modules
+	= (No, dcl_modules)
+imported_decl_to_opt_string all_expl_imp_decls dcl_ident dcl_index STE_Member def_mod_index
+		dcl_modules
+	= (No, dcl_modules)
+imported_decl_to_opt_string all_expl_imp_decls dcl_ident dcl_index STE_DclFunction def_mod_index
+		dcl_modules
+	= (Yes dcl_ident.id_name, dcl_modules)
+imported_decl_to_opt_string all_expl_imp_decls dcl_ident dcl_index STE_Class def_mod_index
+		dcl_modules
+	= (Yes ("class "+++dcl_ident.id_name+++"(..)"), dcl_modules)
+// AA..
+imported_decl_to_opt_string all_expl_imp_decls dcl_ident dcl_index STE_Generic def_mod_index
+		dcl_modules
+	= (Yes ("generic "+++dcl_ident.id_name+++"(..)"), dcl_modules)	
+// ..AA
+imported_decl_to_opt_string all_expl_imp_decls dcl_ident dcl_index (STE_Instance _) def_mod_index
+		dcl_modules
+	# ({ins_type}, dcl_modules)
+			 = dcl_modules![def_mod_index].dcl_common.com_instance_defs.[dcl_index]
+	= (Yes ("instance "+++dcl_ident.id_name+++" "+++
+		separated " " (map type_to_string ins_type.it_types)), dcl_modules)
+imported_decl_to_opt_string all_expl_imp_decls dcl_ident dcl_index STE_Type def_mod_index
+		dcl_modules
+	# ({td_rhs}, dcl_modules)
+			 = dcl_modules![def_mod_index].dcl_common.com_type_defs.[dcl_index]
+	  dcl_string
+		  	= ":: "+++(case td_rhs of
+						AlgType constructors
+							-> dcl_ident.id_name+++constructor_bracket def_mod_index all_expl_imp_decls constructors
+						RecordType _
+							-> dcl_ident.id_name+++"{..}"
+						_
+							-> dcl_ident.id_name)
+	= (Yes dcl_string, dcl_modules)
+
+// only for portToNewSyntax
+type_to_string (TA {type_name} _) = possibly_replace_predef_symbols type_name.id_name
+type_to_string (TB type) = toString type
+type_to_string (TV {tv_name}) = tv_name.id_name
+type_to_string x = abort ("bug nr 945 in module check"--->x)
+
+possibly_replace_predef_symbols s
+	| s=="_list"
+		= "[]"
+	| s % (0,5) == "_tuple"
+		= (toString ['(':repeatn ((toInt (s%(6, (size s) - 1))) - 1) ','])+++")"
+	| s=="_array"
+		= "{}"
+	| s=="_!array"
+		= "{!}"
+	| s=="_#array"
+		= "{#}"
+	= s
+
+instance toString BasicType
+  where
+	toString BT_Int = "Int"
+	toString BT_Char = "Char"
+	toString BT_Real = "Real"
+	toString BT_Bool = "Bool"
+	toString BT_Dynamic = "Dynamic"
+	toString BT_File = "File"
+	toString BT_World = "World"
+	toString _ = abort "bug nr 346 in module check"
+
+// only for portToNewSyntax
+separated _ []
+	= ""
+separated separator [h:t]
+	= foldl (\l r->l+++separator+++r) h t
+
+constructor_bracket def_mod_index all_expl_imp_decls constructors
+	# expl_imp_constructor_strings
+			= [ ds_ident.id_name \\ {ds_ident} <- constructors
+				| is_expl_imported_constructor def_mod_index ds_ident all_expl_imp_decls ]
+	| isEmpty expl_imp_constructor_strings
+		= ""
+	= "("+++separated "," expl_imp_constructor_strings+++")"
+	
+// only for portToNewSyntax
+is_expl_imported_constructor def_mod_index ds_ident []
+	= False
+is_expl_imported_constructor def_mod_index ds_ident [{dcl_ident, dcl_kind=STE_Imported STE_Constructor def_mod_index2}:_]
+	| dcl_ident==ds_ident && def_mod_index==def_mod_index2
+		= True
+	// GOTO next alternative
+is_expl_imported_constructor def_mod_index ds_ident [h:t]
+	= is_expl_imported_constructor def_mod_index ds_ident t
+
+fwriteNewSyntax importStrings file
+	| isEmpty importStrings
+		= fwrites "import @#$@@!!" file
+	# with_commas = (map (\s->s+++", ") (butLast importStrings))++[last importStrings+++";"]
+	  lines = split_in_lines 12 with_commas [] []
+	  lines = [hd lines:[["\t":line]\\ line<-tl lines]]
+	  line_strings = [ foldl (+++) " " (line++["\n"]) \\ line<-lines ]
+	= fwrites (foldl (+++) "import" line_strings) file
+  where
+ 	max_line_length = 80
+	split_in_lines i [] inner_accu outer_accu
+		# accu = if (isEmpty inner_accu) outer_accu [reverse inner_accu:outer_accu]
+		= reverse accu
+	split_in_lines i [h:t] inner_accu outer_accu
+		# s = size h
+		| s+i>max_line_length
+			| isEmpty inner_accu
+				= split_in_lines (s+i) t [h] outer_accu
+			= split_in_lines (s+cTabWidth) t [h] [inner_accu:outer_accu]
+		= split_in_lines (s+i) t [h:inner_accu] outer_accu
+// only for portToNewSyntax
+
+butLast [] = []
+butLast [x] = []
+butLast [h:t] = [h: butLast t]
+
+// MW: fake..
+openFile file_name cs
+	# world							= bigBang
+	  (ok, newFile, world)			= fopen file_name FWriteText world
+	  cs							= forget world cs
+	  cs = case ok of
+			True	-> cs
+			_		# cs_error = checkError "" ("can't open file \""+++file_name+++" in current directory.") cs.cs_error
+					-> { cs & cs_error=cs_error }
+	= (newFile, cs)
+
+closeFile file cs
+	# world				= bigBang
+	  (ok, world)		= fclose file world
+	= forget world cs
+
+bigBang :: .World
+bigBang = cast 1
+// creates a world from scratch
+
+forget :: !.x !.y -> .y
+forget x y = y
+
+cast :: !.a -> .b
+cast a
+	= code
+		{
+			pop_a 0
+		}
+// ..fake
+// END only for portToNewSyntax
+// END only for portToNewSyntax
+// END only for portToNewSyntax
+// END only for portToNewSyntax
+// END only for portToNewSyntax
+// END only for portToNewSyntax
+// END only for portToNewSyntax
diff --git a/frontend/checkFunctionBodies.icl b/frontend/checkFunctionBodies.icl
index 640ed68..6669d71 100644
--- a/frontend/checkFunctionBodies.icl
+++ b/frontend/checkFunctionBodies.icl
@@ -860,9 +860,39 @@ where
 
 checkExpression free_vars (PE_Ident id) e_input e_state e_info cs
 	= checkIdentExpression cIsNotInExpressionList free_vars id e_input e_state e_info cs
+// AA..
+checkExpression free_vars (PE_Generic id=:{id_name,id_info} kind) e_input e_state e_info cs=:{cs_symbol_table, cs_x}
+	//= checkIdentExpression cIsNotInExpressionList free_vars id e_input e_state e_info cs
+	# (entry, cs_symbol_table) = readPtr id_info cs_symbol_table
+	= check_generic_expr free_vars entry id kind e_input e_state e_info {cs & cs_symbol_table = cs_symbol_table}
+	where 
+		check_generic_expr :: ![FreeVar] !SymbolTableEntry !Ident !TypeKind !ExpressionInput !*ExpressionState !*ExpressionInfo !*CheckState
+			-> (!Expression, ![FreeVar], !*ExpressionState, !*ExpressionInfo, !*CheckState)
+		check_generic_expr 
+				free_vars entry=:{ste_kind=STE_Generic,ste_index} id  kind  
+				e_input=:{ei_mod_index}  e_state e_info cs
+			= check_it free_vars ei_mod_index ste_index id kind e_input e_state e_info cs	
+		check_generic_expr 
+				free_vars entry=:{ste_kind=STE_Imported STE_Generic mod_index, ste_index} id kind  
+				e_input e_state e_info cs
+			= check_it free_vars mod_index ste_index id kind e_input e_state e_info cs	
+		check_generic_expr free_vars  entry=:{ste_kind=STE_Empty} id kind  e_input e_state e_info cs=:{cs_error}
+			= (EE, free_vars, e_state, e_info, { cs & cs_error = checkError id "undefined generic" cs_error })
+		check_generic_expr free_vars entry id kind  e_input e_state e_info cs=:{cs_error}
+			= (EE, free_vars, e_state, e_info, { cs & cs_error = checkError id "not a generic" cs_error })						
+
+		check_it free_vars mod_index gen_index id kind e_input e_state=:{es_expr_heap} e_info cs
+			#! symb_kind = SK_Generic { glob_object = gen_index, glob_module = mod_index} kind
+		  	#! symbol = { symb_name = id, symb_kind = symb_kind, symb_arity = 0 }			
+			#! (new_info_ptr, es_expr_heap) = newPtr EI_Empty es_expr_heap
+			#! app = { app_symb = symbol, app_args = [], app_info_ptr = new_info_ptr }
+			#! e_state = { e_state & es_expr_heap = es_expr_heap }
+			#! cs = { cs & cs_x.x_needed_modules = cs_x.x_needed_modules bitor cNeedStdGeneric }
+			= (App app, free_vars, e_state, e_info, cs)
+		 
+// ..AA
 checkExpression free_vars expr e_input e_state e_info cs
-	= abort "checkExpression (check.icl, line 1433)" // <<- expr
-
+	= abort "checkExpression (checkFunctionBodies.icl, line 868)" // <<- expr
 
 
 checkIdentExpression :: !Bool ![FreeVar] !Ident !ExpressionInput !*ExpressionState !u:ExpressionInfo !*CheckState
diff --git a/frontend/checksupport.dcl b/frontend/checksupport.dcl
index 0e7c42a..d269981 100644
--- a/frontend/checksupport.dcl
+++ b/frontend/checksupport.dcl
@@ -15,6 +15,7 @@ cIsADclModule 		:== True
 cNeedStdArray	:== 1
 cNeedStdEnum	:== 2
 cNeedStdDynamics:== 4
+cNeedStdGeneric	:== 8 // AA
 
 ::	VarHeap :== Heap VarInfo
 
@@ -41,11 +42,12 @@ cConstructorDefs		:== 1
 cSelectorDefs			:== 2
 cClassDefs				:== 3
 cMemberDefs				:== 4
-cInstanceDefs			:== 5
-cFunctionDefs			:== 6
-cMacroDefs				:== 7
+cGenericDefs			:== 5 // AA
+cInstanceDefs			:== 6
+cFunctionDefs			:== 7
+cMacroDefs				:== 8
 
-cConversionTableSize	:== 8
+cConversionTableSize	:== 9 // AA
 
 ::	CommonDefs =
 	{	com_type_defs 		:: !.{# CheckedTypeDef}
@@ -55,6 +57,7 @@ cConversionTableSize	:== 8
 	,	com_member_defs		:: !.{# MemberDef}
 	,	com_instance_defs	:: !.{# ClassInstance}
 //	,	com_instance_types	:: !.{ SymbolType}
+	,	com_generic_defs	:: !.{# GenericDef} // AA
 	}
 
 ::	Declarations = {
@@ -135,6 +138,7 @@ instance <<< IdentPos, ExplImpInfo, DeclarationInfo
 	,	ef_cons_defs		:: !.{# ConsDef}
 	,	ef_member_defs		:: !.{# MemberDef}
 	,	ef_class_defs		:: !.{# ClassDef}
+	,	ef_generic_defs		:: !.{# GenericDef} // AA
 	,	ef_modules			:: !.{# DclModule}
 	,	ef_is_macro_fun		:: !Bool
 	}
diff --git a/frontend/checksupport.icl b/frontend/checksupport.icl
index d2b1e99..401a6c0 100644
--- a/frontend/checksupport.icl
+++ b/frontend/checksupport.icl
@@ -22,6 +22,7 @@ cIsADclModule 		:== True
 cNeedStdArray	:== 1
 cNeedStdEnum	:== 2
 cNeedStdDynamics:== 4
+cNeedStdGeneric	:== 8 // AA
 
 ::	Heaps =
 	{	hp_var_heap			::!.VarHeap
@@ -42,11 +43,12 @@ cConstructorDefs		:== 1
 cSelectorDefs			:== 2
 cClassDefs				:== 3
 cMemberDefs				:== 4
-cInstanceDefs			:== 5
-cFunctionDefs			:== 6
-cMacroDefs				:== 7
+cGenericDefs			:== 5 // AA 
+cInstanceDefs			:== 6
+cFunctionDefs			:== 7
+cMacroDefs				:== 8
 
-cConversionTableSize	:== 8
+cConversionTableSize	:== 9 // AA
 
 instance toInt STE_Kind
 where
@@ -54,8 +56,9 @@ where
 	toInt STE_Constructor			= cConstructorDefs
 	toInt (STE_Field _)				= cSelectorDefs
 	toInt STE_Class					= cClassDefs
+	toInt STE_Generic				= cGenericDefs
 	toInt STE_Member				= cMemberDefs
-	toInt (STE_Instance _)				= cInstanceDefs
+	toInt (STE_Instance _)			= cInstanceDefs
 	toInt STE_DclFunction			= cFunctionDefs
 	toInt (STE_FunctionOrMacro _)	= cMacroDefs
 	toInt _							= NoIndex
@@ -67,6 +70,7 @@ where
 	,	com_class_defs		:: !.{# ClassDef}
 	,	com_member_defs		:: !.{# MemberDef}
 	,	com_instance_defs	:: !.{# ClassInstance}
+	,	com_generic_defs	:: !.{# GenericDef} // AA
 	}
 
 ::	Declarations = {
@@ -206,6 +210,7 @@ where
 	,	ef_cons_defs		:: !.{# ConsDef}
 	,	ef_member_defs		:: !.{# MemberDef}
 	,	ef_class_defs		:: !.{# ClassDef}
+	,	ef_generic_defs		:: !.{# GenericDef} // AA
 	,	ef_modules			:: !.{# DclModule}
 	,	ef_is_macro_fun		:: !Bool
 	}
diff --git a/frontend/checktypes.dcl b/frontend/checktypes.dcl
index 6c4c192..2f45848 100644
--- a/frontend/checktypes.dcl
+++ b/frontend/checktypes.dcl
@@ -29,3 +29,5 @@ decodeTopConsVar cv		:== ~(inc cv)
 
 expandSynonymTypes :: !.Index !*{#CheckedTypeDef} !*{#.DclModule} !*TypeHeaps !*ErrorAdmin
 	-> (!.{#CheckedTypeDef},!.{#DclModule},!.TypeHeaps,!.ErrorAdmin)
+
+removeVariablesFromSymbolTable :: !Int ![TypeVar] !*SymbolTable -> *SymbolTable
diff --git a/frontend/checktypes.icl b/frontend/checktypes.icl
index 15c827d..9996352 100644
--- a/frontend/checktypes.icl
+++ b/frontend/checktypes.icl
@@ -400,25 +400,6 @@ expandSynType mod_index type_index expst=:{exp_type_defs}
 		_
 			-> { expst &  exp_marks = { expst.exp_marks & [type_index] = CS_Checked }}
 
-instance toString KindInfo
-where
-	toString (KI_Var ptr) 		= "*" +++ toString (ptrToInt ptr)
-	toString (KI_Const) 		= "*"
-	toString (KI_Arrow kinds)	= kind_list_to_string kinds
-	where
-		kind_list_to_string [k] = "* -> *"
-		kind_list_to_string [k:ks] = "* -> " +++ kind_list_to_string ks
-/*
-instance toString TypeKind
-where
-	toString (KindVar var_num) = "*" +++ toString var_num
-	toString (KindConst) = "*"
-	toString (KindArrow [k:ks]) = toString k +++ kind_list_to_string ks +++ " -> *"
-	where
-		kind_list_to_string [] = ""
-		kind_list_to_string [k:ks] = " -> " +++ toString k +++ kind_list_to_string ks
-*/
-
 checkTypeDefs :: /* TD */ !Bool !Bool !*{# CheckedTypeDef} !Index !*{# ConsDef} !*{# SelectorDef} !*{# DclModule} !*VarHeap !*TypeHeaps !*CheckState
 	-> (!*{# CheckedTypeDef}, !*{# ConsDef}, !*{# SelectorDef}, !*{# DclModule}, !*VarHeap, !*TypeHeaps, !*CheckState)
 checkTypeDefs /* TD */ is_dcl_module is_main_dcl type_defs module_index  cons_defs selector_defs modules var_heap type_heaps cs
@@ -1171,6 +1152,8 @@ where
 			= create_class_dictionaries mod_index (inc class_index) class_defs modules rev_dictionary_list indexes type_var_heap var_heap cs
 			= (class_defs, modules, rev_dictionary_list, indexes, type_var_heap, var_heap, cs)			
 
+	create_class_dictionary :: !Index !Index !*{#ClassDef} !w:{#DclModule} !v:[SymbolPtr] !u:Indexes !*TypeVarHeap !*VarHeap !*CheckState 
+		-> (!*{#ClassDef}, !w:{#DclModule}, !v:[SymbolPtr], !u:Indexes, !*TypeVarHeap, !*VarHeap, !*CheckState)
 	create_class_dictionary mod_index class_index  class_defs =:{[class_index] = class_def } modules rev_dictionary_list
 			indexes type_var_heap var_heap cs=:{cs_symbol_table,cs_error}
 		# {class_name,class_args,class_arity,class_members,class_context,class_dictionary=ds=:{ds_ident={id_info}}} = class_def
@@ -1241,6 +1224,7 @@ where
 											ste_def_level = NotALevel, ste_previous = abort "empty SymbolTableEntry" })
 							<:= (cons_id_info, { ste_kind = STE_DictCons cons_def, ste_index = index_cons,
 											ste_def_level = NotALevel, ste_previous = abort "empty SymbolTableEntry" })})
+
 		# ({ste_kind}, cs_symbol_table) = readPtr id_info cs_symbol_table
 		| ste_kind == STE_Empty
 			= (class_defs, modules, rev_dictionary_list, indexes, type_var_heap, var_heap,
diff --git a/frontend/explicitimports.icl b/frontend/explicitimports.icl
index 3487eaa..3485570 100644
--- a/frontend/explicitimports.icl
+++ b/frontend/explicitimports.icl
@@ -547,6 +547,7 @@ instance toString STE_Kind where
 	toString STE_Constructor 			= "constructor"
 	toString (STE_Field _) 				= "field"
 	toString STE_Class 					= "class"
+	toString STE_Generic 				= "generic"			//AA
 	toString STE_Member 				= "class member"
 	toString (STE_Instance _)			= "instance"
 
@@ -623,7 +624,7 @@ instance check_completeness CheckedBody where
 instance check_completeness ClassDef where
 	check_completeness {class_context} cci ccs
 		= check_completeness class_context cci ccs
-
+		
 instance check_completeness ClassInstance where
 	check_completeness {ins_class, ins_type} cci ccs
 		= check_completeness ins_type cci
diff --git a/frontend/frontend.icl b/frontend/frontend.icl
index 4a825cf..b8d6cce 100644
--- a/frontend/frontend.icl
+++ b/frontend/frontend.icl
@@ -2,6 +2,8 @@ implementation module frontend
 
 import scanner, parse, postparse, check, type, trans, convertcases, overloading, utilities, convertDynamics
 //import RWSDebug
+import analtypes
+import generics
 
 :: FrontEndSyntaxTree
 	=	{	fe_icl :: !IclModule
@@ -121,17 +123,37 @@ frontEndInterface upToPhase mod_ident search_paths dcl_modules functions_and_mac
 	| upToPhase == FrontEndPhaseCheck
 		=	frontSyntaxTree cached_functions_and_macros n_functions_and_macros_in_dcl_modules main_dcl_module_n predef_symbols hash_table files error io out tcl_file icl_mod dcl_mods fun_defs components array_instances optional_dcl_icl_conversions global_fun_range heaps
 
+// AA..
+	# error_admin = {ea_file = error, ea_loc = [], ea_ok = True }
+	# ti_common_defs = {{dcl_common \\ {dcl_common} <-: dcl_mods } & [main_dcl_module_n] = icl_common }
+	# (td_infos, type_heaps, error_admin) = analTypeDefs ti_common_defs icl_used_module_numbers type_heaps error_admin
+	# heaps = { heaps & hp_type_heaps = type_heaps }
+
+	#! (components, ti_common_defs, fun_defs, generic_range, td_infos, heaps, hash_table, predef_symbols, dcl_mods, error_admin) = 
+		case False of
+		True -> convertGenerics 
+					components main_dcl_module_n ti_common_defs fun_defs td_infos 
+					heaps hash_table predef_symbols dcl_mods error_admin
+		False -> (components, ti_common_defs, fun_defs, {ir_to=0,ir_from=0}, td_infos, heaps, hash_table, predef_symbols, dcl_mods, error_admin)	
+
+	# icl_common = ti_common_defs.[main_dcl_module_n]	
+	# error = error_admin.ea_file
+// ..AA
+
 	# (ok, fun_defs, array_instances, type_code_instances, common_defs, imported_funs, type_def_infos, heaps, predef_symbols, error,out)
-		= typeProgram (components -*-> "Typing") main_dcl_module_n icl_functions icl_specials list_inferred_types icl_common [a\\a<-:icl_import] dcl_mods icl_used_module_numbers heaps predef_symbols error out dcl_mods
+		= typeProgram (components -*-> "Typing") main_dcl_module_n fun_defs/*icl_functions*/ icl_specials list_inferred_types icl_common [a\\a<-:icl_import] dcl_mods icl_used_module_numbers td_infos heaps predef_symbols error out dcl_mods
 
 	| not ok
 		= (No,{},0,main_dcl_module_n,predef_symbols, hash_table, files, error, io, out, tcl_file, heaps)
+			
 
-	# (components, fun_defs) 		= partitionateFunctions (fun_defs -*-> "partitionateFunctions") [ global_fun_range, icl_instances, icl_specials]
+	# (fun_def_size, fun_defs) = usize fun_defs
+	# (components, fun_defs) 		= partitionateFunctions (fun_defs -*-> "partitionateFunctions") [ global_fun_range, icl_instances, icl_specials, generic_range]
+		
 //	  (components, fun_defs, error)	= showTypes components 0 fun_defs error
 //	  (components, fun_defs, error)	= showComponents components 0 True fun_defs error
 //	  (fun_defs, error)	= showFunctions array_instances fun_defs error
-
+		
 	| upToPhase == FrontEndPhaseTypeCheck
 		=	frontSyntaxTree cached_functions_and_macros n_functions_and_macros_in_dcl_modules main_dcl_module_n predef_symbols hash_table files error io out tcl_file icl_mod dcl_mods fun_defs components array_instances optional_dcl_icl_conversions global_fun_range heaps
 
@@ -242,8 +264,7 @@ where
 			= show_component funs show_types fun_defs (file <<< fun_def.fun_type <<< '\n' <<< fun_def)
 			= show_component funs show_types fun_defs (file <<< fun_def)
 //		= show_component funs show_types fun_defs (file <<< fun_def.fun_symb)
-
-	
+			
 showComponents2 :: !{! Group} !Int !*{# FunDef} !{! ConsClasses} !*File  -> (!*{# FunDef},!*File)
 showComponents2 comps comp_index fun_defs acc_args file
 	| comp_index >= (size comps)
diff --git a/frontend/generics.dcl b/frontend/generics.dcl
new file mode 100644
index 0000000..8ee5187
--- /dev/null
+++ b/frontend/generics.dcl
@@ -0,0 +1,10 @@
+definition module generics 
+
+import checksupport
+from transform import Group
+
+convertGenerics :: !{!Group} !Int !{#CommonDefs} !*{# FunDef} !*TypeDefInfos !*Heaps !*HashTable !*PredefinedSymbols !u:{# DclModule} !*ErrorAdmin 
+	-> (!{!Group}, !{#CommonDefs}, !*{# FunDef}, !IndexRange, !*TypeDefInfos, !*Heaps, !*HashTable, !*PredefinedSymbols, !u:{# DclModule}, !*ErrorAdmin)
+
+getGenericMember :: !(Global Index) !TypeKind !{#CommonDefs} -> (Bool, Global Index)
+	
\ No newline at end of file
diff --git a/frontend/generics.icl b/frontend/generics.icl
new file mode 100644
index 0000000..0291b59
--- /dev/null
+++ b/frontend/generics.icl
@@ -0,0 +1,2044 @@
+implementation module generics
+
+import StdEnv
+import _aconcat
+import hashtable
+import checksupport
+import checktypes
+import check
+from transform import Group
+from type import buildCurriedType
+import analtypes
+
+:: *GenericState = {
+	gs_modules				:: !*{#CommonDefs},
+	gs_fun_defs				:: !*{# FunDef},
+	gs_groups				:: !{!Group},
+	gs_td_infos 			:: !*TypeDefInfos,
+	gs_gtd_infos			:: !*GenericTypeDefInfos,
+	gs_heaps				:: !*Heaps,
+	gs_main_dcl_module_n	:: !Index,
+	gs_first_fun			:: !Index,
+	gs_last_fun				:: !Index,
+	gs_first_group			:: !Index,
+	gs_last_group			:: !Index,
+	gs_predefs				:: !PredefinedSymbols,
+	gs_error 				:: !*ErrorAdmin	
+	}
+
+:: GenericTypeDefInfo  
+	= GTDI_Empty 							// no generic rep needed
+	| GTDI_Generic GenericType				// generic representataion
+
+:: GenericTypeDefInfos :== {# .{GenericTypeDefInfo}}
+
+:: GenericType = {
+	gt_type 				:: !AType,			// generic type representation
+	gt_type_args			:: ![TypeVar],		// same as in td_info
+	gt_iso					:: !DefinedSymbol,	// isomorphim function index 		
+	gt_isomap_group			:: !Index, 			// isomap function group
+	gt_isomap				:: !DefinedSymbol,	// isomap function for the type
+ 	gt_isomap_from			:: !DefinedSymbol,	// from-part of isomap
+	gt_isomap_to			:: !DefinedSymbol 	// to-part 
+	}
+
+EmptyDefinedSymbol :== MakeDefinedSymbol {id_name="",id_info=nilPtr} NoIndex 0	
+EmptyGenericType :== {
+	gt_type 		= makeAType TE,
+	gt_type_args	= [], 
+	gt_iso 			= EmptyDefinedSymbol, 
+	gt_isomap_group = NoIndex, 
+	gt_isomap 		= EmptyDefinedSymbol,
+	gt_isomap_from 	= EmptyDefinedSymbol,
+	gt_isomap_to 	= EmptyDefinedSymbol
+	}
+
+:: IsoDirection = IsoTo | IsoFrom
+
+instance toBool GenericTypeDefInfo where
+	toBool GTDI_Empty 		= False
+	toBool (GTDI_Generic _) 	= True
+
+convertGenerics :: !{!Group} !Int !{#CommonDefs} !*{# FunDef} !*TypeDefInfos !*Heaps !*HashTable !*PredefinedSymbols !u:{# DclModule} !*ErrorAdmin 
+	-> (!{!Group}, !{#CommonDefs}, !*{# FunDef}, !IndexRange, !*TypeDefInfos, !*Heaps, !*HashTable, !*PredefinedSymbols, !u:{# DclModule}, !*ErrorAdmin)
+convertGenerics 
+		groups main_dcl_module_n modules fun_defs td_infos heaps
+		hash_table predefs dcl_modules error
+
+	#! (fun_defs_size, fun_defs) = usize fun_defs 
+	#! groups_size = size groups	
+
+	#! (predef_size, predefs) = usize predefs
+	#! (gs_predefs, predefs) = arrayCopyBegin predefs predef_size
+	
+	// ??? How to map 2-d unique array not so ugly ??? 
+	#! (td_infos_sizes, td_infos) = get_sizes 0 td_infos
+		with 
+			get_sizes :: Int !*TypeDefInfos -> ([Int], !*TypeDefInfos)
+			get_sizes n td_infos
+				#! td_infos_size = size td_infos
+				| n == td_infos_size = ([], td_infos)
+				#! row_size = size td_infos.[n]
+				# (row_sizes, td_infos) = get_sizes (n + 1) td_infos
+				= ([row_size : row_sizes], td_infos)
+	#! gtd_infos = { createArray s GTDI_Empty \\ s <- td_infos_sizes } 
+								
+	#! gs = {gs_modules = {m \\m <-: modules}, // unique copy
+			gs_groups = groups, gs_fun_defs = fun_defs, 
+			gs_td_infos = td_infos,
+			gs_gtd_infos = gtd_infos, 
+			gs_heaps = heaps,
+			gs_main_dcl_module_n = main_dcl_module_n,
+			gs_first_fun = fun_defs_size, gs_last_fun = fun_defs_size,
+			gs_first_group = groups_size, gs_last_group = groups_size,
+			gs_predefs = gs_predefs,
+			gs_error = error} 
+	
+	#! (generic_types, gs) = collectGenericTypes gs
+		---> "*** collect generic types"
+	
+	#! generic_types = generic_types ---> ("collected generic types", generic_types)
+	
+	#! (instance_types, gs) = convertInstances gs
+		---> "*** build classes and bind instances"
+		
+	#! instance_types = instance_types ---> ("collected instsance types", instance_types)	
+		
+	#! (td_indexes, gs) = collectGenericTypeDefs (generic_types ++ instance_types) gs	
+		---> "*** collect type definitions for which a generic representation must be created"
+		
+	#! (iso_funs, iso_groups, gs) = buildIsoFunctions td_indexes gs	
+		---> "*** build isomorphisms for type definitions"	
+	#! (isomap_type_funs, isomap_type_groups, gs) = buildIsomapsForTypeDefs td_indexes gs	
+		---> "*** build maps for type definitions"	
+	#! (isomap_gen_funs, isomap_gen_groups, gs) = buildIsomapsForGenerics gs 		
+		---> "*** build maps for generic function types"	
+	#! (instance_funs, instance_groups, gs) = buildInstances gs
+		---> "*** build instances"	
+	#! (star_funs, star_groups, gs) = buildKindConstInstances gs
+		---> "*** build shortcut instances for kind *"	
+
+	// the order in the lists below is important! 
+	// Indexes are allocated in that order.
+	#! new_funs = iso_funs ++ isomap_type_funs ++ isomap_gen_funs ++ instance_funs ++ star_funs
+	#! new_groups = iso_groups ++ isomap_type_groups ++ isomap_gen_groups ++ instance_groups ++ star_groups	
+		//---> ("created isomaps", length isomap_funs, length isomap_groups)
+
+	#! gs = addFunsAndGroups new_funs new_groups gs	
+		---> "*** add geenrated functions"
+	#! gs = determineMemberTypes 0 0 gs
+		---> "*** determine types of member instances"	
+	
+	//| True
+	//	= abort "-----------------\n"
+				
+	#! {gs_modules, gs_groups, gs_fun_defs, gs_td_infos, 
+		gs_heaps,
+		gs_error} = gs	
+	
+	#! {hte_symbol_heap} = hash_table
+	#! cs = {
+		cs_symbol_table = hte_symbol_heap, 
+		cs_predef_symbols = predefs, 
+		cs_error = gs_error, 
+		cs_x= {
+			x_needed_modules = 0,
+			x_main_dcl_module_n = main_dcl_module_n, 
+			x_is_dcl_module = False,
+			x_type_var_position = 0, 
+			directly_imported_dcl_modules = []
+			}
+		}
+
+	# (common_defs, gs_modules) = gs_modules![main_dcl_module_n]
+	# class_defs = { x \\ x <-: common_defs.com_class_defs } // make unique copy
+	# {hp_type_heaps=hp_type_heaps=:{th_vars}, hp_var_heap} = gs_heaps
+		
+	# (class_defs, dcl_modules, new_type_defs, new_selector_defs, new_cons_defs, th_vars, hp_var_heap, cs) =
+		createClassDictionaries 
+			main_dcl_module_n 
+			class_defs 
+			dcl_modules 
+			(size common_defs.com_type_defs) 
+			(size common_defs.com_selector_defs) 
+			(size common_defs.com_cons_defs) 
+			th_vars hp_var_heap cs
+		
+	# gs_heaps = {gs_heaps & hp_var_heap = hp_var_heap, hp_type_heaps = {hp_type_heaps & th_vars = th_vars}} 
+
+	# common_defs = { common_defs & 
+		com_class_defs = class_defs, 
+		com_type_defs = arrayPlusList common_defs.com_type_defs new_type_defs,
+		com_selector_defs = arrayPlusList common_defs.com_selector_defs new_selector_defs,
+		com_cons_defs = arrayPlusList common_defs.com_cons_defs new_cons_defs}
+		
+	# gs_modules = { gs_modules & [main_dcl_module_n] = common_defs } 
+	# {cs_symbol_table, cs_predef_symbols, cs_error} = cs
+	# hash_table = { hash_table & hte_symbol_heap = cs_symbol_table }	
+	
+	# index_range = {ir_from = gs.gs_first_fun, ir_to = gs.gs_last_fun}
+		 			
+	= (	gs_groups, gs_modules, gs_fun_defs, index_range, gs_td_infos, gs_heaps, hash_table, 
+		cs_predef_symbols, dcl_modules, cs_error)
+
+	
+// for each generic instance
+// - generate class and class member, if needed
+// - rebind generic instance from generic to class
+// - returns list of instance types for building generic representation
+convertInstances :: !*GenericState	
+	-> (![Type], !*GenericState)
+convertInstances gs
+	= convert_modules 0 gs 
+where
+
+	convert_modules module_index gs=:{gs_modules}
+		#! num_modules = size gs_modules
+		| module_index == num_modules
+			= ([], gs)	
+		#! (common_defs, gs_modules) = gs_modules ! [module_index] 
+		#! instance_defs = {i \\ i <-: common_defs.com_instance_defs} // make unique copy		
+
+		#! (new_types, instance_defs, gs) =
+			convert_instances module_index 0 instance_defs {gs & gs_modules = gs_modules}
+		#! (types, gs) = convert_modules (inc module_index) gs
+		
+		#! {gs_modules} = gs
+		#! (common_defs, gs_modules) = gs_modules ! [module_index]
+		#! gs_modules = { gs_modules & [module_index] = {common_defs & com_instance_defs = instance_defs}} 
+		= (new_types ++ types, {gs & gs_modules = gs_modules})
+
+	convert_instances module_index instance_index instance_defs gs
+		#! num_instance_defs = size instance_defs
+		| instance_index == num_instance_defs
+			= ([], instance_defs, gs)													
+		#! (new_types, instance_defs, gs) = convert_instance module_index instance_index instance_defs gs 			
+		#! (types, instance_defs, gs) = convert_instances module_index (inc instance_index) instance_defs gs		
+		= (new_types ++ types, instance_defs, gs)	
+		
+	convert_instance :: !Index !Index !*{#ClassInstance} !*GenericState
+		-> (![Type], !*{#ClassInstance}, !*GenericState)	
+	convert_instance module_index instance_index instance_defs gs=:{gs_td_infos}
+
+		#! (instance_def, instance_defs) = instance_defs ! [instance_index]
+		| not instance_def.ins_is_generic
+			= ([], instance_defs, {gs & gs_td_infos = gs_td_infos})
+			
+		// determine the kind of the instance type
+		#! it_type = hd instance_def.ins_type.it_types
+		#! (kind, gs_td_infos) = kindOfType it_type gs_td_infos
+		#! gs = {gs & gs_td_infos = gs_td_infos}	
+
+		// generate class and update the instance to point to the class		
+		#! (_, gs) 			= buildClassDef instance_def.ins_class KindConst gs	
+		#! (class_glob, gs) = buildClassDef instance_def.ins_class kind gs	
+		#! ins_ident = instance_def.ins_ident
+		#! ins_ident = { ins_ident & id_name = ins_ident.id_name +++ ":" +++ (toString kind)}
+		#! instance_def = { instance_def & ins_class = class_glob, ins_ident = ins_ident }
+		#! instance_defs = { instance_defs & [instance_index] = instance_def}
+
+		| instance_def.ins_generate
+			= ([it_type], instance_defs, gs)
+			= ([], instance_defs, gs)
+
+
+collectGenericTypes :: !*GenericState -> (![Type], !*GenericState)
+collectGenericTypes gs=:{gs_modules} 
+	# (types, gs_modules) = collect_in_modules 0 0 gs_modules
+	= (types, {gs & gs_modules = gs_modules})
+where
+	collect_in_modules module_index generic_index gs_modules
+		#! size_gs_modules = size gs_modules 
+		| module_index == size_gs_modules
+			= ([], gs_modules) 
+		# (generic_defs, gs_modules) = gs_modules ! [module_index].com_generic_defs 
+		#! size_generic_defs = size generic_defs
+		| generic_index == size_generic_defs
+			= collect_in_modules (inc module_index) 0 gs_modules
+		# {gen_type={st_args, st_result}} = generic_defs . [generic_index]
+		# (types, gs_modules) = collect_in_modules module_index (inc generic_index) gs_modules
+		= ([at_type \\ {at_type} <- [st_result:st_args]] ++ types, gs_modules)	
+		 				
+// find all types whose generic representation is needed
+collectGenericTypeDefs :: ![Type] !*GenericState
+	-> (![Global Index], !*GenericState)
+collectGenericTypeDefs types gs
+	# (td_indexes, gs) = collect_in_types types gs
+	= (map fst td_indexes, gs)
+where
+
+	collect_in_types :: ![Type] !*GenericState  
+		-> (![(Global Index, Int)], !*GenericState)
+	collect_in_types [] gs = ([], gs)
+	collect_in_types [type:types] gs
+		# (td_indexes1, gs) = collect_in_type type gs
+		# (td_indexes2, gs) = collect_in_types types gs
+		= (merge_td_indexes td_indexes1 td_indexes2, gs)
+		
+	collect_in_type :: !Type !*GenericState 
+		-> (![(Global Index, Int)], !*GenericState)
+	collect_in_type 
+			(TA type_symb_indet=:{type_index, type_name} args) 
+			gs=:{gs_gtd_infos, gs_td_infos, gs_modules}
+		# {glob_module, glob_object} = type_index	
+		# (gtd_info, gs_gtd_infos) = gs_gtd_infos ! [glob_module, glob_object]
+		| toBool gtd_info // already marked
+			= ([], {gs & gs_gtd_infos = gs_gtd_infos})
+		#! gs_gtd_infos = {gs_gtd_infos & [glob_module, glob_object] = GTDI_Generic EmptyGenericType}
+			---> ("collect in type " +++ type_name.id_name +++ ": " +++ 
+					toString glob_module +++ " " +++ toString glob_object)						
+		#! (type_def, gs_modules) = getTypeDef glob_module glob_object gs_modules
+		#! (td_info, gs_td_infos) = gs_td_infos ! [glob_module, glob_object]
+		# gs = {gs & gs_td_infos = gs_td_infos, gs_gtd_infos = gs_gtd_infos, gs_modules = gs_modules}
+		# (td_indexes, gs) = collect_in_type_def_rhs glob_module type_def.td_rhs gs
+		= (merge_td_indexes [(type_index, td_info.tdi_group_nr)] td_indexes, gs)				
+	collect_in_type (arg --> res) gs
+		#! (td_indexes1, gs) = collect_in_type arg.at_type gs
+		#! (td_indexes2, gs) = collect_in_type res.at_type gs
+		= (td_indexes1 ++ td_indexes2, gs)
+	collect_in_type (cons_var :@: args) gs
+		# types = [ at_type \\ {at_type} <- args] 
+		= collect_in_types types gs				
+	collect_in_type _ gs
+		= ([], gs)
+	
+	collect_in_type_def_rhs :: !Index !TypeRhs !*GenericState 
+		-> (![(Global Index, Int)], !*GenericState)		 
+	collect_in_type_def_rhs mod (AlgType cons_def_symbols) gs
+		= collect_in_conses mod cons_def_symbols gs
+	collect_in_type_def_rhs mod (RecordType {rt_constructor})	gs
+		= collect_in_conses mod [rt_constructor] gs				
+	collect_in_type_def_rhs mod (SynType {at_type})	gs			
+		= collect_in_type at_type gs 
+	collect_in_type_def_rhs mod (AbstractType _) gs				
+		= abort "ERROR: can not build generic type representation for an abstract type\n" 		
+	collect_in_type_def_rhs mod UnknownType	gs
+		= abort "ERROR: can not build generic type representation for an unknown type\n" 
+	collect_in_type_def_rhs mod _	gs
+		= abort "ERROR: unknown TypeRhs\n" 
+	
+	collect_in_conses :: !Index ![DefinedSymbol] !*GenericState 
+		-> (![(Global Index, Int)], !*GenericState)
+	collect_in_conses mod [] gs 
+		= ([], gs)
+	collect_in_conses mod [{ds_index, ds_ident} : cons_def_symbols] gs=:{gs_modules}
+		#! ({cons_type={st_args}}, gs_modules) = getConsDef mod ds_index gs_modules
+			---> ("mark cons " +++ ds_ident.id_name)
+		#! types = [ at_type \\ {at_type} <- st_args] 
+		#! (td_indexes1, gs) = collect_in_types types {gs & gs_modules=gs_modules}
+		#! (td_indexes2, gs) = collect_in_conses mod cons_def_symbols gs
+		= (merge_td_indexes td_indexes1 td_indexes2, gs)
+
+	collect_in_symbol_type {st_args, st_result} gs
+		# (td_indexes1, gs) = collect_in_types (map (\x->x.at_type) st_args)  gs
+		# (td_indexes2, gs) = collect_in_type st_result.at_type gs
+		= (merge_td_indexes td_indexes1 td_indexes2, gs)
+		 
+	merge_td_indexes x y 
+		= mergeBy (\(_,l) (_,r) ->l < r) x y 
+
+buildIsoFunctions :: ![Global Index] !*GenericState
+	-> (![FunDef], ![Group], !*GenericState)
+buildIsoFunctions [] gs = ([], [], gs)
+buildIsoFunctions [type_index:type_indexes] gs
+	# (iso_funs1, iso_groups1, gs) = build_function type_index gs
+	# (iso_funs2, iso_groups2, gs) = buildIsoFunctions type_indexes gs	 
+	= (iso_funs1 ++ iso_funs2, iso_groups1 ++ iso_groups2, gs) 
+where
+	build_function {glob_module, glob_object} gs
+		# (from_fun_index, 	from_group_index, gs) 	= newFunAndGroupIndex gs
+		# (to_fun_index, 	to_group_index, gs) 	= newFunAndGroupIndex gs
+		# (iso_fun_index, 	iso_group_index, gs) 	= newFunAndGroupIndex gs
+			
+		# {gs_gtd_infos, gs_modules, gs_predefs} = gs
+		# (type_def=:{td_name}, gs_modules) = getTypeDef glob_module glob_object gs_modules 
+		# (common_defs, gs_modules) = gs_modules ! [glob_module]		
+		# generic_rep_type = buildGenericRepType type_def.td_rhs gs_predefs common_defs 
+	
+		# iso_def_sym = {
+			ds_ident  = {id_name="iso:"+++type_def.td_name.id_name, id_info = nilPtr },
+			ds_index  = iso_fun_index,
+			ds_arity  = 0	
+			}
+	
+		# from_def_sym = {
+			ds_ident  = {id_name="iso_from:"+++type_def.td_name.id_name, id_info = nilPtr },
+			ds_index  = from_fun_index,
+			ds_arity  = 1	
+			}
+	
+		# to_def_sym = {
+			ds_ident  = {id_name="iso_to:"+++type_def.td_name.id_name, id_info = nilPtr },
+			ds_index  = to_fun_index,
+			ds_arity  = 1	
+			}
+		# gtd_info = GTDI_Generic { 
+			gt_type 		= generic_rep_type,
+			gt_type_args	= [atv_variable \\ {atv_variable} <- type_def.td_args], 
+			gt_iso 			= iso_def_sym,
+			gt_isomap_group	= NoIndex,
+			gt_isomap		= EmptyDefinedSymbol,		
+			gt_isomap_from	= EmptyDefinedSymbol,		
+			gt_isomap_to	= EmptyDefinedSymbol		
+			}
+	
+		# gs_gtd_infos = {gs_gtd_infos & [glob_module, glob_object] = gtd_info} 
+		# gs = { gs & gs_gtd_infos = gs_gtd_infos, gs_modules = gs_modules }
+	
+		# (from_fun_def, gs) = buildIsoFrom from_def_sym from_group_index glob_module type_def gs	
+		# (to_fun_def, gs) = buildIsoTo to_def_sym to_group_index glob_module type_def gs	
+		# (iso_fun_def, gs) = 
+			//buildUndefFunction iso_fun_index iso_group_index iso_name 1 gs_predefs gs_heaps	
+			buildIsoRecord iso_def_sym iso_group_index from_def_sym to_def_sym gs	
+	
+		# funs = [ 
+			from_fun_def, 
+			to_fun_def, 
+			iso_fun_def]
+		# groups = [
+			{group_members = [from_fun_index]}, 
+			{group_members = [to_fun_index]}, 
+			{group_members = [iso_fun_index]}]
+	
+		= (funs, groups, gs)
+	
+buildIsomapsForTypeDefs :: ![Global Index] !*GenericState
+	-> (![FunDef], ![Group], !*GenericState)
+buildIsomapsForTypeDefs td_indexes gs=:{gs_last_group}
+	# gs = foldSt fill_function_indexes td_indexes gs
+	# first_group = gs_last_group
+	# (funs, gs) = build_isomap_functions td_indexes gs
+	# (last_group, gs) = gs ! gs_last_group
+	# groups = createArray (last_group - first_group) []
+		---> ("created " +++ toString (last_group - first_group) +++ " isomap groups")
+	# groups = collect_groups first_group funs groups
+	# groups = [ {group_members = fs} \\ fs <-: groups ] 
+	= (funs, groups, gs)
+where	
+
+	fill_function_indexes :: !(Global Index) !*GenericState -> !*GenericState
+	fill_function_indexes {glob_module, glob_object} gs=:{gs_gtd_infos}
+
+		# (from_fun_index, gs) = newFunIndex gs
+		# (to_fun_index, gs) = newFunIndex gs
+		# (rec_fun_index, gs) = newFunIndex gs
+
+		# (gs=:{gs_gtd_infos, gs_modules}) = gs
+		# (type_def=:{td_name, td_arity}, gs_modules) = getTypeDef glob_module glob_object gs_modules
+		# (GTDI_Generic gt, gs_gtd_infos) = gs_gtd_infos ! [glob_module, glob_object]
+
+		# gtd_info = GTDI_Generic {gt & 
+			gt_isomap_from 	= { 
+				ds_ident = {id_name="isomap_from:"+++td_name.id_name, id_info=nilPtr}, 
+				ds_index = from_fun_index, 
+				ds_arity = (td_arity + 1)
+				},
+			gt_isomap_to 	= { 
+				ds_ident = {id_name="isomap_to:"+++td_name.id_name, id_info=nilPtr}, 
+				ds_index = to_fun_index, 
+				ds_arity = (td_arity + 1)
+				},
+			gt_isomap 		= { 
+				ds_ident = {id_name="isomap:"+++td_name.id_name, id_info=nilPtr}, 
+				ds_index = rec_fun_index, 
+				ds_arity = td_arity
+				}
+			}		
+		# gs_gtd_infos = {gs_gtd_infos & [glob_module, glob_object] = gtd_info}		
+		= {gs & gs_gtd_infos = gs_gtd_infos, gs_modules = gs_modules}			
+	
+	build_isomap_functions :: ![Global Index] !*GenericState
+		-> (![FunDef], !*GenericState)		
+	build_isomap_functions [] gs = ([], gs)
+	build_isomap_functions [{glob_module, glob_object}:td_indexes] gs
+		# (funs1, gs) = build_isomap_function glob_module glob_object gs
+		# (funs2, gs) = build_isomap_functions td_indexes gs
+		= (funs1 ++ funs2, gs)
+	
+	build_isomap_function module_index type_def_index gs
+
+		# (group_index, gs)  = get_group module_index type_def_index gs
+
+		# {gs_modules, gs_gtd_infos} = gs
+		# (type_def=:{td_name}, gs_modules) = getTypeDef module_index type_def_index gs_modules
+		
+		# (GTDI_Generic {gt_isomap, gt_isomap_to, gt_isomap_from}, gs_gtd_infos) 
+			= gs_gtd_infos![module_index, type_def_index]
+		
+		# gs = { gs & gs_gtd_infos = gs_gtd_infos, gs_modules = gs_modules } 
+
+		# (from_fun_def, gs) = 
+			buildIsomapFromTo IsoFrom gt_isomap_from group_index module_index type_def_index gs
+		# (to_fun_def, gs) = 
+			buildIsomapFromTo IsoTo gt_isomap_to group_index module_index type_def_index gs
+		# (rec_fun_def, gs) = 
+			buildIsomapForTypeDef gt_isomap group_index module_index type_def gt_isomap_from gt_isomap_to gs
+		
+		# funs = [ from_fun_def, to_fun_def, rec_fun_def ]		
+		= (funs, gs)
+			---> from_fun_def 
+		
+	collect_groups :: !Index ![FunDef] !*{[Index]} -> !*{[Index]} 
+	collect_groups first_group_index [] groups = groups
+	collect_groups first_group_index [fun=:{fun_symb, fun_index, fun_info={fi_group_index}}:funs] groups
+		# (group, groups) = groups ! [fi_group_index - first_group_index]
+		# groups = {groups & [fi_group_index - first_group_index] = [fun_index:group]}
+			//---> ("add fun " +++ fun_symb.id_name +++ " "+++ toString fun_index +++ 
+			//		" to group " +++ toString fi_group_index) 
+		= collect_groups first_group_index funs groups 
+
+	get_group :: !Index  !Index !*GenericState 
+		-> (!Index, !*GenericState)
+	get_group module_index type_def_index gs=:{gs_gtd_infos}
+		#! gtd_info = gs_gtd_infos . [module_index, type_def_index]
+		# (GTDI_Generic gt) = gtd_info
+		| gt.gt_isomap_group <> NoIndex // group index already allocated
+			= (gt.gt_isomap_group, gs)
+					
+		# (group_index, gs=:{gs_td_infos, gs_gtd_infos}) 
+			= newGroupIndex {gs & gs_gtd_infos = gs_gtd_infos}
+				
+		# (type_def_info, gs_td_infos) = gs_td_infos ! [module_index, type_def_index]
+		# gs_gtd_infos = update_group group_index type_def_info.tdi_group gs_gtd_infos				
+		= (group_index, { gs & gs_gtd_infos = gs_gtd_infos, gs_td_infos = gs_td_infos})
+			---> ("type group number of type " +++ toString module_index +++ " " +++ 
+					toString type_def_index +++ " is " +++ toString type_def_info.tdi_group_nr)
+
+	update_group :: !Index ![Global Index] !*GenericTypeDefInfos -> !*GenericTypeDefInfos
+	update_group group_index [] gtd_infos = gtd_infos	
+	update_group group_index [{glob_module, glob_object}:type_def_global_indexes] gtd_infos
+		# (gtd_info, gtd_infos) = gtd_infos ! [glob_module, glob_object]
+		# (GTDI_Generic gt) = gtd_info
+		| gt.gt_isomap_group <> NoIndex 
+			= abort "sanity check: updating already updated group\n"
+		# gtd_info = GTDI_Generic {gt & gt_isomap_group = group_index }
+		# gtd_infos = {gtd_infos & [glob_module, glob_object] = gtd_info}
+		= update_group group_index type_def_global_indexes gtd_infos
+
+
+buildIsomapsForGenerics :: !*GenericState
+	-> (![FunDef], ![Group], !*GenericState)
+buildIsomapsForGenerics gs
+	= build_modules 0 gs
+where
+	build_modules module_index gs=:{gs_modules}
+		#! num_modules = size gs_modules
+		| module_index == num_modules
+			= ([], [], gs)					
+		# (common_defs, gs_modules) = gs_modules ! [module_index]
+		#  {com_generic_defs} = common_defs
+		# com_generic_defs = {g \\ g <-: com_generic_defs} // make unique copy		
+		# (new_funs, new_groups, com_generic_defs, gs) =
+			build_isomaps module_index 0 com_generic_defs {gs & gs_modules = gs_modules}
+		# (funs, groups, gs) = build_modules (inc module_index) gs
+		# {gs_modules} = gs
+		# gs_modules = { gs_modules & [module_index] = {common_defs & com_generic_defs = com_generic_defs}} 
+		= (new_funs ++ funs, new_groups ++ groups, {gs & gs_modules = gs_modules})
+
+	build_isomaps module_index generic_index generic_defs gs		
+		#! num_generic_defs = size generic_defs
+		| generic_index == num_generic_defs
+			= ([], [], generic_defs, gs)													
+		# (new_funs, new_groups, generic_defs, gs) = build_isomap module_index generic_index generic_defs gs 			
+		# (funs, groups, generic_defs, gs) = build_isomaps module_index (inc generic_index) generic_defs gs		
+		= (new_funs ++ funs, new_groups ++ groups, generic_defs, gs)	
+
+	build_isomap module_index generic_index generic_defs gs				
+		# (generic_def=:{gen_name, gen_type, gen_arity}, generic_defs) = generic_defs ! [generic_index] 		
+		# (fun_index, group_index, gs) = newFunAndGroupIndex gs 		
+		# def_sym = {
+			ds_ident = {id_name="isomap:"+++gen_name.id_name, id_info = nilPtr}, 
+			ds_index = fun_index, 
+			ds_arity = gen_arity
+			}
+		# generic_defs = {generic_defs & [generic_index] = {generic_def & gen_isomap = def_sym}}				
+		# (fun_def, gs) = buildIsomapForGeneric def_sym group_index generic_def gs
+		//# (fun_def, gs) = build_undef_fun def_sym group_index gs	
+		# group = {group_members = [fun_index]}			
+		= ([fun_def], [group], generic_defs, gs)
+	where
+		build_undef_fun def_sym group gs=:{gs_heaps, gs_predefs}
+			# (fun_def, gs_heaps) = buildUndefFunction def_sym group gs_predefs gs_heaps
+			= (fun_def, {gs & gs_heaps = gs_heaps})
+						
+// generate instances  
+buildInstances :: !*GenericState	
+	-> (![FunDef], ![Group], !*GenericState)
+buildInstances gs
+	= build_modules 0 gs
+where
+	build_modules :: !Index !*GenericState 
+		-> (![FunDef], ![Group], !*GenericState)
+	build_modules module_index gs=:{gs_modules}
+		#! num_modules = size gs_modules
+		| module_index == num_modules
+			= ([], [], gs)					
+		# (common_defs, gs_modules) = gs_modules ! [module_index]
+		#  {com_instance_defs} = common_defs
+		# com_instance_defs = {i \\ i <-: com_instance_defs} // make unique copy		
+		# (new_funs, new_groups, com_instance_defs, gs) =
+			build_instances module_index 0 com_instance_defs {gs & gs_modules = gs_modules}
+		# (funs, groups, gs) = build_modules (inc module_index) gs
+		# {gs_modules} = gs
+		# gs_modules = { gs_modules & [module_index] = {common_defs & com_instance_defs = com_instance_defs}} 
+		= (new_funs ++ funs, new_groups ++ groups, {gs & gs_modules = gs_modules})
+
+	build_instances :: !Index !Index !*{#ClassInstance} !*GenericState 
+		-> (![FunDef], ![Group], !*{#ClassInstance}, !*GenericState)
+	build_instances module_index instance_index instance_defs gs
+		#! num_instance_defs = size instance_defs
+		| instance_index == num_instance_defs
+			= ([], [], instance_defs, gs)													
+		# (new_funs, new_groups, instance_defs, gs) = build_instance module_index instance_index instance_defs gs 			
+		# (funs, groups, instance_defs, gs) = build_instances module_index (inc instance_index) instance_defs gs		
+		= (new_funs ++ funs, new_groups ++ groups, instance_defs, gs)	
+	
+	build_instance :: !Index !Index !*{#ClassInstance} !*GenericState 
+		-> (![FunDef], ![Group], !*{#ClassInstance}, !*GenericState)	
+	build_instance module_index instance_index instance_defs gs=:{gs_modules}
+		# (instance_def, instance_defs) = instance_defs ! [instance_index]
+		| not instance_def.ins_generate
+			= ([], [], instance_defs, gs)
+
+		# {ins_class, ins_generic} = instance_def				
+		# (class_def, gs_modules) = getClassDef ins_class.glob_module ins_class.glob_object.ds_index gs_modules
+		# (member_def, gs_modules) = getMemberDef ins_class.glob_module class_def.class_members.[0].ds_index gs_modules
+		# (generic_def, gs_modules) = getGenericDef ins_generic.glob_module ins_generic.glob_object gs_modules 
+		# it_type = hd instance_def.ins_type.it_types
+
+		# (fun_index, group_index, gs) = newFunAndGroupIndex {gs & gs_modules=gs_modules}
+		# fun_def_sym = {
+			ds_ident = instance_def.ins_ident, 
+			ds_index = fun_index, 
+			ds_arity = member_def.me_type.st_arity
+			}
+						
+		//# (fun_def, gs) = build_dummy_instance fun_def_sym group_index gs	
+		# (fun_def, gs) = buildInstance fun_def_sym group_index instance_def generic_def gs
+
+		# instance_def = { instance_def & ins_members = {fun_def_sym} }		
+		# instance_defs = {instance_defs & [instance_index] = instance_def} 
+		= ([fun_def], [{group_members = [fun_index]}], instance_defs, gs)
+		
+	build_dummy_instance fun_def_sym group_index gs=:{gs_predefs, gs_heaps}
+		# (fun_def, gs_heaps) = buildUndefFunction fun_def_sym group_index gs_predefs gs_heaps
+		= (fun_def, {gs & gs_heaps = gs_heaps}) 
+
+// generate kind star instances  
+buildKindConstInstances :: !*GenericState	
+	-> (![FunDef], ![Group], !*GenericState)
+buildKindConstInstances gs
+	= build_modules 0 gs
+where
+	build_modules :: !Index !*GenericState 
+		-> (![FunDef], ![Group], !*GenericState)
+	build_modules module_index gs=:{gs_modules}
+
+		#! num_modules = size gs_modules
+		| module_index == num_modules
+			= ([], [], {gs & gs_modules = gs_modules})					
+		# (new_funs, new_groups, instance_defs, gs) =
+			build_instances module_index 0 {gs & gs_modules = gs_modules}
+		# (funs, groups, gs) = build_modules (inc module_index) gs
+		# {gs_modules} = gs
+
+		// add instances 
+		# (common_defs=:{com_instance_defs}, gs_modules) = gs_modules ! [module_index]		
+		# com_instance_defs = arrayPlusList com_instance_defs instance_defs		
+		# gs_modules = { gs_modules & [module_index] = {common_defs & com_instance_defs = com_instance_defs}} 
+		= (new_funs ++ funs, new_groups ++ groups, {gs & gs_modules = gs_modules})
+
+	build_instances :: !Index !Index !*GenericState 
+		-> (![FunDef], ![Group], ![ClassInstance], !*GenericState)
+	build_instances module_index instance_index gs=:{gs_modules}
+		# ({com_instance_defs}, gs_modules) = gs_modules ! [module_index]
+		#! num_instance_defs = size com_instance_defs		
+		# gs = { gs & gs_modules = gs_modules }		
+		| instance_index == num_instance_defs
+			= ([], [], [], gs)
+																
+		# (new_funs, new_groups, new_instance_defs, gs) = build_instance module_index instance_index gs 			
+		# (funs, groups, instance_defs, gs) = build_instances module_index (inc instance_index) gs		
+		= (new_funs ++ funs, new_groups ++ groups, new_instance_defs ++ instance_defs, gs)	
+	build_instance :: !Index !Index !*GenericState 
+		-> (![FunDef], ![Group], ![ClassInstance], !*GenericState)	
+	build_instance module_index instance_index gs=:{gs_modules, gs_td_infos, gs_heaps}
+		# (instance_def, gs_modules) = getInstanceDef module_index instance_index gs_modules		
+		# {	ins_ident, ins_type, ins_pos,
+			ins_generate, ins_is_generic, ins_generic} = instance_def
+		
+		| not (/*ins_generate &&*/ ins_is_generic)
+			= ([], [], [], {gs & gs_td_infos = gs_td_infos, gs_modules = gs_modules, gs_heaps = gs_heaps})
+
+		# it_type = hd ins_type.it_types
+		#! (kind, gs_td_infos) = kindOfType it_type gs_td_infos
+		| kind == KindConst
+			= ([], [], [], { gs & gs_td_infos = gs_td_infos, gs_modules = gs_modules, gs_heaps = gs_heaps})
+
+		# (generic_def, gs_modules) = getGenericDef ins_generic.glob_module ins_generic.glob_object gs_modules
+		# (ok, class_def_sym) = getClassForKind generic_def KindConst
+		| not ok
+			= abort "no class for kind *"			
+		# (class_def, gs_modules) = getClassDef ins_generic.glob_module class_def_sym.ds_index gs_modules 
+		# (member_def, gs_modules) = getMemberDef ins_generic.glob_module class_def.class_members.[0].ds_index gs_modules 	
+
+		# (new_ins_type, gs_heaps) = 
+			build_instance_type ins_type kind {glob_module=ins_generic.glob_module, glob_object=class_def_sym} gs_heaps
+
+		# gs = {gs & gs_modules=gs_modules, gs_td_infos = gs_td_infos, gs_heaps = gs_heaps}
+		# (fun_index, group_index, gs) = newFunAndGroupIndex gs
+		# fun_def_sym = {
+			ds_ident = class_def.class_name, // kind star name 
+			ds_index = fun_index, 
+			ds_arity = member_def.me_type.st_arity
+			}
+						
+		//# (fun_def, gs) = build_dummy_instance fun_def_sym group_index gs	
+		# generic_def_sym = {
+			ds_ident=generic_def.gen_name, 
+			ds_index=ins_generic.glob_object,
+			ds_arity=0
+			}
+		# (fun_def, gs) = 
+			buildKindConstInstance fun_def_sym group_index ins_generic.glob_module generic_def_sym kind gs
+
+		# new_instance_def = {
+			ins_class 		= {glob_module = ins_generic.glob_module, glob_object = class_def_sym},	
+			ins_ident 		= class_def.class_name,	
+			ins_type  		= new_ins_type,
+			ins_members 	= {fun_def_sym},
+			ins_specials 	= SP_None,
+			ins_pos			= ins_pos, 
+			ins_is_generic	= True, 
+			ins_generate	= False,
+			ins_generic 	= ins_generic
+			}
+			---> fun_def
+
+		= ([fun_def], [{group_members = [fun_index]}], [new_instance_def], gs)
+		
+	build_dummy_instance fun_def_sym group_index gs=:{gs_predefs, gs_heaps}
+		# (fun_def, gs_heaps) = buildUndefFunction fun_def_sym group_index gs_predefs gs_heaps
+		= (fun_def, {gs & gs_heaps = gs_heaps})
+		
+	build_instance_type ins_type=:{it_vars, it_types, it_context} (KindArrow kinds) class_glob_def_sym heaps		
+		# type_var_names = ["a" +++ toString i \\ i <- [1 .. (length kinds) - 1]]
+		# (type_vars, heaps) = mapSt buildTypeVar type_var_names heaps
+		# type_var_types = map TV type_vars 	
+		# new_type_args = map makeAType type_var_types
+
+		# (TA type_symb_ident=:{type_arity} type_args) = hd it_types		
+		# new_type = TA	{type_symb_ident & type_arity = type_arity + length new_type_args} (type_args ++ new_type_args)
+		
+		# (new_contexts, heaps) = mapSt (build_type_context class_glob_def_sym) type_var_types heaps
+		
+		# new_ins_type = { ins_type & 
+			it_vars = it_vars ++ type_vars,
+			it_types = [new_type],
+			it_context = it_context ++ new_contexts
+			}
+		= (new_ins_type, heaps)
+			---> new_ins_type
+		
+	build_type_var name heaps=:{hp_type_heaps=hp_type_heaps=:{th_vars}}
+		# (tv_info_ptr, th_vars) = newPtr TVI_Empty th_vars
+		# type_var = {
+			tv_name = {id_name = name, id_info = nilPtr},
+			tv_info_ptr = tv_info_ptr
+			}
+		= (	type_var, {heaps & hp_type_heaps = {hp_type_heaps & th_vars = th_vars}})
+			
+	build_type_context class_glob_def_sym type heaps=:{hp_var_heap}
+		# (var_info_ptr, hp_var_heap) = newPtr VI_Empty hp_var_heap			
+		# type_context = {
+		
+			tc_class = class_glob_def_sym,
+			tc_types = [type],
+			tc_var	 = var_info_ptr
+			}
+		= (type_context, {heaps & hp_var_heap = hp_var_heap})	
+									
+// for all generic instances determine and set types
+// of their functions
+determineMemberTypes :: !Index !Index !*GenericState	
+	-> !*GenericState
+determineMemberTypes module_index ins_index 
+		gs=:{gs_modules, gs_fun_defs, gs_heaps=gs_heaps=:{hp_var_heap, hp_type_heaps}}
+	# (num_modules, gs_modules) = usize gs_modules
+	| module_index == num_modules
+		= {gs & gs_modules = gs_modules}
+	# (common_defs=:{com_instance_defs}, gs_modules) = gs_modules![module_index]		
+	| ins_index == size com_instance_defs
+		= determineMemberTypes (inc module_index) 0 {gs & gs_modules = gs_modules} 		
+	# (instance_def, com_instance_defs) = com_instance_defs![ins_index]
+	| not instance_def.ins_is_generic		
+		= determineMemberTypes module_index (inc ins_index) {gs & gs_modules = gs_modules}
+	
+	# {ins_class, ins_type, ins_members} = instance_def
+	# (class_def, gs_modules) = getClassDef ins_class.glob_module ins_class.glob_object.ds_index gs_modules
+	# (member_def, gs_modules) = getMemberDef ins_class.glob_module class_def.class_members.[0].ds_index gs_modules
+	# {me_type, me_class_vars}  = member_def
+		
+		
+		
+	// determine type of the member instance		
+	# (symbol_type, _, hp_type_heaps) = 
+		determineTypeOfMemberInstance me_type me_class_vars ins_type SP_None hp_type_heaps
+	# (st_context, hp_var_heap) = initializeContextVariables symbol_type.st_context hp_var_heap
+	# symbol_type = {symbol_type & st_context = st_context}			
+	
+	// update the instance function
+	# fun_index = ins_members.[0].ds_index
+	# (fun_def, gs_fun_defs) = gs_fun_defs![fun_index]
+	# fun_def = {fun_def & fun_type = (Yes symbol_type)} 
+
+	# gs_fun_defs = {gs_fun_defs & [fun_index] = fun_def}
+	
+	# gs = { gs & 
+		gs_modules = gs_modules, 
+		gs_fun_defs = gs_fun_defs,
+		gs_heaps = {gs_heaps & hp_type_heaps = hp_type_heaps, hp_var_heap = hp_var_heap} 
+		}
+		---> (symbol_type, 
+				[ tv_name.id_name+++"<"+++toString (ptrToInt tv_info_ptr)+++">" \\ 
+					{tv_name, tv_info_ptr} <- me_type.st_vars],				
+				[ tv_name.id_name+++"<"+++toString (ptrToInt tv_info_ptr)+++">" \\ 
+					{tv_name, tv_info_ptr} <- symbol_type.st_vars])			
+
+	= determineMemberTypes module_index (inc ins_index) gs
+
+kindOfType :: !Type !*TypeDefInfos -> (!TypeKind, !*TypeDefInfos)
+kindOfType (TA type_cons args) td_infos
+	# {glob_object,glob_module} = type_cons.type_index
+	# ({tdi_kinds}, td_infos) = td_infos![glob_module,glob_object] 
+	# kinds = drop (length args) tdi_kinds	
+	| isEmpty kinds 
+		= (KindConst, td_infos) 
+		= (KindArrow (kinds ++ [KindConst]), td_infos)
+kindOfType (TV _) td_infos = (KindConst, td_infos)
+kindOfType (GTV _) td_infos = (KindConst, td_infos)
+kindOfType (TQV _) td_infos = (KindConst, td_infos)
+kindOfType _ td_infos = (KindConst, td_infos)
+			
+buildClassDef :: /*generic*/!(Global DefinedSymbol) !TypeKind !*GenericState
+	-> (/*class*/!(Global DefinedSymbol), !*GenericState)	
+buildClassDef 
+		generic_glob=:{glob_module, glob_object={ds_ident, ds_index}} 
+		kind 
+		gs=:{gs_modules, gs_heaps=gs_heaps=:{hp_type_heaps=hp_type_heaps=:{th_vars}, hp_var_heap}}
+	#! (common_defs=:{com_generic_defs, com_class_defs, com_member_defs}, gs_modules) = gs_modules![glob_module]
+	#! (generic_def=:{gen_name=gen_name=:{id_name}, gen_type, gen_pos, gen_classes}, com_generic_defs) = com_generic_defs![ds_index]
+	
+	// check if the class is already created
+	# (found, class_symbol) = getClassForKind generic_def kind
+	| found 
+		= (	{glob_module = glob_module, glob_object = class_symbol}, 
+			{gs & gs_modules = gs_modules}) 
+
+	#! id_name = id_name +++ ":" +++ (toString kind) 
+	#! ident = {id_name = id_name, id_info = nilPtr}
+
+	// allocate new class and member
+	#! class_index = size com_class_defs
+	#! class_ds = {ds_ident = ident, ds_index = class_index, ds_arity = 1}
+	#! glob_class = {glob_module = glob_module, glob_object = class_ds}	       
+	#! member_index = size com_member_defs
+
+	// class argument
+	#! (tv_info_ptr, th_vars) = newPtr TVI_Empty th_vars 
+	#! class_arg = {tv_name = {id_name = "class_var", id_info = nilPtr}, tv_info_ptr = tv_info_ptr}	
+
+	// member
+	#! (type_ptr, hp_var_heap) = newPtr VI_Empty hp_var_heap 
+	#! (tc_var_ptr, hp_var_heap) = newPtr VI_Empty hp_var_heap  
+	#! type_context = { 
+		tc_class = glob_class,
+		tc_types = [ TV class_arg ], 
+		tc_var = tc_var_ptr 				// ???
+		}
+	#! hp_type_heaps = {hp_type_heaps & th_vars = th_vars}	
+	#! (member_type, hp_type_heaps) = buildMemberType generic_def kind class_arg hp_type_heaps
+	#! member_type = { member_type & st_context = [type_context : gen_type.st_context] }
+	#! member_def = {
+		me_symb = ident,
+		me_class = {glob_module = glob_module, glob_object = class_index},
+		me_offset = 0,
+		me_type = member_type,
+		me_type_ptr = type_ptr,				// empty
+		me_class_vars = [class_arg], 		// the same variable as in the class
+		me_pos = gen_pos,
+		me_priority = NoPrio
+		}
+	
+	// class
+	#! class_member = {ds_ident=ident, ds_index = member_index, ds_arity = member_def.me_type.st_arity}
+	#! class_dictionary = { 
+		ds_ident = {id_name = id_name, id_info = nilPtr}, 
+		ds_arity = 0, 
+		ds_index = NoIndex/*index in the type def table, filled in later*/ 
+		}
+	#! class_def = { 
+		class_name = ident, 
+		class_arity = 1,  
+		class_args = [class_arg],
+	    class_context = [], 
+	    class_pos = gen_pos, 
+	    class_members = createArray 1 class_member, 
+	    class_cons_vars = case kind of KindConst -> 0; _ -> 1,
+	    class_dictionary = class_dictionary
+	    }	 
+	    
+	#! com_class_defs = append_array com_class_defs class_def
+	#! com_member_defs = append_array com_member_defs member_def	
+	#! generic_def = {generic_def & gen_classes = [class_ds : gen_classes] }
+	#! com_generic_defs = {(copy_array com_generic_defs) & [ds_index] = generic_def}
+	#! common_defs = {common_defs & 
+		com_class_defs = com_class_defs, 
+		com_generic_defs = com_generic_defs, 
+		com_member_defs = com_member_defs}	
+	#! gs_modules = {gs_modules & [glob_module] = common_defs} 
+	#! gs = { gs &
+		gs_modules = gs_modules,
+		gs_heaps = { gs_heaps & hp_type_heaps = hp_type_heaps, hp_var_heap = hp_var_heap}
+		}		
+	= (glob_class, gs) 
+		---> ("generated class " +++ id_name)
+where
+	append_array array el = arrayConcat array {el}
+	copy_array array = {x \\ x <-: array}	
+
+// create an instance of a polykinded (generic) type of a given kind
+buildMemberType :: !GenericDef !TypeKind !TypeVar !*TypeHeaps -> (!SymbolType, !*TypeHeaps)
+buildMemberType generic_def=:{gen_name,gen_type,gen_args} kind class_var type_heaps 
+	// each generic type variable is replaced by the class var
+	#! class_vars = repeatn (length gen_args) class_var		
+
+	// each free type variable is substitued by a fresh var
+	#! (fresh_st_vars, type_heaps) = mapSt subst_fresh_type_var gen_type.st_vars type_heaps 
+
+	// each generic variable is substituted by generic application
+	#! (gen_type, type_heaps) = generate_member_type gen_type gen_args kind class_vars type_heaps
+
+	#! (fresh_st_args, type_heaps) = substitute gen_type.st_args type_heaps
+	#! (fresh_st_result, type_heaps) = substitute gen_type.st_result type_heaps	
+	
+	#! gen_type = {gen_type &
+		st_vars = gen_type.st_vars ++ fresh_st_vars,
+		st_args = fresh_st_args,
+		st_result = fresh_st_result
+		}
+
+	= (gen_type, type_heaps)
+
+where		
+	generate_member_type :: !SymbolType ![TypeVar] !TypeKind ![TypeVar] !*TypeHeaps -> (!SymbolType, !*TypeHeaps)
+	generate_member_type 
+			gen_type gen_args 
+			kind class_vars type_heaps
+		#! (gen_type_varss, type_heaps) = subst_generic_vars gen_args class_vars kind type_heaps
+		#! (fresh_st_args, type_heaps) = substitute gen_type.st_args type_heaps
+		#! (fresh_st_result, type_heaps) = substitute gen_type.st_result type_heaps	
+
+		#! gen_type_varss = transpose gen_type_varss
+		#! (arg_types, type_heaps) = generate_args gen_type gen_args kind gen_type_varss type_heaps
+		#! generated_symbol_type = {gen_type & 
+			st_vars = (removeDup class_vars) ++ (flatten gen_type_varss), 
+			st_args = arg_types ++ fresh_st_args,
+			st_arity = gen_type.st_arity + (length arg_types), 
+			st_result = fresh_st_result
+			}
+		= (generated_symbol_type, type_heaps)
+			//---> ("generated member type", type)
+			
+	subst_generic_vars :: ![TypeVar] ![TypeVar] !TypeKind !*TypeHeaps -> (![[TypeVar]], !*TypeHeaps) 
+	subst_generic_vars [] [] _ type_heaps = ([], type_heaps)
+	subst_generic_vars [type_var:type_vars] [class_var:class_vars] kind type_heaps
+		# (new_type_vars, type_heaps) = subst_generic_var type_var class_var kind type_heaps
+		# (new_type_varss, type_heaps) = subst_generic_vars type_vars class_vars kind type_heaps
+		= ([new_type_vars : new_type_varss], type_heaps)
+	subst_generic_vars _ _ _ type_heaps 
+		= abort "inconsistent number of type variables to be substituted"
+	
+	// create substitution of variable for cons var application
+	// a => (t a1 .. ak), where k is arity of kind	
+	subst_generic_var :: !TypeVar !TypeVar !TypeKind !*TypeHeaps -> (![TypeVar], !*TypeHeaps)
+	subst_generic_var type_var type_cons_var KindConst type_heaps=:{th_vars}
+		# th_vars = th_vars <:= (type_var.tv_info_ptr, TVI_Type (TV type_cons_var))
+		= ([], {type_heaps & th_vars = th_vars})
+			//---> ("subst var for kind *", type_var, type_cons_var) 		
+	subst_generic_var type_var type_cons_var kind=:(KindArrow kinds) type_heaps=:{th_vars}
+		# (new_vars, th_vars) = fresh_type_vars ((length kinds) - 1) type_var th_vars
+		# type = (CV type_cons_var) :@: (map (\tv -> makeAType (TV tv)) new_vars)
+		# th_vars = th_vars <:= (type_var.tv_info_ptr, TVI_Type type)
+		= (new_vars, {type_heaps & th_vars = th_vars})
+			//---> ("subst var for kind " +++ toString kind, type_var, type) 		
+				 										
+	fresh_type_vars :: !Int !TypeVar !*TypeVarHeap -> (![TypeVar], !*TypeVarHeap)
+	fresh_type_vars num type_var th_vars
+		= mapSt (\i st->fresh_var i type_var st) [1..num] th_vars
+		where 
+			fresh_var i type_var th_vars
+				# id_name = type_var.tv_name.id_name +++ "_" +++ (toString i)
+				# (tv_info_ptr, th_vars) = newPtr TVI_Empty th_vars 
+				# var = {tv_name = {id_name = id_name, id_info = nilPtr}, tv_info_ptr = tv_info_ptr}	
+				= (var, th_vars)
+
+	subst_fresh_type_var :: !TypeVar !*TypeHeaps -> (!TypeVar, !*TypeHeaps) 
+	subst_fresh_type_var type_var=:{tv_name,tv_info_ptr} type_heaps=:{th_vars}
+		# (new_tv_info_ptr, th_vars) = newPtr TVI_Empty th_vars 
+		# new_type_var = {tv_name={id_name=tv_name.id_name,id_info=nilPtr}, tv_info_ptr = new_tv_info_ptr }
+		//# th_vars = writePtr tv_info_ptr (TVI_Type (TV new_type_var)) th_vars
+		# th_vars = th_vars <:= (tv_info_ptr, TVI_Type (TV new_type_var))
+		= (new_type_var, {type_heaps & th_vars = th_vars})
+
+	// generate additional arguments that appear due to lifting
+	generate_args :: !SymbolType ![TypeVar] !TypeKind ![[TypeVar]] !*TypeHeaps -> (![AType], !*TypeHeaps)				
+	generate_args gen_type gen_args KindConst _ type_heaps 
+		= ([], type_heaps)
+	generate_args gen_type gen_args (KindArrow kinds) type_varss type_heaps
+		= generate gen_type gen_args (init kinds) type_varss type_heaps
+	where
+		generate gen_type gen_args [] [] type_heaps = ([], type_heaps)
+		generate gen_type gen_args [kind:kinds] [type_vars:type_varss] type_heaps
+			# (symbol_type, type_heaps) = generate_member_type gen_type gen_args kind type_vars type_heaps
+				//---> ("generate arg for kind " +++ toString kind, type_vars)
+			# type = symbol_type_to_atype symbol_type					
+			# (types, type_heaps) = generate gen_type gen_args kinds type_varss type_heaps
+			= ([type:types], type_heaps)
+		generate gen_type gen_args kinds type_varss type_heaps 
+			= abort "inconsistent kind and type var lists"   
+
+	symbol_type_to_atype :: SymbolType -> AType 
+	symbol_type_to_atype {st_args, st_result}
+		= foldr (\x y -> makeAType (x --> y)) st_result st_args
+
+		 
+buildGenericRepType :: !TypeRhs !PredefinedSymbols !CommonDefs 
+	-> AType
+buildGenericRepType (AlgType alts) predefs common_defs
+	= build_sum alts predefs common_defs.com_cons_defs
+where
+	build_sum :: ![DefinedSymbol] !PredefinedSymbols !{#ConsDef} -> !AType
+	build_sum [] predefs cons_defs = abort "no alternatives in typedef"
+	build_sum [{ds_index}] predefs cons_defs
+		#  cons_args = cons_defs.[ds_index].cons_type.st_args		
+		= buildProductType cons_args predefs 
+	build_sum alts predefs cons_defs 
+		# (l,r) = splitAt ((length alts) / 2) alts 
+		= buildATypeEITHER (build_sum l predefs cons_defs) (build_sum r predefs cons_defs) predefs
+			
+buildGenericRepType (RecordType {rt_constructor={ds_index}}) predefs common_defs
+	# {cons_type={st_args}} = common_defs . com_cons_defs . [ds_index]
+	= buildProductType st_args predefs
+
+buildGenericRepType (SynType type) predefs common_defs
+	= type // is that correct ???
+
+buildGenericRepType (AbstractType _) predefs common_defs
+	= abort "can not create generic representation of an abstract type" 
+		
+buildGenericRepType _ predefs cons_defs 
+	= abort "cannot generate generic type represenation of this type"
+
+			
+buildIsoRecord :: !DefinedSymbol !Int !DefinedSymbol !DefinedSymbol !*GenericState
+	-> (!FunDef, !*GenericState)
+buildIsoRecord 
+		def_sym group_index from_fun to_fun 
+		gs=:{gs_heaps, gs_main_dcl_module_n, gs_predefs}
+	# (from_expr, gs_heaps) 	= buildFunApp gs_main_dcl_module_n from_fun [] gs_heaps
+	# (to_expr, gs_heaps) 		= buildFunApp gs_main_dcl_module_n to_fun [] gs_heaps	
+	# (iso_expr, gs_heaps) 		= buildISO to_expr from_expr gs_predefs gs_heaps
+	# fun_def = makeFunction def_sym group_index [] iso_expr No [] [from_fun.ds_index, to_fun.ds_index]					
+	= (fun_def, {gs & gs_heaps = gs_heaps})
+where
+	build_fun_expr mod_index fun_def heaps=:{hp_expression_heap}
+		# (expr_info_ptr, hp_expression_heap) = newPtr EI_Empty hp_expression_heap
+		# global_index = {glob_module = mod_index/*gs_maindcl_module_n???*/, glob_object = fun_def.fun_index}
+		# fun_symb = {
+			symb_name = fun_def.fun_symb, 
+			symb_kind = SK_Function global_index, 
+			symb_arity = 0 //fun_def.fun_arity 
+			}
+		# fun_expr = App {app_symb = fun_symb, app_args = [], app_info_ptr = expr_info_ptr}	
+		= (fun_expr, {heaps & hp_expression_heap = hp_expression_heap})
+
+// convert a type to ot's generic representation
+buildIsoTo :: !DefinedSymbol !Int !Int !CheckedTypeDef !*GenericState
+	-> (!FunDef, !*GenericState)
+buildIsoTo 
+		def_sym group_index type_def_mod 
+		type_def=:{td_rhs, td_name, td_index} 
+		gs=:{gs_heaps, gs_predefs}
+	# (arg_expr, arg_var, gs_heaps) = buildVarExpr "x" gs_heaps 
+	# (body_expr, free_vars, gs_heaps) = build_body type_def_mod td_index td_rhs arg_expr gs_predefs gs_heaps	
+	# fun_def = makeFunction def_sym group_index [arg_var] body_expr No free_vars []	
+	= (fun_def, {gs & gs_heaps = gs_heaps})
+		//---> fun_def
+where
+	build_body :: !Int !Int !TypeRhs !Expression !PredefinedSymbols !*Heaps 
+		-> (!Expression, ![FreeVar], !*Heaps)
+ 	build_body type_def_mod type_def_index (AlgType def_symbols) arg_expr predefs heaps
+		= build_body1 type_def_mod type_def_index def_symbols arg_expr predefs heaps
+	
+	build_body type_def_mod type_def_index (RecordType {rt_constructor}) arg_expr predefs heaps		
+		= build_body1 type_def_mod type_def_index [rt_constructor] arg_expr predefs heaps
+
+	build_body type_def_mod type_def_index (AbstractType _) arg_expr predefs heaps
+		= abort "cannot build isomorphisms for an abstract type\n" 			 	
+	build_body type_def_mod type_def_index _ arg_expr predefs heaps
+		= abort "building isomorphisms for this type is not supported\n"
+	
+	build_body1 type_def_mod type_def_index def_symbols arg_expr predefs heaps
+		# (case_alts, free_vars, heaps) = 
+			build_alts 0 (length def_symbols) type_def_mod def_symbols predefs heaps
+		# case_patterns = AlgebraicPatterns {glob_module = type_def_mod, glob_object = type_def_index} case_alts
+		# (case_expr, heaps) = buildCaseExpr arg_expr case_patterns heaps
+		= (case_expr, free_vars, heaps)	
+			//---> (free_vars, case_expr)	
+				
+	build_alts :: !Int !Int !Int ![DefinedSymbol] PredefinedSymbols !*Heaps 
+		-> ([AlgebraicPattern], [FreeVar], !*Heaps)
+	build_alts i n type_def_mod [] predef heaps = ([], [], heaps) 
+	build_alts i n type_def_mod [def_symbol:def_symbols] predefs heaps
+		# (alt, fvs, heaps) = build_alt i n type_def_mod def_symbol predefs heaps
+		# (alts, free_vars, heaps) =  build_alts (i+1) n type_def_mod def_symbols predefs heaps 		
+		= ([alt:alts], fvs ++ free_vars, heaps)
+
+	build_alt :: !Int !Int !Int !DefinedSymbol PredefinedSymbols !*Heaps 
+		-> (AlgebraicPattern, [FreeVar], !*Heaps)
+	build_alt i n type_def_mod def_symbol=:{ds_ident, ds_arity} predefs heaps		
+		# names = ["x" +++ toString (i+1) +++ toString k \\ k <- [1..ds_arity]]
+		# (var_exprs, vars, heaps) = buildVarExprs names heaps 
+		# (expr, heaps) = build_prod var_exprs predefs heaps
+		# (expr, heaps) = build_sum i n expr predefs heaps
+				
+		# alg_pattern = {
+			ap_symbol = {glob_module = type_def_mod, glob_object = def_symbol},
+			ap_vars = vars,
+			ap_expr = expr,
+			ap_position = NoPos
+			}
+		= (alg_pattern, vars, heaps)
+
+	build_sum :: !Int !Int !Expression !PredefinedSymbols !*Heaps -> (!Expression, !*Heaps)
+	build_sum i n expr predefs heaps
+		| n == 0 	= abort "build sum of zero elements\n"
+		| i >= n	= abort "error building sum"
+		| n == 1 	= (expr, heaps)
+		| i < (n/2) 
+			# (expr, heaps) = build_sum i (n/2) expr predefs heaps
+			= buildLEFT expr predefs heaps
+		| otherwise
+			# (expr, heaps) = build_sum (i - (n/2)) (n - (n/2)) expr predefs heaps
+			= buildRIGHT expr predefs heaps
+
+	build_prod :: ![Expression] !PredefinedSymbols !*Heaps -> (!Expression, !*Heaps)
+	build_prod [] predefs heaps = buildUNIT predefs heaps 
+	build_prod [expr] predefs heaps = (expr, heaps)
+	build_prod exprs predefs heaps
+		# (lexprs, rexprs) = splitAt ((length exprs)/2) exprs  
+		# (lexpr, heaps) = build_prod lexprs predefs heaps
+		# (rexpr, heaps) = build_prod rexprs predefs heaps
+		= buildPAIR lexpr rexpr predefs heaps
+
+// convert from generic representation to type
+buildIsoFrom :: !DefinedSymbol !Int !Int !CheckedTypeDef !*GenericState
+	-> (!FunDef, !*GenericState)
+buildIsoFrom 
+		def_sym group_index type_def_mod 
+		type_def=:{td_rhs, td_name, td_index} 
+		gs=:{gs_predefs, gs_heaps}
+	# (body_expr, free_vars, gs_heaps) = build_body type_def_mod td_rhs gs_predefs gs_heaps
+	# [arg_var: free_vars] = free_vars	
+	# fun_def = makeFunction def_sym group_index [arg_var] body_expr No free_vars []	
+	= (fun_def, {gs & gs_heaps = gs_heaps} )
+		//---> fun_def
+where	
+	build_body :: !Int !TypeRhs !PredefinedSymbols !*Heaps 
+		-> (!Expression, ![FreeVar], !*Heaps)
+ 	build_body type_def_mod (AlgType def_symbols) predefs heaps
+		= build_sum type_def_mod def_symbols predefs heaps
+	build_body type_def_mod (RecordType {rt_constructor}) predefs heaps				
+		= build_sum type_def_mod [rt_constructor] predefs heaps	
+	build_body type_def_mod (AbstractType _) predefs heaps
+		= abort "cannot build isomorphisms for an abstract type\n" 			 	
+	build_body type_def_mod _ predefs heaps
+		= abort "builing isomorphisms for this is not supported\n"
+
+	build_sum :: !Index [DefinedSymbol] !PredefinedSymbols !*Heaps
+		-> (!Expression, ![FreeVar], !*Heaps)
+	build_sum type_def_mod [] predefs heaps
+		= abort "algebraic type with no constructors!\n"
+	build_sum type_def_mod [def_symbol] predefs heaps
+		# (cons_app_expr, cons_args, heaps) = build_cons_app type_def_mod def_symbol heaps
+		# (alt_expr, free_vars, heaps) = build_prod cons_app_expr cons_args predefs heaps 
+		= (alt_expr, free_vars, heaps)
+	build_sum type_def_mod def_symbols predefs heaps
+		# (var_expr, var, heaps) = buildVarExpr "e" heaps
+		# (left_def_symbols, right_def_symbols) = splitAt ((length def_symbols) /2) def_symbols
+	
+		# (left_expr, left_vars, heaps) = build_sum type_def_mod left_def_symbols predefs heaps
+		# (right_expr, right_vars, heaps) = build_sum type_def_mod right_def_symbols predefs heaps
+	
+		# (case_expr, heaps) = 
+			buildCaseEITHERExpr var_expr (hd left_vars, left_expr) (hd right_vars, right_expr) predefs heaps
+		# vars = [var : left_vars ++ right_vars]
+		= (case_expr, vars, heaps)
+	
+	build_prod :: !Expression ![FreeVar] !PredefinedSymbols !*Heaps
+		-> (!Expression, ![FreeVar], !*Heaps)
+	build_prod expr [] predefs heaps
+		# (var_expr, var, heaps) = buildVarExpr "x" heaps 
+		# (case_expr, heaps) = buildCaseUNITExpr var_expr expr predefs heaps	
+		= (case_expr, [var], heaps)
+	build_prod expr [cons_arg_var] predefs heaps
+		= (expr, [cons_arg_var], heaps)	
+	build_prod expr cons_arg_vars predefs heaps
+		# (var_expr, var, heaps) = buildVarExpr "p" heaps
+		# (left_vars, right_vars) = splitAt ((length cons_arg_vars) /2) cons_arg_vars
+		 
+		# (expr, left_vars, heaps) = build_prod expr left_vars predefs heaps
+		# (expr, right_vars, heaps) = build_prod expr right_vars predefs heaps
+		
+		# (case_expr, heaps) = buildCasePAIRExpr var_expr (hd left_vars) (hd right_vars) expr predefs heaps
+		
+		# vars = [var : left_vars ++ right_vars]	
+		= (case_expr, vars, heaps) 
+	
+	build_cons_app :: !Index !DefinedSymbol !*Heaps 
+		-> (!Expression, [FreeVar], !*Heaps)
+	build_cons_app cons_mod def_symbol=:{ds_arity} heaps
+		# names = ["x"  +++ toString k \\ k <- [1..ds_arity]]
+		# (var_exprs, vars, heaps) = buildVarExprs names heaps 
+		# (expr, heaps) = buildConsApp cons_mod def_symbol var_exprs heaps
+		= (expr, vars, heaps) 
+
+buildIsomapFromTo :: !IsoDirection !DefinedSymbol !Int !Int !Int !*GenericState
+	-> (!FunDef, !*GenericState)
+buildIsomapFromTo 
+		iso_dir def_sym group_index type_def_mod type_def_index 
+		gs=:{gs_heaps, gs_modules}
+	# (type_def=:{td_name, td_index, td_arity}, gs_modules) 
+		= getTypeDef type_def_mod type_def_index gs_modules
+	# arg_names = [ "isomap" +++ toString n \\ n <- [1 .. td_arity]]
+	# (isomap_arg_vars, gs_heaps) = buildFreeVars arg_names gs_heaps 
+	# (arg_expr, arg_var, gs_heaps) = buildVarExpr "x" gs_heaps
+	# gs = {gs & gs_heaps = gs_heaps, gs_modules = gs_modules}
+	# (body_expr, free_vars, gs) = 
+		build_body iso_dir type_def_mod td_index type_def arg_expr isomap_arg_vars gs	
+
+	# (fun_type, gs) = build_type iso_dir type_def_mod type_def_index gs
+	# fun_def = makeFunction def_sym group_index (isomap_arg_vars ++ [arg_var]) body_expr (Yes fun_type) free_vars []	
+	= (fun_def, gs)
+where
+	build_body :: !IsoDirection !Int !Int !CheckedTypeDef !Expression ![FreeVar] !*GenericState
+		-> (Expression, [FreeVar], !*GenericState)
+	build_body iso_dir type_def_mod type_def_index type_def=:{td_rhs=(AlgType def_symbols)} arg_expr isomap_arg_vars gs
+		= build_body1 iso_dir type_def_mod type_def_index type_def def_symbols arg_expr isomap_arg_vars gs
+		
+	build_body iso_dir type_def_mod type_def_index type_def=:{td_rhs=(RecordType {rt_constructor})} arg_expr isomap_arg_vars gs
+		= build_body1 iso_dir type_def_mod type_def_index type_def [rt_constructor] arg_expr isomap_arg_vars gs
+				
+	build_body iso_dir type_def_mod type_def_index _ arg_expr isomap_arg_vars gs
+		= abort "cannot generate isomap for the type"		
+
+	build_body1 iso_dir type_def_mod type_def_index type_def def_symbols arg_expr isomap_arg_vars gs
+		# (case_alts, free_vars, gs=:{gs_heaps}) = 
+			build_alts iso_dir 0 (length def_symbols) type_def_mod def_symbols isomap_arg_vars type_def gs
+		# case_patterns = AlgebraicPatterns {glob_module = type_def_mod, glob_object = type_def_index} case_alts
+		# (case_expr, gs_heaps) = buildCaseExpr arg_expr case_patterns gs_heaps
+		= (case_expr, free_vars, {gs & gs_heaps = gs_heaps})
+
+	build_alts :: !IsoDirection !Int !Int !Int ![DefinedSymbol] ![FreeVar] !CheckedTypeDef !*GenericState 
+		-> ([AlgebraicPattern], [FreeVar], !*GenericState)
+	build_alts iso_dir i n type_def_mod [] arg_vars type_def gs 
+		= ([], [], gs) 
+	build_alts iso_dir i n type_def_mod [def_symbol:def_symbols] arg_vars type_def gs
+		# (alt, fvs, gs) = build_alt iso_dir i n type_def_mod def_symbol arg_vars type_def gs
+		# (alts, free_vars, gs) = build_alts iso_dir (i+1) n type_def_mod def_symbols arg_vars type_def gs 		
+		= ([alt:alts], fvs ++ free_vars, gs)
+
+	build_alt :: !IsoDirection !Int !Int !Int !DefinedSymbol ![FreeVar] !CheckedTypeDef !*GenericState 
+		-> (AlgebraicPattern, [FreeVar], !*GenericState)
+	build_alt 
+			iso_dir i n type_def_mod def_symbol=:{ds_ident, ds_arity, ds_index} 
+			fun_arg_vars type_def gs=:{gs_heaps, gs_modules}		
+		# names = ["x" +++ toString (i+1) +++ toString k \\ k <- [1..ds_arity]]
+		# (cons_arg_vars, gs_heaps) = buildFreeVars names gs_heaps
+		# (cons_def=:{cons_type}, gs_modules) = getConsDef type_def_mod ds_index gs_modules 				
+		# gs = {gs & gs_heaps = gs_heaps, gs_modules = gs_modules}
+		
+		# (cons_arg_exprs, gs=:{gs_heaps}) = 
+			build_cons_args iso_dir cons_type.st_args cons_arg_vars fun_arg_vars type_def gs 
+		# (expr, gs_heaps) = buildConsApp type_def_mod def_symbol cons_arg_exprs gs_heaps				
+		# alg_pattern = {
+			ap_symbol = {glob_module = type_def_mod, glob_object = def_symbol},
+			ap_vars = cons_arg_vars,
+			ap_expr = expr,
+			ap_position = NoPos
+			}
+		= (alg_pattern, cons_arg_vars, {gs & gs_heaps = gs_heaps})
+	
+	build_cons_args :: !IsoDirection ![AType] ![FreeVar] ![FreeVar] !CheckedTypeDef !*GenericState 
+		-> ([!Expression], !*GenericState)
+	build_cons_args iso_dir [] [] fun_arg_vars type_def gs = ([], gs) 	
+	build_cons_args	iso_dir [arg_type:arg_types] [cons_arg_var:cons_arg_vars] fun_arg_vars type_def gs
+		# (arg_expr, gs) = build_cons_arg iso_dir arg_type cons_arg_var fun_arg_vars type_def gs
+		# (arg_exprs, gs) = build_cons_args iso_dir arg_types cons_arg_vars fun_arg_vars type_def gs 
+		= ([arg_expr : arg_exprs], gs)
+	
+	build_cons_arg :: !IsoDirection !AType !FreeVar ![FreeVar] !CheckedTypeDef !*GenericState 
+		-> (!Expression, !*GenericState)	
+	build_cons_arg iso_dir type cons_arg_var fun_vars type_def gs
+		# type_def_args = [atv_variable \\ {atv_variable} <- type_def.td_args]	
+		# (iso_expr, gs) = buildIsomapExpr type type_def_args fun_vars gs
+		# {gs_heaps, gs_predefs} = gs
+		# sel_expr = case iso_dir of 
+			IsoTo 	-> buildIsoToSelectionExpr iso_expr gs_predefs  
+			IsoFrom -> buildIsoFromSelectionExpr iso_expr gs_predefs  
+ 		# (cons_var_expr, _, gs_heaps) = buildBoundVarExpr cons_arg_var gs_heaps
+		= (sel_expr @ [cons_var_expr], {gs & gs_heaps = gs_heaps})
+
+
+	build_type :: !IsoDirection !Int !Int !*GenericState
+		-> (!SymbolType, !*GenericState)
+	build_type 
+			iso_dir module_index type_def_index 
+			gs=:{gs_heaps, gs_modules, gs_predefs}
+	
+		#! ({td_arity, td_name}, gs_modules) = getTypeDef module_index type_def_index gs_modules 		
+	
+		# (arg_types, tvs1, tvs2, gs_heaps) = build_arg_types gs_predefs [1 .. td_arity] gs_heaps
+						
+		# type_symb_ident = {
+			type_name = td_name,
+			type_index = { glob_module = module_index, glob_object = type_def_index },
+			type_arity = td_arity,
+			type_prop = { 
+				tsp_sign = {sc_pos_vect=cAllBitsClear, sc_neg_vect=cAllBitsClear},
+				tsp_propagation = cAllBitsClear, 
+				tsp_coercible = False
+				}
+			}				
+		# type1 = makeAType (TA type_symb_ident (map (makeAType o TV) tvs1))  
+		# type2 = makeAType (TA type_symb_ident (map (makeAType o TV) tvs2)) 
+		# (arg_type, res_type) = case iso_dir of
+			IsoTo 	-> (type1, type2)
+			IsoFrom -> (type2, type1)
+			 
+		# symbol_type = {
+			st_vars = tvs1 ++ tvs2,
+			st_args = arg_types ++ [arg_type],
+			st_arity = td_arity + 1,
+			st_result = res_type,
+			st_context = [],
+			st_attr_vars = [],
+			st_attr_env = []
+			}
+		#! gs = {gs & gs_heaps = gs_heaps, gs_modules = gs_modules}
+		= (symbol_type, gs)
+	 	
+	build_arg_type predefs arg_no heaps
+		# (type_var1, heaps) = buildTypeVar ("a"+++toString arg_no) heaps
+		# type1 = makeAType (TV type_var1)
+		# (type_var2, heaps) = buildTypeVar ("b"+++toString arg_no) heaps
+		# type2 = makeAType (TV type_var2)
+		# iso_type = buildATypeISO type1 type2 predefs 
+		= (iso_type, type_var1, type_var2, heaps)
+		
+	build_arg_types predefs [] heaps
+		= ([], [], [], heaps)
+	build_arg_types predefs [n:ns] heaps
+		# (t, tv1, tv2, heaps) = build_arg_type predefs n heaps
+		# (ts, tvs1, tvs2, heaps) = build_arg_types predefs ns heaps
+		= ([t:ts], [tv1:tvs1], [tv2:tvs2], heaps)	
+
+buildIsomapForTypeDef :: !DefinedSymbol !Int !Int !CheckedTypeDef !DefinedSymbol !DefinedSymbol !*GenericState
+	-> (!FunDef, !*GenericState)
+buildIsomapForTypeDef	
+		fun_def_sym group_index type_def_mod 
+		type_def=:{td_name, td_index, td_arity}
+		from_fun to_fun 
+		gs=:{gs_main_dcl_module_n, gs_heaps, gs_predefs}	 
+	# arg_names = [ "iso" +++ toString n \\ n <- [1 .. td_arity]]  
+	# (arg_exprs, arg_vars, gs_heaps) = buildVarExprs arg_names gs_heaps
+		
+	# (from_expr, gs_heaps) = buildFunApp gs_main_dcl_module_n from_fun arg_exprs gs_heaps
+	# (to_expr, gs_heaps) 	= buildFunApp gs_main_dcl_module_n to_fun arg_exprs gs_heaps	
+	# (iso_expr, gs_heaps) 	= buildISO to_expr from_expr gs_predefs gs_heaps
+	# fun_def = makeFunction fun_def_sym group_index arg_vars iso_expr No [] [from_fun.ds_index, to_fun.ds_index]					
+	= (fun_def, {gs & gs_heaps = gs_heaps})
+
+buildIsomapForGeneric :: !DefinedSymbol !Int !GenericDef !*GenericState
+	-> (!FunDef, !*GenericState)
+buildIsomapForGeneric def_sym group_index {gen_type, gen_arity, gen_args} gs=:{gs_heaps}
+	#! arg_names = [ "iso" +++ toString n \\ n <- [1 .. gen_arity]]
+	#! (arg_vars, gs_heaps) = buildFreeVars arg_names gs_heaps
+	#! type = curry_symbol_type gen_type
+	#! (body_expr, gs) = buildIsomapExpr type gen_args arg_vars {gs & gs_heaps = gs_heaps} 	
+	#! fun_def = makeFunction def_sym group_index arg_vars body_expr No [] []					
+	= (fun_def, gs) 	
+where 	
+	curry_symbol_type :: SymbolType -> AType 
+	curry_symbol_type {st_args, st_result} 
+		#(type, _, _) = buildCurriedType st_args st_result TA_None [] 0
+		= type
+
+// expression that does mapping of a type
+buildIsomapExpr :: !AType ![TypeVar] ![FreeVar] !*GenericState
+	-> (!Expression, !*GenericState)
+buildIsomapExpr {at_type} arg_type_vars arg_vars gs
+	= build_expr at_type arg_type_vars arg_vars gs	
+where
+
+	build_expr :: !Type ![TypeVar] ![FreeVar] !*GenericState
+		-> (!Expression, !*GenericState)
+	build_expr (TA {type_index, type_name} args) arg_type_vars arg_vars gs
+		# (arg_exprs, gs) = build_exprs args arg_type_vars arg_vars gs
+		# {gs_heaps, gs_main_dcl_module_n, gs_gtd_infos} = gs			
+		# (gtd_info, gs_gtd_infos) = gs_gtd_infos ! [type_index.glob_module, type_index.glob_object]		
+		# gt = case gtd_info of
+			 		(GTDI_Generic gt) -> gt
+			 		_ 	-> abort ("not a generic type " +++ type_name.id_name) 
+		# (expr, gs_heaps) = buildFunApp gs_main_dcl_module_n gt.gt_isomap arg_exprs gs_heaps			
+		= (expr, {gs & gs_heaps = gs_heaps, gs_gtd_infos = gs_gtd_infos})
+	
+	build_expr (arg --> res) arg_type_vars arg_vars gs
+		# (arg_expr, gs) = buildIsomapExpr arg arg_type_vars arg_vars gs
+		# (res_expr, gs) = buildIsomapExpr res arg_type_vars arg_vars gs				
+		# {gs_heaps, gs_main_dcl_module_n, gs_predefs} = gs		
+		# (expr, gs_heaps) = buildIsomapArrowApp arg_expr res_expr gs_predefs gs_heaps
+		= (expr, {gs & gs_heaps = gs_heaps})
+
+	build_expr (cons_var :@: args) arg_type_vars arg_vars gs
+		# (arg_exprs, gs) = build_exprs args arg_type_vars arg_vars gs
+		# type_var = case cons_var of
+			CV type_var -> type_var
+			_ -> abort "cons_var not implemented\n"
+		# (cons_var_expr, gs) = build_expr_for_type_var type_var arg_type_vars arg_vars gs
+		= (cons_var_expr @ arg_exprs, gs)
+
+	build_expr (TB baric_type) arg_type_vars arg_vars gs=:{gs_predefs, gs_heaps}		
+		# (expr, gs_heaps) = buildIsomapIdApp gs_predefs gs_heaps
+		= (expr, {gs & gs_heaps = gs_heaps})
+						
+	build_expr (TV type_var) arg_type_vars arg_vars gs
+		= build_expr_for_type_var type_var arg_type_vars arg_vars gs
+	build_expr (GTV type_var) arg_type_vars arg_vars gs
+		= build_expr_for_type_var type_var arg_type_vars arg_vars gs 
+	build_expr (TQV type_var) arg_type_vars arg_vars gs
+		= build_expr_for_type_var type_var arg_type_vars arg_vars gs 
+	build_expr (TLifted type_var) arg_type_vars arg_vars gs
+		= build_expr_for_type_var type_var arg_type_vars arg_vars gs 
+
+	build_expr _ arg_type_vars arg_vars gs
+		= abort "type does not match\n"
+	
+	build_exprs [] arg_type_vars arg_vars gs 
+		= ([], gs)
+	build_exprs [type:types] arg_type_vars arg_vars gs
+		# (expr, gs) = buildIsomapExpr type arg_type_vars arg_vars gs
+		# (exprs, gs) = build_exprs types arg_type_vars arg_vars gs
+		= ([expr:exprs], gs)
+			 			
+	build_expr_for_type_var type_var arg_type_vars arg_vars gs=:{gs_predefs, gs_heaps}
+		# (var_expr, gs_heaps) = buildExprForTypeVar type_var arg_type_vars arg_vars gs_predefs gs_heaps 
+		= (var_expr, {gs & gs_heaps = gs_heaps})
+	
+buildInstance :: !DefinedSymbol !Int !ClassInstance !GenericDef !*GenericState
+	-> (!FunDef, !*GenericState)
+buildInstance 
+		def_sym group_index 
+		instance_def=:{ins_type, ins_generic} 
+		generic_def=:{gen_name, gen_type, gen_isomap} 
+		gs=:{gs_heaps}	
+
+	#! original_arity 	= gen_type.st_arity
+	#! generated_arity 	= def_sym.ds_arity - original_arity // depends on kind
+	
+	#! generated_arg_names = [ "f"/*gen_name.id_name*/ +++ toString n \\ n <- [1 .. generated_arity]]
+	#! (generated_arg_vars, gs_heaps) = buildFreeVars generated_arg_names gs_heaps	
+	#! original_arg_names = 	[ "x" +++ toString n \\ n <- [1 .. original_arity]]  
+	#! (original_arg_exprs, original_arg_vars, gs_heaps) = buildVarExprs original_arg_names gs_heaps	
+	#! arg_vars = generated_arg_vars ++ original_arg_vars
+	
+	#! (gt=:{gt_type, gt_type_args}, gs) = get_generic_type ins_type {gs & gs_heaps = gs_heaps } 	
+	#! gen_glob_def_sym = {
+		glob_module = ins_generic.glob_module,
+		glob_object = {
+			ds_ident = gen_name,
+			ds_index = ins_generic.glob_object,
+			ds_arity = 0
+			}
+		} 
+		
+	#! (adaptor_expr, gs)	 = build_adaptor_expr gt gen_isomap gs  
+		---> ("generic type", gt_type)
+	#! (instance_expr, gs)	 = build_instance_expr gt_type gt_type_args generated_arg_vars gen_glob_def_sym gs 
+	#! body_expr = (adaptor_expr @ [instance_expr]) @ original_arg_exprs
+
+	#! fun_def = makeFunction def_sym group_index arg_vars body_expr No [] []					
+	= (fun_def, gs) 	
+where
+	get_generic_type :: !InstanceType !*GenericState 
+		-> (GenericType, !*GenericState)
+	get_generic_type ins_type gs=:{gs_modules, gs_gtd_infos}
+		# instance_type = hd ins_type.it_types
+		# {type_index} = case instance_type of 
+			TA type_symb_ident _ -> type_symb_ident
+			_ -> abort "invalid type of generic instance"
+		
+		#! (gtd_info, gs_gtd_infos) = gs_gtd_infos ! [type_index.glob_module, type_index.glob_object]
+		# (GTDI_Generic gt) = gtd_info 
+		= (gt, {gs & gs_gtd_infos = gs_gtd_infos, gs_modules = gs_modules})
+	
+	build_adaptor_expr {gt_iso, gt_type} gen_isomap gs=:{gs_heaps, gs_main_dcl_module_n, gs_predefs}
+		// create n iso applications 
+		# (iso_exprs, gs_heaps) = build_iso_exprs gen_isomap.ds_arity gt_iso gs_main_dcl_module_n gs_heaps		
+		# (isomap_expr, gs_heaps) = buildFunApp gs_main_dcl_module_n gen_isomap iso_exprs gs_heaps
+		# sel_expr = buildIsoFromSelectionExpr isomap_expr gs_predefs 
+		= (sel_expr, {gs & gs_heaps = gs_heaps})
+		
+	build_iso_exprs n iso gs_main_dcl_module_n gs_heaps
+		| n == 0 = ([], gs_heaps)
+		# (expr, gs_heaps) = buildFunApp gs_main_dcl_module_n iso [] gs_heaps	
+		# (exprs, gs_heaps) = build_iso_exprs (n - 1) iso gs_main_dcl_module_n gs_heaps	
+		= ([expr:exprs], gs_heaps)
+	
+	build_instance_expr :: !AType ![TypeVar] ![FreeVar] !(Global DefinedSymbol) !*GenericState 
+		-> (Expression, !*GenericState)
+	build_instance_expr {at_type} type_vars vars gen_sym gs 
+		= build_instance_expr1 at_type type_vars vars gen_sym gs
+	
+	build_instance_expr1 (TA {type_name, type_index, type_arity} type_args) type_vars vars gen_sym gs	
+		# (arg_exprs, gs=:{gs_heaps}) = 
+			mapSt (\t gs -> build_instance_expr t type_vars vars gen_sym gs) type_args gs
+		# (kind, gs) = get_kind_of_type_def type_index gs	
+		= build_generic_app gen_sym kind arg_exprs gs
+
+	build_instance_expr1 (arg_type --> res_type) type_vars vars gen_sym gs	
+		= abort "build_instance_expr1: arrow type\n"
+	build_instance_expr1 (type_cons_var :@: type_args) type_vars vars gen_sym gs	
+		= abort "build_instance_expr1: type cons var application\n"
+				
+	build_instance_expr1 (TB basic_type) type_vars vars gen_sym gs 	
+		= build_generic_app gen_sym KindConst [] gs
+	build_instance_expr1 (TV type_var) type_vars vars gen_sym gs 
+		= build_expr_for_type_var type_var type_vars vars gs 
+	build_instance_expr1 (GTV type_var) type_vars vars gen_sym gs 
+		= build_expr_for_type_var type_var type_vars vars gs 
+	build_instance_expr1 (TQV type_var) type_vars vars gen_sym gs 
+		= build_expr_for_type_var type_var type_vars vars gs 
+	build_instance_expr1 _ type_vars vars gen_sym gs
+		= abort "build_instance_expr1: type does not match\n" 
+	
+		
+	build_expr_for_type_var type_var type_vars vars gs=:{gs_predefs, gs_heaps}
+		# (var_expr, gs_heaps) = buildExprForTypeVar type_var type_vars vars gs_predefs gs_heaps 
+		= (var_expr, {gs & gs_heaps = gs_heaps})
+		
+	build_generic_app {glob_module, glob_object} kind arg_exprs gs=:{gs_heaps}
+		# (expr, gs_heaps) = buildGenericApp glob_module glob_object kind arg_exprs gs_heaps
+		= (expr, {gs & gs_heaps = gs_heaps})	
+
+	get_kind_of_type_def {glob_module, glob_object} gs=:{gs_td_infos}
+		# (td_info, gs_td_infos) = gs_td_infos ! [glob_module, glob_object]
+		= (make_kind td_info.tdi_kinds, {gs & gs_td_infos = gs_td_infos})
+	where	
+		make_kind [] = KindConst
+		make_kind ks = KindArrow (ks ++ [KindConst])
+
+		 			
+buildExprForTypeVar :: TypeVar [TypeVar] [FreeVar] !PredefinedSymbols !*Heaps 
+	-> (!Expression, !*Heaps)
+buildExprForTypeVar type_var type_vars vars predefs heaps 
+	| length type_vars <> length vars 
+		= abort "buildExprForTypeVar: inconsistent arguments\n"
+	# tv_info_ptrs = {tv_info_ptr \\ {tv_info_ptr} <- type_vars}
+	# index = find_in_array 0 tv_info_ptrs type_var.tv_info_ptr
+	| index == (-1)		
+		= buildIsomapIdApp predefs heaps
+		# (expr, var, heaps) = buildBoundVarExpr (vars !! index) heaps
+		= (expr, heaps)
+
+where
+	find_in_array :: !Int !{#TypeVarInfoPtr} !TypeVarInfoPtr -> !Int 
+	find_in_array index array el 
+		| index == size array  	= -1 	
+		| array.[index] == el 	= index
+								= find_in_array (inc index) array el	
+
+
+buildKindConstInstance :: !DefinedSymbol !Int !Index !DefinedSymbol !TypeKind !GenericState
+	-> (!FunDef, !*GenericState)
+buildKindConstInstance 
+		def_sym group_index 
+		generic_module generic_def_sym kind=:(KindArrow kinds) 
+		gs=:{gs_heaps}
+	#! arg_names = ["x" +++ toString i \\ i <- [1 .. def_sym.ds_arity]]
+	#! (arg_exprs, arg_vars, gs_heaps) = buildVarExprs arg_names gs_heaps
+	
+	# (gen_exprs, gs_heaps) = mapSt build_gen_expr [1 .. (length kinds) - 1] gs_heaps
+	  
+	#! (body_expr, gs_heaps) = buildGenericApp generic_module generic_def_sym kind (gen_exprs ++ arg_exprs) gs_heaps
+	#! fun_def = makeFunction def_sym group_index arg_vars body_expr No [] []					
+	= (fun_def, {gs & gs_heaps = gs_heaps})	
+where
+	build_gen_expr _ heaps
+		= buildGenericApp generic_module generic_def_sym KindConst [] heaps
+										
+//===========================================
+// access to common definitions
+//===========================================
+
+  	
+getTypeDef :: !Index  !Index !u:{#CommonDefs} -> (!CheckedTypeDef, !u:{#CommonDefs})
+getTypeDef mod_index type_index modules
+	# (common_defs=:{com_type_defs}, modules) = modules![mod_index]
+	# type_def = com_type_defs.[type_index]
+	= (type_def, modules)
+
+getConsDef :: !Index  !Index !u:{#CommonDefs} -> (!ConsDef, !u:{#CommonDefs})
+getConsDef mod_index type_index modules
+	# (common_defs=:{com_cons_defs}, modules) = modules![mod_index]
+	# cons_def = com_cons_defs.[type_index]
+	= (cons_def, modules)
+
+getSelectorDef :: !Index  !Index !u:{#CommonDefs} -> (!SelectorDef, !u:{#CommonDefs})
+getSelectorDef mod_index type_index modules
+	# (common_defs=:{com_selector_defs}, modules) = modules![mod_index]
+	# sel_def = com_selector_defs.[type_index]
+	= (sel_def, modules)
+
+
+getInstanceDef :: !Index !Index !u:{#CommonDefs} -> (!ClassInstance, !u:{#CommonDefs})
+getInstanceDef mod_index ins_index modules
+	# (common_defs=:{com_instance_defs}, modules) = modules![mod_index]
+	# instance_def = com_instance_defs.[ins_index]
+	= (instance_def, modules)
+		 			
+getGenericDef :: !Index !Index !u:{#CommonDefs} -> (!GenericDef, !u:{#CommonDefs})
+getGenericDef module_index generic_index modules
+	# (common_defs=:{com_generic_defs}, modules) = modules![module_index]
+	# generic_def = com_generic_defs.[generic_index]
+	= (generic_def, modules)
+
+getClassDef :: !Index !Index !u:{#CommonDefs} -> (!ClassDef, !u:{#CommonDefs})
+getClassDef module_index class_index modules
+	#! (common_defs=:{com_class_defs}, modules) = modules![module_index]
+	#! class_def = com_class_defs.[class_index]
+	= (class_def, modules)
+
+getMemberDef :: !Index !Index !u:{#CommonDefs} -> (!MemberDef, !u:{#CommonDefs})
+getMemberDef module_index member_index modules
+	# (common_defs=:{com_member_defs}, modules) = modules![module_index]
+	# member_def = com_member_defs.[member_index]
+	= (member_def, modules)
+	
+getGenericMember :: !(Global Index) !TypeKind !{#CommonDefs} -> (Bool, Global Index)
+getGenericMember {glob_module, glob_object} kind modules
+	# (generic_def, modules) = getGenericDef glob_module glob_object modules  
+	# (ok, def_sym) = getClassForKind generic_def kind
+	| not ok = (False, undef)		
+	# (class_def, modules) = getClassDef glob_module def_sym.ds_index modules
+	# {ds_index} = class_def.class_members.[0]
+	= (True, {glob_module = glob_module, glob_object = ds_index})
+
+getClassForKind :: !GenericDef !TypeKind
+	-> (Bool, DefinedSymbol)
+getClassForKind {gen_classes, gen_name} kind 
+	# class_name = gen_name.id_name +++ ":" +++ toString kind
+	= get_class gen_classes class_name
+where
+	get_class :: ![DefinedSymbol] !String -> (Bool, DefinedSymbol) 
+	get_class [] name 
+		= (False, undef)
+	get_class [class_ds=:{ds_ident}:class_dss] name
+		| ds_ident.id_name == name	= (True, class_ds)	 
+		| otherwise					= get_class class_dss name
+			
+//===================================
+// Types 
+//===================================
+
+makeAType :: Type -> AType
+makeAType t = {at_attribute = TA_Multi, at_annotation = AN_None, at_type = t}
+
+buildPredefTypeApp :: !Int [AType] !PredefinedSymbols -> !AType
+buildPredefTypeApp predef_index args predefs
+	# {pds_ident, pds_module, pds_def} = predefs.[predef_index]
+	# global_index = {glob_module = pds_module, glob_object = pds_def}
+	# type_symb = MakeTypeSymbIdent global_index pds_ident (length args) 		  
+	= makeAType (TA type_symb args)	
+
+buildATypeISO	x y predefs = buildPredefTypeApp PD_TypeISO [x, y] predefs
+buildATypeUNIT  predefs		= buildPredefTypeApp PD_TypeUNIT [] predefs
+buildATypePAIR x y predefs 	= buildPredefTypeApp PD_TypePAIR [x, y] predefs
+buildATypeEITHER x y predefs = buildPredefTypeApp PD_TypeEITHER [x, y] predefs
+
+
+buildProductType :: ![AType] !PredefinedSymbols -> !AType 
+buildProductType [] predefs = buildATypeUNIT predefs
+buildProductType [type] predefs = type
+buildProductType types predefs
+	#  (l,r) = splitAt ((length types) / 2) types
+	= buildATypePAIR (buildProductType l predefs) (buildProductType r predefs) predefs
+
+//===================================
+// Functions 
+//===================================
+
+makeFunction :: !DefinedSymbol !Index ![FreeVar] Expression !(Optional SymbolType) [FreeVar] [Index] 
+	-> FunDef
+makeFunction {ds_index, ds_arity, ds_ident} group_index arg_vars body_expr opt_sym_type local_vars fun_call_indexes
+	| length arg_vars <> ds_arity 
+		= abort "length arg_vars <> ds_arity\n"  
+	= {
+		fun_symb = ds_ident,
+		fun_arity = ds_arity,
+		fun_priority = NoPrio,
+		fun_body = TransformedBody {
+			tb_args = arg_vars,
+			tb_rhs = body_expr
+			},
+		fun_type = opt_sym_type,
+		fun_pos = NoPos,
+		fun_index = ds_index,
+		fun_kind  = FK_ImpFunction cNameNotLocationDependent,
+		fun_lifted = 0,
+		fun_info = {	
+			fi_calls = map (\ind->{fc_level = NotALevel, fc_index = ind}) fun_call_indexes,	
+			fi_group_index = group_index,
+			fi_def_level = NotALevel,
+			fi_free_vars =  [],
+			fi_local_vars = local_vars,
+			fi_dynamics = [],
+			fi_is_macro_fun = False
+			}	
+		}
+
+newGroupIndex gs=:{gs_last_group} = (gs_last_group, {gs & gs_last_group = gs_last_group + 1})
+newFunIndex gs=:{gs_last_fun} = (gs_last_fun, {gs & gs_last_fun = gs_last_fun + 1})
+newFunAndGroupIndex gs=:{gs_last_fun, gs_last_group} 
+	= (gs_last_fun, gs_last_group, {gs & gs_last_fun = gs_last_fun + 1, gs_last_group = gs_last_group + 1})
+
+/*
+addFunsAndGroups :: ![FunDef] ![Group] (!*GenericState) -> !*GenericState
+addFunsAndGroups new_fun_defs new_groups gs=:{gs_fun_defs, gs_groups, gs_last_fun}
+	# gs_fun_defs 	= arrayPlusList gs_fun_defs new_fun_defs
+	# gs_groups 	= arrayPlusList gs_groups new_groups
+	
+	# (last_fun_def, gs_fun_defs) = gs_fun_defs![gs_last_fun - 1]
+	| last_fun_def.fun_index <> gs_last_fun - 1
+		= abort "addFunsAndGroups: inconsistently added functions\n"	 
+
+	= {gs & gs_fun_defs = gs_fun_defs, gs_groups = gs_groups}
+*/
+addFunsAndGroups :: ![FunDef] ![Group] (!*GenericState) -> !*GenericState
+addFunsAndGroups new_fun_defs new_groups 
+		gs=:{gs_fun_defs, gs_groups, gs_first_fun, gs_last_fun, gs_first_group, gs_last_group}
+	# gs_fun_defs = add_funs new_fun_defs gs_fun_defs gs_first_fun gs_last_fun
+	# gs_groups = add_groups new_groups gs_groups gs_first_group gs_last_group
+	# (gs_groups, gs_fun_defs) = check_groups gs_first_group gs_groups gs_fun_defs
+	= {gs & gs_fun_defs = gs_fun_defs, gs_groups = gs_groups}
+where
+	add_funs new_fun_defs gs_fun_defs gs_first_fun gs_last_fun
+		# n_gs_fun_defs = size gs_fun_defs
+		# n_new_fun_defs = length new_fun_defs
+		| n_new_fun_defs <> gs_last_fun - gs_first_fun
+			= abort "error in number of fun_defs" 	
+		# fun_defs = createArray (n_new_fun_defs + n_gs_fun_defs) 
+			(makeFunction EmptyDefinedSymbol NoIndex [] EE No [] [])
+		#! fun_defs = { fun_defs & [i] = gs_fun_defs . [i] \\ i <- [0..(n_gs_fun_defs - 1)]}
+		#! fun_defs = { fun_defs & [i] = check_fun fun_def i \\ 
+			i <- [n_gs_fun_defs .. (n_gs_fun_defs + n_new_fun_defs - 1)] & 
+			fun_def <- new_fun_defs }
+		= fun_defs
+						
+	add_groups new_groups gs_groups gs_first_group gs_last_group 
+		# n_gs_groups = size gs_groups
+		# n_new_groups = length new_groups
+		| n_new_groups <> gs_last_group - gs_first_group
+			= abort "error in number of groups"
+		# groups = createArray (n_gs_groups + n_new_groups) {group_members = []}
+		#! groups = { groups & [i] = gs_groups . [i] \\ i <- [0..(n_gs_groups - 1)]}
+		#! groups = { groups & [i] = group \\ 
+			i <- [n_gs_groups .. (n_gs_groups + n_new_groups - 1)] & 		
+			group <- new_groups }
+		= groups
+	
+	check_fun fun_def index
+		| fun_def.fun_index == index 
+			= fun_def
+			= abort ("conflicting fun_indexes of " +++ fun_def.fun_symb.id_name +++
+				toString fun_def.fun_index +++ " and " +++ toString index) 
+	
+	check_groups group_index groups funs 
+		| group_index == size groups = (groups, funs)
+		# (group, groups) = groups ! [group_index]
+			//---> ("check group " +++ toString group_index)
+		# funs = check_group group_index group.group_members funs 				
+		= check_groups (group_index + 1) groups funs
+	
+	check_group group_index [] funs = funs
+	check_group group_index [fun_index:fun_indexes] funs
+		# (fun, funs) = funs ! [fun_index]
+		# funs = funs
+			---> (fun.fun_symb, fun.fun_index) 
+		| fun.fun_info.fi_group_index == group_index
+			= check_group group_index fun_indexes funs
+			= abort ("inconsistent group " +++ toString group_index +++ ": " +++ 
+				toString fun_index +++ " and " +++ toString fun.fun_info.fi_group_index)		 		
+
+buildIdFunction :: !DefinedSymbol Int !Ident !PredefinedSymbols !*Heaps-> (!FunDef, !*Heaps)
+buildIdFunction def_sym group_index name predefs heaps
+	# (arg_expr, arg_var, heaps) = buildVarExpr "x" heaps 
+	# fun_def = makeFunction def_sym group_index [arg_var] arg_expr No [] []		
+	= (fun_def, heaps)
+	
+buildUndefFunction :: !DefinedSymbol !Int !PredefinedSymbols !*Heaps-> (!FunDef, !*Heaps)
+buildUndefFunction def_sym group_index predefs heaps
+	# names = [ "x" +++ toString i \\ i <- [1 .. def_sym.ds_arity]]
+	# (arg_vars, heaps) = mapSt build_free_var names heaps
+	# (body_expr, heaps) = buildUndefFunApp [] predefs heaps
+	//# (body_expr, heaps) = buildUNIT predefs heaps
+	# fun_def = makeFunction def_sym group_index arg_vars body_expr No [] []		
+	= (fun_def, heaps)
+where
+	build_free_var :: !String !*Heaps -> (!FreeVar, !*Heaps)
+	build_free_var name heaps=:{hp_var_heap}
+		# (var_info_ptr, hp_var_heap) = newPtr VI_Empty hp_var_heap
+		# var_name = { id_name = name, id_info = nilPtr }
+		# free_var = { fv_def_level = NotALevel, fv_count = 0, fv_info_ptr = var_info_ptr, fv_name = var_name}
+		= (free_var, {heaps & hp_var_heap = hp_var_heap})
+
+//===================================
+// Case patterns
+//===================================
+
+buildPredefConsPattern :: !Int ![FreeVar] !Expression !PredefinedSymbols
+	-> AlgebraicPattern
+buildPredefConsPattern predef_index vars expr predefs
+	# {pds_ident, pds_module, pds_def} = predefs.[predef_index]
+	# cons_def_symbol = {
+		ds_ident = pds_ident,
+		ds_arity = length vars,
+		ds_index = pds_def
+		}
+	# pattern = {
+		ap_symbol = {glob_module = pds_module, glob_object = cons_def_symbol},
+		ap_vars = vars,
+		ap_expr = expr,
+		ap_position = NoPos		
+		}
+	= pattern
+
+buildUNITPattern expr predefs :== buildPredefConsPattern PD_ConsUNIT [] expr predefs
+buildLEFTPattern var expr predefs :== buildPredefConsPattern PD_ConsLEFT [var] expr predefs
+buildRIGHTPattern var expr predefs :== buildPredefConsPattern PD_ConsRIGHT [var] expr predefs
+buildPAIRPattern var1 var2 expr predefs :== buildPredefConsPattern PD_ConsPAIR [var1, var2] expr predefs
+
+//===================================
+// Expressions 
+//===================================
+
+buildConsApp :: !Index DefinedSymbol ![Expression] !*Heaps 
+	-> (!Expression, !*Heaps) 
+buildConsApp cons_mod {ds_ident, ds_index, ds_arity} arg_exprs heaps=:{hp_expression_heap}
+	# (expr_info_ptr, hp_expression_heap) = newPtr EI_Empty hp_expression_heap
+	# cons_glob = {glob_module = cons_mod, glob_object = ds_index}
+	# expr = App {
+		app_symb = {
+			symb_name = ds_ident, 
+			symb_kind = SK_Constructor cons_glob, 
+			symb_arity = ds_arity }, 
+		app_args = arg_exprs, 
+		app_info_ptr = expr_info_ptr} 	
+	# heaps = { heaps & hp_expression_heap = hp_expression_heap } 
+	= (expr, heaps)	
+
+buildFunApp :: !Index DefinedSymbol ![Expression] !*Heaps 
+	-> (!Expression, !*Heaps) 
+buildFunApp fun_mod {ds_ident, ds_index, ds_arity} arg_exprs heaps=:{hp_expression_heap}
+	# (expr_info_ptr, hp_expression_heap) = newPtr EI_Empty hp_expression_heap
+	# fun_glob = {glob_module = fun_mod, glob_object = ds_index}
+	# expr = App {
+		app_symb = {
+			symb_name = ds_ident, 
+			symb_kind = SK_Function fun_glob, 
+			symb_arity = length arg_exprs }, 
+		app_args = arg_exprs, 
+		app_info_ptr = expr_info_ptr} 	
+	# heaps = { heaps & hp_expression_heap = hp_expression_heap } 
+	= (expr, heaps)	
+
+buildGenericApp :: !Index !DefinedSymbol !TypeKind ![Expression] !*Heaps
+	-> (!Expression, !*Heaps)
+buildGenericApp module_index {ds_ident, ds_index} kind arg_exprs heaps=:{hp_expression_heap}
+	# (expr_info_ptr, hp_expression_heap) = newPtr EI_Empty hp_expression_heap
+	# glob_index = {glob_module = module_index, glob_object = ds_index}
+	# expr = App {
+		app_symb = {
+			symb_name = ds_ident, 
+			symb_kind = SK_Generic glob_index kind, 
+			symb_arity = length arg_exprs }, 
+		app_args = arg_exprs, 
+		app_info_ptr = expr_info_ptr} 	
+	# heaps = { heaps & hp_expression_heap = hp_expression_heap } 
+	= (expr, heaps)	
+
+buildCaseExpr :: Expression CasePatterns !*Heaps 
+	-> (!Expression, !*Heaps)
+buildCaseExpr case_arg case_alts heaps=:{hp_expression_heap}	
+	# (expr_info_ptr, hp_expression_heap) = newPtr EI_Empty hp_expression_heap
+	# expr = Case {
+		case_expr = case_arg,
+		case_guards = case_alts,
+		case_default = No,
+		case_ident = No,
+		case_info_ptr = expr_info_ptr,
+		case_default_pos = NoPos 
+		}
+	# heaps = { heaps & hp_expression_heap = hp_expression_heap}	
+	= (expr, heaps)
+
+buildCaseUNITExpr :: !Expression !Expression !PredefinedSymbols !*Heaps 
+	-> (!Expression, !*Heaps)
+buildCaseUNITExpr arg_expr body_expr predefs heaps
+	# unit_pat = buildUNITPattern body_expr predefs
+	# {pds_module, pds_def} = predefs.[PD_TypeUNIT]
+	# case_patterns = AlgebraicPatterns {glob_module = pds_module, glob_object = pds_def} [unit_pat]
+	= buildCaseExpr arg_expr case_patterns heaps
+
+buildCaseEITHERExpr :: !Expression (!FreeVar, !Expression) (!FreeVar, !Expression) !PredefinedSymbols !*Heaps 
+	-> (!Expression, !*Heaps)
+buildCaseEITHERExpr arg_expr (left_var, left_expr) (right_var, right_expr) predefs heaps
+	# left_pat = buildLEFTPattern left_var left_expr predefs
+	# right_pat = buildRIGHTPattern right_var right_expr predefs
+	# {pds_module, pds_def} = predefs.[PD_TypeEITHER]
+	# case_patterns = AlgebraicPatterns {glob_module = pds_module, glob_object = pds_def} [left_pat, right_pat]
+	= buildCaseExpr arg_expr case_patterns heaps
+
+buildCasePAIRExpr :: !Expression !FreeVar !FreeVar !Expression !PredefinedSymbols !*Heaps
+	-> (!Expression, !*Heaps)
+buildCasePAIRExpr arg_expr var1 var2 body_expr predefs heaps
+	# pair_pat = buildPAIRPattern var1 var2 body_expr predefs	
+	# {pds_module, pds_def} = predefs.[PD_TypePAIR]
+	# case_patterns = AlgebraicPatterns {glob_module = pds_module, glob_object = pds_def} [pair_pat]	
+	= buildCaseExpr arg_expr case_patterns heaps
+
+buildPredefConsApp :: !Int [Expression] !PredefinedSymbols !*Heaps
+	-> (!Expression, !*Heaps)
+buildPredefConsApp predef_index args predefs heaps=:{hp_expression_heap}
+	# {pds_ident, pds_module, pds_def} = predefs.[predef_index]
+	# global_index = {glob_module = pds_module, glob_object = pds_def}
+	# symb_ident = {
+		symb_name = pds_ident, 
+		symb_kind = SK_Constructor global_index, 
+		symb_arity = length args 
+		}
+	# (expr_info_ptr, hp_expression_heap) = newPtr EI_Empty hp_expression_heap
+	# app = App {app_symb = symb_ident, app_args = args, app_info_ptr = expr_info_ptr} 
+	= (app, {heaps & hp_expression_heap = hp_expression_heap})
+
+buildISO to_expr from_expr predefs heaps :== buildPredefConsApp PD_ConsISO [to_expr, from_expr] predefs heaps
+buildUNIT predefs heaps		:== buildPredefConsApp PD_ConsUNIT [] predefs heaps
+buildPAIR x y predefs heaps	:== buildPredefConsApp PD_ConsPAIR [x, y] predefs heaps
+buildLEFT x predefs heaps	:== buildPredefConsApp PD_ConsLEFT [x] predefs heaps
+buildRIGHT x predefs heaps	:== buildPredefConsApp PD_ConsRIGHT [x] predefs heaps
+
+buildPredefFunApp :: !Int [Expression] !PredefinedSymbols !*Heaps
+	-> (!Expression, !*Heaps)
+buildPredefFunApp predef_index args predefs heaps=:{hp_expression_heap}
+	# {pds_ident, pds_module, pds_def} = predefs.[predef_index]
+	# global_index = {glob_module = pds_module, glob_object = pds_def}
+	# symb_ident = {
+		symb_name = pds_ident, 
+		symb_kind = SK_Function global_index, 
+		symb_arity = length args 
+		}
+	# (expr_info_ptr, hp_expression_heap) = newPtr EI_Empty hp_expression_heap
+	# app = App {app_symb = symb_ident, app_args = args, app_info_ptr = expr_info_ptr} 
+	= (app, {heaps & hp_expression_heap = hp_expression_heap})
+
+buildUndefFunApp args predefs heaps :== buildPredefFunApp PD_undef args predefs heaps 
+buildIsomapArrowApp x y predefs heaps :== buildPredefFunApp PD_isomap_ARROW_ [x,y] predefs heaps
+buildIsomapIdApp predefs heaps :== buildPredefFunApp PD_isomap_ID [] predefs heaps
+ 	
+buildIsoToSelectionExpr :: !Expression !PredefinedSymbols -> Expression
+buildIsoToSelectionExpr record_expr predefs
+	# {pds_module, pds_def, pds_ident} = predefs . [PD_iso_to]
+	# selector = { 
+		glob_module = pds_module, 
+		glob_object = {ds_ident = pds_ident, ds_index = pds_def, ds_arity = 1}}
+	= Selection No record_expr [RecordSelection selector 0]
+
+buildIsoFromSelectionExpr :: !Expression !PredefinedSymbols -> Expression
+buildIsoFromSelectionExpr record_expr predefs 
+	# {pds_module, pds_def, pds_ident} = predefs . [PD_iso_from]
+	# selector = { 
+		glob_module = pds_module, 
+		glob_object = {ds_ident = pds_ident, ds_index = pds_def, ds_arity = 1}}
+	= Selection No record_expr [RecordSelection selector 1]
+
+buildVarExpr :: !String !*Heaps	-> (!Expression, !FreeVar, !*Heaps)
+buildVarExpr name heaps=:{hp_var_heap, hp_expression_heap} 
+	# (expr_info_ptr, hp_expression_heap) = newPtr EI_Empty hp_expression_heap
+	# (var_info_ptr, hp_var_heap) = newPtr VI_Empty hp_var_heap
+	# var_name = { id_name = name, id_info = nilPtr }
+	# fv = { fv_def_level = NotALevel, fv_count = 1, fv_info_ptr = var_info_ptr, fv_name = var_name}
+	# var = Var {var_name = var_name, var_expr_ptr = expr_info_ptr, var_info_ptr = var_info_ptr } 
+	# hp_var_heap = writePtr var_info_ptr (VI_Expression var) hp_var_heap
+	# heaps = { heaps & hp_var_heap = hp_var_heap, hp_expression_heap = hp_expression_heap } 
+	= (var, fv, heaps)
+
+buildVarExprs :: ![String] !*Heaps -> (![Expression], [!FreeVar], !*Heaps)	 		
+buildVarExprs [] heaps = ([], [], heaps)
+buildVarExprs [name:names] heaps 
+	# (expr, var, heaps) = buildVarExpr name heaps
+	# (exprs, vars, heaps) = buildVarExprs names heaps 
+	= ([expr:exprs], [var:vars], heaps)
+
+buildFreeVar :: !String !*Heaps -> (!FreeVar, !*Heaps)
+buildFreeVar name heaps=:{hp_var_heap}
+	# (var_info_ptr, hp_var_heap) = newPtr VI_Empty hp_var_heap
+	# var_name = { id_name = name, id_info = nilPtr }
+	# var = { fv_def_level = NotALevel, fv_count = 1, fv_info_ptr = var_info_ptr, fv_name = var_name}
+	= (var, {heaps & hp_var_heap = hp_var_heap})
+
+buildFreeVars :: ![String] !*Heaps -> (![FreeVar], !*Heaps)
+buildFreeVars names heaps = mapSt buildFreeVar names heaps 	
+
+// create expression from a variable  
+buildBoundVarExpr :: !FreeVar !*Heaps -> (!Expression, !FreeVar, !*Heaps)
+buildBoundVarExpr free_var=:{fv_info_ptr, fv_name, fv_count} heaps=:{hp_expression_heap, hp_var_heap} 
+	# (expr_info_ptr, hp_expression_heap) = newPtr EI_Empty hp_expression_heap
+	# expr = Var {var_name = fv_name, var_expr_ptr = expr_info_ptr, var_info_ptr = fv_info_ptr } 
+	# hp_var_heap = writePtr fv_info_ptr (VI_Expression expr) hp_var_heap
+	# heaps = { heaps & hp_var_heap = hp_var_heap, hp_expression_heap = hp_expression_heap } 		
+	= (expr, {free_var & fv_count = fv_count + 1}, heaps)
+
+buildBoundVarExprs :: ![FreeVar] !*Heaps -> (![Expression], ![FreeVar], !*Heaps)
+buildBoundVarExprs [] heaps = ([], [], heaps)
+buildBoundVarExprs [free_var:free_vars] heaps
+	# (expr, free_var, heaps) = buildBoundVarExpr free_var heaps
+	# (exprs, free_vars, heaps) = buildBoundVarExprs free_vars heaps
+	= ([expr:exprs], [free_var:free_vars], heaps)
+
+
+buildTypeVar name heaps=:{hp_type_heaps=hp_type_heaps=:{th_vars}}
+	# (tv_info_ptr, th_vars) = newPtr TVI_Empty th_vars
+	# type_var = {
+		tv_name = {id_name = name, id_info = nilPtr},
+		tv_info_ptr = tv_info_ptr
+		}
+	= (	type_var, {heaps & hp_type_heaps = {hp_type_heaps & th_vars = th_vars}})
+
+
+transpose []             = []
+transpose [[] : xss]     = transpose xss
+transpose [[x:xs] : xss] = 
+	[[x : [hd l \\ l <- xss]] : transpose [xs : [ tl l \\  l <- xss]]]
+
+ 			
\ No newline at end of file
diff --git a/frontend/overloading.icl b/frontend/overloading.icl
index 6fb4c94..3df8017 100644
--- a/frontend/overloading.icl
+++ b/frontend/overloading.icl
@@ -3,6 +3,7 @@ implementation module overloading
 import StdEnv
 
 import syntax, check, type, typesupport, utilities, unitype, predef, checktypes, convertDynamics // ,RWSDebug
+import generics // AA
 
 ::	InstanceTree = IT_Node !(Global Index) !InstanceTree !InstanceTree | IT_Empty 
 
@@ -711,6 +712,13 @@ where
 			= find_instance_of_member me_class me_offset {rcs & rcs_constraints_contexts = rcs_constraints_contexts ++ rcss}
 		find_instance_of_member_in_constraints me_class me_offset []
 			= abort "Error in module overloading: find_instance_of_member_in_constraints\n"
+// AA..			
+convertOverloadedCall defs contexts symbol=:{symb_kind = SK_Generic gen_glob kind} expr_ptr class_appls heaps_and_ptrs
+	# (found, member_glob) = getGenericMember gen_glob kind defs
+	| not found
+		= abort "convertOverloadedCall: no class for kind"	
+ 		=  convertOverloadedCall defs contexts {symbol & symb_kind = SK_OverloadedFunction member_glob} expr_ptr class_appls heaps_and_ptrs  				
+// ..AA
 convertOverloadedCall defs contexts {symb_name,symb_kind = SK_TypeCode} expr_info_ptr class_appls heaps_and_ptrs
 	# (class_expressions, (heaps, ptrs)) = convertClassApplsToExpressions defs contexts class_appls heaps_and_ptrs
 	= ({ heaps & hp_expression_heap = heaps.hp_expression_heap <:= (expr_info_ptr, EI_TypeCodes (map expressionToTypeCodeExpression class_expressions))}, ptrs)
@@ -868,7 +876,6 @@ getClassVariable symb var_info_ptr var_heap error
 		(_, var_heap)
 			-> (symb, var_info_ptr, var_heap, overloadingError symb error)
 
-
 updateDynamics :: ![Index] ![LocalTypePatternVariable] !Int !*{#FunDef} !*{! FunctionType} !*ExpressionHeap !*TypeCodeInfo !*VarHeap !*ErrorAdmin !*{#PredefinedSymbol}
 	-> (!*{#FunDef}, !*{! FunctionType}, !*ExpressionHeap, !*TypeCodeInfo, !*VarHeap, !*ErrorAdmin, !*{#PredefinedSymbol})
 updateDynamics funs type_pattern_vars main_dcl_module_n fun_defs fun_env symbol_heap type_code_info var_heap error predef_symbols
diff --git a/frontend/parse.icl b/frontend/parse.icl
index b888fbb..557f6d7 100644
--- a/frontend/parse.icl
+++ b/frontend/parse.icl
@@ -287,7 +287,7 @@ where
 		  	  (defs, pState)		= want_definitions (SetGlobalContext iclmodule) pState
 			  {ps_scanState,ps_hash_table,ps_error,ps_pre_def_symbols}
 			  						= pState
-			  defs = if (ParseOnly && id_name <> "StdOverloaded" && id_name <> "StdArray" && id_name <> "StdEnum" && id_name <> "StdBool" && id_name <> "StdDynamics")
+			  defs = if (ParseOnly && id_name <> "StdOverloaded" && id_name <> "StdArray" && id_name <> "StdEnum" && id_name <> "StdBool" && id_name <> "StdDynamics" && id_name <> "StdGeneric")
 						[PD_Import imports \\ PD_Import imports <- defs]
 						defs
 			  mod					= { mod_name = mod_ident, mod_type = mod_type, mod_imports = [], mod_imported_objects = [], mod_defs = defs }
@@ -413,6 +413,13 @@ where
 			= (False,abort "no def(2)",parseError "definition" No "class definitions are only at the global level" pState)
 	   		# (classdef, pState) = wantClassDefinition context pos pState
 	   		= (True, classdef, pState)
+	// AA..
+	try_definition context GenericToken pos pState
+		| ~(isGlobalContext context)
+			= (False,abort "no def(2)",parseError "definition" No "generic definitions are only at the global level" pState)
+	   		# (gendef, pState) = wantGenericDefinition context pos pState
+	   		= (True, gendef, pState)	 
+	// ..AA  		
 	try_definition context InstanceToken pos pState
 		| ~(isGlobalContext context)
 			= (False,abort "no def(2)",parseError "definition" No "instance declarations are only at the global level" pState)
@@ -1062,22 +1069,30 @@ wantInstanceDeclaration context pi_pos pState
 	  (pi_class, pState) = stringToIdent class_name IC_Class pState
 	  ((pi_types, pi_context), pState) = want_instance_type pState
 	  (pi_ident, pState) = stringToIdent class_name (IC_Instance pi_types) pState
+// AA..
+	# (token, pState) = nextToken TypeContext pState
+	| token == GenericToken
+		# pState = wantEndOfDefinition "generic instance declaration" pState
+		= (PD_Instance {pi_class = pi_class, pi_ident = pi_ident, pi_types = pi_types, pi_context = pi_context,
+							pi_members = [], pi_specials = SP_None, pi_pos = pi_pos, pi_generate = True}, pState)
+// ..AA
 	| isIclContext context
-		# pState = want_begin_group pState
+		# pState = tokenBack pState // AA
+		  pState = want_begin_group pState
 		  (pi_members, pState) = wantDefinitions context pState
 		  pState = wantEndGroup "instance" pState
 
 		= (PD_Instance {pi_class = pi_class, pi_ident = pi_ident, pi_types = pi_types, pi_context = pi_context,
-						pi_members = pi_members, pi_specials = SP_None, pi_pos = pi_pos }, pState)
+						pi_members = pi_members, pi_specials = SP_None, pi_pos = pi_pos, pi_generate = False }, pState)
 	// otherwise // ~ (isIclContext context)
-		# (token, pState) = nextToken TypeContext pState
 		| token == CommaToken
+			// AA: # (token, pState) = nextToken TypeContext pState 		
 			# (pi_types_and_contexts, pState)	= want_instance_types pState
 			  (idents, pState)		= seqList [stringToIdent class_name (IC_Instance type) \\ (type,context) <- pi_types_and_contexts] pState
 			= (PD_Instances
 //				[	{ pi_class = pi_class, pi_ident = pi_ident, pi_types = type, pi_context = context // voor martin
 				[	{ pi_class = pi_class, pi_ident = ident, pi_types = type, pi_context = context
-					, pi_members = [], pi_specials = SP_None, pi_pos = pi_pos}
+					, pi_members = [], pi_specials = SP_None, pi_pos = pi_pos, pi_generate = False}
 				\\	(type,context)	<- [ (pi_types, pi_context) : pi_types_and_contexts ]
 				&	ident			<- [ pi_ident : idents ]
 				]
@@ -1087,7 +1102,8 @@ wantInstanceDeclaration context pi_pos pState
 			# (specials, pState) = optionalSpecials (tokenBack pState)
 			  pState = wantEndOfDefinition "instance declaration" pState
 			= (PD_Instance {pi_class = pi_class, pi_ident = pi_ident, pi_types = pi_types, pi_context = pi_context,
-							pi_members = [], pi_specials = specials, pi_pos = pi_pos}, pState)
+							pi_members = [], pi_specials = specials, pi_pos = pi_pos, pi_generate = False}, pState)
+		
 where
 	want_begin_group pState  // For JvG layout
 		# (token, pState) = nextToken TypeContext pState
@@ -1186,6 +1202,48 @@ optionalCoercions pState
 			  , parseError "Function type: optional coercions" (Yes token) "<attribute variable>" pState
 			  )
 
+// AA..
+/*
+	Generic definitions
+*/
+
+wantGenericDefinition :: !ParseContext !Position !ParseState -> (!ParsedDefinition, !ParseState)
+wantGenericDefinition context pos pState
+	# (name, pState) = want_name pState
+	| name == "" = (PD_Erroneous, pState)
+	# (ident, pState) = stringToIdent name IC_Class pState
+	# (member_ident, pState) = stringToIdent name IC_Expression pState
+	# (arg_vars, pState) = wantList "generic variable(s)" try_variable pState
+		
+	# pState = wantToken TypeContext "generic definition" DoubleColonToken pState
+	# (type, pState) = want_type pState		//	SymbolType
+	# pState = wantEndOfDefinition "generic definition" pState
+	# gen_def = {
+		gen_name = ident,
+		gen_member_name = member_ident, 
+		gen_type = type, 
+		gen_args = arg_vars,
+		gen_arity = length arg_vars,
+		gen_pos = pos, 
+		gen_classes = [],
+		gen_isomap = MakeDefinedSymbol {id_name="",id_info=nilPtr} NoIndex 0
+		}
+	= (PD_Generic gen_def, pState)	
+	where
+		want_name pState 
+			# (token, pState) = nextToken TypeContext pState
+			= 	case token of
+				IdentToken name -> (name, pState)
+				_ -> ("", parseError "Generic Definition" (Yes token) "<identifier>" pState)
+		want_type :: !ParseState -> (!SymbolType, !ParseState)
+		want_type pState = want pState // SymbolType 		
+
+		try_variable pState
+			# (token, pState) = nextToken TypeContext pState
+			= tryTypeVarT token pState
+
+// ..AA
+
 /*
 	Type definitions
 */
@@ -1949,6 +2007,10 @@ trySimpleExpression is_pattern pState
 		= trySimpleRhsExpression pState
 
 trySimpleExpressionT :: !Token !Bool !ParseState -> (!Bool, !ParsedExpr, !ParseState)
+
+
+// AA..
+/*
 trySimpleExpressionT (IdentToken name) is_pattern pState
 	| isLowerCaseName name
 	# (id, pState) = stringToIdent name IC_Expression pState
@@ -1967,6 +2029,38 @@ trySimpleExpressionT (IdentToken name) is_pattern pState
 //	| isUpperCaseName name || ~ is_pattern
 	# (id, pState) = stringToIdent name IC_Expression pState
 	= (True, PE_Ident id, pState)
+*/
+
+trySimpleExpressionT (IdentToken name) is_pattern pState
+	| isLowerCaseName name
+	# (id, pState) = stringToIdent name IC_Expression pState
+	| is_pattern
+		# (token, pState) = nextToken FunctionContext pState
+		| token == DefinesColonToken
+			# (succ, expr, pState) = trySimpleExpression is_pattern pState
+			| succ
+				= (True, PE_Bound { bind_dst = id, bind_src = expr }, pState)
+				= (True, PE_Empty, parseError "simple expression" No "expression" pState)
+			// token <> DefinesColonToken
+			= (True, PE_Ident id, tokenBack pState)
+		// not is_pattern
+		# (token, pState) = nextToken FunctionContext pState
+		| token == GenericOpenToken
+			# (kind, pState) = wantKind pState	
+			= (True, PE_Generic id kind, pState)
+			= (True, PE_Ident id, tokenBack pState)			
+			
+trySimpleExpressionT (IdentToken name) is_pattern pState
+//	| isUpperCaseName name || ~ is_pattern
+	# (id, pState) = stringToIdent name IC_Expression pState
+	# (token, pState) = nextToken FunctionContext pState
+	| token == GenericOpenToken
+		# (kind, pState) = wantKind pState	
+		= (True, PE_Generic id kind, pState)
+		= (True, PE_Ident id, tokenBack pState)
+
+// ..AA
+
 trySimpleExpressionT SquareOpenToken is_pattern pState
 	# (list_expr, pState) = wantListExp is_pattern pState
 	= (True, list_expr, pState)
@@ -2844,6 +2938,36 @@ wantBeginGroup msg pState
 				->	pState
 			_	->	parseError msg (Yes token) "begin group without layout, {," pState
 
+// AA..
+wantKind :: !ParseState -> !(!TypeKind, ParseState)
+wantKind pState
+	# (token, pState) = nextToken TypeContext pState
+	# (kind, pState) = want_simple_kind token pState
+	# (token, pState) = nextToken TypeContext pState
+	= want_kind kind token pState
+	where
+		want_simple_kind AsteriskToken pState		= (KindConst, pState)
+		want_simple_kind (IntToken str) pState
+			# n = toInt str
+			| n == 0	= (KindConst, pState)
+			| n > 0 	= (KindArrow (repeatn (n+1) KindConst), pState)
+			| otherwise = (KindConst, parseError "invalid kind" No "positive integer expected" pState)
+		want_simple_kind OpenToken pState 			= wantKind pState
+		want_simple_kind GenericOpenToken pState 	= wantKind pState
+		want_simple_kind token pState 
+			= (KindConst, parseError "invalid kind" (Yes token) "* or (" pState)
+
+		want_kind kind ArrowToken pState
+			# (rhs, pState) = wantKind pState
+			= 	case rhs of
+				(KindArrow ks) 	-> (KindArrow [kind : ks], pState)
+				_				-> (KindArrow [kind, rhs], pState)
+		want_kind kind CloseToken pState 				= (kind, pState)
+		want_kind kind GenericCloseToken pState 		= (kind, pState)
+		want_kind kind token pState	
+			= (kind, parseError "invalid kind" (Yes token) ")" pState)
+// ..AA 
+
 /*
 	Functions on the parse pState
 */
diff --git a/frontend/postparse.icl b/frontend/postparse.icl
index 91e845c..def5cd8 100644
--- a/frontend/postparse.icl
+++ b/frontend/postparse.icl
@@ -725,7 +725,7 @@ where
 
 MakeEmptyModule name :==  { mod_name = name, mod_type = MK_None, mod_imports = [], mod_imported_objects = [],
 	mod_defs = {	def_types = [], def_constructors = [], def_selectors = [], def_classes = [], def_macros = { ir_from = 0, ir_to = 0 },
-					def_members = [], def_funtypes = [], def_instances = [] } }
+					def_members = [], def_funtypes = [], def_instances = [], /* AA */ def_generics = [] } }
 
 parseAndScanDclModule :: !Ident !Position ![ScannedModule] ![Ident] !SearchPaths !*Files !*CollectAdmin
 	-> *(!Bool, ![ScannedModule], !*Files, !*CollectAdmin)
@@ -1072,6 +1072,10 @@ where
 	    = ([], ca)	
 reorganiseDefinitions icl_module [PD_Instances class_instances : defs] cons_count sel_count mem_count type_count ca
 	= reorganiseDefinitions icl_module ([PD_Instance class_instance \\ class_instance <- class_instances] ++ defs) cons_count sel_count mem_count type_count ca
+reorganiseDefinitions icl_module [PD_Generic gen : defs] cons_count sel_count mem_count type_count ca
+	# 	(fun_defs, c_defs, imports, imported_objects, ca) = reorganiseDefinitions icl_module defs cons_count sel_count mem_count type_count ca
+		c_defs = {c_defs & def_generics = [gen : c_defs.def_generics]}
+	= (fun_defs, c_defs, imports, imported_objects, ca)
 reorganiseDefinitions icl_module [PD_Import new_imports : defs] cons_count sel_count mem_count type_count ca
 	# (fun_defs, c_defs, imports, imported_objects, ca) = reorganiseDefinitions icl_module defs cons_count sel_count mem_count type_count ca
 	= (fun_defs, c_defs, new_imports ++ imports, imported_objects, ca)
@@ -1083,7 +1087,7 @@ reorganiseDefinitions icl_module [def:defs] _ _ _ _ ca
 
 reorganiseDefinitions icl_module [] _ _ _ _ ca
 	= ([], { def_types = [], def_constructors = [], def_selectors = [], def_macros = [], def_classes = [], def_members = [],
-			def_instances = [], def_funtypes = [] }, [], [], ca)
+			def_instances = [], def_funtypes = [], /* AA */ def_generics = [] }, [], [], ca)
 
 belongsToTypeSpec name prio new_name is_infix :==
 	name == new_name && sameFixity prio is_infix
diff --git a/frontend/predef.dcl b/frontend/predef.dcl
index 8115648..cfa0c04 100644
--- a/frontend/predef.dcl
+++ b/frontend/predef.dcl
@@ -36,64 +36,89 @@ PD_TypeVar_a31				:== 101
 
 /* Dynamics */
 
-PD_TypeCodeMember			:== 123
+PD_TypeCodeMember			:== 102
 // MV ...
-PD_DynamicTemp				:== 131
-PD_DynamicValue				:== 132
-PD_DynamicType				:== 133
+PD_DynamicTemp				:== 103
+PD_DynamicValue				:== 104
+PD_DynamicType				:== 105
 // ... MV
 
 /* identifiers present in the hastable */
 
-PD_StdArray					:== 102
-PD_StdEnum					:== 103
-PD_StdBool					:== 104
+PD_StdArray					:== 106
+PD_StdEnum					:== 107
+PD_StdBool					:== 108
 
-PD_AndOp					:== 105
-PD_OrOp						:== 106
+PD_AndOp					:== 109
+PD_OrOp						:== 110
 
 
 /* Array functions */
 
-PD_ArrayClass				:== 107
+PD_ArrayClass				:== 111
 
-PD_CreateArrayFun			:== 108
-PD__CreateArrayFun			:== 109
-PD_ArraySelectFun			:== 110
-PD_UnqArraySelectFun		:== 111
-PD_ArrayUpdateFun			:== 112
-PD_ArrayReplaceFun			:== 113
-PD_ArraySizeFun				:== 114
-PD_UnqArraySizeFun			:== 115
+PD_CreateArrayFun			:== 112
+PD__CreateArrayFun			:== 113
+PD_ArraySelectFun			:== 114
+PD_UnqArraySelectFun		:== 115
+PD_ArrayUpdateFun			:== 116
+PD_ArrayReplaceFun			:== 117
+PD_ArraySizeFun				:== 118
+PD_UnqArraySizeFun			:== 119
 
 /* Enum/Comprehension functions */
 
-PD_SmallerFun				:== 116
-PD_IncFun					:== 117
-PD_From						:== 118
-PD_FromThen					:== 119
-PD_FromTo					:== 120
-PD_FromThenTo				:== 121
+PD_SmallerFun				:== 120
+PD_IncFun					:== 121
+PD_From						:== 122
+PD_FromThen					:== 123
+PD_FromTo					:== 124
+PD_FromThenTo				:== 125
 
 /* Dynamics */
 
-PD_TypeCodeClass			:== 122
+PD_TypeCodeClass			:== 126
 
-PD_TypeObjectType			:== 124
-PD_TypeConsSymbol			:== 125
-PD_unify					:== 126
+PD_TypeObjectType			:== 127
+PD_TypeConsSymbol			:== 128
+PD_unify					:== 129
 // MV ..
-PD_coerce					:== 127
-PD_variablePlaceholder		:== 128
-PD_StdDynamics				:== 129
-PD_undo_indirections		:== 130
-
-PD_Start					:== 134
+PD_coerce					:== 130
+PD_variablePlaceholder		:== 131
+PD_StdDynamics				:== 132
+PD_undo_indirections		:== 133
+
+/* Generics */
+PD_StdGeneric				:== 134
+PD_TypeISO					:== 135
+PD_ConsISO					:== 136
+PD_iso_to					:== 137
+PD_iso_from					:== 138
+
+PD_TypeUNIT					:== 139
+PD_ConsUNIT					:== 140
+PD_TypeEITHER				:== 141
+PD_ConsLEFT					:== 142
+PD_ConsRIGHT				:== 143
+PD_TypePAIR					:== 144
+PD_ConsPAIR					:== 145
+PD_TypeARROW				:== 146
+PD_ConsARROW				:== 147
+
+PD_isomap_ARROW_			:== 148
+PD_isomap_ID				:== 149
+
+/* StdMisc */
+PD_StdMisc					:== 150
+PD_abort					:== 151
+PD_undef					:== 152
+
+PD_Start					:== 153
 
 // MW..
-PD_DummyForStrictAliasFun	:== 135
+PD_DummyForStrictAliasFun	:== 154
 
-PD_NrOfPredefSymbols		:== 136
+PD_NrOfPredefSymbols		:== 155
 // ..MW
 
 GetTupleConsIndex tup_arity :== PD_Arity2TupleSymbol + tup_arity - 2
diff --git a/frontend/predef.icl b/frontend/predef.icl
index 68e1697..327e7ba 100644
--- a/frontend/predef.icl
+++ b/frontend/predef.icl
@@ -34,62 +34,89 @@ PD_TypeVar_a31				:== 101
 
 /* Dynamics */
 
-PD_TypeCodeMember			:== 123
-PD_DynamicTemp				:== 131
-PD_DynamicValue				:== 132
-PD_DynamicType				:== 133
+PD_TypeCodeMember			:== 102
+// MV ...
+PD_DynamicTemp				:== 103
+PD_DynamicValue				:== 104
+PD_DynamicType				:== 105
+// ... MV
 
 /* identifiers present in the hastable */
 
-PD_StdArray					:== 102
-PD_StdEnum					:== 103
-PD_StdBool					:== 104
+PD_StdArray					:== 106
+PD_StdEnum					:== 107
+PD_StdBool					:== 108
 
-PD_AndOp					:== 105
-PD_OrOp						:== 106
+PD_AndOp					:== 109
+PD_OrOp						:== 110
 
 
 /* Array functions */
 
-PD_ArrayClass				:== 107
+PD_ArrayClass				:== 111
 
-PD_CreateArrayFun			:== 108
-PD__CreateArrayFun			:== 109
-PD_ArraySelectFun			:== 110
-PD_UnqArraySelectFun		:== 111
-PD_ArrayUpdateFun			:== 112
-PD_ArrayReplaceFun			:== 113
-PD_ArraySizeFun				:== 114
-PD_UnqArraySizeFun			:== 115
+PD_CreateArrayFun			:== 112
+PD__CreateArrayFun			:== 113
+PD_ArraySelectFun			:== 114
+PD_UnqArraySelectFun		:== 115
+PD_ArrayUpdateFun			:== 116
+PD_ArrayReplaceFun			:== 117
+PD_ArraySizeFun				:== 118
+PD_UnqArraySizeFun			:== 119
 
 /* Enum/Comprehension functions */
 
-PD_SmallerFun				:== 116
-PD_IncFun					:== 117
-PD_From						:== 118
-PD_FromThen					:== 119
-PD_FromTo					:== 120
-PD_FromThenTo				:== 121
+PD_SmallerFun				:== 120
+PD_IncFun					:== 121
+PD_From						:== 122
+PD_FromThen					:== 123
+PD_FromTo					:== 124
+PD_FromThenTo				:== 125
 
 /* Dynamics */
 
-PD_TypeCodeClass			:== 122
+PD_TypeCodeClass			:== 126
 
-PD_TypeObjectType			:== 124
-PD_TypeConsSymbol			:== 125
-PD_unify					:== 126
+PD_TypeObjectType			:== 127
+PD_TypeConsSymbol			:== 128
+PD_unify					:== 129
 // MV ..
-PD_coerce					:== 127
-PD_variablePlaceholder		:== 128
-PD_StdDynamics				:== 129
-PD_undo_indirections		:== 130
-
-PD_Start					:== 134
+PD_coerce					:== 130
+PD_variablePlaceholder		:== 131
+PD_StdDynamics				:== 132
+PD_undo_indirections		:== 133
+
+/* Generics */
+PD_StdGeneric				:== 134
+PD_TypeISO					:== 135
+PD_ConsISO					:== 136
+PD_iso_to					:== 137
+PD_iso_from					:== 138
+
+PD_TypeUNIT					:== 139
+PD_ConsUNIT					:== 140
+PD_TypeEITHER				:== 141
+PD_ConsLEFT					:== 142
+PD_ConsRIGHT				:== 143
+PD_TypePAIR					:== 144
+PD_ConsPAIR					:== 145
+PD_TypeARROW				:== 146
+PD_ConsARROW				:== 147
+
+PD_isomap_ARROW_			:== 148
+PD_isomap_ID				:== 149
+
+/* StdMisc */
+PD_StdMisc					:== 150
+PD_abort					:== 151
+PD_undef					:== 152
+
+PD_Start					:== 153
 
 // MW..
-PD_DummyForStrictAliasFun	:== 135
+PD_DummyForStrictAliasFun	:== 154
 
-PD_NrOfPredefSymbols		:== 136
+PD_NrOfPredefSymbols		:== 155
 // ..MW
 
 
@@ -139,7 +166,7 @@ where
 				= build_variables (inc var_number) max_arity (tables <<= (var_name, PD_TypeVar_a0 + var_number))
 
 	fill_table_with_hashing tables
-		# tables	= tables
+		# (predefs, hash_table) = tables	
 					<<- ("StdArray", IC_Module, PD_StdArray) <<- ("StdEnum", IC_Module, PD_StdEnum) <<- ("StdBool", IC_Module, PD_StdBool)
 					<<- ("&&", IC_Expression, PD_AndOp) <<- ("||", IC_Expression, PD_OrOp)
 					<<- ("Array", IC_Class, PD_ArrayClass)
@@ -163,21 +190,46 @@ where
 					<<-	("_coerce",				IC_Expression, PD_coerce) /* MV */
 					<<- ("StdDynamic",			IC_Module, PD_StdDynamics)
 					<<- ("_undo_indirections",	IC_Expression, PD_undo_indirections)
-// MV ...
+// MV..
 					<<- ("DynamicTemp",			IC_Type, PD_DynamicTemp)
-
-		# (predef_symbol_table,hash_table)
-			= tables
-		# ({pds_ident},predef_symbol_table)
-			= predef_symbol_table![PD_DynamicTemp]
-			
-		# tables = (predef_symbol_table,hash_table)
-					<<- ("type",				IC_Field pds_ident, PD_DynamicType)
-					<<- ("value",				IC_Field pds_ident, PD_DynamicValue)
-					<<- ("Start",				IC_Expression, PD_Start)
+// ..MV
 					
-		= tables
-// ... MV
+// AA..
+					<<- ("StdGeneric",			IC_Module, 		PD_StdGeneric)
+					<<- ("ISO",					IC_Type, 		PD_TypeISO)
+					<<- ("_ISO",				IC_Expression, 	PD_ConsISO)					
+					//<<- ("iso_from",			IC_Field {id_name="", id_info=nilPtr}, PD_iso_from)
+					//<<- ("iso_to",			IC_Field {id_name="", id_info=nilPtr}, PD_iso_to)					
+					<<- ("UNIT",				IC_Type, 		PD_TypeUNIT)
+					<<- ("UNIT",				IC_Expression,	PD_ConsUNIT)
+					<<- ("EITHER",				IC_Type, 		PD_TypeEITHER)
+					<<- ("LEFT",				IC_Expression,	PD_ConsLEFT)
+					<<- ("RIGHT",				IC_Expression,	PD_ConsRIGHT)
+					<<- ("PAIR",				IC_Type, 		PD_TypePAIR)					
+					<<- ("PAIR",				IC_Expression,	PD_ConsPAIR)					
+					<<- ("ARROW",				IC_Type, 		PD_TypeARROW)
+					<<- ("ARROW",				IC_Expression, 	PD_ConsARROW)										
+					<<- ("isomap_ARROW_",		IC_Expression, 	PD_isomap_ARROW_)										
+					<<- ("isomap_ID",			IC_Expression, 	PD_isomap_ID)										
+
+					<<- ("StdMisc",				IC_Module, 		PD_StdMisc)
+					<<- ("abort",				IC_Expression, 	PD_abort)
+					<<- ("undef",				IC_Expression, 	PD_undef)					
+// ..AA					
+					
+					<<- ("Start",				IC_Expression, PD_Start)
+
+		# ({pds_ident}, predefs) = predefs![PD_TypeISO]
+		# (predefs, hash_table)= (predefs, hash_table) 
+			<<- ("iso_from", 			IC_Field pds_ident, PD_iso_from)
+			<<- ("iso_to", 				IC_Field pds_ident, PD_iso_to)
+
+		# ({pds_ident}, predefs) = predefs![PD_DynamicTemp]
+		# (predefs, hash_table)= (predefs, hash_table) 
+			<<- ("type",				IC_Field pds_ident, PD_DynamicType)
+			<<- ("value",				IC_Field pds_ident, PD_DynamicValue)
+			<<- ("Start",				IC_Expression, PD_Start)
+		= (predefs, hash_table)
 
 MakeTupleConsSymbIndex arity 	:== arity - 2 + cArity2TupleConsSymbIndex
 MakeTupleTypeSymbIndex arity 	:== arity - 2 + cArity2TupleTypeSymbIndex
@@ -250,7 +302,7 @@ buildPredefinedModule pre_def_symbols
 		 mod_defs = {
 			def_types = [string_def, list_def : type_defs], def_constructors
 						= [ParsedConstructorToConsDef cons_def, ParsedConstructorToConsDef nil_def : cons_defs], def_selectors = [], def_classes = [class_def],
-			def_macros = { ir_from = 0, ir_to = 0 }, def_members = [member_def], def_funtypes = [alias_dummy_type], def_instances = [] }}, pre_def_symbols)
+			def_macros = { ir_from = 0, ir_to = 0 }, def_members = [member_def], def_funtypes = [alias_dummy_type], def_instances = [], /* AA */ def_generics = [] }}, pre_def_symbols)
 where
 	add_tuple_defs pre_mod_id tup_arity type_defs cons_defs pre_def_symbols
 		| tup_arity >= 2
@@ -273,7 +325,7 @@ where
 
 	new_defined_symbol symbol_index arity ds_index pre_def_symbols
 		# (ds_ident, pre_def_symbols) = pre_def_symbols![symbol_index]
-		= ({ ds_ident = ds_ident.pds_ident, ds_arity = 2, ds_index = ds_index }, pre_def_symbols)
+		= ({ ds_ident = ds_ident.pds_ident, ds_arity = arity/*AA: was 2*/, ds_index = ds_index }, pre_def_symbols)
 	
 	make_type_def type_cons_index type_vars type_rhs pre_def_symbols
 		# (type_ident, pre_def_symbols) = pre_def_symbols![type_cons_index]
diff --git a/frontend/scanner.dcl b/frontend/scanner.dcl
index daa8bab..6ec95bf 100644
--- a/frontend/scanner.dcl
+++ b/frontend/scanner.dcl
@@ -88,7 +88,6 @@ instance <<< FilePosition
 	|	DynamicToken			//		dynamic
 	|	DynamicTypeToken		//		Dynamic
 
-	
 	|	PriorityToken Priority	//		infixX N
 
 	|	CodeToken				//		code
@@ -99,6 +98,11 @@ instance <<< FilePosition
 	|	EndGroupToken			//		generated automatically
 	|	EndOfFileToken			//		end of file
 	|	ErrorToken String		//		if an error occured
+
+	| 	GenericToken			//		generic	
+	|	GenericOpenToken		//		{|
+	|	GenericCloseToken		//		|}
+
 	
 :: Context
 	=	GeneralContext
diff --git a/frontend/scanner.icl b/frontend/scanner.icl
index d0f3fe7..9ff470f 100644
--- a/frontend/scanner.icl
+++ b/frontend/scanner.icl
@@ -185,6 +185,11 @@ where
 	|	EndOfFileToken			//		end of file
 	|	ErrorToken String		//		an error has occured
 
+	| 	GenericToken			//		generic
+	|	GenericOpenToken		//		{|
+	|	GenericCloseToken		//		|}
+
+
 ::	Context
 	=	GeneralContext
 	|	TypeContext
@@ -565,13 +570,21 @@ Scan :: !Char !Input !Context -> (!Token, !Input)
 Scan '(' input co			= (OpenToken, input)
 Scan ')' input co			= (CloseToken, input)
 Scan '{' input CodeContext	= ScanCodeBlock input
-Scan '{' input co			= (CurlyOpenToken, input)
+//Scan '{' input co			= (CurlyOpenToken, input)
+// AA ...
+Scan c0=:'{' input co
+	# (eof, c1, input)		= ReadNormalChar input
+	| eof					= (CurlyOpenToken, input)
+	| c1 == '|'				= (GenericOpenToken, input)
+							= (CurlyOpenToken, charBack input)
+// ... AA
 Scan '}' input co			= (CurlyCloseToken, input)
 Scan '[' input co			= (SquareOpenToken, input)
 Scan ']' input co			= (SquareCloseToken, input)
 Scan c0=:'|' input co
 	# (eof, c1, input)		= ReadNormalChar input
 	| eof					= (BarToken, input)
+	| c1 == '}'				= (GenericCloseToken, input) // AA
 	| isSpecialChar c1		= ScanOperator 1 input [c1, c0] co
 							= (BarToken, charBack input)
 Scan ',' input co			= (CommaToken, input)
@@ -765,6 +778,7 @@ CheckEveryContext s input
 	"with"		->	(WithToken			, input)
 	"class" 	->	(ClassToken			, input)
 	"instance"	->	(InstanceToken		, input)
+	"generic" 	->	(GenericToken		, input)
 	"otherwise"	->	(OtherwiseToken		, input)
 	"!"			->	(ExclamationToken	, input)
 //	"::"		->	(DoubleColonToken	, input)
@@ -1522,6 +1536,8 @@ where
 	toString CurlyCloseToken		= "}"
 	toString SquareOpenToken		= "["
 	toString SquareCloseToken		= "]"
+	toString GenericOpenToken		= "{|"
+	toString GenericCloseToken		= "|}"	
 	toString DotToken				= "."
 	toString SemicolonToken			= ";"
 	toString ColonToken				= ": (ColonToken)"
diff --git a/frontend/syntax.dcl b/frontend/syntax.dcl
index 845043e..a30e5ab 100644
--- a/frontend/syntax.dcl
+++ b/frontend/syntax.dcl
@@ -42,6 +42,7 @@ instance toString Ident
 				| STE_Field !Ident
 				| STE_Class
 				| STE_Member
+				| STE_Generic			// AA: For generic declarations
 				| STE_Instance !Ident // argument: the class (used in explicitimports (1.3 syntax only))
 				| STE_Variable !VarInfoPtr
 				| STE_TypeVariable !TypeVarInfoPtr
@@ -116,6 +117,7 @@ instance toString Ident
 	,	def_macros			:: !macro_defs
 	,	def_classes			:: ![ClassDef]
 	,	def_members			:: ![MemberDef]
+	,	def_generics		:: ![GenericDef] // AA
 	,	def_funtypes		:: ![FunType]
 	,	def_instances		:: ![instance_kind]
 	}
@@ -159,6 +161,7 @@ cIsNotAFunction :== False
 	|	PD_Type ParsedTypeDef
 	|	PD_TypeSpec Position Ident Priority (Optional SymbolType) Specials
 	|	PD_Class ClassDef [ParsedDefinition]
+	|	PD_Generic GenericDef // AA
 	|	PD_Instance (ParsedInstance ParsedDefinition)
 	|	PD_Instances [ParsedInstance ParsedDefinition]
 	|	PD_Import [ParsedImport]
@@ -197,6 +200,7 @@ cNameLocationDependent :== True
 	,	pi_pos		:: !Position
 	,	pi_members	:: ![member]
 	,	pi_specials	:: !Specials
+	,	pi_generate  :: !Bool // AA: instance is to be generated
 	}
 
 /*
@@ -265,6 +269,20 @@ cNameLocationDependent :== True
 	,	me_priority 	:: !Priority
 	}
 
+// AA ... 
+::	GenericDef = 
+	{	gen_name		:: !Ident	// the generics name in the IC_Class
+	,	gen_member_name	:: !Ident	// the generics name in the IC_Member
+	,	gen_args		:: ![TypeVar]
+	, 	gen_arity 		:: !Int		// number of gen_args
+	,	gen_type		:: !SymbolType
+	, 	gen_pos			:: !Position
+	, 	gen_classes		:: ![DefinedSymbol] // generated classes
+	,	gen_isomap		:: !DefinedSymbol	// isomap function
+	}
+	
+// ... AA
+
 ::	InstanceType =
 	{	it_vars			:: [TypeVar]
 	,	it_types		:: ![Type]
@@ -279,6 +297,9 @@ cNameLocationDependent :== True
 	,	ins_members		:: !{# DefinedSymbol}
 	,	ins_specials	:: !Specials
 	,	ins_pos			:: !Position
+	,	ins_is_generic	:: !Bool				//AA 
+	, 	ins_generate	:: !Bool				//AA
+	,	ins_generic		:: !Global Index		//AA 	
 	}
 
 /*
@@ -573,6 +594,7 @@ cNonRecursiveAppl	:== False
 				| SK_Function !(Global Index)
 				| SK_LocalMacroFunction !Index
 				| SK_OverloadedFunction !(Global Index)
+				| SK_Generic !(Global Index) !TypeKind		// AA
 				| SK_Constructor !(Global Index)
 				| SK_Macro !(Global Index)
 //				| SK_RecordSelector !(Global Index)
@@ -795,6 +817,7 @@ cNonRecursiveAppl	:== False
 			|	TempQV !TempVarId				/* Auxiliary, used during type checking */
 
 			|	TLifted !TypeVar				/* Auxiliary, used during type checking of lifted arguments */
+
 			|	TE
 
 ::	ConsVariable = CV 		!TypeVar
@@ -877,7 +900,13 @@ cNonRecursiveAppl	:== False
 ::	BasicValue	= BVI !String | BVC !String | BVB !Bool | BVR !String | BVS !String
 
 
-::	TypeKind = KindVar !KindInfoPtr | KindConst | KindArrow !Int
+//::	TypeKind = KindVar !KindInfoPtr | KindConst | KindArrow !Int
+::	TypeKind = KindVar !KindInfoPtr | KindConst | KindArrow ![TypeKind]
+
+instance toString TypeKind
+instance <<< TypeKind
+instance == TypeKind
+instance toString KindInfo
 
 /* A few obscure type definitions */
 
@@ -967,6 +996,9 @@ cNonUniqueSelection	:== False
 
 				| PE_DynamicPattern !ParsedExpr !DynamicType
 				| PE_Dynamic !ParsedExpr !(Optional DynamicType)
+				
+				| PE_Generic !Ident !TypeKind	/* AA: For generics, kind indexed identifier */
+				
 				| PE_Empty
 
 ::	ParsedSelection	= PS_Record !Ident !(Optional Ident)
@@ -1259,7 +1291,11 @@ ParsedConstructorToConsDef pc :==
 ParsedInstanceToClassInstance pi members :==
  	{	ins_class = {glob_object = MakeDefinedSymbol pi.pi_class NoIndex (length pi.pi_types), glob_module = NoIndex}, ins_ident = pi.pi_ident, 
  		ins_type = { it_vars = [], it_types = pi.pi_types, it_attr_vars = [],
- 					 it_context = pi.pi_context }, ins_members = members, ins_specials = pi.pi_specials, ins_pos = pi.pi_pos }
+ 					 it_context = pi.pi_context }, ins_members = members, ins_specials = pi.pi_specials, ins_pos = pi.pi_pos, 
+ 		/*AA*/
+ 		ins_is_generic = False, 
+ 		ins_generate = pi.pi_generate, 
+ 		ins_generic = {glob_module = NoIndex, glob_object = NoIndex}}
 
 MakeTypeDef name lhs rhs attr contexts pos  :== 
 	{	td_name = name, td_index = -1, td_arity = length lhs, td_args = lhs, td_attrs = [], td_attribute = attr, td_context = contexts,
diff --git a/frontend/syntax.icl b/frontend/syntax.icl
index d5201ae..6385d81 100644
--- a/frontend/syntax.icl
+++ b/frontend/syntax.icl
@@ -43,6 +43,7 @@ where toString {import_module} = toString import_module
 				| STE_Field !Ident
 				| STE_Class
 				| STE_Member
+				| STE_Generic			// AA: For generic declarations
 				| STE_Instance !Ident // the class (for explicit imports (1.3 syntax only))
 				| STE_Variable !VarInfoPtr
 				| STE_TypeVariable !TypeVarInfoPtr
@@ -104,6 +105,7 @@ where toString {import_module} = toString import_module
 	,	def_macros			:: !macro_defs
 	,	def_classes			:: ![ClassDef]
 	,	def_members			:: ![MemberDef]
+	,	def_generics		:: ![GenericDef] // AA
 	,	def_funtypes		:: ![FunType]
 	,	def_instances		:: ![instance_kind]
 	}
@@ -145,6 +147,7 @@ cIsNotAFunction :== False
 	|	PD_Type ParsedTypeDef
 	|	PD_TypeSpec Position Ident Priority (Optional SymbolType) Specials
 	|	PD_Class ClassDef [ParsedDefinition]
+	|	PD_Generic GenericDef // AA
 	|	PD_Instance (ParsedInstance ParsedDefinition)
 	|	PD_Instances [ParsedInstance ParsedDefinition]
 	|	PD_Import [ParsedImport]
@@ -183,6 +186,7 @@ cNameLocationDependent :== True
 	,	pi_pos		:: !Position
 	,	pi_members	:: ![member]
 	,	pi_specials	:: !Specials
+	,	pi_generate  :: !Bool // AA: instance is to be generated
 	}
 
 
@@ -248,6 +252,19 @@ cNameLocationDependent :== True
 	,	me_priority 	:: !Priority
 	}
 
+// AA.. 
+::	GenericDef = 
+	{	gen_name		:: !Ident	// the generics name in IC_Class 
+	,	gen_member_name	:: !Ident	// the generics name in IC_Member
+	,	gen_args		:: ![TypeVar]
+	,	gen_arity		:: !Int 		// number of gen_args 
+	,	gen_type		:: !SymbolType
+	, 	gen_pos			:: !Position
+	, 	gen_classes		:: ![DefinedSymbol] // generated classes
+	,	gen_isomap		:: !DefinedSymbol	// isomap function
+	}
+
+// ..AA
 
 ::	InstanceType =
 	{	it_vars			:: [TypeVar]
@@ -263,6 +280,9 @@ cNameLocationDependent :== True
 	,	ins_members		:: !{# DefinedSymbol}
 	,	ins_specials	:: !Specials
 	,	ins_pos			:: !Position
+	,	ins_is_generic	:: !Bool			//AA 
+	, 	ins_generate	:: !Bool			//AA
+	,	ins_generic		:: !Global Index	//AA
 	}
 
 ::	Import from_symbol =
@@ -523,6 +543,7 @@ cNotVarNumber :== -1
 				| SK_Function !(Global Index)
 				| SK_LocalMacroFunction !Index
 				| SK_OverloadedFunction !(Global Index)
+				| SK_Generic !(Global Index) !TypeKind		// AA
 				| SK_Constructor !(Global Index)
 				| SK_Macro !(Global Index)
 //				| SK_RecordSelector !(Global Index)
@@ -740,6 +761,7 @@ cNotVarNumber :== -1
 			|	TempQV !TempVarId				/* Auxiliary, used during type checking */
 
 			|	TLifted !TypeVar				/* Auxiliary, used during type checking of lifted arguments */
+
 			|	TE
 
 ::	ConsVariable = CV 		!TypeVar
@@ -824,7 +846,8 @@ cNotVarNumber :== -1
 ::	BasicValue	= BVI !String | BVC !String | BVB !Bool | BVR !String | BVS !String
 
 
-::	TypeKind = KindVar !KindInfoPtr | KindConst | KindArrow !Int
+//::	TypeKind = KindVar !KindInfoPtr | KindConst | KindArrow !Int
+::	TypeKind = KindVar !KindInfoPtr | KindConst | KindArrow ![TypeKind]
 
 ::	Occurrence =
 	{	occ_ref_count	:: !ReferenceCount
@@ -917,6 +940,9 @@ cNonUniqueSelection	:== False
 
 				| PE_DynamicPattern !ParsedExpr !DynamicType
 				| PE_Dynamic !ParsedExpr !(Optional DynamicType)
+				
+				| PE_Generic !Ident !TypeKind	/* AA: For generics, kind indexed identifier */
+				
 				| PE_Empty
 
 ::	ParsedSelection	= PS_Record !Ident !(Optional Ident)
@@ -1621,20 +1647,43 @@ where
 				| sc_neg_vect bitand index_bit == 0
 					= write_signs (file <<< '+') (sc_pos_vect bitand (bitnot index_bit)) sc_neg_vect (inc index)
 					= write_signs (file <<< 'T') (sc_pos_vect bitand (bitnot index_bit)) (sc_neg_vect bitand (bitnot index_bit)) (inc index)
+
+// AA..
+instance toString TypeKind
+where
+	toString (KindVar _) 		= "**"
+	toString KindConst			= "*"
+//	toString (KindArrow args) 	= toString (length args) 
+	toString (KindArrow args) 	= "{" +++ (to_string args) +++ "}" 
+	where
+		to_string []		= "??????" 
+		to_string [k]		= toString k  
+		to_string [k:ks]	= (toString k) +++ "->" +++ (to_string ks)
+
+// ..AA
+
 				
 instance <<< TypeKind
 where
-	(<<<) file (KindVar _) = file <<< "**"
-	(<<<) file KindConst
-		= file <<< '*'
-	(<<<) file (KindArrow arity)
-		= write_kinds file arity
+	(<<<) file kind 		= file <<< (toString kind)
+
+instance == TypeKind 
+where
+	(==) KindConst KindConst = True
+	(==) (KindArrow xs) (KindArrow ys) = xs == ys
+	(==) _ _ = False
+				
+
+instance toString KindInfo
+where
+	toString (KI_Var ptr) 		= "*" +++ toString (ptrToInt ptr)
+	toString (KI_Const) 		= "*"
+	toString (KI_Arrow kinds)	= kind_list_to_string kinds
 	where
-		write_kinds file 1
-			= file <<< "* -> *"
-		write_kinds file n
-			= write_kinds (file <<< "* -> ") (dec n)
-		
+		kind_list_to_string [] = " ?????? "
+		kind_list_to_string [k] = "* -> *"
+		kind_list_to_string [k:ks] = "* -> " +++ kind_list_to_string ks
+
 
 instance <<< TypeDefInfo
 where
@@ -1855,6 +1904,11 @@ where
 	(<<<) file
 		STE_Class
 			= file <<< "STE_Class"
+// AA..			
+	(<<<) file
+		STE_Generic
+			= file <<< "STE_Generic"
+// ..AA
 	(<<<) file
 		(STE_Field _)
 			= file <<< "STE_Field"
@@ -1980,7 +2034,11 @@ ParsedConstructorToConsDef pc :==
 ParsedInstanceToClassInstance pi members :==
  	{	ins_class = {glob_object = MakeDefinedSymbol pi.pi_class NoIndex (length pi.pi_types), glob_module = NoIndex}, ins_ident = pi.pi_ident, 
  		ins_type = { it_vars = [], it_types = pi.pi_types, it_attr_vars = [],
- 					 it_context = pi.pi_context }, ins_members = members, ins_specials = pi.pi_specials, ins_pos = pi.pi_pos }
+ 					 it_context = pi.pi_context }, ins_members = members, ins_specials = pi.pi_specials, ins_pos = pi.pi_pos, 
+ 		/*AA*/
+  		ins_is_generic = False, 
+ 		ins_generate = pi.pi_generate, 
+ 		ins_generic = {glob_module = NoIndex, glob_object = NoIndex}}
 
 MakeTypeDef name lhs rhs attr contexts pos  :== 
 	{	td_name = name, td_index = -1, td_arity = length lhs, td_args = lhs, td_attrs = [], td_attribute = attr, td_context = contexts,
diff --git a/frontend/type.dcl b/frontend/type.dcl
index 359c3a3..621ba84 100644
--- a/frontend/type.dcl
+++ b/frontend/type.dcl
@@ -3,11 +3,16 @@ definition module type
 import StdArray
 import syntax, check
 
-typeProgram ::!{! Group} !Int !*{# FunDef} !IndexRange !(Optional Bool) !CommonDefs ![Declaration] !{# DclModule} !NumberSet !*Heaps !*PredefinedSymbols !*File !*File !{# DclModule}
-	-> (!Bool, !*{# FunDef}, !IndexRange, {! GlobalTCType}, !{# CommonDefs}, !{# {# FunType} }, !.TypeDefInfos, !*Heaps, !*PredefinedSymbols, !*File, !*File)
+typeProgram ::!{! Group} !Int !*{# FunDef} !IndexRange  !(Optional Bool) !CommonDefs ![Declaration] !{# DclModule} !NumberSet !*TypeDefInfos !*Heaps !*PredefinedSymbols !*File !*File !{# DclModule}
+	-> (!Bool, !*{# FunDef}, !IndexRange, {! GlobalTCType}, !{# CommonDefs}, !{# {# FunType} }, !*TypeDefInfos, !*Heaps, !*PredefinedSymbols, !*File, !*File)
+//typeProgram ::!{! Group} !Int !*{# FunDef} !IndexRange !(Optional Bool) !CommonDefs ![Declaration] !{# DclModule} !NumberSet !*Heaps !*PredefinedSymbols !*File !*File !{# DclModule}
+//	-> (!Bool, !*{# FunDef}, !IndexRange, {! GlobalTCType}, !{# CommonDefs}, !{# {# FunType} }, !.TypeDefInfos, !*Heaps, !*PredefinedSymbols, !*File, !*File)
 
 addPropagationAttributesToAType :: {#CommonDefs} !AType !*PropState -> *(!AType,Int,!*PropState);
 
+buildCurriedType :: [AType] AType TypeAttribute [AttrCoercion] Int 
+	-> (AType,[AttrCoercion],Int) // AA: exported from the module
+
 ::	PropState =
 	{	prop_type_heaps	:: !.TypeHeaps
 	,	prop_td_infos	:: !.TypeDefInfos
diff --git a/frontend/type.icl b/frontend/type.icl
index 2962f5a..d7c1c73 100644
--- a/frontend/type.icl
+++ b/frontend/type.icl
@@ -3,6 +3,7 @@ implementation module type
 import StdEnv
 import syntax, typesupport, check, analtypes, overloading, unitype, refmark, predef, utilities, compare_constructor // , RWSDebug
 import cheat
+import generics // AA
 
 ::	TypeInput =
 	{	ti_common_defs	:: !{# CommonDefs }
@@ -408,8 +409,10 @@ cannotUnify t1 t2 position=:(CP_Expression expr) err=:{ea_loc=[ip:_]}
 			# err = pushErrorAdmin { ip & ip_ident.id_name = id_name, ip_line = line } err
 			  err = errorHeading type_error err
 			  err = popErrorAdmin err
-			-> { err & ea_file = err.ea_file <<< " cannot unify " <:: (type_error_format, t1, Yes initialTypeVarBeautifulizer) 
-											<<< " with " <:: (type_error_format, t2, Yes initialTypeVarBeautifulizer) <<< '\n' }
+//			-> { err & ea_file = err.ea_file <<< " cannot unify " <:: (type_error_format, t1, Yes initialTypeVarBeautifulizer) 
+//											<<< " with " <:: (type_error_format, t2, Yes initialTypeVarBeautifulizer) <<< '\n' }
+			-> { err & ea_file = err.ea_file <<< " cannot unify " <:: (type_error_format, t1, No) 
+											<<< " with " <:: (type_error_format, t2, No) <<< '\n' }
 		_
 			-> cannot_unify t1 t2 position err 
 cannotUnify t1 t2 position err 
@@ -422,8 +425,10 @@ cannot_unify t1 t2 position err
 					-> ea_file <<< "\"" <<< position <<< "\""
 				_
 					-> ea_file
-	  ea_file = ea_file <<< " cannot unify " <:: (type_error_format, t1, Yes initialTypeVarBeautifulizer) 
-						<<< " with " <:: (type_error_format, t2, Yes initialTypeVarBeautifulizer)
+	  ea_file = ea_file <<< " cannot unify " <:: (type_error_format, t1, No) 
+						<<< " with " <:: (type_error_format, t2, No)
+//	  ea_file = ea_file <<< " cannot unify " <:: (type_error_format, t1, Yes initialTypeVarBeautifulizer) 
+//						<<< " with " <:: (type_error_format, t2, Yes initialTypeVarBeautifulizer)
 	  ea_file = case position of
 	  			CP_FunArg _ _
 	  				-> ea_file
@@ -741,6 +746,7 @@ where
 cWithFreshContextVars 		:== True		
 cWithoutFreshContextVars 	:== False		
 
+freshSymbolType :: !Bool !SymbolType {#u:CommonDefs} !*TypeState -> (!TempSymbolType,![Int],!*TypeState)
 freshSymbolType fresh_context_vars st=:{st_vars,st_args,st_result,st_context,st_attr_vars,st_attr_env,st_arity} common_defs
 				ts=:{ts_var_store,ts_attr_store,ts_type_heaps,ts_td_infos,ts_var_heap}
 	# (th_vars, ts_var_store)		= fresh_type_variables st_vars (ts_type_heaps.th_vars, ts_var_store)
@@ -753,7 +759,7 @@ freshSymbolType fresh_context_vars st=:{st_vars,st_args,st_result,st_context,st_
 	  cons_variables				= foldSt (collect_cons_variables_in_tc common_defs) tst_context []
 	= ({ tst_args = tst_args, tst_result = tst_result, tst_context = tst_context, tst_attr_env = attr_env, tst_arity = st_arity, tst_lifted = 0 }, cons_variables,
 	   { ts & ts_var_store = ts_var_store, ts_attr_store = ts_attr_store, ts_type_heaps = copy_heaps, ts_var_heap = ts_var_heap})
-//		---> ("freshSymbolType", tst_args, tst_result, tst_context)
+		//---> ("freshSymbolType", st, tst_args, tst_result, tst_context)
 	where
 		fresh_type_variables :: .[TypeVar] *(*Heap TypeVarInfo,.Int) -> (!.Heap TypeVarInfo,!Int);
 		fresh_type_variables type_variables state
@@ -960,8 +966,8 @@ addPropagationAttributesToAType modules type=:{at_type = TA cons_id=:{type_index
 		
 			my_kind_to_int KindConst
 				= 0
-			my_kind_to_int (KindArrow int_kind)
-				= int_kind
+			my_kind_to_int (KindArrow k)
+				= length k
 
 addPropagationAttributesToAType modules type=:{at_type} ps
 	# (at_type, ps) = addPropagationAttributesToType modules at_type ps
@@ -1017,6 +1023,8 @@ where
 
 emptyIdent =: { id_name = "", id_info = nilPtr }
 
+buildCurriedType :: [AType] AType TypeAttribute [AttrCoercion] Int 
+	-> (AType,[AttrCoercion],Int) //AA: exported from the module
 buildCurriedType [] type cum_attr attr_env attr_store
 	= (type, attr_env, attr_store)
 buildCurriedType [at=:{at_attribute}:ats] type cum_attr attr_env attr_store
@@ -1111,7 +1119,7 @@ getSymbolType ti=:{ti_functions,ti_common_defs,ti_main_dcl_module_n} {symb_kind
 				  (fun_type_copy,ts) = currySymbolType fun_type_copy symb_arity ts
 				-> (fun_type_copy, cons_variables, [], ts)
 			_
-				-> abort ("getSymbolType "+++toString symb_name+++toString glob_object)
+				-> abort ("getSymbolType: SK_Function "+++toString symb_name+++" "+++toString glob_object)
 //				-> abort "getSymbolType (type.icl)" ---> (symb_name, glob_object, fun_type)
 		# {ft_type,ft_type_ptr,ft_specials} = ti_functions.[glob_module].[glob_object]
 		| glob_module>=size ti_functions || glob_object>=size ti_functions.[glob_module]
@@ -1142,12 +1150,19 @@ getSymbolType ti=:{ti_functions,ti_common_defs,ti_main_dcl_module_n} {symb_kind
 			  (fun_type_copy,ts) = currySymbolType fun_type_copy symb_arity ts
 			-> (fun_type_copy, cons_variables, [], ts)
 		_
-			-> abort ("getSymbolType "+++toString symb_name+++toString glob_object)
+			-> abort ("getSymbolType SK_LocalMacroFunction: "+++toString symb_name+++" " +++toString glob_object)
 //			-> abort "getSymbolType (type.icl)" ---> (symb_name, glob_object, fun_type)
 getSymbolType ti=:{ti_common_defs} {symb_kind = SK_OverloadedFunction {glob_module,glob_object}, symb_arity} ts
 	# {me_symb, me_type,me_type_ptr} = ti_common_defs.[glob_module].com_member_defs.[glob_object]
 	  (fun_type_copy, cons_variables, ts) = determineSymbolTypeOfFunction me_symb symb_arity me_type me_type_ptr ti_common_defs ts
 	= (fun_type_copy, cons_variables, [], ts)
+// AA..	
+getSymbolType ti=:{ti_common_defs} symbol=:{symb_kind = SK_Generic gen_glob kind} ts
+	# (found, member_glob) = getGenericMember gen_glob kind ti_common_defs
+	| not found
+		= abort "getSymbolType: no class for kind"	
+ 	= getSymbolType ti {symbol & symb_kind = SK_OverloadedFunction member_glob} ts  		
+// ..AA	
 
 class requirements a :: !TypeInput !a !(!u:Requirements, !*TypeState) -> (!AType, !Optional ExprInfoPtr, !(!u:Requirements, !*TypeState))
 
@@ -1160,7 +1175,7 @@ where
 			VI_Type type _
 				-> type
 			_
-				-> abort "requirements BoundVar" // ---> (var_name <<- var_info))
+				-> abort "requirements BoundVar " // ---> (var_name <<- var_info))
 			, Yes var_expr_ptr, (reqs, ts))
 
 instance requirements App
@@ -1581,7 +1596,7 @@ makeBase fun_or_cons_ident arg_nr [{fv_name, fv_info_ptr}:vars] [type:types] ts_
 	# optional_position = if (is_rare_name fv_name) (Yes (CP_FunArg fun_or_cons_ident arg_nr)) No
 	  ts_var_heap = ts_var_heap <:= (fv_info_ptr, VI_Type type optional_position)
 	= makeBase fun_or_cons_ident (arg_nr+1) vars types ts_var_heap
-
+	 	
 attributedBasicType (BT_String string_type) ts=:{ts_attr_store}
 	= ({ at_annotation = AN_None, at_attribute = TA_TempVar ts_attr_store, at_type = string_type}, {ts & ts_attr_store = inc ts_attr_store})
 attributedBasicType bas_type ts=:{ts_attr_store}
@@ -1850,23 +1865,52 @@ addLiftedArgumentsToSymbolType st=:{st_arity,st_args,st_vars,st_attr_vars,st_con
 	,	fe_location		:: !IdentPos
 	}
 
-typeProgram ::!{! Group} !Int !*{# FunDef} !IndexRange  !(Optional Bool) !CommonDefs ![Declaration] !{# DclModule} !NumberSet !*Heaps !*PredefinedSymbols !*File !*File !{# DclModule}
-	-> (!Bool, !*{# FunDef}, !IndexRange, {! GlobalTCType}, !{# CommonDefs}, !{# {# FunType} }, !.TypeDefInfos, !*Heaps, !*PredefinedSymbols, !*File, !*File)
-typeProgram comps main_dcl_module_n fun_defs specials list_inferred_types icl_defs imports modules used_module_numbers heaps=:{hp_var_heap, hp_expression_heap, hp_type_heaps} predef_symbols file out dcl_modules
+typeProgram ::!{! Group} !Int !*{# FunDef} !IndexRange  !(Optional Bool) !CommonDefs ![Declaration] !{# DclModule} !NumberSet !*TypeDefInfos !*Heaps !*PredefinedSymbols !*File !*File !{# DclModule} 
+	-> (!Bool, !*{# FunDef}, !IndexRange, {! GlobalTCType}, !{# CommonDefs}, !{# {# FunType} }, !*TypeDefInfos, !*Heaps, !*PredefinedSymbols, !*File, !*File)
+typeProgram comps main_dcl_module_n fun_defs specials list_inferred_types icl_defs imports modules used_module_numbers td_infos heaps=:{hp_var_heap, hp_expression_heap, hp_type_heaps} predef_symbols file out dcl_modules
+
+//typeProgram ::!{! Group} !Int !*{# FunDef} !IndexRange  !(Optional Bool) !CommonDefs ![Declaration] !{# DclModule} !NumberSet !*Heaps !*PredefinedSymbols !*File !*File !{# DclModule}
+//	-> (!Bool, !*{# FunDef}, !IndexRange, {! GlobalTCType}, !{# CommonDefs}, !{# {# FunType} }, !.TypeDefInfos, !*Heaps, !*PredefinedSymbols, !*File, !*File)
+//typeProgram comps main_dcl_module_n fun_defs specials list_inferred_types icl_defs imports modules used_module_numbers heaps=:{hp_var_heap, hp_expression_heap, hp_type_heaps} predef_symbols file out dcl_modules
+
 	#! fun_env_size = size fun_defs
+
 	# ts_error = {ea_file = file, ea_loc = [], ea_ok = True }
 	  ti_common_defs = {{dcl_common \\ {dcl_common} <-: modules } & [main_dcl_module_n] = icl_defs }
-	  ti_functions	 = {dcl_functions \\ {dcl_functions} <-: modules }
+	  ti_functions	 = {dcl_functions \\ {dcl_functions} <-: modules }	  
 
 	  type_def_sizes =  [ size com_type_defs \\ {com_type_defs} <-: ti_common_defs ]
-	  class_def_sizes = [ size com_class_defs \\ {com_class_defs} <-: ti_common_defs ]
-	  class_instances = { {  IT_Empty \\ i <- [0 .. dec size] } \\ size <- class_def_sizes }
-	  
+      class_def_sizes = [ size com_class_defs \\ {com_class_defs} <-: ti_common_defs ]
+      class_instances = { {  IT_Empty \\ i <- [0 .. dec size] } \\ size <- class_def_sizes }
+
+/*
 	  (td_infos, hp_type_heaps, ts_error) = analTypeDefs ti_common_defs used_module_numbers hp_type_heaps ts_error
+	  
+	| not ts_error.ea_ok
+		= (ts_error.ea_ok, fun_defs, { ir_from = 0, ir_to = 0 }, {}, ti_common_defs, ti_functions, icl_defs, td_infos,
+			{ heaps & hp_type_heaps = hp_type_heaps }, predef_symbols, hash_table, ts_error.ea_file, out)
+
+*/
+// AA..
+/*
+	# ti_common_defs = {x \\ x <-: ti_common_defs }
 
+	# (ti_common_defs, comps, fun_defs, td_infos, hp_type_heaps, hp_var_heap, hash_table, predef_symbols, modules, ts_error) = 
+		convertGenerics main_dcl_module_n ti_common_defs comps fun_defs td_infos hp_type_heaps hp_var_heap hash_table predef_symbols modules ts_error
 	| not ts_error.ea_ok
-		= (ts_error.ea_ok, fun_defs, { ir_from = 0, ir_to = 0 }, {}, ti_common_defs, ti_functions, td_infos,
-			{ heaps & hp_type_heaps = hp_type_heaps }, predef_symbols, ts_error.ea_file, out)
+		= (ts_error.ea_ok, fun_defs, { ir_from = 0, ir_to = 0 }, {}, ti_common_defs, ti_functions, icl_defs, td_infos,
+			{ heaps & hp_type_heaps = hp_type_heaps,  hp_var_heap = hp_var_heap}, predef_symbols, hash_table, ts_error.ea_file, out)
+	# icl_defs = ti_common_defs.[main_dcl_module_n]	
+
+	#! fun_env_size = size fun_defs
+	# ti_functions = {dcl_functions \\ {dcl_functions} <-: modules }
+
+	# (td_infos, hp_type_heaps, ts_error) = analTypeDefs ti_common_defs used_module_numbers hp_type_heaps ts_error
+	# class_def_sizes = [ size com_class_defs \\ {com_class_defs} <-: ti_common_defs ]
+	# class_instances = { {  IT_Empty \\ i <- [0 .. dec size] } \\ size <- class_def_sizes }
+*/	
+// ..AA
+
 	# state = collect_imported_instances imports ti_common_defs {} ts_error class_instances hp_type_heaps.th_vars td_infos 
 	  (_, ts_error, class_instances, th_vars, td_infos) = collect_and_check_instances (size icl_defs.com_instance_defs) ti_common_defs state
 	  
@@ -1899,8 +1943,11 @@ where
 		= iFoldSt (update_instances_of_class common_defs main_dcl_module_n) 0 nr_of_instances state
 
 	update_instances_of_class common_defs mod_index ins_index (dummy, error, class_instances, type_var_heap, td_infos)
-		# {ins_class={glob_object={ds_index},glob_module},ins_type={it_types},ins_pos} = common_defs.[mod_index].com_instance_defs.[ins_index]
-		  (mod_instances, class_instances) = replace class_instances glob_module dummy
+		#!{ins_class={glob_object={ds_ident={id_name}, ds_index},glob_module},ins_type={it_types},ins_pos} = common_defs.[mod_index].com_instance_defs.[ins_index]
+		  id_name = id_name ---> ("update_instances_of_class" +++ id_name +++ " " +++ (toString glob_module) +++ 
+		  	" " +++ toString (size class_instances))	
+		  (mod_instances, class_instances) = replace class_instances glob_module dummy 
+		  id_name = id_name ---> "done"	
 		  (instances, mod_instances) = replace mod_instances ds_index IT_Empty
 		  (error, instances) = insert it_types ins_index mod_index common_defs error instances
 		  (_, mod_instances) = replace mod_instances ds_index instances
diff --git a/frontend/type_io.icl b/frontend/type_io.icl
index 7d1a56c..ec58cf3 100644
--- a/frontend/type_io.icl
+++ b/frontend/type_io.icl
@@ -462,6 +462,7 @@ where
 			,	com_class_defs		= {}
 			,	com_member_defs		= {}
 			,	com_instance_defs	= {}
+			,	com_generic_defs	= {}
 			}
 		= (ok1&&ok2,common_defs,tcl_file)