pub fn poll_canceled(&mut self, cx: &mut Context) -> Poll<()> {
        match self.inner.upgrade() {
            Some(inner) => {
                inner.borrow_mut().tx_task.register(cx.waker());
                Poll::Pending
            }
            None => Poll::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 `complete`.
///
/// 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 `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.
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 `complete`.

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 `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 . 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 ` complete ` . 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 ` 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_canceled(&mut self, cx: &mut Context) -> Poll<()> {
        match self.inner.upgrade() {
            Some(inner) => {
                inner.borrow_mut().tx_task.register(cx.waker());
                Poll::Pending
            }
            None => Poll::Ready(()),
        }
    }
pub fn poll_canceled ( & mut self , cx : & mut Context ) -> Poll < ( ) > { match self . inner . upgrade ( ) { Some ( inner ) => { inner . borrow_mut ( ) . tx_task . register ( cx . waker ( ) ) ; Poll :: Pending } None => Poll :: 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
cx
&mut Context