 
 /// A composable object which represents an event stream where multiple events are flowing.
 public class Stream<A> {
-    
-    typealias Cont = Channel<A> -> (Packet<A> -> ())?
 
     public func subscribe(f: Packet<A> -> ()) { return open().subscribe(f) }
 
-    public func open(callerContext: ExecutionContext, _ cont: Cont) -> Channel<A> {
+    public func open(callerContext: ExecutionContext, _ cont: Channel<A> -> ()) -> Channel<A> {
         return undefined()
     }
     
     public func open(callerContext: ExecutionContext) -> Channel<A> {
-        return open(callerContext) { _ in nil }
+        return open(callerContext) { _ in }
     }
 }
 

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

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