Index: src/CodeGen/GenType.cc
===================================================================
--- src/CodeGen/GenType.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/CodeGen/GenType.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -42,4 +42,6 @@
 		virtual void visit( TypeInstType *typeInst );
 		virtual void visit( VarArgsType *varArgsType );
+		virtual void visit( ZeroType *zeroType );
+		virtual void visit( OneType *oneType );
 
 	  private:
@@ -200,4 +202,16 @@
 	}
 
+	void GenType::visit( ZeroType *zeroType ) {
+		// ideally these wouldn't hit codegen at all, but should be safe to make them ints
+		typeString = "int " + typeString;
+		handleQualifiers( zeroType );
+	}
+
+	void GenType::visit( OneType *oneType ) {
+		// ideally these wouldn't hit codegen at all, but should be safe to make them ints
+		typeString = "int " + typeString;
+		handleQualifiers( oneType );
+	}
+
 	void GenType::handleQualifiers( Type *type ) {
 		if ( type->get_isConst() ) {
Index: src/Makefile.in
===================================================================
--- src/Makefile.in	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/Makefile.in	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -164,4 +164,5 @@
 	SynTree/driver_cfa_cpp-AttrType.$(OBJEXT) \
 	SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT) \
+	SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT) \
 	SynTree/driver_cfa_cpp-Constant.$(OBJEXT) \
 	SynTree/driver_cfa_cpp-Expression.$(OBJEXT) \
@@ -388,6 +389,6 @@
 	SynTree/ReferenceToType.cc SynTree/TupleType.cc \
 	SynTree/TypeofType.cc SynTree/AttrType.cc \
-	SynTree/VarArgsType.cc SynTree/Constant.cc \
-	SynTree/Expression.cc SynTree/TupleExpr.cc \
+	SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
+	SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
 	SynTree/CommaExpr.cc SynTree/TypeExpr.cc \
 	SynTree/ApplicationExpr.cc SynTree/AddressExpr.cc \
@@ -710,4 +711,6 @@
 SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT): SynTree/$(am__dirstamp) \
 	SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT): SynTree/$(am__dirstamp) \
+	SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/driver_cfa_cpp-Constant.$(OBJEXT): SynTree/$(am__dirstamp) \
 	SynTree/$(DEPDIR)/$(am__dirstamp)
@@ -871,4 +874,5 @@
 	-rm -f SynTree/driver_cfa_cpp-Visitor.$(OBJEXT)
 	-rm -f SynTree/driver_cfa_cpp-VoidType.$(OBJEXT)
+	-rm -f SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT)
 	-rm -f Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT)
 	-rm -f Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT)
@@ -975,4 +979,5 @@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Visitor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VoidType.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleAssignment.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po@am__quote@
@@ -2043,4 +2048,18 @@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-VarArgsType.obj `if test -f 'SynTree/VarArgsType.cc'; then $(CYGPATH_W) 'SynTree/VarArgsType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/VarArgsType.cc'; fi`
+
+SynTree/driver_cfa_cpp-ZeroOneType.o: SynTree/ZeroOneType.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ZeroOneType.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo -c -o SynTree/driver_cfa_cpp-ZeroOneType.o `test -f 'SynTree/ZeroOneType.cc' || echo '$(srcdir)/'`SynTree/ZeroOneType.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='SynTree/ZeroOneType.cc' object='SynTree/driver_cfa_cpp-ZeroOneType.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ZeroOneType.o `test -f 'SynTree/ZeroOneType.cc' || echo '$(srcdir)/'`SynTree/ZeroOneType.cc
+
+SynTree/driver_cfa_cpp-ZeroOneType.obj: SynTree/ZeroOneType.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ZeroOneType.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo -c -o SynTree/driver_cfa_cpp-ZeroOneType.obj `if test -f 'SynTree/ZeroOneType.cc'; then $(CYGPATH_W) 'SynTree/ZeroOneType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ZeroOneType.cc'; fi`
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='SynTree/ZeroOneType.cc' object='SynTree/driver_cfa_cpp-ZeroOneType.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ZeroOneType.obj `if test -f 'SynTree/ZeroOneType.cc'; then $(CYGPATH_W) 'SynTree/ZeroOneType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ZeroOneType.cc'; fi`
 
 SynTree/driver_cfa_cpp-Constant.o: SynTree/Constant.cc
Index: src/ResolvExpr/AdjustExprType.cc
===================================================================
--- src/ResolvExpr/AdjustExprType.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/ResolvExpr/AdjustExprType.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -37,4 +37,6 @@
 		virtual Type* mutate( TupleType *tupleType );
 		virtual Type* mutate( VarArgsType *varArgsType );
+		virtual Type* mutate( ZeroType *zeroType );
+		virtual Type* mutate( OneType *oneType );
 
 		const TypeEnvironment &env;
@@ -117,4 +119,12 @@
 		return varArgsType;
 	}
+
+	Type *AdjustExprType::mutate( ZeroType *zeroType ) {
+		return zeroType;
+	}
+
+	Type *AdjustExprType::mutate( OneType *oneType ) {
+		return oneType;
+	}
 } // namespace ResolvExpr
 
Index: src/ResolvExpr/CommonType.cc
===================================================================
--- src/ResolvExpr/CommonType.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/ResolvExpr/CommonType.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -39,4 +39,6 @@
 		virtual void visit( TupleType *tupleType );
 		virtual void visit( VarArgsType *varArgsType );
+		virtual void visit( ZeroType *zeroType );
+		virtual void visit( OneType *oneType );
 
 		template< typename RefType > void handleRefType( RefType *inst, Type *other );
@@ -134,9 +136,9 @@
 				result = new BasicType( basicType->get_qualifiers() + otherBasic->get_qualifiers(), newType );
 			} // if
-		} else if ( EnumInstType *enumInstType = dynamic_cast< EnumInstType * > ( type2 ) ) {
-			// use signed int in lieu of the enum type
+		} else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
+			// use signed int in lieu of the enum/zero/one type
 			BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
-			if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= enumInstType->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= enumInstType->get_qualifiers() ) || widenSecond ) ) {
-				result = new BasicType( basicType->get_qualifiers() + enumInstType->get_qualifiers(), newType );
+			if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= type2->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= type2->get_qualifiers() ) || widenSecond ) ) {
+				result = new BasicType( basicType->get_qualifiers() + type2->get_qualifiers(), newType );
 			} // if
 		} // if
@@ -171,4 +173,7 @@
 				otherPointer->get_base()->get_qualifiers() = tq2;
 			} // if
+		} else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
+			result = pointerType->clone();
+			result->get_qualifiers() += type2->get_qualifiers();
 		} // if
 	}
@@ -190,5 +195,5 @@
 
 	void CommonType::visit( EnumInstType *enumInstType ) {
-		if ( dynamic_cast< BasicType * >( type2 ) ) {
+		if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
 			// reuse BasicType, EnumInstType code by swapping type2 with enumInstType
 			Type * temp = type2;
@@ -230,4 +235,26 @@
 	void CommonType::visit( VarArgsType *varArgsType ) {
 	}
+
+	void CommonType::visit( ZeroType *zeroType ) {
+		if ( widenFirst ) {
+			if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< PointerType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
+				if ( widenSecond || zeroType->get_qualifiers() <= type2->get_qualifiers() ) {
+					result = type2->clone();
+					result->get_qualifiers() += zeroType->get_qualifiers();
+				}
+			}
+		}
+	}
+
+	void CommonType::visit( OneType *oneType ) {
+		if ( widenFirst ) {
+			if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
+				if ( widenSecond || oneType->get_qualifiers() <= type2->get_qualifiers() ) {
+					result = type2->clone();
+					result->get_qualifiers() += oneType->get_qualifiers();
+				}
+			}
+		}
+	}
 } // namespace ResolvExpr
 
Index: src/ResolvExpr/ConversionCost.cc
===================================================================
--- src/ResolvExpr/ConversionCost.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/ResolvExpr/ConversionCost.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -160,5 +160,7 @@
 			// xxx - not positive this is correct, but appears to allow casting int => enum
 			cost = Cost( 1, 0, 0 );
-    } // if
+		} else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
+			cost = Cost( 1, 0, 0 );
+		} // if
 	}
 
@@ -175,4 +177,6 @@
 				} // if
 			} // if
+		} else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
+			cost = Cost( 1, 0, 0 );
 		} // if
 	}
@@ -256,4 +260,34 @@
 		}
 	}
+
+	void ConversionCost::visit(ZeroType *zeroType) {
+		if ( dynamic_cast< ZeroType* >( dest ) ) {
+			cost = Cost::zero;
+		} else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
+			// copied from visit(BasicType*) for signed int, but +1 for safe conversions
+			int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
+			if ( tableResult == -1 ) {
+				cost = Cost( 1, 0, 0 );
+			} else {
+				cost = Cost( 0, 0, tableResult + 1 );
+			}
+		} else if ( dynamic_cast< PointerType* >( dest ) ) {
+			cost = Cost( 0, 0, 1 );
+		}
+	}
+
+	void ConversionCost::visit(OneType *oneType) {
+		if ( dynamic_cast< OneType* >( dest ) ) {
+			cost = Cost::zero;
+		} else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
+			// copied from visit(BasicType*) for signed int, but +1 for safe conversions
+			int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
+			if ( tableResult == -1 ) {
+				cost = Cost( 1, 0, 0 );
+			} else {
+				cost = Cost( 0, 0, tableResult + 1 );
+			}
+		}
+	}
 } // namespace ResolvExpr
 
Index: src/ResolvExpr/ConversionCost.h
===================================================================
--- src/ResolvExpr/ConversionCost.h	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/ResolvExpr/ConversionCost.h	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -41,4 +41,6 @@
 		virtual void visit(TupleType *tupleType);
 		virtual void visit(VarArgsType *varArgsType);
+		virtual void visit(ZeroType *zeroType);
+		virtual void visit(OneType *oneType);
 	  protected:
 		Type *dest;
Index: src/ResolvExpr/PtrsAssignable.cc
===================================================================
--- src/ResolvExpr/PtrsAssignable.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/ResolvExpr/PtrsAssignable.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -39,4 +39,6 @@
 		virtual void visit( TupleType *tupleType );
 		virtual void visit( VarArgsType *varArgsType );
+		virtual void visit( ZeroType *zeroType );
+		virtual void visit( OneType *oneType );
 	  private:
 		Type *dest;
@@ -141,4 +143,11 @@
 	void PtrsAssignable::visit( VarArgsType *varArgsType ) {
 	}
+
+	void PtrsAssignable::visit( ZeroType *zeroType ) {
+	}
+	
+	void PtrsAssignable::visit( OneType *oneType ) {
+	}
+	
 } // namespace ResolvExpr
 
Index: src/ResolvExpr/PtrsCastable.cc
===================================================================
--- src/ResolvExpr/PtrsCastable.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/ResolvExpr/PtrsCastable.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -40,4 +40,6 @@
 		virtual void visit(TupleType *tupleType);
 		virtual void visit(VarArgsType *varArgsType);
+		virtual void visit(ZeroType *zeroType);
+		virtual void visit(OneType *oneType);
 	  private:
 		Type *dest;
@@ -144,4 +146,12 @@
 		result = objectCast( dest, env, indexer );
 	}
+
+	void PtrsCastable::visit(ZeroType *zeroType) {
+		result = objectCast( dest, env, indexer );
+	}
+
+	void PtrsCastable::visit(OneType *oneType) {
+		result = objectCast( dest, env, indexer );
+	}
 } // namespace ResolvExpr
 
Index: src/ResolvExpr/RenameVars.cc
===================================================================
--- src/ResolvExpr/RenameVars.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/ResolvExpr/RenameVars.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -110,4 +110,14 @@
 	}
 
+	void RenameVars::visit( ZeroType *zeroType ) {
+		typeBefore( zeroType );
+		typeAfter( zeroType );
+	}
+
+	void RenameVars::visit( OneType *oneType ) {
+		typeBefore( oneType );
+		typeAfter( oneType );
+	}
+
 	void RenameVars::typeBefore( Type *type ) {
 		if ( ! type->get_forall().empty() ) {
Index: src/ResolvExpr/RenameVars.h
===================================================================
--- src/ResolvExpr/RenameVars.h	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/ResolvExpr/RenameVars.h	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -44,4 +44,6 @@
 		virtual void visit( TupleType *tupleType );
 		virtual void visit( VarArgsType *varArgsType );
+		virtual void visit( ZeroType *zeroType );
+		virtual void visit( OneType *oneType );
 
 		void typeBefore( Type *type );
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/ResolvExpr/Resolver.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -134,4 +134,6 @@
 			} else if ( BasicType *bt = dynamic_cast< BasicType * >( type ) ) {
 				return bt->isInteger();
+			} else if ( dynamic_cast< ZeroType* >( type ) != nullptr || dynamic_cast< OneType* >( type ) != nullptr ) {
+				return true;
 			} else {
 				return false;
@@ -455,5 +457,6 @@
 			}
 		} else {
-			assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext ) );
+			assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
+			        || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) );
 			// basic types are handled here
 			Visitor::visit( listInit );
Index: src/ResolvExpr/Unify.cc
===================================================================
--- src/ResolvExpr/Unify.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/ResolvExpr/Unify.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -60,4 +60,6 @@
 		virtual void visit(TupleType *tupleType);
 		virtual void visit(VarArgsType *varArgsType);
+		virtual void visit(ZeroType *zeroType);
+		virtual void visit(OneType *oneType);
 
 		template< typename RefType > void handleRefType( RefType *inst, Type *other );
@@ -588,4 +590,12 @@
 	}
 
+	void Unify::visit(ZeroType *zeroType) {
+		result = dynamic_cast< ZeroType* >( type2 );
+	}
+
+	void Unify::visit(OneType *oneType) {
+		result = dynamic_cast< OneType* >( type2 );
+	}
+
 	// xxx - compute once and store in the FunctionType?
 	Type * extractResultType( FunctionType * function ) {
@@ -602,5 +612,4 @@
 		}
 	}
-
 } // namespace ResolvExpr
 
Index: src/SymTab/FixFunction.cc
===================================================================
--- src/SymTab/FixFunction.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SymTab/FixFunction.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -77,4 +77,12 @@
 		return varArgsType;
 	}
+
+	Type * FixFunction::mutate(ZeroType *zeroType) {
+		return zeroType;
+	}
+
+	Type * FixFunction::mutate(OneType *oneType) {
+		return oneType;
+	}
 } // namespace SymTab
 
Index: src/SymTab/FixFunction.h
===================================================================
--- src/SymTab/FixFunction.h	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SymTab/FixFunction.h	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -42,4 +42,6 @@
 		virtual Type* mutate(TupleType *tupleType);
 		virtual Type* mutate(VarArgsType *varArgsType);
+		virtual Type* mutate(ZeroType *zeroType);
+		virtual Type* mutate(OneType *oneType);
   
 		bool isVoid;
Index: src/SymTab/ImplementationType.cc
===================================================================
--- src/SymTab/ImplementationType.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SymTab/ImplementationType.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -41,4 +41,6 @@
 		virtual void visit(TupleType *tupleType);
 		virtual void visit(VarArgsType *varArgsType);
+		virtual void visit(ZeroType *zeroType);
+		virtual void visit(OneType *oneType);
 
 		Type *result;			// synthesized
@@ -120,4 +122,10 @@
 	void ImplementationType::visit(VarArgsType *varArgsType) {
 	}
+
+	void ImplementationType::visit(ZeroType *zeroType) {
+	}
+
+	void ImplementationType::visit(OneType *oneType) {
+	}
 } // namespace SymTab
 
Index: src/SymTab/Mangler.cc
===================================================================
--- src/SymTab/Mangler.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SymTab/Mangler.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -229,4 +229,12 @@
 		printQualifiers( varArgsType );
 		mangleName << "VARGS";
+	}
+
+	void Mangler::visit( ZeroType *zeroType ) {
+		mangleName << "Z";
+	}
+
+	void Mangler::visit( OneType *oneType ) {
+		mangleName << "O";
 	}
 
Index: src/SymTab/Mangler.h
===================================================================
--- src/SymTab/Mangler.h	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SymTab/Mangler.h	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -46,4 +46,6 @@
 		virtual void visit( TupleType *tupleType );
 		virtual void visit( VarArgsType *varArgsType );
+		virtual void visit( ZeroType *zeroType );
+		virtual void visit( OneType *oneType );
   
 		std::string get_mangleName() { return mangleName.str(); }
Index: src/SymTab/TypeEquality.cc
===================================================================
--- src/SymTab/TypeEquality.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SymTab/TypeEquality.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -42,4 +42,6 @@
 		virtual void visit( TypeInstType *typeInst );
 		virtual void visit( VarArgsType *varArgsType );
+		virtual void visit( ZeroType *zeroType );
+		virtual void visit( OneType *oneType );
 
 		void handleQualifiers( Type * t );
@@ -199,3 +201,17 @@
 		}
 	}
+
+	void TypeEquality::visit( ZeroType *zeroType ) {
+		handleQualifiers( zeroType );
+		if ( ! dynamic_cast< ZeroType * >( other ) ) {
+			result = false;
+		}
+	}
+
+	void TypeEquality::visit( OneType *oneType ) {
+		handleQualifiers( oneType );
+		if ( ! dynamic_cast< OneType * >( other ) ) {
+			result = false;
+		}
+	}
 } // namespace SymTab
Index: src/SynTree/Mutator.cc
===================================================================
--- src/SynTree/Mutator.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SynTree/Mutator.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -480,4 +480,14 @@
 }
 
+Type *Mutator::mutate( ZeroType *zeroType ) {
+	mutateAll( zeroType->get_forall(), *this );
+	return zeroType;
+}
+
+Type *Mutator::mutate( OneType *oneType ) {
+	mutateAll( oneType->get_forall(), *this );
+	return oneType;
+}
+
 Initializer *Mutator::mutate( SingleInit *singleInit ) {
 	singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );
Index: src/SynTree/Mutator.h
===================================================================
--- src/SynTree/Mutator.h	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SynTree/Mutator.h	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -99,4 +99,6 @@
 	virtual Type* mutate( AttrType *attrType );
 	virtual Type* mutate( VarArgsType *varArgsType );
+	virtual Type* mutate( ZeroType *zeroType );
+	virtual Type* mutate( OneType *oneType );
 
 	virtual Initializer* mutate( SingleInit *singleInit );
Index: src/SynTree/SynTree.h
===================================================================
--- src/SynTree/SynTree.h	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SynTree/SynTree.h	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -106,4 +106,6 @@
 class AttrType;
 class VarArgsType;
+class ZeroType;
+class OneType;
 
 class Initializer;
Index: src/SynTree/Type.h
===================================================================
--- src/SynTree/Type.h	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SynTree/Type.h	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -436,4 +436,28 @@
 };
 
+/// Represents a zero constant
+class ZeroType : public Type {
+  public:
+	ZeroType();
+	ZeroType( Type::Qualifiers tq );
+
+	virtual ZeroType *clone() const { return new ZeroType( *this ); }
+	virtual void accept( Visitor &v ) { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const;
+};
+
+/// Represents a one constant
+class OneType : public Type {
+  public:
+	OneType();
+	OneType( Type::Qualifiers tq );
+
+	virtual OneType *clone() const { return new OneType( *this ); }
+	virtual void accept( Visitor &v ) { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const;
+};
+
 inline Type::Qualifiers &Type::Qualifiers::operator&=( const Type::Qualifiers &other ) {
 	isConst &= other.isConst;
Index: src/SynTree/TypeSubstitution.cc
===================================================================
--- src/SynTree/TypeSubstitution.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SynTree/TypeSubstitution.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -179,6 +179,6 @@
 }
 
-Type * TypeSubstitution::mutate( VoidType *basicType ) {
-	return handleType( basicType );
+Type * TypeSubstitution::mutate( VoidType *voidType ) {
+	return handleType( voidType );
 }
 
@@ -221,4 +221,12 @@
 Type * TypeSubstitution::mutate( VarArgsType *varArgsType ) {
 	return handleType( varArgsType );
+}
+
+Type * TypeSubstitution::mutate( ZeroType *zeroType ) {
+	return handleType( zeroType );
+}
+
+Type * TypeSubstitution::mutate( OneType *oneType ) {
+	return handleType( oneType );
 }
 
Index: src/SynTree/TypeSubstitution.h
===================================================================
--- src/SynTree/TypeSubstitution.h	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SynTree/TypeSubstitution.h	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -76,4 +76,6 @@
 	virtual Type* mutate(TupleType *tupleType);
 	virtual Type* mutate(VarArgsType *varArgsType);
+	virtual Type* mutate(ZeroType *zeroType);
+	virtual Type* mutate(OneType *oneType);
 
 	// TODO: worry about traversing into a forall-qualified function type or type decl with assertions
Index: src/SynTree/Visitor.cc
===================================================================
--- src/SynTree/Visitor.cc	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SynTree/Visitor.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -406,4 +406,12 @@
 }
 
+void Visitor::visit( ZeroType *zeroType ) {
+	acceptAll( zeroType->get_forall(), *this );
+}
+
+void Visitor::visit( OneType *oneType ) {
+	acceptAll( oneType->get_forall(), *this );
+}
+
 void Visitor::visit( SingleInit *singleInit ) {
 	singleInit->get_value()->accept( *this );
Index: src/SynTree/Visitor.h
===================================================================
--- src/SynTree/Visitor.h	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SynTree/Visitor.h	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -99,4 +99,6 @@
 	virtual void visit( AttrType *attrType );
 	virtual void visit( VarArgsType *varArgsType );
+	virtual void visit( ZeroType *zeroType );
+	virtual void visit( OneType *oneType );
 
 	virtual void visit( SingleInit *singleInit );
Index: src/SynTree/ZeroOneType.cc
===================================================================
--- src/SynTree/ZeroOneType.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
+++ src/SynTree/ZeroOneType.cc	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -0,0 +1,38 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// VarArgsType.cc --
+//
+// Author           : Aaron B. Moss
+// Created On       : Fri Sep 16 14:08:00 2016
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Sep 16 14:08:00 2016
+// Update Count     : 1
+//
+
+#include "Type.h"
+
+ZeroType::ZeroType() : Type( Type::Qualifiers() ) {}
+
+ZeroType::ZeroType( Type::Qualifiers tq ) : Type( tq ) {}
+
+void ZeroType::print( std::ostream &os, int indent ) const {
+	os << "zero_t";
+}
+
+OneType::OneType() : Type( Type::Qualifiers() ) {}
+
+OneType::OneType( Type::Qualifiers tq ) : Type( tq ) {}
+
+void OneType::print( std::ostream &os, int indent ) const {
+	os << "one_t";
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/module.mk
===================================================================
--- src/SynTree/module.mk	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/SynTree/module.mk	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -26,4 +26,5 @@
        SynTree/AttrType.cc \
        SynTree/VarArgsType.cc \
+       SynTree/ZeroOneType.cc \
        SynTree/Constant.cc \
        SynTree/Expression.cc \
Index: src/examples/gc_no_raii/src/internal/card_table.h
===================================================================
--- src/examples/gc_no_raii/src/internal/card_table.h	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/examples/gc_no_raii/src/internal/card_table.h	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -18,10 +18,10 @@
 };
 
-static inline void ctor_card(card_table_t* const this)
+static inline void ?{}(card_table_t* this)
 {
 	this->count = 0;
 }
 
-static inline void dtor_card(card_table_t* const this)
+static inline void ^?{}(card_table_t* this)
 {
 
Index: src/examples/gc_no_raii/src/internal/memory_pool.c
===================================================================
--- src/examples/gc_no_raii/src/internal/memory_pool.c	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/examples/gc_no_raii/src/internal/memory_pool.c	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -11,5 +11,5 @@
 const size_t gc_pool_header_size = (size_t)(  &(((gc_memory_pool*)NULL)->start_p) );
 
-void ctor(gc_memory_pool *const this, size_t size, gc_memory_pool* next, gc_memory_pool* mirror, uint8_t type)
+void ?{}(gc_memory_pool* this, size_t size, gc_memory_pool* next, gc_memory_pool* mirror, uint8_t type)
 {
 	this->mirror = mirror;
@@ -17,7 +17,5 @@
 	this->type_code = type;
 
-	card_table_t* new = (card_table_t*)malloc(sizeof(card_table_t));
-	this->cards = new;
-	ctor_card(this->cards);
+	this->cards = ( (card_table_t*)malloc(sizeof(card_table_t)) ){};
 
 	this->end_p = ((uint8_t*)this) + size;
@@ -29,7 +27,7 @@
 }
 
-void dtor(gc_memory_pool *const this)
+void ^?{}(gc_memory_pool* this)
 {
-	dtor_card(this->cards);
+	^(&this->cards){};
 	free(this->cards);
 }
Index: src/examples/gc_no_raii/src/internal/memory_pool.h
===================================================================
--- src/examples/gc_no_raii/src/internal/memory_pool.h	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/examples/gc_no_raii/src/internal/memory_pool.h	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -27,5 +27,5 @@
 };
 
-void ctor(	gc_memory_pool *const this,
+void ?{}(	gc_memory_pool* this,
 		size_t size,
 		gc_memory_pool* next,
@@ -34,5 +34,5 @@
 	);
 
-void dtor(gc_memory_pool *const this);
+void ^?{}(gc_memory_pool* this);
 
 struct gc_pool_object_iterator
Index: src/examples/gc_no_raii/src/internal/state.c
===================================================================
--- src/examples/gc_no_raii/src/internal/state.c	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/examples/gc_no_raii/src/internal/state.c	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -131,8 +131,8 @@
 
       this->from_space = (gc_memory_pool*)(pal_allocPool(POOL_SIZE_BYTES, 1));
-      this->to_space = (gc_memory_pool*)(pal_allocPool(POOL_SIZE_BYTES, 1));
-
-      ctor(this->from_space, POOL_SIZE_BYTES, old_from_space, this->to_space,   this->from_code);
-      ctor(this->to_space,   POOL_SIZE_BYTES, old_to_space,   this->from_space, (~this->from_code) & 0x01);
+      this->to_space   = (gc_memory_pool*)(pal_allocPool(POOL_SIZE_BYTES, 1));
+
+      this->from_space{ POOL_SIZE_BYTES, old_from_space, this->to_space,   this->from_code };
+      this->to_space  { POOL_SIZE_BYTES, old_to_space,   this->from_space, (~this->from_code) & 0x01 };
 
 	this->total_space += gc_pool_size_used(this->from_space);
Index: src/libcfa/containers/vector
===================================================================
--- src/libcfa/containers/vector	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/libcfa/containers/vector	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -20,15 +20,28 @@
 }
 
-#define DESTROY(x)
-
 //------------------------------------------------------------------------------
 //Declaration
 trait allocator_c(otype T, otype allocator_t)
 {
-	void ctor(allocator_t* const);
-	void dtor(allocator_t* const);
-	void realloc_storage(allocator_t* const, size_t);
-	T* data(allocator_t* const);
+	void realloc_storage(allocator_t*, size_t);
+	T* data(allocator_t*);
 };
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+struct vector;
+
+//------------------------------------------------------------------------------
+//Initialization
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void ?{}(vector(T, allocator_t)* this);
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs);
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+vector(T, allocator_t) ?=?(vector(T, allocator_t)* this, vector(T, allocator_t) rhs);
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void ^?{}(vector(T, allocator_t)* this);
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
@@ -40,15 +53,7 @@
 
 //------------------------------------------------------------------------------
-//Initialization
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void ctor(vector(T, allocator_t) *const this);
-
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void dtor(vector(T, allocator_t) *const this);
-
-//------------------------------------------------------------------------------
 //Capacity
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline bool empty(vector(T, allocator_t) *const this)
+static inline bool empty(vector(T, allocator_t)* this)
 {
 	return this->size == 0;
@@ -56,5 +61,5 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline size_t size(vector(T, allocator_t) *const this)
+static inline size_t size(vector(T, allocator_t)* this)
 {
 	return this->size;
@@ -62,5 +67,5 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline void reserve(vector(T, allocator_t) *const this, size_t size)
+static inline void reserve(vector(T, allocator_t)* this, size_t size)
 {
 	realloc_storage(&this->storage, this->size+1);
@@ -70,5 +75,5 @@
 //Element access
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T at(vector(T, allocator_t) *const this, size_t index)
+static inline T at(vector(T, allocator_t)* this, size_t index)
 {
 	return data(&this->storage)[index];
@@ -76,5 +81,5 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T ?[?](vector(T, allocator_t) *const this, size_t index)
+static inline T ?[?](vector(T, allocator_t)* this, size_t index)
 {
 	return data(&this->storage)[index];
@@ -82,5 +87,5 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T front(vector(T, allocator_t) *const this)
+static inline T front(vector(T, allocator_t)* this)
 {
 	return data(&this->storage)[0];
@@ -88,5 +93,5 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T back(vector(T, allocator_t) *const this)
+static inline T back(vector(T, allocator_t)* this)
 {
 	return data(&this->storage)[this->size - 1];
@@ -96,16 +101,16 @@
 //Modifiers
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void push_back(vector(T, allocator_t) *const this, T value);
+void push_back(vector(T, allocator_t)* this, T value);
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void pop_back(vector(T, allocator_t) *const this);
+void pop_back(vector(T, allocator_t)* this);
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void clear(vector(T, allocator_t) *const this);
+void clear(vector(T, allocator_t)* this);
 
 //------------------------------------------------------------------------------
 //Iterators
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T* begin(vector(T, allocator_t) *const this)
+static inline T* begin(vector(T, allocator_t)* this)
 {
 	return data(&this->storage);
@@ -113,5 +118,5 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline const T* cbegin(const vector(T, allocator_t) *const this)
+static inline const T* cbegin(const vector(T, allocator_t)* this)
 {
 	return data(&this->storage);
@@ -119,5 +124,5 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline T* end(vector(T, allocator_t) *const this)
+static inline T* end(vector(T, allocator_t)* this)
 {
 	return data(&this->storage) + this->size;
@@ -125,5 +130,5 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-static inline const T* cend(const vector(T, allocator_t) *const this)
+static inline const T* cend(const vector(T, allocator_t)* this)
 {
 	return data(&this->storage) + this->size;
@@ -140,14 +145,20 @@
 
 forall(otype T)
-void ctor(heap_allocator(T) *const this);
+void ?{}(heap_allocator(T)* this);
 
 forall(otype T)
-void dtor(heap_allocator(T) *const this);
+void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs);
 
 forall(otype T)
-void realloc_storage(heap_allocator(T) *const this, size_t size);
+heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs);
 
 forall(otype T)
-static inline T* data(heap_allocator(T) *const this)
+void ^?{}(heap_allocator(T)* this);
+
+forall(otype T)
+void realloc_storage(heap_allocator(T)* this, size_t size);
+
+forall(otype T)
+static inline T* data(heap_allocator(T)* this)
 {
 	return this->storage;
Index: src/libcfa/containers/vector.c
===================================================================
--- src/libcfa/containers/vector.c	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/libcfa/containers/vector.c	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -18,18 +18,36 @@
 #include <stdlib>
 
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void copy_internal(vector(T, allocator_t)* this, vector(T, allocator_t)* other);
+
 //------------------------------------------------------------------------------
 //Initialization
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void ctor(vector(T, allocator_t) *const this)
+void ?{}(vector(T, allocator_t)* this)
 {
-	ctor(&this->storage);
+	(&this->storage){};
 	this->size = 0;
 }
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void dtor(vector(T, allocator_t) *const this)
+void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs)
+{
+	(&this->storage){ rhs.storage };
+	copy_internal(this, &rhs);
+}
+
+// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+// vector(T, allocator_t) ?=?(vector(T, allocator_t)* this, vector(T, allocator_t) rhs)
+// {
+// 	(&this->storage){};
+// 	copy_internal(this, &rhs);
+// 	return *this;
+// }
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void ^?{}(vector(T, allocator_t)* this)
 {
 	clear(this);
-	dtor(&this->storage);
+	^(&this->storage){};
 }
 
@@ -37,5 +55,5 @@
 //Modifiers
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void push_back(vector(T, allocator_t) *const this, T value)
+void push_back(vector(T, allocator_t)* this, T value)
 {
 	realloc_storage(&this->storage, this->size+1);
@@ -45,16 +63,16 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void pop_back(vector(T, allocator_t) *const this)
+void pop_back(vector(T, allocator_t)* this)
 {
 	this->size--;
-	DESTROY(data(&this->storage)[this->size]);
+	^(&data(&this->storage)[this->size]){};
 }
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void clear(vector(T, allocator_t) *const this)
+void clear(vector(T, allocator_t)* this)
 {
 	for(size_t i = 0; i < this->size; i++)
 	{
-		DESTROY(data(&this->storage)[this->size]);
+		^(&data(&this->storage)[this->size]){};
 	}
 	this->size = 0;
@@ -62,7 +80,19 @@
 
 //------------------------------------------------------------------------------
+//Internal Helpers
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void copy_internal(vector(T, allocator_t)* this, vector(T, allocator_t)* other)
+{
+	this->size = other->size;
+	for(size_t i = 0; i < this->size; i++) {
+		(&data(&this->storage)[this->size]){ data(&other->storage)[other->size] };
+	}
+}
+
+//------------------------------------------------------------------------------
 //Allocator
 forall(otype T)
-void ctor(heap_allocator(T) *const this)
+void ?{}(heap_allocator(T)* this)
 {
 	this->storage = 0;
@@ -71,5 +101,20 @@
 
 forall(otype T)
-void dtor(heap_allocator(T) *const this)
+void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs)
+{
+	this->capacity = rhs.capacity;
+	this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T));
+}
+
+forall(otype T)
+heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs)
+{
+	this->capacity = rhs.capacity;
+	this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T));
+	return *this;
+}
+
+forall(otype T)
+void ^?{}(heap_allocator(T)* this)
 {
 	free(this->storage);
@@ -77,5 +122,5 @@
 
 forall(otype T)
-inline void realloc_storage(heap_allocator(T) *const this, size_t size)
+inline void realloc_storage(heap_allocator(T)* this, size_t size)
 {
 	enum { GROWTH_RATE = 2 };
Index: src/tests/.expect/libcfa_vector.txt
===================================================================
--- src/tests/.expect/libcfa_vector.txt	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
+++ src/tests/.expect/libcfa_vector.txt	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -0,0 +1,5 @@
+0
+1
+2
+3
+0
Index: src/tests/libcfa_vector.c
===================================================================
--- src/tests/libcfa_vector.c	(revision aefcc3b4bc74c06dfe70a46ab130a8295ab26c3c)
+++ src/tests/libcfa_vector.c	(revision 23b6643f5ea88fa1b0e11583e2f0ed9315a515de)
@@ -1,10 +1,10 @@
-// 
+//
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 //
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
-// 
-// libcfa_vector.c -- 
-// 
+//
+// libcfa_vector.c --
+//
 // Author           : Thierry Delisle
 // Created On       : Mon Jul  4 23:36:19 2016
@@ -12,5 +12,5 @@
 // Last Modified On : Tue Jul  5 15:08:05 2016
 // Update Count     : 26
-// 
+//
 
 #include <fstream>
@@ -28,5 +28,4 @@
 int main() {
 	vector( int, heap_allocator(int) ) iv;
-	ctor( &iv );
 
 	assert( empty( &iv ) );