Index: libcfa/src/concurrency/channel.hfa
===================================================================
--- libcfa/src/concurrency/channel.hfa	(revision d3b8752a534585aa168dacfe646fe4a2c9043084)
+++ libcfa/src/concurrency/channel.hfa	(revision 7a2c6b18c5cb56b773ed31882645adeb6eabb772)
@@ -68,4 +68,6 @@
     #endif
 };
+static inline void ?{}( channel(T) & this, channel(T) this2 ) = void;
+static inline void ?=?( channel(T) & this, channel(T) this2 ) = void;
 
 static inline void ?{}( channel(T) &c, size_t _size ) with(c) {
@@ -372,24 +374,24 @@
 // type used by select statement to capture a chan read as the selected operation
 struct chan_read {
-    T & ret;
-    channel(T) & chan;
+    T * ret;
+    channel(T) * chan;
 };
 __CFA_SELECT_GET_TYPE( chan_read(T) );
 
-static inline void ?{}( chan_read(T) & cr, channel(T) & chan, T & ret ) {
-    &cr.chan = &chan;
-    &cr.ret = &ret;
-}
-static inline chan_read(T) ?<<?( T & ret, channel(T) & chan ) { chan_read(T) cr{ chan, ret }; return cr; }
-
-static inline void __handle_select_closed_read( chan_read(T) & this, select_node & node ) with(this.chan, this) {
-    __closed_remove( chan, ret );
+static inline void ?{}( chan_read(T) & cr, channel(T) * chan, T * ret ) {
+    cr.chan = chan;
+    cr.ret = ret;
+}
+static inline chan_read(T) ?<<?( T & ret, channel(T) & chan ) { chan_read(T) cr{ &chan, &ret }; return cr; }
+
+static inline void __handle_select_closed_read( chan_read(T) & this, select_node & node ) with(*this.chan, this) {
+    __closed_remove( *chan, *ret );
     // if we get here then the insert succeeded
     __make_select_node_available( node );
 }
 
-static inline bool register_select( chan_read(T) & this, select_node & node ) with(this.chan, this) {
-    lock( mutex_lock );
-    node.extra = &ret; // set .extra so that if it == 0p later in on_selected it is due to channel close
+static inline bool register_select( chan_read(T) & this, select_node & node ) with(*this.chan, this) {
+    lock( mutex_lock );
+    node.extra = ret; // set .extra so that if it == 0p later in on_selected it is due to channel close
 
     #ifdef CHAN_STATS
@@ -406,5 +408,5 @@
 
             if ( __handle_pending( prods, node ) ) {
-                __prods_handoff( chan, ret );
+                __prods_handoff( *chan, *ret );
                 __make_select_node_sat( node ); // need to to mark SAT now that we know operation is done or else threads could get stuck in __mark_select_node
                 unlock( mutex_lock );
@@ -432,5 +434,5 @@
     ZeroSize: if ( size == 0 && !prods`isEmpty ) {
         if ( !__handle_waituntil_OR( prods ) ) break ZeroSize;
-        __prods_handoff( chan, ret );
+        __prods_handoff( *chan, *ret );
         __set_avail_then_unlock( node, mutex_lock );
         return true;
@@ -449,12 +451,12 @@
 
     // Remove from buffer
-    __do_remove( chan, ret );
+    __do_remove( *chan, *ret );
     __set_avail_then_unlock( node, mutex_lock );
     return true;
 }
-static inline bool unregister_select( chan_read(T) & this, select_node & node ) { return unregister_chan( this.chan, node ); }
+static inline bool unregister_select( chan_read(T) & this, select_node & node ) { return unregister_chan( *this.chan, node ); }
 static inline bool on_selected( chan_read(T) & this, select_node & node ) with(this) {
     if ( unlikely(node.extra == 0p) ) {
-        if ( !exception_in_flight() ) __closed_remove( chan, ret ); // check if woken up due to closed channel
+        if ( !exception_in_flight() ) __closed_remove( *chan, *ret ); // check if woken up due to closed channel
         else return false;
     }
@@ -465,38 +467,42 @@
 // type used by select statement to capture a chan read as the selected operation that doesn't have a param to read to
 struct chan_read_no_ret {
-    T ret;
-    chan_read( T ) cr;
+    T retval;
+    chan_read( T ) c_read;
 };
 __CFA_SELECT_GET_TYPE( chan_read_no_ret(T) );
 
 static inline void ?{}( chan_read_no_ret(T) & this, channel(T) & chan ) {
-    this.cr{ chan, this.ret };
-}
-static inline chan_read_no_ret(T) remove( channel(T) & chan ) { chan_read_no_ret(T) cr{ chan }; return cr; }
-static inline bool register_select( chan_read_no_ret(T) & this, select_node & node ) { return register_select( this.cr, node ); }
-static inline bool unregister_select( chan_read_no_ret(T) & this, select_node & node ) { return unregister_select( this.cr, node ); }
-static inline bool on_selected( chan_read_no_ret(T) & this, select_node & node ) { return on_selected( this.cr, node ); }
+    this.c_read{ &chan, &this.retval };
+}
+
+static inline chan_read_no_ret(T) remove( channel(T) & chan ) { chan_read_no_ret(T) c_read{ chan }; return c_read; }
+static inline bool register_select( chan_read_no_ret(T) & this, select_node & node ) { 
+    this.c_read.ret = &this.retval;
+    return register_select( this.c_read, node );
+}
+static inline bool unregister_select( chan_read_no_ret(T) & this, select_node & node ) { return unregister_select( this.c_read, node ); }
+static inline bool on_selected( chan_read_no_ret(T) & this, select_node & node ) { return on_selected( this.c_read, node ); }
 
 // type used by select statement to capture a chan write as the selected operation
 struct chan_write {
     T elem;
-    channel(T) & chan;
+    channel(T) * chan;
 };
 __CFA_SELECT_GET_TYPE( chan_write(T) );
 
-static inline void ?{}( chan_write(T) & cw, channel(T) & chan, T elem ) {
-    &cw.chan = &chan;
+static inline void ?{}( chan_write(T) & cw, channel(T) * chan, T elem ) {
+    cw.chan = chan;
     memcpy( (void *)&cw.elem, (void *)&elem, sizeof(T) );
 }
-static inline chan_write(T) ?<<?( channel(T) & chan, T elem ) { chan_write(T) cw{ chan, elem }; return cw; }
-static inline chan_write(T) insert( T elem, channel(T) & chan) { chan_write(T) cw{ chan, elem }; return cw; }
-
-static inline void __handle_select_closed_write( chan_write(T) & this, select_node & node ) with(this.chan, this) {
-    __closed_insert( chan, elem );
+static inline chan_write(T) ?<<?( channel(T) & chan, T elem ) { chan_write(T) cw{ &chan, elem }; return cw; }
+static inline chan_write(T) insert( T elem, channel(T) & chan) { chan_write(T) cw{ &chan, elem }; return cw; }
+
+static inline void __handle_select_closed_write( chan_write(T) & this, select_node & node ) with(*this.chan, this) {
+    __closed_insert( *chan, elem );
     // if we get here then the insert succeeded
     __make_select_node_available( node );
 }
 
-static inline bool register_select( chan_write(T) & this, select_node & node ) with(this.chan, this) {
+static inline bool register_select( chan_write(T) & this, select_node & node ) with(*this.chan, this) {
     lock( mutex_lock );
     node.extra = &elem; // set .extra so that if it == 0p later in on_selected it is due to channel close
@@ -516,5 +522,5 @@
 
             if ( __handle_pending( cons, node ) ) {
-                __cons_handoff( chan, elem );
+                __cons_handoff( *chan, elem );
                 __make_select_node_sat( node ); // need to to mark SAT now that we know operation is done or else threads could get stuck in __mark_select_node
                 unlock( mutex_lock );
@@ -543,5 +549,5 @@
     ConsEmpty: if ( !cons`isEmpty ) {
         if ( !__handle_waituntil_OR( cons ) ) break ConsEmpty;
-        __cons_handoff( chan, elem );
+        __cons_handoff( *chan, elem );
         __set_avail_then_unlock( node, mutex_lock );
         return true;
@@ -560,13 +566,13 @@
 
     // otherwise carry out write either via normal insert
-    __buf_insert( chan, elem );
+    __buf_insert( *chan, elem );
     __set_avail_then_unlock( node, mutex_lock );
     return true;
 }
-static inline bool unregister_select( chan_write(T) & this, select_node & node ) { return unregister_chan( this.chan, node ); }
+static inline bool unregister_select( chan_write(T) & this, select_node & node ) { return unregister_chan( *this.chan, node ); }
 
 static inline bool on_selected( chan_write(T) & this, select_node & node ) with(this) { 
     if ( unlikely(node.extra == 0p) ) {
-        if ( !exception_in_flight() ) __closed_insert( chan, elem ); // check if woken up due to closed channel
+        if ( !exception_in_flight() ) __closed_insert( *chan, elem ); // check if woken up due to closed channel
         else return false;
     }
Index: libcfa/src/concurrency/locks.hfa
===================================================================
--- libcfa/src/concurrency/locks.hfa	(revision d3b8752a534585aa168dacfe646fe4a2c9043084)
+++ libcfa/src/concurrency/locks.hfa	(revision 7a2c6b18c5cb56b773ed31882645adeb6eabb772)
@@ -140,5 +140,5 @@
 };
 
-static inline void ?{}(mcs_node & this) { this.next = 0p; }
+static inline void ?{}( mcs_node & this ) { this.next = 0p; }
 
 static inline mcs_node * volatile & ?`next ( mcs_node * node ) {
@@ -150,5 +150,5 @@
 };
 
-static inline void lock(mcs_lock & l, mcs_node & n) {
+static inline void lock( mcs_lock & l, mcs_node & n ) {
 	if(push(l.queue, &n))
 		wait(n.sem);
@@ -174,5 +174,5 @@
 };
 
-static inline void ?{}(mcs_spin_node & this) { this.next = 0p; this.locked = true; }
+static inline void ?{}( mcs_spin_node & this ) { this.next = 0p; this.locked = true; }
 
 struct mcs_spin_lock {
@@ -180,5 +180,5 @@
 };
 
-static inline void lock(mcs_spin_lock & l, mcs_spin_node & n) {
+static inline void lock( mcs_spin_lock & l, mcs_spin_node & n ) {
     n.locked = true;
 	mcs_spin_node * prev = __atomic_exchange_n(&l.queue.tail, &n, __ATOMIC_SEQ_CST);
@@ -273,6 +273,6 @@
 };
 static inline void  ?{}( go_mutex & this ) with(this) { val = 0; }
-// static inline void ?{}( go_mutex & this, go_mutex this2 ) = void; // these don't compile correctly at the moment so they should be omitted
-// static inline void ?=?( go_mutex & this, go_mutex this2 ) = void;
+static inline void ?{}( go_mutex & this, go_mutex this2 ) = void;
+static inline void ?=?( go_mutex & this, go_mutex this2 ) = void;
 
 static inline bool internal_try_lock(go_mutex & this, int & compare_val, int new_val ) with(this) {