 
 class Source<A>: Stream<A> {
 
-    override func open(callerContext: ExecutionContext, _ cont: Cont) -> Channel<A> {
-        let chan = Dispatcher<A>(callerContext, isolate(callerContext))
-        if let f = cont(chan) {
-            chan.subscribe(f)
-        }
-        chan.calleeContext.schedule(callerContext, 0) {
-            self.invoke(chan)
-        }
+    override func open(callerContext: ExecutionContext, _ cont: Channel<A> -> ()) -> Channel<A> {
+        let (chan) = Dispatcher<A>(callerContext, isolate(callerContext))
+        cont(chan)
+        chan.calleeContext.schedule(callerContext, 0) { self.invoke(chan) }
         return chan
     }
     

                base = nil
                for e in map.values { e.close() }
            }
            self.open(outer.calleeContext) { (base = $0)
                return { e in
                    switch e {
                    case .Next(let x):
                        let k = f(+x)

                chan.emitIfOpen(.Done())
            }
        }
        outer.open(chan.calleeContext) {
            base = $0
            base!.subscribe { e in
                if let x = e.error {
                    chan.emitIfOpen(.Fail(x))
                }
