Index: src/libcfa/bits/containers.h
===================================================================
--- src/libcfa/bits/containers.h	(revision b3048d49aeb2ea2dd5d01939e5b683c1307b07d1)
+++ src/libcfa/bits/containers.h	(revision 65deb18a7ffff4dccefdf2611afde3cadd19efb0)
@@ -140,15 +140,16 @@
 
 #ifdef __cforall
+
 	forall(dtype T | is_node(T))
-	static inline void ?{}( __queue(T) & this ) {
-		(this.head){ NULL };
-		(this.tail){ &this.head };
+	static inline void ?{}( __queue(T) & this ) with( this ) {
+		head{ NULL };
+		tail{ &head };
 	}
 
 	forall(dtype T | is_node(T) | sized(T))
-	static inline void append( __queue(T) & this, T * val ) {
-		verify(this.tail != NULL);
-		*this.tail = val;
-		this.tail = &get_next( *val );
+	static inline void append( __queue(T) & this, T * val ) with( this ) {
+		verify(tail != NULL);
+		*tail = val;
+		tail = &get_next( *val );
 	}
 
@@ -167,5 +168,5 @@
 
 	forall(dtype T | is_node(T) | sized(T))
-	static inline T * remove( __queue(T) & this, T ** it ) {
+	static inline T * remove( __queue(T) & this, T ** it ) with( this ) {
 		T * val = *it;
 		verify( val );
@@ -173,13 +174,20 @@
 		(*it) = get_next( *val );
 
-		if( this.tail == &get_next( *val ) ) {
-			this.tail = it;
+		if( tail == &get_next( *val ) ) {
+			tail = it;
 		}
 
 		get_next( *val ) = NULL;
 
-		verify( (this.head == NULL) == (&this.head == this.tail) );
-		verify( *this.tail == NULL );
+		verify( (head == NULL) == (&head == tail) );
+		verify( *tail == NULL );
 		return val;
 	}
 #endif
+
+//-----------------------------------------------------------------------------
+// Tools
+//-----------------------------------------------------------------------------
+#ifdef __cforall
+
+#endif
Index: src/libcfa/concurrency/coroutine.c
===================================================================
--- src/libcfa/concurrency/coroutine.c	(revision b3048d49aeb2ea2dd5d01939e5b683c1307b07d1)
+++ src/libcfa/concurrency/coroutine.c	(revision 65deb18a7ffff4dccefdf2611afde3cadd19efb0)
@@ -118,5 +118,5 @@
 } //ctxSwitchDirect
 
-void create_stack( coStack_t* this, unsigned int storageSize ) {
+void create_stack( coStack_t* this, unsigned int storageSize ) with( *this ) {
 	//TEMP HACK do this on proper kernel startup
 	if(pageSize == 0ul) pageSize = sysconf( _SC_PAGESIZE );
@@ -124,40 +124,40 @@
 	size_t cxtSize = libCeiling( sizeof(machine_context_t), 8 ); // minimum alignment
 
-	if ( (intptr_t)this->storage == 0 ) {
-		this->userStack = false;
-		this->size = libCeiling( storageSize, 16 );
+	if ( (intptr_t)storage == 0 ) {
+		userStack = false;
+		size = libCeiling( storageSize, 16 );
 		// use malloc/memalign because "new" raises an exception for out-of-memory
 
 		// assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment
-		__cfaabi_dbg_debug_do( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) );
-		__cfaabi_dbg_no_debug_do( this->storage = malloc( cxtSize + this->size + 8 ) );
+		__cfaabi_dbg_debug_do( storage = memalign( pageSize, cxtSize + size + pageSize ) );
+		__cfaabi_dbg_no_debug_do( storage = malloc( cxtSize + size + 8 ) );
 
 		__cfaabi_dbg_debug_do(
-			if ( mprotect( this->storage, pageSize, PROT_NONE ) == -1 ) {
+			if ( mprotect( storage, pageSize, PROT_NONE ) == -1 ) {
 				abortf( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) );
 			} // if
 		);
 
-		if ( (intptr_t)this->storage == 0 ) {
-			abortf( "Attempt to allocate %d bytes of storage for coroutine or task execution-state but insufficient memory available.", this->size );
+		if ( (intptr_t)storage == 0 ) {
+			abortf( "Attempt to allocate %d bytes of storage for coroutine or task execution-state but insufficient memory available.", size );
 		} // if
 
-		__cfaabi_dbg_debug_do( this->limit = (char *)this->storage + pageSize );
-		__cfaabi_dbg_no_debug_do( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment
+		__cfaabi_dbg_debug_do( limit = (char *)storage + pageSize );
+		__cfaabi_dbg_no_debug_do( limit = (char *)libCeiling( (unsigned long)storage, 16 ) ); // minimum alignment
 
 	} else {
-		assertf( ((size_t)this->storage & (libAlign() - 1)) != 0ul, "Stack storage %p for task/coroutine must be aligned on %d byte boundary.", this->storage, (int)libAlign() );
-		this->userStack = true;
-		this->size = storageSize - cxtSize;
+		assertf( ((size_t)storage & (libAlign() - 1)) != 0ul, "Stack storage %p for task/coroutine must be aligned on %d byte boundary.", storage, (int)libAlign() );
+		userStack = true;
+		size = storageSize - cxtSize;
 
-		if ( this->size % 16 != 0u ) this->size -= 8;
+		if ( size % 16 != 0u ) size -= 8;
 
-		this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ); // minimum alignment
+		limit = (char *)libCeiling( (unsigned long)storage, 16 ); // minimum alignment
 	} // if
-	assertf( this->size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", this->size, MinStackSize );
+	assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", size, MinStackSize );
 
-	this->base = (char *)this->limit + this->size;
-	this->context = this->base;
-	this->top = (char *)this->context + cxtSize;
+	base = (char *)limit + size;
+	context = base;
+	top = (char *)context + cxtSize;
 }
 
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision b3048d49aeb2ea2dd5d01939e5b683c1307b07d1)
+++ src/libcfa/concurrency/kernel.c	(revision 65deb18a7ffff4dccefdf2611afde3cadd19efb0)
@@ -85,24 +85,24 @@
 }
 
-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;
-	this.starter = NULL;
-}
-
-void ?{}( thread_desc & this, current_stack_info_t * info) {
-	(this.self_cor){ info };
+void ?{}( coStack_t & this, current_stack_info_t * info) with( this ) {
+	size      = info->size;
+	storage   = info->storage;
+	limit     = info->limit;
+	base      = info->base;
+	context   = info->context;
+	top       = info->top;
+	userStack = true;
+}
+
+void ?{}( coroutine_desc & this, current_stack_info_t * info) with( this ) {
+	stack{ info };
+	name = "Main Thread";
+	errno_ = 0;
+	state = Start;
+	starter = NULL;
+}
+
+void ?{}( thread_desc & this, current_stack_info_t * info) with( this ) {
+	self_cor{ info };
 }
 
@@ -131,5 +131,5 @@
 void ?{}(processor & this, cluster * cltr) {
 	this.cltr = cltr;
-	(this.terminated){ 0 };
+	this.terminated{ 0 };
 	this.do_terminate = false;
 	this.preemption_alarm = NULL;
@@ -141,5 +141,5 @@
 void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) {
 	this.cltr = cltr;
-	(this.terminated){ 0 };
+	this.terminated{ 0 };
 	this.do_terminate = false;
 	this.preemption_alarm = NULL;
@@ -152,18 +152,18 @@
 }
 
-void ^?{}(processor & this) {
-	if( ! this.do_terminate ) {
+void ^?{}(processor & this) with( this ){
+	if( ! do_terminate ) {
 		__cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
-		this.do_terminate = true;
-		P( this.terminated );
-		pthread_join( this.kernel_thread, NULL );
-	}
-}
-
-void ?{}(cluster & this) {
-	(this.ready_queue){};
-	( this.ready_queue_lock ){};
-
-	this.preemption = default_preemption();
+		do_terminate = true;
+		P( terminated );
+		pthread_join( kernel_thread, NULL );
+	}
+}
+
+void ?{}(cluster & this) with( this ) {
+	ready_queue{};
+	ready_queue_lock{};
+
+	preemption = default_preemption();
 }
 
@@ -238,30 +238,30 @@
 // Once a thread has finished running, some of
 // its final actions must be executed from the kernel
-void finishRunning(processor * this) {
-	if( this->finish.action_code == Release ) {
-		unlock( *this->finish.lock );
-	}
-	else if( this->finish.action_code == Schedule ) {
-		ScheduleThread( this->finish.thrd );
-	}
-	else if( this->finish.action_code == Release_Schedule ) {
-		unlock( *this->finish.lock );
-		ScheduleThread( this->finish.thrd );
-	}
-	else if( this->finish.action_code == Release_Multi ) {
-		for(int i = 0; i < this->finish.lock_count; i++) {
-			unlock( *this->finish.locks[i] );
+void finishRunning(processor * this) with( this->finish ) {
+	if( action_code == Release ) {
+		unlock( *lock );
+	}
+	else if( action_code == Schedule ) {
+		ScheduleThread( thrd );
+	}
+	else if( action_code == Release_Schedule ) {
+		unlock( *lock );
+		ScheduleThread( thrd );
+	}
+	else if( action_code == Release_Multi ) {
+		for(int i = 0; i < lock_count; i++) {
+			unlock( *locks[i] );
 		}
 	}
-	else if( this->finish.action_code == Release_Multi_Schedule ) {
-		for(int i = 0; i < this->finish.lock_count; i++) {
-			unlock( *this->finish.locks[i] );
+	else if( action_code == Release_Multi_Schedule ) {
+		for(int i = 0; i < lock_count; i++) {
+			unlock( *locks[i] );
 		}
-		for(int i = 0; i < this->finish.thrd_count; i++) {
-			ScheduleThread( this->finish.thrds[i] );
+		for(int i = 0; i < thrd_count; i++) {
+			ScheduleThread( thrds[i] );
 		}
 	}
 	else {
-		assert(this->finish.action_code == No_Action);
+		assert(action_code == No_Action);
 	}
 }
@@ -332,16 +332,18 @@
 	verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-	lock(   this_processor->cltr->ready_queue_lock __cfaabi_dbg_ctx2 );
-	append( this_processor->cltr->ready_queue, thrd );
-	unlock( this_processor->cltr->ready_queue_lock );
-
-	verify( disable_preempt_count > 0 );
-}
-
-thread_desc * nextThread(cluster * this) {
-	verify( disable_preempt_count > 0 );
-	lock( this->ready_queue_lock __cfaabi_dbg_ctx2 );
-	thread_desc * head = pop_head( this->ready_queue );
-	unlock( this->ready_queue_lock );
+	with( *this_processor->cltr ) {
+		lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
+		append( ready_queue, thrd );
+		unlock( ready_queue_lock );
+	}
+
+	verify( disable_preempt_count > 0 );
+}
+
+thread_desc * nextThread(cluster * this) with( *this ) {
+	verify( disable_preempt_count > 0 );
+	lock( ready_queue_lock __cfaabi_dbg_ctx2 );
+	thread_desc * head = pop_head( ready_queue );
+	unlock( ready_queue_lock );
 	verify( disable_preempt_count > 0 );
 	return head;
@@ -359,5 +361,5 @@
 	disable_interrupts();
 	this_processor->finish.action_code = Release;
-	this_processor->finish.lock = lock;
+	this_processor->finish.lock        = lock;
 
 	verify( disable_preempt_count > 0 );
@@ -369,9 +371,7 @@
 
 void BlockInternal( thread_desc * thrd ) {
-	assert(thrd);
 	disable_interrupts();
-	assert( thrd->self_cor.state != Halted );
 	this_processor->finish.action_code = Schedule;
-	this_processor->finish.thrd = thrd;
+	this_processor->finish.thrd        = thrd;
 
 	verify( disable_preempt_count > 0 );
@@ -386,6 +386,6 @@
 	disable_interrupts();
 	this_processor->finish.action_code = Release_Schedule;
-	this_processor->finish.lock = lock;
-	this_processor->finish.thrd = thrd;
+	this_processor->finish.lock        = lock;
+	this_processor->finish.thrd        = thrd;
 
 	verify( disable_preempt_count > 0 );
@@ -399,6 +399,6 @@
 	disable_interrupts();
 	this_processor->finish.action_code = Release_Multi;
-	this_processor->finish.locks = locks;
-	this_processor->finish.lock_count = count;
+	this_processor->finish.locks       = locks;
+	this_processor->finish.lock_count  = count;
 
 	verify( disable_preempt_count > 0 );
@@ -412,8 +412,8 @@
 	disable_interrupts();
 	this_processor->finish.action_code = Release_Multi_Schedule;
-	this_processor->finish.locks = locks;
-	this_processor->finish.lock_count = lock_count;
-	this_processor->finish.thrds = thrds;
-	this_processor->finish.thrd_count = thrd_count;
+	this_processor->finish.locks       = locks;
+	this_processor->finish.lock_count  = lock_count;
+	this_processor->finish.thrds       = thrds;
+	this_processor->finish.thrd_count  = thrd_count;
 
 	verify( disable_preempt_count > 0 );
@@ -427,6 +427,6 @@
 	verify( disable_preempt_count > 0 );
 	this_processor->finish.action_code = thrd ? Release_Schedule : Release;
-	this_processor->finish.lock = lock;
-	this_processor->finish.thrd = thrd;
+	this_processor->finish.lock        = lock;
+	this_processor->finish.thrd        = thrd;
 
 	suspend();
@@ -579,29 +579,29 @@
 void ^?{}(semaphore & this) {}
 
-void P(semaphore & this) {
-	lock( this.lock __cfaabi_dbg_ctx2 );
-	this.count -= 1;
-	if ( this.count < 0 ) {
+void P(semaphore & this) with( this ){
+	lock( lock __cfaabi_dbg_ctx2 );
+	count -= 1;
+	if ( count < 0 ) {
 		// queue current task
-		append( this.waiting, (thread_desc *)this_thread );
+		append( waiting, (thread_desc *)this_thread );
 
 		// atomically release spin lock and block
-		BlockInternal( &this.lock );
+		BlockInternal( &lock );
 	}
 	else {
-	    unlock( this.lock );
-	}
-}
-
-void V(semaphore & this) {
+	    unlock( lock );
+	}
+}
+
+void V(semaphore & this) with( this ) {
 	thread_desc * thrd = NULL;
-	lock( this.lock __cfaabi_dbg_ctx2 );
-	this.count += 1;
-	if ( this.count <= 0 ) {
+	lock( lock __cfaabi_dbg_ctx2 );
+	count += 1;
+	if ( count <= 0 ) {
 		// remove task at head of waiting list
-		thrd = pop_head( this.waiting );
-	}
-
-	unlock( this.lock );
+		thrd = pop_head( waiting );
+	}
+
+	unlock( lock );
 
 	// make new owner
Index: src/libcfa/concurrency/preemption.c
===================================================================
--- src/libcfa/concurrency/preemption.c	(revision b3048d49aeb2ea2dd5d01939e5b683c1307b07d1)
+++ src/libcfa/concurrency/preemption.c	(revision 65deb18a7ffff4dccefdf2611afde3cadd19efb0)
@@ -70,7 +70,7 @@
 static pthread_t alarm_thread;                        // pthread handle to alarm thread
 
-void ?{}(event_kernel_t & this) {
-	(this.alarms){};
-	(this.lock){};
+void ?{}(event_kernel_t & this) with( this ) {
+	alarms{};
+	lock{};
 }
 
@@ -159,5 +159,5 @@
 	// If counter reaches 0, execute any pending CtxSwitch
 	void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-		processor * proc   = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
+		processor   * proc = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
 		thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
 
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision b3048d49aeb2ea2dd5d01939e5b683c1307b07d1)
+++ src/libcfa/concurrency/thread.c	(revision 65deb18a7ffff4dccefdf2611afde3cadd19efb0)
@@ -31,34 +31,34 @@
 // Thread ctors and dtors
 
-void ?{}(thread_desc& this) {
-	(this.self_cor){};
-	this.self_cor.name = "Anonymous Coroutine";
-	this.self_mon.owner = &this;
-	this.self_mon.recursion = 1;
-	this.self_mon_p = &this.self_mon;
-	this.next = NULL;
+void ?{}(thread_desc& this) with( this ) {
+	self_cor{};
+	self_cor.name = "Anonymous Coroutine";
+	self_mon.owner = &this;
+	self_mon.recursion = 1;
+	self_mon_p = &self_mon;
+	next = NULL;
 
-	(this.monitors){ &this.self_mon_p, 1, (fptr_t)0 };
+	monitors{ &self_mon_p, 1, (fptr_t)0 };
 }
 
-void ^?{}(thread_desc& this) {
-	^(this.self_cor){};
+void ^?{}(thread_desc& this) with( this ) {
+	^self_cor{};
 }
 
 forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
-void ?{}( scoped(T)& this ) {
-	(this.handle){};
-	__thrd_start(this.handle);
+void ?{}( scoped(T)& this ) with( this ) {
+	handle{};
+	__thrd_start(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);
+void ?{}( scoped(T)& this, P params ) with( this ) {
+	handle{ params };
+	__thrd_start(handle);
 }
 
 forall( dtype T | sized(T) | is_thread(T) )
-void ^?{}( scoped(T)& this ) {
-	^(this.handle){};
+void ^?{}( scoped(T)& this ) with( this ) {
+	^handle{};
 }
 
@@ -68,5 +68,5 @@
 void __thrd_start( T& this ) {
 	coroutine_desc* thrd_c = get_coroutine(this);
-	thread_desc*  thrd_h = get_thread   (this);
+	thread_desc   * thrd_h = get_thread   (this);
 	thrd_c->last = this_coroutine;
 
Index: src/libcfa/interpose.h
===================================================================
--- src/libcfa/interpose.h	(revision b3048d49aeb2ea2dd5d01939e5b683c1307b07d1)
+++ src/libcfa/interpose.h	(revision 65deb18a7ffff4dccefdf2611afde3cadd19efb0)
@@ -16,5 +16,5 @@
 #pragma once
 
-void * interpose_symbol( const char* symbol, , const char *version );
+void * interpose_symbol( const char* symbol, const char *version );
 
 extern __typeof__( abort ) libc_abort __attribute__(( noreturn ));