Index: src/Validate/Autogen.cpp
===================================================================
--- src/Validate/Autogen.cpp	(revision c2cf2d02c178c5380965cdd16a90c4de037542a5)
+++ 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 c2cf2d02c178c5380965cdd16a90c4de037542a5)
+++ 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);
 }