Index: libcfa/src/concurrency/coroutine.cfa
===================================================================
--- libcfa/src/concurrency/coroutine.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ libcfa/src/concurrency/coroutine.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -46,10 +46,10 @@
 
 //-----------------------------------------------------------------------------
-FORALL_DATA_INSTANCE(CoroutineCancelled, (dtype coroutine_t), (coroutine_t))
-
-forall(dtype T)
+FORALL_DATA_INSTANCE(CoroutineCancelled, (coroutine_t &), (coroutine_t))
+
+forall(T &)
 void mark_exception(CoroutineCancelled(T) *) {}
 
-forall(dtype T)
+forall(T &)
 void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) {
 	dst->virtual_table = src->virtual_table;
@@ -58,5 +58,5 @@
 }
 
-forall(dtype T)
+forall(T &)
 const char * msg(CoroutineCancelled(T) *) {
 	return "CoroutineCancelled(...)";
@@ -64,5 +64,5 @@
 
 // This code should not be inlined. It is the error path on resume.
-forall(dtype T | is_coroutine(T))
+forall(T & | is_coroutine(T))
 void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc ) {
 	verify( desc->cancellation );
@@ -148,5 +148,5 @@
 // Part of the Public API
 // Not inline since only ever called once per coroutine
-forall(dtype T | is_coroutine(T))
+forall(T & | is_coroutine(T))
 void prime(T& cor) {
 	$coroutine* this = get_coroutine(cor);
Index: libcfa/src/concurrency/coroutine.hfa
===================================================================
--- libcfa/src/concurrency/coroutine.hfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ libcfa/src/concurrency/coroutine.hfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -22,13 +22,13 @@
 //-----------------------------------------------------------------------------
 // Exception thrown from resume when a coroutine stack is cancelled.
-FORALL_DATA_EXCEPTION(CoroutineCancelled, (dtype coroutine_t), (coroutine_t)) (
+FORALL_DATA_EXCEPTION(CoroutineCancelled, (coroutine_t &), (coroutine_t)) (
 	coroutine_t * the_coroutine;
 	exception_t * the_exception;
 );
 
-forall(dtype T)
+forall(T &)
 void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src);
 
-forall(dtype T)
+forall(T &)
 const char * msg(CoroutineCancelled(T) *);
 
@@ -37,5 +37,5 @@
 // Anything that implements this trait can be resumed.
 // Anything that is resumed is a coroutine.
-trait is_coroutine(dtype T | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) {
+trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) {
 	void main(T & this);
 	$coroutine * get_coroutine(T & this);
@@ -60,5 +60,5 @@
 //-----------------------------------------------------------------------------
 // Public coroutine API
-forall(dtype T | is_coroutine(T))
+forall(T & | is_coroutine(T))
 void prime(T & cor);
 
@@ -72,5 +72,5 @@
 	void __cfactx_invoke_coroutine(void (*main)(void *), void * this);
 
-	forall(dtype T)
+	forall(T &)
 	void __cfactx_start(void (*main)(T &), struct $coroutine * cor, T & this, void (*invoke)(void (*main)(void *), void *));
 
@@ -129,9 +129,9 @@
 }
 
-forall(dtype T | is_coroutine(T))
+forall(T & | is_coroutine(T))
 void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc );
 
 // Resume implementation inlined for performance
-forall(dtype T | is_coroutine(T))
+forall(T & | is_coroutine(T))
 static inline T & resume(T & cor) {
 	// optimization : read TLS once and reuse it
Index: libcfa/src/concurrency/future.hfa
===================================================================
--- libcfa/src/concurrency/future.hfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ libcfa/src/concurrency/future.hfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -19,5 +19,5 @@
 #include "monitor.hfa"
 
-forall( otype T ) {
+forall( T ) {
 	struct future {
 		inline future_t;
@@ -58,5 +58,5 @@
 }
 
-forall( otype T ) {
+forall( T ) {
 	monitor multi_future {
 		inline future_t;
Index: libcfa/src/concurrency/locks.cfa
===================================================================
--- libcfa/src/concurrency/locks.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ libcfa/src/concurrency/locks.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -7,5 +7,5 @@
 //-----------------------------------------------------------------------------
 // info_thread
-forall(dtype L | is_blocking_lock(L)) {
+forall(L & | is_blocking_lock(L)) {
 	struct info_thread {
 		// used to put info_thread on a dl queue (aka sequence)
@@ -195,5 +195,5 @@
 //-----------------------------------------------------------------------------
 // alarm node wrapper
-forall(dtype L | is_blocking_lock(L)) {
+forall(L & | is_blocking_lock(L)) {
 	struct alarm_node_wrap {
 		alarm_node_t alarm_node;
@@ -239,5 +239,5 @@
 //-----------------------------------------------------------------------------
 // condition variable
-forall(dtype L | is_blocking_lock(L)) {
+forall(L & | is_blocking_lock(L)) {
 
 	void ?{}( condition_variable(L) & this ){
Index: libcfa/src/concurrency/locks.hfa
===================================================================
--- libcfa/src/concurrency/locks.hfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ libcfa/src/concurrency/locks.hfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -13,5 +13,5 @@
 //-----------------------------------------------------------------------------
 // is_blocking_lock
-trait is_blocking_lock(dtype L | sized(L)) {
+trait is_blocking_lock(L & | sized(L)) {
 	// For synchronization locks to use when acquiring
 	void on_notify( L &, struct $thread * );
@@ -31,5 +31,5 @@
 // the info thread is a wrapper around a thread used
 // to store extra data for use in the condition variable
-forall(dtype L | is_blocking_lock(L)) {
+forall(L & | is_blocking_lock(L)) {
 	struct info_thread;
 
@@ -120,5 +120,5 @@
 //-----------------------------------------------------------------------------
 // Synchronization Locks
-forall(dtype L | is_blocking_lock(L)) {
+forall(L & | is_blocking_lock(L)) {
 	struct condition_variable {
 		// Spin lock used for mutual exclusion
Index: libcfa/src/concurrency/monitor.cfa
===================================================================
--- libcfa/src/concurrency/monitor.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ libcfa/src/concurrency/monitor.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -50,5 +50,5 @@
 static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t &, $monitor * monitors [], __lock_size_t count );
 
-forall(dtype T | sized( T ))
+forall(T & | sized( T ))
 static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val );
 static inline __lock_size_t count_max    ( const __waitfor_mask_t & mask );
@@ -949,5 +949,5 @@
 }
 
-forall(dtype T | sized( T ))
+forall(T & | sized( T ))
 static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val ) {
 	if( !val ) return size;
Index: libcfa/src/concurrency/monitor.hfa
===================================================================
--- libcfa/src/concurrency/monitor.hfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ libcfa/src/concurrency/monitor.hfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -22,5 +22,5 @@
 #include "stdlib.hfa"
 
-trait is_monitor(dtype T) {
+trait is_monitor(T &) {
 	$monitor * get_monitor( T & );
 	void ^?{}( T & mutex );
@@ -59,5 +59,5 @@
 void ^?{}( monitor_dtor_guard_t & this );
 
-static inline forall( dtype T | sized(T) | { void ^?{}( T & mutex ); } )
+static inline forall( T & | sized(T) | { void ^?{}( T & mutex ); } )
 void delete( T * th ) {
 	^(*th){};
Index: libcfa/src/concurrency/mutex.cfa
===================================================================
--- libcfa/src/concurrency/mutex.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ libcfa/src/concurrency/mutex.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -164,5 +164,5 @@
 }
 
-forall(dtype L | is_lock(L))
+forall(L & | is_lock(L))
 void wait(condition_variable & this, L & l) {
 	lock( this.lock __cfaabi_dbg_ctx2 );
@@ -176,5 +176,5 @@
 //-----------------------------------------------------------------------------
 // Scopes
-forall(dtype L | is_lock(L))
+forall(L & | is_lock(L))
 void lock_all  ( L * locks[], size_t count) {
 	// Sort locks based on addresses
@@ -188,5 +188,5 @@
 }
 
-forall(dtype L | is_lock(L))
+forall(L & | is_lock(L))
 void unlock_all( L * locks[], size_t count) {
 	// Lock all
Index: libcfa/src/concurrency/mutex.hfa
===================================================================
--- libcfa/src/concurrency/mutex.hfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ libcfa/src/concurrency/mutex.hfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -70,5 +70,5 @@
 void unlock(recursive_mutex_lock & this) __attribute__((deprecated("use concurrency/locks.hfa instead")));
 
-trait is_lock(dtype L | sized(L)) {
+trait is_lock(L & | sized(L)) {
 	void lock  (L &);
 	void unlock(L &);
@@ -94,10 +94,10 @@
 void wait(condition_variable & this) __attribute__((deprecated("use concurrency/locks.hfa instead")));
 
-forall(dtype L | is_lock(L))
+forall(L & | is_lock(L))
 void wait(condition_variable & this, L & l) __attribute__((deprecated("use concurrency/locks.hfa instead")));
 
 //-----------------------------------------------------------------------------
 // Scopes
-forall(dtype L | is_lock(L)) {
+forall(L & | is_lock(L)) {
 	#if !defined( __TUPLE_ARRAYS_EXIST__ )
 	void lock  ( L * locks [], size_t count);
Index: libcfa/src/concurrency/thread.cfa
===================================================================
--- libcfa/src/concurrency/thread.cfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ libcfa/src/concurrency/thread.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -62,7 +62,7 @@
 }
 
-FORALL_DATA_INSTANCE(ThreadCancelled, (dtype thread_t), (thread_t))
+FORALL_DATA_INSTANCE(ThreadCancelled, (thread_t &), (thread_t))
 
-forall(dtype T)
+forall(T &)
 void copy(ThreadCancelled(T) * dst, ThreadCancelled(T) * src) {
 	dst->virtual_table = src->virtual_table;
@@ -71,15 +71,15 @@
 }
 
-forall(dtype T)
+forall(T &)
 const char * msg(ThreadCancelled(T) *) {
 	return "ThreadCancelled";
 }
 
-forall(dtype T)
+forall(T &)
 static void default_thread_cancel_handler(ThreadCancelled(T) & ) {
 	abort( "Unhandled thread cancellation.\n" );
 }
 
-forall(dtype T | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)))
+forall(T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)))
 void ?{}( thread_dtor_guard_t & this,
 		T & thrd, void(*cancelHandler)(ThreadCancelled(T) &)) {
@@ -124,5 +124,5 @@
 //-----------------------------------------------------------------------------
 // Starting and stopping threads
-forall( dtype T | is_thread(T) )
+forall( T & | is_thread(T) )
 void __thrd_start( T & this, void (*main_p)(T &) ) {
 	$thread * this_thrd = get_thread(this);
@@ -140,5 +140,5 @@
 //-----------------------------------------------------------------------------
 // Support for threads that don't ues the thread keyword
-forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
+forall( T & | sized(T) | is_thread(T) | { void ?{}(T&); } )
 void ?{}( scoped(T)& this ) with( this ) {
 	handle{};
@@ -146,5 +146,5 @@
 }
 
-forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
+forall( T &, P... | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
 void ?{}( scoped(T)& this, P params ) with( this ) {
 	handle{ params };
@@ -152,5 +152,5 @@
 }
 
-forall( dtype T | sized(T) | is_thread(T) )
+forall( T & | sized(T) | is_thread(T) )
 void ^?{}( scoped(T)& this ) with( this ) {
 	^handle{};
@@ -158,5 +158,5 @@
 
 //-----------------------------------------------------------------------------
-forall(dtype T | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)))
+forall(T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)))
 T & join( T & this ) {
 	thread_dtor_guard_t guard = { this, defaultResumptionHandler };
Index: libcfa/src/concurrency/thread.hfa
===================================================================
--- libcfa/src/concurrency/thread.hfa	(revision fcd0b9d7282c8c187cc0111baf35ab6d4fb846a2)
+++ libcfa/src/concurrency/thread.hfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
@@ -26,5 +26,5 @@
 //-----------------------------------------------------------------------------
 // thread trait
-trait is_thread(dtype T) {
+trait is_thread(T &) {
 	void ^?{}(T& mutex this);
 	void main(T& this);
@@ -32,13 +32,13 @@
 };
 
-FORALL_DATA_EXCEPTION(ThreadCancelled, (dtype thread_t), (thread_t)) (
+FORALL_DATA_EXCEPTION(ThreadCancelled, (thread_t &), (thread_t)) (
 	thread_t * the_thread;
 	exception_t * the_exception;
 );
 
-forall(dtype T)
+forall(T &)
 void copy(ThreadCancelled(T) * dst, ThreadCancelled(T) * src);
 
-forall(dtype T)
+forall(T &)
 const char * msg(ThreadCancelled(T) *);
 
@@ -47,8 +47,8 @@
 
 // Inline getters for threads/coroutines/monitors
-forall( dtype T | is_thread(T) )
+forall( T & | is_thread(T) )
 static inline $coroutine* get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; }
 
-forall( dtype T | is_thread(T) )
+forall( T & | is_thread(T) )
 static inline $monitor  * get_monitor  (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; }
 
@@ -60,5 +60,5 @@
 extern struct cluster * mainCluster;
 
-forall( dtype T | is_thread(T) )
+forall( T & | is_thread(T) )
 void __thrd_start( T & this, void (*)(T &) );
 
@@ -82,5 +82,5 @@
 };
 
-forall( dtype T | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)) )
+forall( T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)) )
 void ?{}( thread_dtor_guard_t & this, T & thrd, void(*)(ThreadCancelled(T) &) );
 void ^?{}( thread_dtor_guard_t & this );
@@ -89,16 +89,16 @@
 // thread runner
 // Structure that actually start and stop threads
-forall( dtype T | sized(T) | is_thread(T) )
+forall( T & | sized(T) | is_thread(T) )
 struct scoped {
 	T handle;
 };
 
-forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
+forall( 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); } )
+forall( T &, P... | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
 void ?{}( scoped(T)& this, P params );
 
-forall( dtype T | sized(T) | is_thread(T) )
+forall( T & | sized(T) | is_thread(T) )
 void ^?{}( scoped(T)& this );
 
@@ -115,5 +115,5 @@
 void unpark( $thread * this );
 
-forall( dtype T | is_thread(T) )
+forall( T & | is_thread(T) )
 static inline void unpark( T & this ) { if(!&this) return; unpark( get_thread( this ) );}
 
@@ -128,5 +128,5 @@
 //----------
 // join
-forall( dtype T | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)) )
+forall( T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)) )
 T & join( T & this );