Index: src/libcfa/containers/maybe
===================================================================
--- src/libcfa/containers/maybe	(revision 20877d2eef6ecadc8e9da4a79b2995277fb25362)
+++ src/libcfa/containers/maybe	(revision aca65621fec224ce52fce478fdf5225511cb845b)
@@ -29,17 +29,17 @@
 
 forall(otype T)
-void ?{}(maybe(T) * this);
+void ?{}(maybe(T) & this);
 
 forall(otype T)
-void ?{}(maybe(T) * this, T value);
+void ?{}(maybe(T) & this, T value);
 
 forall(otype T)
-void ?{}(maybe(T) * this, maybe(T) other);
+void ?{}(maybe(T) & this, maybe(T) other);
 
 forall(otype T)
-void ^?{}(maybe(T) * this);
+void ^?{}(maybe(T) & this);
 
 forall(otype T)
-maybe(T) ?=?(maybe(T) * this, maybe(T) other);
+maybe(T) ?=?(maybe(T) & this, maybe(T) other);
 
 forall(otype T)
Index: src/libcfa/containers/maybe.c
===================================================================
--- src/libcfa/containers/maybe.c	(revision 20877d2eef6ecadc8e9da4a79b2995277fb25362)
+++ src/libcfa/containers/maybe.c	(revision aca65621fec224ce52fce478fdf5225511cb845b)
@@ -19,39 +19,40 @@
 
 forall(otype T)
-void ?{}(maybe(T) * this) {
-	this->has_value = false;
+void ?{}(maybe(T) & this) {
+	this.has_value = false;
 }
 
 forall(otype T)
-void ?{}(maybe(T) * this, T value) {
-	this->has_value = true;
-	(&this->value){value};
+void ?{}(maybe(T) & this, T value) {
+	this.has_value = true;
+	(this.value){value};
 }
 
 forall(otype T)
-void ?{}(maybe(T) * this, maybe(T) other) {
-	this->has_value = other.has_value;
+void ?{}(maybe(T) & this, maybe(T) other) {
+	this.has_value = other.has_value;
 	if (other.has_value) {
-		(&this->value){other.value};
+		(this.value){other.value};
 	}
 }
 
 forall(otype T)
-maybe(T) ?=?(maybe(T) * this, maybe(T) that) {
-	if (this->has_value & that.has_value) {
-		this->value = that.value;
-	} else if (this->has_value) {
-		^(&this->value){};
-		this->has_value = false;
+maybe(T) ?=?(maybe(T) & this, maybe(T) that) {
+	if (this.has_value & that.has_value) {
+		this.value = that.value;
+	} else if (this.has_value) {
+		^(this.value){};
+		this.has_value = false;
 	} else if (that.has_value) {
-		this->has_value = true;
-		(&this->value){that.value};
+		this.has_value = true;
+		(this.value){that.value};
 	}
+	return this;
 }
 
 forall(otype T)
-void ^?{}(maybe(T) * this) {
-	if (this->has_value) {
-		^(&this->value){};
+void ^?{}(maybe(T) & this) {
+	if (this.has_value) {
+		^(this.value){};
 	}
 }
@@ -89,5 +90,5 @@
 	} else {
 		this->has_value = true;
-		(&this->value){value};
+		(this->value){value};
 	}
 }
@@ -97,5 +98,5 @@
 	if (this->has_value) {
 		this->has_value = false;
-		^(&this->value){};
+		^(this->value){};
 	}
 }
Index: src/libcfa/containers/vector
===================================================================
--- src/libcfa/containers/vector	(revision 20877d2eef6ecadc8e9da4a79b2995277fb25362)
+++ src/libcfa/containers/vector	(revision aca65621fec224ce52fce478fdf5225511cb845b)
@@ -31,14 +31,14 @@
 
 forall(otype T)
-void ?{}(heap_allocator(T)* this);
+void ?{}(heap_allocator(T)& this);
 
 forall(otype T)
-void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs);
+void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs);
 
 forall(otype T)
-heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs);
+heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs);
 
 forall(otype T)
-void ^?{}(heap_allocator(T)* this);
+void ^?{}(heap_allocator(T)& this);
 
 forall(otype T)
@@ -65,14 +65,14 @@
 //Initialization
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void ?{}(vector(T, allocator_t)* this);
+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);
+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);
+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);
+void ^?{}(vector(T, allocator_t)& this);
 
 forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t))
Index: src/libcfa/containers/vector.c
===================================================================
--- src/libcfa/containers/vector.c	(revision 20877d2eef6ecadc8e9da4a79b2995277fb25362)
+++ src/libcfa/containers/vector.c	(revision aca65621fec224ce52fce478fdf5225511cb845b)
@@ -24,15 +24,15 @@
 //Initialization
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void ?{}(vector(T, allocator_t)* this)
+void ?{}(vector(T, allocator_t)& this)
 {
-	(&this->storage){};
-	this->size = 0;
+	(this.storage){};
+	this.size = 0;
 }
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs)
+void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs)
 {
-	(&this->storage){ rhs.storage };
-	copy_internal(this, &rhs);
+	(this.storage){ rhs.storage };
+	copy_internal(&this, &rhs);
 }
 
@@ -46,8 +46,8 @@
 
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-void ^?{}(vector(T, allocator_t)* this)
+void ^?{}(vector(T, allocator_t)& this)
 {
-	clear(this);
-	^(&this->storage){};
+	clear(&this);
+	^(this.storage){};
 }
 
@@ -66,5 +66,5 @@
 {
 	this->size--;
-	^(&data(&this->storage)[this->size]){};
+	^(data(&this->storage)[this->size]){};
 }
 
@@ -74,5 +74,5 @@
 	for(size_t i = 0; i < this->size; i++)
 	{
-		^(&data(&this->storage)[this->size]){};
+		^(data(&this->storage)[this->size]){};
 	}
 	this->size = 0;
@@ -87,5 +87,5 @@
 	this->size = other->size;
 	for(size_t i = 0; i < this->size; i++) {
-		(&data(&this->storage)[this->size]){ data(&other->storage)[other->size] };
+		(data(&this->storage)[this->size]){ data(&other->storage)[other->size] };
 	}
 }
@@ -94,29 +94,29 @@
 //Allocator
 forall(otype T)
-void ?{}(heap_allocator(T)* this)
+void ?{}(heap_allocator(T)& this)
 {
-	this->storage = 0;
-	this->capacity = 0;
+	this.storage = 0;
+	this.capacity = 0;
 }
 
 forall(otype T)
-void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs)
+void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs)
 {
-	this->capacity = rhs.capacity;
-	this->storage = (T*)realloc((void*)this->storage, this->capacity * sizeof(T));
+	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)
+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;
+	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)
+void ^?{}(heap_allocator(T)& this)
 {
-	free(this->storage);
+	free(this.storage);
 }