Index: src/libcfa/containers/vector
===================================================================
--- src/libcfa/containers/vector	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/libcfa/containers/vector	(revision 65660bd065cbc0b68c92db2425b5984d675dff58)
@@ -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 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/libcfa/containers/vector.c	(revision 65660bd065cbc0b68c92db2425b5984d675dff58)
@@ -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 };