Index: src/libcfa/concurrency/alarm.c
===================================================================
--- src/libcfa/concurrency/alarm.c	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/concurrency/alarm.c	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -56,25 +56,25 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
-	this->thrd = thrd;
-	this->alarm = alarm;
-	this->period = period;
-	this->next = 0;
-	this->set = false;
-	this->kernel_alarm = false;
+void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
+	this.thrd = thrd;
+	this.alarm = alarm;
+	this.period = period;
+	this.next = 0;
+	this.set = false;
+	this.kernel_alarm = false;
 }
 
-void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
-	this->proc = proc;
-	this->alarm = alarm;
-	this->period = period;
-	this->next = 0;
-	this->set = false;
-	this->kernel_alarm = true;
+void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
+	this.proc = proc;
+	this.alarm = alarm;
+	this.period = period;
+	this.next = 0;
+	this.set = false;
+	this.kernel_alarm = true;
 }
 
-void ^?{}( alarm_node_t * this ) {
-	if( this->set ) {
-		unregister_self( this );
+void ^?{}( alarm_node_t & this ) {
+	if( this.set ) {
+		unregister_self( &this );
 	}
 }
Index: src/libcfa/concurrency/alarm.h
===================================================================
--- src/libcfa/concurrency/alarm.h	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/concurrency/alarm.h	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -56,7 +56,7 @@
 typedef alarm_node_t ** __alarm_it_t;
 
-void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 );
-void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 );
-void ^?{}( alarm_node_t * this );
+void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 );
+void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 );
+void ^?{}( alarm_node_t & this );
 
 struct alarm_list_t {
@@ -65,7 +65,7 @@
 };
 
-static inline void ?{}( alarm_list_t * this ) {
-	this->head = 0;
-	this->tail = &this->head;
+static inline void ?{}( alarm_list_t & this ) {
+	this.head = 0;
+	this.tail = &this.head;
 }
 
Index: src/libcfa/concurrency/coroutine
===================================================================
--- src/libcfa/concurrency/coroutine	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/concurrency/coroutine	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -34,9 +34,9 @@
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}(coStack_t * this);
-void ?{}(coroutine_desc * this);
-void ?{}(coroutine_desc * this, const char * name);
-void ^?{}(coStack_t * this);
-void ^?{}(coroutine_desc * this);
+void ?{}(coStack_t & this);
+void ?{}(coroutine_desc & this);
+void ?{}(coroutine_desc & this, const char * name);
+void ^?{}(coStack_t & this);
+void ^?{}(coroutine_desc & this);
 
 //-----------------------------------------------------------------------------
Index: src/libcfa/concurrency/coroutine.c
===================================================================
--- src/libcfa/concurrency/coroutine.c	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/concurrency/coroutine.c	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -43,50 +43,50 @@
 //-----------------------------------------------------------------------------
 // Coroutine ctors and dtors
-void ?{}(coStack_t* this) {
-	this->size		= 65000;	// size of stack
-	this->storage	= NULL;	// pointer to stack
-	this->limit		= NULL;	// stack grows towards stack limit
-	this->base		= NULL;	// base of stack
-	this->context	= NULL;	// address of cfa_context_t
-	this->top		= NULL;	// address of top of storage
-	this->userStack	= false;
+void ?{}(coStack_t& this) {
+	this.size		= 65000;	// size of stack
+	this.storage	= NULL;	// pointer to stack
+	this.limit		= NULL;	// stack grows towards stack limit
+	this.base		= NULL;	// base of stack
+	this.context	= NULL;	// address of cfa_context_t
+	this.top		= NULL;	// address of top of storage
+	this.userStack	= false;
 }
 
-void ?{}(coStack_t* this, size_t size) {
+void ?{}(coStack_t& this, size_t size) {
 	this{};
-	this->size = size;
+	this.size = size;
 
-	create_stack(this, this->size);
+	create_stack(&this, this.size);
 }
 
-void ?{}(coroutine_desc* this) {
+void ?{}(coroutine_desc& this) {
 	this{ "Anonymous Coroutine" };
 }
 
-void ?{}(coroutine_desc* this, const char * name) {
-	this->name = name;
-	this->errno_ = 0;
-	this->state = Start;
-	this->starter = NULL;
-	this->last = NULL;
+void ?{}(coroutine_desc& this, const char * name) {
+	this.name = name;
+	this.errno_ = 0;
+	this.state = Start;
+	this.starter = NULL;
+	this.last = NULL;
 }
 
-void ?{}(coroutine_desc* this, size_t size) {
+void ?{}(coroutine_desc& this, size_t size) {
 	this{};
-	(&this->stack){size};
+	(this.stack){size};
 }
 
-void ^?{}(coStack_t* this) {
+void ^?{}(coStack_t& this) {
 	if ( ! this->userStack ) {
 		LIB_DEBUG_DO(
-			if ( mprotect( this->storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
-				abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", this, errno, strerror( errno ) );
+			if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
+				abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
 			}
 		);
-		free( this->storage );
+		free( this.storage );
 	}
 }
 
-void ^?{}(coroutine_desc* this) {}
+void ^?{}(coroutine_desc& this) {}
 
 // Part of the Public API
Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/concurrency/invoke.h	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -48,14 +48,14 @@
       #ifdef __CFORALL__
       extern "Cforall" {
-            void ?{}( struct __thread_queue_t * );
+            void ?{}( struct __thread_queue_t & );
             void append( struct __thread_queue_t *, struct thread_desc * );
             struct thread_desc * pop_head( struct __thread_queue_t * );
 
-            void ?{}( struct __condition_stack_t * );
+            void ?{}( struct __condition_stack_t & );
             void push( struct __condition_stack_t *, struct __condition_criterion_t * );
             struct __condition_criterion_t * pop( struct __condition_stack_t * );
 
-            void ?{}(spinlock * this);
-            void ^?{}(spinlock * this);
+            void ?{}(spinlock & this);
+            void ^?{}(spinlock & this);
       }
       #endif
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/concurrency/kernel	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -39,6 +39,6 @@
 };
 
-void  ?{}(semaphore * this, int count = 1);
-void ^?{}(semaphore * this);
+void  ?{}(semaphore & this, int count = 1);
+void ^?{}(semaphore & this);
 void P(semaphore * this);
 void V(semaphore * this);
@@ -52,6 +52,6 @@
 };
 
-void ?{}(cluster * this);
-void ^?{}(cluster * this);
+void ?{}(cluster & this);
+void ^?{}(cluster & this);
 
 //-----------------------------------------------------------------------------
@@ -69,10 +69,10 @@
 	unsigned short thrd_count;
 };
-static inline void ?{}(FinishAction * this) {
-	this->action_code = No_Action;
-	this->thrd = NULL;
-	this->lock = NULL;
+static inline void ?{}(FinishAction & this) {
+	this.action_code = No_Action;
+	this.thrd = NULL;
+	this.lock = NULL;
 }
-static inline void ^?{}(FinishAction * this) {}
+static inline void ^?{}(FinishAction & this) {}
 
 struct processor {
@@ -94,7 +94,7 @@
 };
 
-void ?{}(processor * this);
-void ?{}(processor * this, cluster * cltr);
-void ^?{}(processor * this);
+void ?{}(processor & this);
+void ?{}(processor & this, cluster * cltr);
+void ^?{}(processor & this);
 
 #endif //KERNEL_H
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/concurrency/kernel.c	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -75,109 +75,109 @@
 };
 
-void ?{}( current_stack_info_t * this ) {
-	CtxGet( this->ctx );
-	this->base = this->ctx.FP;
-	this->storage = this->ctx.SP;
+void ?{}( current_stack_info_t & this ) {
+	CtxGet( this.ctx );
+	this.base = this.ctx.FP;
+	this.storage = this.ctx.SP;
 
 	rlimit r;
 	getrlimit( RLIMIT_STACK, &r);
-	this->size = r.rlim_cur;
-
-	this->limit = (void *)(((intptr_t)this->base) - this->size);
-	this->context = &mainThreadCtxStorage;
-	this->top = this->base;
-}
-
-void ?{}( coStack_t * this, current_stack_info_t * info) {
-	this->size = info->size;
-	this->storage = info->storage;
-	this->limit = info->limit;
-	this->base = info->base;
-	this->context = info->context;
-	this->top = info->top;
-	this->userStack = true;
-}
-
-void ?{}( coroutine_desc * this, current_stack_info_t * info) {
-	(&this->stack){ info };
-	this->name = "Main Thread";
-	this->errno_ = 0;
-	this->state = Start;
-}
-
-void ?{}( thread_desc * this, current_stack_info_t * info) {
-	(&this->cor){ info };
+	this.size = r.rlim_cur;
+
+	this.limit = (void *)(((intptr_t)this.base) - this.size);
+	this.context = &mainThreadCtxStorage;
+	this.top = this.base;
+}
+
+void ?{}( coStack_t & this, current_stack_info_t * info) {
+	this.size = info->size;
+	this.storage = info->storage;
+	this.limit = info->limit;
+	this.base = info->base;
+	this.context = info->context;
+	this.top = info->top;
+	this.userStack = true;
+}
+
+void ?{}( coroutine_desc & this, current_stack_info_t * info) {
+	(this.stack){ info };
+	this.name = "Main Thread";
+	this.errno_ = 0;
+	this.state = Start;
+}
+
+void ?{}( thread_desc & this, current_stack_info_t * info) {
+	(this.cor){ info };
 }
 
 //-----------------------------------------------------------------------------
 // Processor coroutine
-void ?{}(processorCtx_t * this, processor * proc) {
-	(&this->__cor){ "Processor" };
-	this->proc = proc;
-	proc->runner = this;
-}
-
-void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) {
-	(&this->__cor){ info };
-	this->proc = proc;
-	proc->runner = this;
-}
-
-void ?{}(processor * this) {
+void ?{}(processorCtx_t & this, processor * proc) {
+	(this.__cor){ "Processor" };
+	this.proc = proc;
+	proc->runner = &this;
+}
+
+void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info) {
+	(this.__cor){ info };
+	this.proc = proc;
+	proc->runner = &this;
+}
+
+void ?{}(processor & this) {
 	this{ systemCluster };
 }
 
-void ?{}(processor * this, cluster * cltr) {
-	this->cltr = cltr;
-	(&this->terminated){ 0 };
-	this->is_terminated = false;
-	this->preemption_alarm = NULL;
-	this->preemption = default_preemption();
-	this->pending_preemption = false;
-
-	start( this );
-}
-
-void ?{}(processor * this, cluster * cltr, processorCtx_t * runner) {
-	this->cltr = cltr;
-	(&this->terminated){ 0 };
-	this->is_terminated = false;
-	this->preemption_alarm = NULL;
-	this->preemption = default_preemption();
-	this->pending_preemption = false;
-	this->kernel_thread = pthread_self();
-
-	this->runner = runner;
+void ?{}(processor & this, cluster * cltr) {
+	this.cltr = cltr;
+	(this.terminated){ 0 };
+	this.is_terminated = false;
+	this.preemption_alarm = NULL;
+	this.preemption = default_preemption();
+	this.pending_preemption = false;
+
+	start( &this );
+}
+
+void ?{}(processor & this, cluster * cltr, processorCtx_t * runner) {
+	this.cltr = cltr;
+	(this.terminated){ 0 };
+	this.is_terminated = false;
+	this.preemption_alarm = NULL;
+	this.preemption = default_preemption();
+	this.pending_preemption = false;
+	this.kernel_thread = pthread_self();
+
+	this.runner = runner;
 	LIB_DEBUG_PRINT_SAFE("Kernel : constructing system processor context %p\n", runner);
-	runner{ this };
+	(*runner){ &this };
 }
 
 LIB_DEBUG_DO( bool validate( alarm_list_t * this ); )
 
-void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) {
-	(&this->alarms){};
-	(&this->alarm_lock){};
-	this->pending_alarm = false;
-
-	(&this->proc){ cltr, runner };
-
-	verify( validate( &this->alarms ) );
-}
-
-void ^?{}(processor * this) {
-	if( ! this->is_terminated ) {
-		LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this);
-		this->is_terminated = true;
-		P( &this->terminated );
-		pthread_join( this->kernel_thread, NULL );
-	}
-}
-
-void ?{}(cluster * this) {
-	( &this->ready_queue ){};
-	( &this->lock ){};
-}
-
-void ^?{}(cluster * this) {
+void ?{}(system_proc_t & this, cluster * cltr, processorCtx_t * runner) {
+	(this.alarms){};
+	(this.alarm_lock){};
+	this.pending_alarm = false;
+
+	(this.proc){ cltr, runner };
+
+	verify( validate( &this.alarms ) );
+}
+
+void ^?{}(processor & this) {
+	if( ! this.is_terminated ) {
+		LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
+		this.is_terminated = true;
+		P( this.terminated );
+		pthread_join( this.kernel_thread, NULL );
+	}
+}
+
+void ?{}(cluster & this) {
+	( this.ready_queue ){};
+	( this.lock ){};
+}
+
+void ^?{}(cluster & this) {
 
 }
@@ -582,8 +582,8 @@
 //-----------------------------------------------------------------------------
 // Locks
-void ?{}( spinlock * this ) {
-	this->lock = 0;
-}
-void ^?{}( spinlock * this ) {
+void ?{}( spinlock & this ) {
+	this.lock = 0;
+}
+void ^?{}( spinlock & this ) {
 
 }
@@ -619,10 +619,10 @@
 }
 
-void  ?{}( semaphore * this, int count = 1 ) {
-	(&this->lock){};
-	this->count = count;
-	(&this->waiting){};
-}
-void ^?{}(semaphore * this) {}
+void  ?{}( semaphore & this, int count = 1 ) {
+	(this.lock){};
+	this.count = count;
+	(this.waiting){};
+}
+void ^?{}(semaphore & this) {}
 
 void P(semaphore * this) {
@@ -658,7 +658,7 @@
 //-----------------------------------------------------------------------------
 // Queues
-void ?{}( __thread_queue_t * this ) {
-	this->head = NULL;
-	this->tail = &this->head;
+void ?{}( __thread_queue_t & this ) {
+	this.head = NULL;
+	this.tail = &this.head;
 }
 
@@ -681,6 +681,6 @@
 }
 
-void ?{}( __condition_stack_t * this ) {
-	this->top = NULL;
+void ?{}( __condition_stack_t & this ) {
+	this.top = NULL;
 }
 
Index: src/libcfa/concurrency/monitor
===================================================================
--- src/libcfa/concurrency/monitor	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/concurrency/monitor	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -24,7 +24,7 @@
 #include "stdlib"
 
-static inline void ?{}(monitor_desc * this) {
-	this->owner = NULL;
-	this->recursion = 0;
+static inline void ?{}(monitor_desc & this) {
+	this.owner = NULL;
+	this.recursion = 0;
 }
 
@@ -40,6 +40,6 @@
 }
 
-void ?{}( monitor_guard_t * this, monitor_desc ** m, int count );
-void ^?{}( monitor_guard_t * this );
+void ?{}( monitor_guard_t & this, monitor_desc ** m, int count );
+void ^?{}( monitor_guard_t & this );
 
 //-----------------------------------------------------------------------------
@@ -66,5 +66,5 @@
 };
 
-void ?{}( __condition_blocked_queue_t * );
+void ?{}( __condition_blocked_queue_t & );
 void append( __condition_blocked_queue_t *, __condition_node_t * );
 __condition_node_t * pop_head( __condition_blocked_queue_t * );
@@ -76,11 +76,11 @@
 };
 
-static inline void ?{}( condition * this ) {
-	this->monitors = NULL;
-	this->monitor_count = 0;
+static inline void ?{}( condition & this ) {
+	this.monitors = NULL;
+	this.monitor_count = 0;
 }
 
-static inline void ^?{}( condition * this ) {
-	free( this->monitors );
+static inline void ^?{}( condition & this ) {
+	free( this.monitors );
 }
 
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/concurrency/monitor.c	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -140,12 +140,12 @@
 }
 
-void ?{}( monitor_guard_t * this, monitor_desc ** m, int count ) {
-	this->m = m;
-	this->count = count;
-	qsort(this->m, count);
-	enter( this->m, this->count );
-
-	this->prev_mntrs = this_thread->current_monitors;
-	this->prev_count = this_thread->current_monitor_count;
+void ?{}( monitor_guard_t & this, monitor_desc ** m, int count ) {
+	this.m = m;
+	this.count = count;
+	qsort(this.m, count);
+	enter( this.m, this.count );
+
+	this.prev_mntrs = this_thread->current_monitors;
+	this.prev_count = this_thread->current_monitor_count;
 
 	this_thread->current_monitors      = m;
@@ -153,30 +153,30 @@
 }
 
-void ^?{}( monitor_guard_t * this ) {
-	leave( this->m, this->count );
-
-	this_thread->current_monitors      = this->prev_mntrs;
-	this_thread->current_monitor_count = this->prev_count;
-}
-
-void ?{}(__condition_node_t * this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) {
-	this->waiting_thread = waiting_thread;
-	this->count = count;
-	this->next = NULL;
-	this->user_info = user_info;
-}
-
-void ?{}(__condition_criterion_t * this ) {
-	this->ready  = false;
-	this->target = NULL;
-	this->owner  = NULL;
-	this->next   = NULL;
-}
-
-void ?{}(__condition_criterion_t * this, monitor_desc * target, __condition_node_t * owner ) {
-	this->ready  = false;
-	this->target = target;
-	this->owner  = owner;
-	this->next   = NULL;
+void ^?{}( monitor_guard_t & this ) {
+	leave( this.m, this.count );
+
+	this_thread->current_monitors      = this.prev_mntrs;
+	this_thread->current_monitor_count = this.prev_count;
+}
+
+void ?{}(__condition_node_t & this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) {
+	this.waiting_thread = waiting_thread;
+	this.count = count;
+	this.next = NULL;
+	this.user_info = user_info;
+}
+
+void ?{}(__condition_criterion_t & this ) {
+	this.ready  = false;
+	this.target = NULL;
+	this.owner  = NULL;
+	this.next   = NULL;
+}
+
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner ) {
+	this.ready  = false;
+	this.target = target;
+	this.owner  = owner;
+	this.next   = NULL;
 }
 
@@ -506,7 +506,7 @@
 }
 
-void ?{}( __condition_blocked_queue_t * this ) {
-	this->head = NULL;
-	this->tail = &this->head;
+void ?{}( __condition_blocked_queue_t & this ) {
+	this.head = NULL;
+	this.tail = &this.head;
 }
 
Index: src/libcfa/concurrency/preemption.c
===================================================================
--- src/libcfa/concurrency/preemption.c	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/concurrency/preemption.c	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -230,15 +230,15 @@
 }
 
-void ?{}( preemption_scope * this, processor * proc ) {
-	(&this->alarm){ proc };
-	this->proc = proc;
-	this->proc->preemption_alarm = &this->alarm;
-	update_preemption( this->proc, this->proc->preemption );
-}
-
-void ^?{}( preemption_scope * this ) {
+void ?{}( preemption_scope & this, processor * proc ) {
+	(this.alarm){ proc };
+	this.proc = proc;
+	this.proc->preemption_alarm = &this.alarm;
+	update_preemption( this.proc, this.proc->preemption );
+}
+
+void ^?{}( preemption_scope & this ) {
 	disable_interrupts();
 
-	update_preemption( this->proc, 0 );
+	update_preemption( this.proc, 0 );
 }
 
Index: src/libcfa/concurrency/preemption.h
===================================================================
--- src/libcfa/concurrency/preemption.h	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/concurrency/preemption.h	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -32,6 +32,6 @@
 };
 
-void ?{}( preemption_scope * this, processor * proc );
-void ^?{}( preemption_scope * this );
+void ?{}( preemption_scope & this, processor * proc );
+void ^?{}( preemption_scope & this );
 
 #endif //PREEMPTION_H
Index: src/libcfa/concurrency/thread
===================================================================
--- src/libcfa/concurrency/thread	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/concurrency/thread	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -29,5 +29,5 @@
 // Anything that is resumed is a coroutine.
 trait is_thread(dtype T) {
-      void ^?{}(T* mutex this);
+      void ^?{}(T& mutex this);
       void main(T* this);
       thread_desc* get_thread(T* this);
@@ -61,6 +61,6 @@
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}(thread_desc* this);
-void ^?{}(thread_desc* this);
+void ?{}(thread_desc& this);
+void ^?{}(thread_desc& this);
 
 //-----------------------------------------------------------------------------
@@ -72,12 +72,12 @@
 };
 
-forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } )
-void ?{}( scoped(T)* this );
+forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
+void ?{}( scoped(T)& this );
 
-forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } )
-void ?{}( scoped(T)* this, P params );
+forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
+void ?{}( scoped(T)& this, P params );
 
 forall( dtype T | sized(T) | is_thread(T) )
-void ^?{}( scoped(T)* this );
+void ^?{}( scoped(T)& this );
 
 void yield();
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/concurrency/thread.c	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -33,34 +33,34 @@
 // Thread ctors and dtors
 
-void ?{}(thread_desc* this) {
-	(&this->cor){};
-	this->cor.name = "Anonymous Coroutine";
-	this->mon.owner = this;
-	this->mon.recursion = 1;
-	this->next = NULL;
+void ?{}(thread_desc& this) {
+	(this.cor){};
+	this.cor.name = "Anonymous Coroutine";
+	this.mon.owner = this;
+	this.mon.recursion = 1;
+	this.next = NULL;
 
-	this->current_monitors      = &this->mon;
-	this->current_monitor_count = 1;
+	this.current_monitors      = &this.mon;
+	this.current_monitor_count = 1;
 }
 
-void ^?{}(thread_desc* this) {
-	^(&this->cor){};
+void ^?{}(thread_desc& this) {
+	^(this.cor){};
 }
 
-forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } )
-void ?{}( scoped(T)* this ) {
-	(&this->handle){};
-	__thrd_start(&this->handle);
+forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
+void ?{}( scoped(T)& this ) {
+	(this.handle){};
+	__thrd_start(&this.handle);
 }
 
-forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } )
-void ?{}( scoped(T)* this, P params ) {
-	(&this->handle){ params };
-	__thrd_start(&this->handle);
+forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
+void ?{}( scoped(T)& this, P params ) {
+	(this.handle){ params };
+	__thrd_start(&this.handle);
 }
 
 forall( dtype T | sized(T) | is_thread(T) )
-void ^?{}( scoped(T)* this ) {
-	^(&this->handle){};
+void ^?{}( scoped(T)& this ) {
+	^(this.handle){};
 }
 
Index: src/libcfa/containers/result
===================================================================
--- src/libcfa/containers/result	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/containers/result	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -35,20 +35,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 a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/libcfa/containers/result.c	(revision cb434518055bb986f86735395964571c3f085a38)
@@ -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;
