             callback(result)
         }
         
-        streamPtr.pointee.data = unsafeBitCast(self, to: UnsafeMutablePointer<Void>.self)
+        streamPtr.pointee.data = retainedVoidPointer(onRead2)
         
         let r = uv_read_start(streamPtr, alloc_buffer) { queue, nread, buf in
             defer {
                 dealloc(buf.pointee.base, capacity: nread)
             }
             
-            let stream = unsafeBitCast(queue.pointee.data, to: Stream.self)
+            let onRead2: GenericResult<Pipe> -> () = releaseVoidPointer(queue.pointee.data)!
             
             let result: GenericResult<Pipe>
             if (nread == Int(UV_EOF.rawValue)) {

            return callback(.Error(SuvError.RuntimeError(message: "Stream is already closed")))
        }
        
        onRead2 = { result in
            if case .Success(let queue) = result {
                let pipePtr = UnsafeMutablePointer<uv_pipe_t>(queue.streamPtr)
                if uv_pipe_pending_count(pipePtr) <= 0 {

                data = .Data(buffer)
            }
            
            stream.pointee.data = retainedVoidPointer(onRead)
            onRead(data)
        }
        
        if r < 0 {
