Index: src/libcfa/containers/maybe
===================================================================
--- src/libcfa/containers/maybe	(revision 6b0b624129f6017f7706b516a24a52e382e3a334)
+++ src/libcfa/containers/maybe	(revision 2ae171d8401152d8289643ca2935d2f09ce16b41)
@@ -27,17 +27,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 6b0b624129f6017f7706b516a24a52e382e3a334)
+++ src/libcfa/containers/maybe.c	(revision 2ae171d8401152d8289643ca2935d2f09ce16b41)
@@ -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/result
===================================================================
--- src/libcfa/containers/result	(revision 6b0b624129f6017f7706b516a24a52e382e3a334)
+++ src/libcfa/containers/result	(revision 2ae171d8401152d8289643ca2935d2f09ce16b41)
@@ -33,20 +33,20 @@
 
 forall(otype T, otype E)
-void ?{}(result(T, E) * this);
+void ?{}(result(T, E) & this);
 
 forall(otype T, otype E)
-void ?{}(result(T, E) * this, one_t, T value);
+void ?{}(result(T, E) & this, one_t, T value);
 
 forall(otype T, otype E)
-void ?{}(result(T, E) * this, zero_t, E error);
+void ?{}(result(T, E) & this, zero_t, E error);
 
 forall(otype T, otype E)
-void ?{}(result(T, E) * this, result(T, E) other);
+void ?{}(result(T, E) & this, result(T, E) other);
 
 forall(otype T, otype E)
-void ^?{}(result(T, E) * this);
+void ^?{}(result(T, E) & this);
 
 forall(otype T, otype E)
-result(T, E) ?=?(result(T, E) * this, result(T, E) other);
+result(T, E) ?=?(result(T, E) & this, result(T, E) other);
 
 forall(otype T, otype E)
Index: src/libcfa/containers/result.c
===================================================================
--- src/libcfa/containers/result.c	(revision 6b0b624129f6017f7706b516a24a52e382e3a334)
+++ src/libcfa/containers/result.c	(revision 2ae171d8401152d8289643ca2935d2f09ce16b41)
@@ -19,54 +19,54 @@
 
 forall(otype T, otype E)
-void ?{}(result(T, E) * this) {
-	this->has_value = false;
-	(&this->error){};
+void ?{}(result(T, E) & this) {
+	this.has_value = false;
+	(this.error){};
 }
 
 forall(otype T, otype E)
-void ?{}(result(T, E) * this, one_t, T value) {
-	this->has_value = true;
-	(&this->value){value};
+void ?{}(result(T, E) & this, one_t, T value) {
+	this.has_value = true;
+	(this.value){value};
 }
 
 forall(otype T, otype E)
-void ?{}(result(T, E) * this, zero_t, E error) {
-	this->has_value = false;
-	(&this->error){error};
+void ?{}(result(T, E) & this, zero_t, E error) {
+	this.has_value = false;
+	(this.error){error};
 }
 
 forall(otype T, otype E)
-void ?{}(result(T, E) * this, result(T, E) other) {
-	this->has_value = other.has_value;
+void ?{}(result(T, E) & this, result(T, E) other) {
+	this.has_value = other.has_value;
 	if (other.has_value) {
-		(&this->value){other.value};
+		(this.value){other.value};
 	} else {
-		(&this->error){other.error};
+		(this.error){other.error};
 	}
 }
 
 forall(otype T, otype E)
-result(T, E) ?=?(result(T, E) * this, result(T, E) that) {
-	if (this->has_value & that.has_value) {
-		this->value = that.value;
-	} else if (this->has_value) {
-		^(&this->value){};
-		this->has_value = false;
-		(&this->error){that.error};
+result(T, E) ?=?(result(T, E) & this, result(T, E) that) {
+	if (this.has_value & that.has_value) {
+		this.value = that.value;
+	} else if (this.has_value) {
+		^(this.value){};
+		this.has_value = false;
+		(this.error){that.error};
 	} else if (that.has_value) {
-		^(&this->error){};
-		this->has_value = true;
-		(&this->value){that.value};
+		^(this.error){};
+		this.has_value = true;
+		(this.value){that.value};
 	} else {
-		this->error = that.error;
+		this.error = that.error;
 	}
 }
 
 forall(otype T, otype E)
-void ^?{}(result(T, E) * this) {
-	if (this->has_value) {
-		^(&this->value){};
+void ^?{}(result(T, E) & this) {
+	if (this.has_value) {
+		^(this.value){};
 	} else {
-		^(&this->error){};
+		^(this.error){};
 	}
 }
@@ -109,7 +109,7 @@
 		this->value = value;
 	} else {
-		^(&this->error){};
+		^(this->error){};
 		this->has_value = true;
-		(&this->value){value};
+		(this->value){value};
 	}
 }
@@ -118,7 +118,7 @@
 void set_error(result(T, E) * this, E error) {
 	if (this->has_value) {
-		^(&this->value){};
+		^(this->value){};
 		this->has_value = false;
-		(&this->error){error};
+		(this->error){error};
 	} else {
 		this->error = error;
Index: src/libcfa/containers/vector
===================================================================
--- src/libcfa/containers/vector	(revision 6b0b624129f6017f7706b516a24a52e382e3a334)
+++ src/libcfa/containers/vector	(revision 2ae171d8401152d8289643ca2935d2f09ce16b41)
@@ -30,14 +30,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)
@@ -64,14 +64,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 6b0b624129f6017f7706b516a24a52e382e3a334)
+++ src/libcfa/containers/vector.c	(revision 2ae171d8401152d8289643ca2935d2f09ce16b41)
@@ -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);
 }