Index: src/ResolvExpr/CandidateFinder.cpp
===================================================================
--- src/ResolvExpr/CandidateFinder.cpp	(revision 61e362feab9ac30e7e3748f946b2cf384102b37b)
+++ src/ResolvExpr/CandidateFinder.cpp	(revision c75b30ae4d3f97678f27275a033614f675b7fdaf)
@@ -891,4 +891,18 @@
 		} else if ( auto unionInst = aggrExpr->result.as< ast::UnionInstType >() ) {
 			addAggMembers( unionInst, aggrExpr, *cand, Cost::unsafe, "" );
+		} else if ( auto enumInst = aggrExpr->result.as< ast::EnumInstType >() ) {
+			// The Attribute Arrays are not yet generated, need to proxy them
+			// as attribute function call
+			const CodeLocation & location = cand->expr->location;
+			if ( enumInst->base && enumInst->base->base ) {
+				auto valueName = new ast::NameExpr(location, "valueE");
+				auto untypedValueCall = new ast::UntypedExpr( 
+					location, valueName, { aggrExpr } );
+				auto result = ResolvExpr::findVoidExpression( untypedValueCall, context );
+				assert( result.get() );
+				CandidateRef newCand = std::make_shared<Candidate>(
+					*cand, result, Cost::safe );
+				candidates.emplace_back( std::move( newCand ) );
+			}
 		}
 	}
@@ -961,14 +975,4 @@
 
 					if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);						
-					// else if (const ast::EnumInstType * enumInst = argType.as<ast::EnumInstType>()) {
-					// 	const ast::EnumDecl * enumDecl = enumInst->base; // Here
-					// 	if ( const ast::Type* enumType = enumDecl->base ) {
-					// 		// instance of enum (T) is a instance of type (T)
-					// 		funcFinder.otypeKeys.insert(Mangle::mangle(enumType, Mangle::NoGenericParams | Mangle::Type));
-					// 	} else {
-					// 		// instance of an untyped enum is techically int
-					// 		funcFinder.otypeKeys.insert(Mangle::mangle(enumDecl, Mangle::NoGenericParams | Mangle::Type));
-					// 	}
-					// }
 					else funcFinder.otypeKeys.insert(Mangle::mangle(argType, Mangle::NoGenericParams | Mangle::Type));
 				}
@@ -1399,6 +1403,34 @@
 		// not sufficient to just pass `variableExpr` here, type might have changed since
 		// creation
-		addCandidate(
-			new ast::VariableExpr{ variableExpr->location, variableExpr->var }, tenv );
+		if ( auto obj =  dynamic_cast<const ast::ObjectDecl *>( variableExpr->var.get() )) {
+			if ( auto enumInstType = dynamic_cast<const ast::EnumInstType *>( obj->type.get() ) ) {
+				if ( enumInstType->base && enumInstType->base->base ) {
+					const CodeLocation & location = variableExpr->location;
+					auto ids = symtab.lookupId( "valueE" );
+						for ( ast::SymbolTable::IdData & id : ids ) {
+							if ( auto func = id.id.as<ast::FunctionDecl>() ) {
+								if ( func->params.size() == 1 ) {
+									ast::ptr<ast::DeclWithType> valueEParam = func->params.front();
+									auto valueEParamType = valueEParam->get_type();
+									ast::OpenVarSet funcOpen;
+									ast::AssertionSet funcNeed, funcHave;
+									ast::TypeEnvironment funcEnv{ tenv };
+									ast::ptr<ast::Type> common;
+									if ( unifyInexact( valueEParamType, enumInstType, funcEnv, funcNeed, funcHave, funcOpen, WidenMode{ true, true }, common ) ) {
+										auto appl = new ast::ApplicationExpr( location,
+											ast::VariableExpr::functionPointer( location,  func), { variableExpr } );
+										// addCandidate( appl, copy( tenv ),  );
+										Candidate cand {appl, copy( tenv )};
+										addCandidate( cand, appl, Cost::safe );
+									}
+								}
+							}
+						}
+				}
+			
+			}
+		} 
+		addCandidate( variableExpr, tenv );
+		
 	}
 
Index: src/ResolvExpr/ConversionCost.cc
===================================================================
--- src/ResolvExpr/ConversionCost.cc	(revision 61e362feab9ac30e7e3748f946b2cf384102b37b)
+++ src/ResolvExpr/ConversionCost.cc	(revision c75b30ae4d3f97678f27275a033614f675b7fdaf)
@@ -279,13 +279,8 @@
 		conversionCostFromBasicToBasic( basicType, dstAsBasic );
 	} else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-		const ast::EnumDecl * enumDecl = enumInst->base.get();
-		if ( enumDecl->isTyped && !enumDecl->base.get() ) {
-			cost = Cost::infinity;
-		} else if ( const ast::Type * enumType = enumDecl->base.get() ) {
-			if ( const ast::BasicType * enumTypeAsBasic = dynamic_cast<const ast::BasicType *>(enumType) ) {
-				conversionCostFromBasicToBasic( basicType, enumTypeAsBasic );
-			} else {
-				cost = Cost::infinity;
-			}
+		auto enumDecl = enumInst->base;
+		if ( auto baseType = enumDecl->base.get() ) {
+			cost = costCalc( basicType, baseType, srcIsLvalue, symtab, env );
+			cost.incUnsafe();
 		} else {
             cost = Cost::unsafe;
@@ -367,11 +362,11 @@
 
 void ConversionCost::postvisit( const ast::EnumInstType * enumInstType ) {
-	const ast::EnumDecl * baseEnum = enumInstType->base;
-	if ( const ast::Type * baseType = baseEnum->base ) {
-		costCalc( baseType, dst, srcIsLvalue, symtab, env );
-	} else {
-		static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
-		cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
-	}
+	//	const ast::EnumDecl * baseEnum = enumInstType->base;
+	// if ( const ast::Type * baseType = baseEnum->base ) {
+	// 	costCalc( baseType, dst, srcIsLvalue, symtab, env );
+	// } else {
+	static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
+	cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+	// }
 	if ( cost < Cost::unsafe ) {
 		cost.incSafe();
Index: src/ResolvExpr/Unify.cc
===================================================================
--- src/ResolvExpr/Unify.cc	(revision 61e362feab9ac30e7e3748f946b2cf384102b37b)
+++ src/ResolvExpr/Unify.cc	(revision c75b30ae4d3f97678f27275a033614f675b7fdaf)
@@ -73,17 +73,4 @@
 		ast::Type * newFirst  = shallowCopy( first  );
 		ast::Type * newSecond = shallowCopy( second );
-		if ( auto temp = dynamic_cast<const ast::EnumInstType *>(first) ) {
-			if ( !dynamic_cast< const ast::EnumInstType * >( second ) ) {
-				const ast::EnumDecl * baseEnum = dynamic_cast<const ast::EnumDecl *>(temp->base.get());
-				if ( auto t = baseEnum->base.get() ) {
-					newFirst = ast::shallowCopy( t );
-				}
-			}
-		} else if ( auto temp = dynamic_cast<const ast::EnumInstType *>(second) ) {
-			const ast::EnumDecl * baseEnum = dynamic_cast<const ast::EnumDecl *>(temp->base.get());
-			if ( auto t = baseEnum->base.get() ) {
-				newSecond = ast::shallowCopy( t );
-			}
-		}
 
 		newFirst ->qualifiers = {};