pub fn poll_cancel(&mut self) -> Poll<(), ()> {
        if let Some(ref cell) = self.inner.upgrade() {
            let mut inner = cell.borrow_mut();
            inner.cancel_task = Some(task::current());
            Ok(Async::NotReady)
        } else {
            Ok(Async::Ready(()))
        }
    }
/// Polls this `Sender` half to detect whether the `Receiver` this has
/// paired with has gone away.
///
/// This function can be used to learn about when the `Receiver` (consumer)
/// half has gone away and nothing will be able to receive a message sent
/// from `send` (or `swap`).
///
/// If `Ready` is returned then it means that the `Receiver` has disappeared
/// and the result this `Sender` would otherwise produce should no longer
/// be produced.
///
/// If `NotReady` is returned then the `Receiver` is still alive and may be
/// able to receive a message if sent. The current task, however, is
/// scheduled to receive a notification if the corresponding `Receiver` goes
/// away.
///
/// # Panics
///
/// Like `Future::poll`, this function will panic if it's not called from
/// within the context of a task. In other words, this should only ever be
/// called from inside another future.
///
/// If you're calling this function from a context that does not have a
/// task, then you can use the `is_canceled` API instead.
Polls this `Sender` half to detect whether the `Receiver` this has
paired with has gone away.





If `NotReady` is returned then the `Receiver` is still alive and may be
able to receive a message if sent. The current task, however, is
scheduled to receive a notification if the corresponding `Receiver` goes
away.
Polls this ` Sender ` half to detect whether the ` Receiver ` this has paired with has gone away . If ` NotReady ` is returned then the ` Receiver ` is still alive and may be able to receive a message if sent . The current task however is scheduled to receive a notification if the corresponding ` Receiver ` goes away .
pub fn poll_cancel(&mut self) -> Poll<(), ()> {
        if let Some(ref cell) = self.inner.upgrade() {
            let mut inner = cell.borrow_mut();
            inner.cancel_task = Some(task::current());
            Ok(Async::NotReady)
        } else {
            Ok(Async::Ready(()))
        }
    }
pub fn poll_cancel ( & mut self ) -> Poll < ( ) , ( ) > { if let Some ( ref cell ) = self . inner . upgrade ( ) { let mut inner = cell . borrow_mut ( ) ; inner . cancel_task = Some ( task :: current ( ) ) ; Ok ( Async :: NotReady ) } else { Ok ( Async :: Ready ( ( ) ) ) } }
Polls this `Sender` half to detect whether the `Receiver` this has
paired with has gone away.
Polls this ` Sender ` half to detect whether the ` Receiver ` this has paired with has gone away .
&mut self
&mut self
panics
Like `Future::poll`, this function will panic if it's not called from
within the context of a task. In other words, this should only ever be
called from inside another future.

If you're calling this function from a context that does not have a
task, then you can use the `is_canceled` API instead.
Like ` Future :: poll ` this function will panic if it ' s not called from within the context of a task . In other words this should only ever be called from inside another future . If you ' re calling this function from a context that does not have a task then you can use the ` is_canceled ` API instead .