Index: libcfa/src/enum.hfa
===================================================================
--- libcfa/src/enum.hfa	(revision 550afde2bf08516ecfe20278bc3e7505fc6c2713)
+++ libcfa/src/enum.hfa	(revision bb336a684788d9fc2c050ab2f56c25353648314a)
@@ -17,5 +17,5 @@
 // Design one
 forall( E, V | Serial( E ) ) trait CfaEnum {
-    char * label( E e );
+    const char * label( E e );
     unsigned int posn( E e );
     V value( E e );
Index: src/AST/Create.cpp
===================================================================
--- src/AST/Create.cpp	(revision 550afde2bf08516ecfe20278bc3e7505fc6c2713)
+++ src/AST/Create.cpp	(revision bb336a684788d9fc2c050ab2f56c25353648314a)
@@ -76,3 +76,19 @@
 }
 
+EnumDecl * asForward( EnumDecl const * decl ) {
+	if ( !decl->body ) {
+		return nullptr;
+	}
+	EnumDecl * fwd = new EnumDecl( decl->location,
+		decl->name,
+		decl->isCfa,
+		vectorCopy( decl->attributes ),
+		decl->linkage,
+		decl->base,
+		decl->hide
+	);
+	fwd->params = vectorCopy( decl->params );
+	return fwd;
 }
+
+}
Index: src/AST/Create.hpp
===================================================================
--- src/AST/Create.hpp	(revision 550afde2bf08516ecfe20278bc3e7505fc6c2713)
+++ src/AST/Create.hpp	(revision bb336a684788d9fc2c050ab2f56c25353648314a)
@@ -24,4 +24,5 @@
 StructDecl * asForward( StructDecl const * );
 UnionDecl * asForward( UnionDecl const * );
+EnumDecl * asForward( EnumDecl const * );
 
 }
Index: src/ResolvExpr/ResolveTypeof.cpp
===================================================================
--- src/ResolvExpr/ResolveTypeof.cpp	(revision 550afde2bf08516ecfe20278bc3e7505fc6c2713)
+++ src/ResolvExpr/ResolveTypeof.cpp	(revision bb336a684788d9fc2c050ab2f56c25353648314a)
@@ -61,8 +61,8 @@
 		if ( typeofType->kind == ast::TypeofType::Basetypeof ) {
 			// replace basetypeof(<enum>) by int
-			if ( newType.as< ast::EnumInstType >() ) {
-				newType = new ast::BasicType(
-					ast::BasicKind::SignedInt, newType->qualifiers, copy(newType->attributes) );
-			}
+			// if ( newType.as< ast::EnumInstType >() ) {
+			// 	newType = new ast::BasicType(
+			// 		ast::BasicKind::SignedInt, newType->qualifiers, copy(newType->attributes) );
+			// }
 			reset_qualifiers(
 				newType,
Index: src/Validate/Autogen.cpp
===================================================================
--- src/Validate/Autogen.cpp	(revision 550afde2bf08516ecfe20278bc3e7505fc6c2713)
+++ src/Validate/Autogen.cpp	(revision bb336a684788d9fc2c050ab2f56c25353648314a)
@@ -88,5 +88,5 @@
 
 	// Internal helpers:
-	void genStandardFuncs();
+	virtual void genStandardFuncs();
 	void produceDecl( const ast::FunctionDecl * decl );
 	void produceForwardDecl( const ast::FunctionDecl * decl );
@@ -196,8 +196,12 @@
 
 	bool shouldAutogen() const final { return true; }
+	void generateAndPrependDecls( std::list<ast::ptr<ast::Decl>> & );
+	void genForwards();
 private:
 	void genFuncBody( ast::FunctionDecl * decl ) final;
 	void genFieldCtors() final;
 	const ast::Decl * getDecl() const final { return decl; }
+protected:
+	void genStandardFuncs() override;
 };
 
@@ -242,5 +246,8 @@
 	enumInst.base = enumDecl;
 	EnumFuncGenerator gen( enumDecl, &enumInst, functionNesting );
-	gen.generateAndAppendFunctions( declsToAddAfter );
+	gen.generateAndPrependDecls( declsToAddBefore );
+
+	EnumFuncGenerator gen2( enumDecl, &enumInst, functionNesting );
+	gen2.generateAndAppendFunctions( declsToAddAfter );
 }
 
@@ -709,4 +716,39 @@
 }
 
+void EnumFuncGenerator::generateAndPrependDecls( std::list<ast::ptr<ast::Decl>> & decls ) {
+	genForwards();
+	decls.splice( decls.end(), forwards );
+}
+
+void EnumFuncGenerator::genForwards() {
+	forwards.push_back( ast::asForward(decl) );
+
+	ast::FunctionDecl *(FuncGenerator::*standardProtos[4])() const = {
+		&EnumFuncGenerator::genCtorProto, &EnumFuncGenerator::genCopyProto,
+		&EnumFuncGenerator::genDtorProto, &EnumFuncGenerator::genAssignProto };
+
+	for ( auto & generator: standardProtos) {
+		ast::FunctionDecl * decl = (this->*generator)();
+		produceForwardDecl( decl );
+	}
+}
+
+void EnumFuncGenerator::genStandardFuncs() {
+	// do everything FuncGenerator does except not make ForwardDecls
+	ast::FunctionDecl *(FuncGenerator::*standardProtos[4])() const = {
+		&EnumFuncGenerator::genCtorProto, &EnumFuncGenerator::genCopyProto,
+		&EnumFuncGenerator::genDtorProto, &EnumFuncGenerator::genAssignProto };
+
+	for ( auto & generator : standardProtos ) {
+		ast::FunctionDecl * decl = (this->*generator)();
+		// produceForwardDecl( decl ); Done in genForwards
+		genFuncBody( decl );
+		if ( CodeGen::isAssignment( decl->name ) ) {
+			appendReturnThis( decl );
+		}
+		produceDecl( decl );
+	}
+}
+
 void EnumFuncGenerator::genFieldCtors() {
 	// Enumerations to not have field constructors.
Index: src/Validate/ImplementEnumFunc.cpp
===================================================================
--- src/Validate/ImplementEnumFunc.cpp	(revision 550afde2bf08516ecfe20278bc3e7505fc6c2713)
+++ src/Validate/ImplementEnumFunc.cpp	(revision bb336a684788d9fc2c050ab2f56c25353648314a)
@@ -104,5 +104,28 @@
 		auto memAsObjectDecl = mem.as<ast::ObjectDecl>();
 		assert(memAsObjectDecl);
-		if (memAsObjectDecl->init) {
+		if (auto& init = memAsObjectDecl->init) {
+			auto singleInit = init.strict_as<ast::SingleInit>();
+			auto nameExpr = singleInit->value.as<ast::NameExpr>();
+			if (nameExpr) {
+				auto name = nameExpr->name;
+				if (auto it = std::find_if(decl->members.begin(), decl->members.end(), 
+					[name](ast::ptr<ast::Decl> mem_decl) {
+						return (mem_decl->name == name);
+					}); it != std::end(decl->members)
+				) {
+					// ast::SingleInit* newInit = new ast::SingleInit(
+					// 	init->location, new ast::CastExpr( nameExpr->location, 
+					// 	nameExpr, new ast::BasicType( ast::BasicKind::UnsignedInt ), ast::ExplicitCast )
+					// );
+					// auto targetInit = (*it).strict_as<ast::ObjectDecl>()->init;
+					// inits.emplace_back( targetInit );
+					auto index = std::distance( decl->members.begin(), it );
+					auto targetInit = inits.at(index).strict_as<ast::SingleInit>();
+					auto targetExpr = targetInit->value;
+					inits.push_back( new ast::SingleInit( targetExpr->location, targetExpr ) );
+					continue;
+				}
+			}
+
 			inits.emplace_back(memAsObjectDecl->init);
 		} else {
@@ -406,5 +429,5 @@
 void EnumAttrFuncGenerator::genTypedEnumFunction(const ast::EnumAttribute attr) {
 	if (attr == ast::EnumAttribute::Value) {
-		if (decl->base) {
+		if (decl->isTyped()) {
 			// TypedEnum's backing arrays
 			std::vector<ast::ptr<ast::Init>> inits = genValueInit();
@@ -441,7 +464,7 @@
 
 void EnumAttrFuncGenerator::genTypedEnumFuncs() {
-	genTypedEnumFunction(ast::EnumAttribute::Value);
-	genTypedEnumFunction(ast::EnumAttribute::Label);
-	genTypedEnumFunction(ast::EnumAttribute::Posn);
+	// genTypedEnumFunction(ast::EnumAttribute::Value);
+	// genTypedEnumFunction(ast::EnumAttribute::Label);
+	// genTypedEnumFunction(ast::EnumAttribute::Posn);
 }
 
@@ -456,8 +479,8 @@
 	std::list<ast::ptr<ast::Decl>>& decls) {
 	// Generate the functions (they go into forwards and definitions).
-	genTypeNameFunc();
+	// genTypeNameFunc();
 	genTypedEnumFuncs();
-	genSerialTraitFuncs();
-	genBoundedFunctions();
+	// genSerialTraitFuncs();
+	// genBoundedFunctions();
 	// Now export the lists contents.
 	decls.splice(decls.end(), forwards);
@@ -483,5 +506,5 @@
 	enumInst.base = enumDecl;
 	EnumAttrFuncGenerator gen(enumDecl, &enumInst, functionNesting);
-	gen.generateAndAppendFunctions(declsToAddAfter);
+	// gen.generateAndAppendFunctions(declsToAddAfter);
 }