 		triggerHandoff = callback
 	}
 
-	private func leave() {
-		dispatch_semaphore_signal(sender)
-		dispatch_semaphore_signal(receiver)
+	// Release both the sender and receiver threads.
+	private func release() {
+		dispatch_semaphore_signal(partner)
+		dispatch_semaphore_signal(partner)
 	}
 
 	// Override the current onReady callback
 	public func onReady(callback: CommReadyCallback) {
 		dispatch_sync(q) {
-			let isReady = self.hasSender && self.hasReceiver
-			if !isReady {
-				self.triggerHandoff = callback
-			} else {
+			self.triggerHandoff = callback
+			if case .Ready = self.handoff {
 				go { callback() }
 			}
 		}
 	}
 
 	// Returns true if the communication went through
-	private func senderEnter(v: V) -> Bool {
-		self.v = v
-		dispatch_sync(q) { self.hasSender = true }
-		dispatch_semaphore_wait(sender, DISPATCH_TIME_FOREVER)
-		if canceled! {
-			return false
-		}
-
-		return true
+	private func senderEnter(v: V) -> HandoffResult {
+		dispatch_sync(q) { self.setValue(v) }
+		return wait().withoutValue
 	}
 
 	// Returns true if the communication went through
-	private func receiverEnter() -> (V?, Bool) {
-		dispatch_sync(q) { self.hasReceiver = true }
-		dispatch_semaphore_wait(receiver, DISPATCH_TIME_FOREVER)
-		if canceled! {
-			return (nil, false)
-		}
-
-		return (v, true)
+	private func receiverEnter() -> HandoffReceiveResult<V> {
+		dispatch_sync(q) { self.hasReader() }
+		return wait()
+	}
+
+	private func wait() -> HandoffReceiveResult<V> {
+		dispatch_semaphore_wait(partner, DISPATCH_TIME_FOREVER)
+		guard case .Done(let result) = handoff else {
+			return .Canceled
+		}
+
+		return result
 	}
 
 	// Returns true if the Comm was canceled
-	public func cancel() -> Bool {
-		var canceled: Bool?
-		dispatch_sync(q) {
-			if self.canceled == nil {
-				self.canceled = true
-				self.leave()
-			}
-
-			canceled = self.canceled
-		}
-
-
-		return canceled!
+	public func cancel() -> HandoffResult {
+		var handoff: Handoff<V> = .Done(.Canceled)
+		dispatch_sync(q) {
+			handoff = self.cancelHandoff()
+		}
+
+		guard case .Done(let result) = handoff else {
+			return .Canceled
+		}
+
+		return result.withoutValue
 	}
 
 	// Returns true if the Comm was executed
-	public func proceed() -> Bool {
-		var canceled: Bool?
-		dispatch_sync(q) {
-			if self.canceled == nil {
-				self.canceled = false
-				self.leave()
-			}
-
-			canceled = self.canceled
-		}
-
-
-		return !(canceled!)
+	public func proceed() -> HandoffResult {
+		var handoff: Handoff<V> = .Done(.Canceled)
+		dispatch_sync(q) {
+			handoff = self.completedHandoff()
+		}
+
+		guard case .Done(let result) = handoff else {
+			return .Canceled
+		}
+
+		return result.withoutValue
 	}
 }
 

		}

		switch action {
		case let .Block(thread)
			where thread.waitForRecv(v): return
		case let .ToReceiver(thread)
			where thread.send(v): return
		default:
			// When thread.waitForRecv(v) or thread.send(v) return false
			// the communication was canceled so the thread recurses into
			// another attempt to send the value.
			send(v)
		}
	}

	public func recv() -> V {

	let ch: C
	let received: (V) -> ()

	private let needResult = dispatch_group_create()
	private var result: HandoffReceiveResult<V> = .Canceled

	public init(channel: C, onSelected: (V) -> ()) {
		ch = channel
