pub fn run_until_stalled(&mut self) {
        run_executor(|cx| match self.poll_pool(cx) {
            // The pool is empty.
            Poll::Ready(()) => Poll::Ready(()),
            Poll::Pending => {
                if woken() {
                    Poll::Pending
                } else {
                    // We're stalled for now.
                    Poll::Ready(())
                }
            }
        });
    }
/// Runs all tasks in the pool and returns if no more progress can be made
/// on any task.
///
/// ```
/// use futures::executor::LocalPool;
/// use futures::task::LocalSpawnExt;
/// use futures::future::{ready, pending};
///
/// let mut pool = LocalPool::new();
/// let spawner = pool.spawner();
///
/// spawner.spawn_local(ready(())).unwrap();
/// spawner.spawn_local(ready(())).unwrap();
/// spawner.spawn_local(pending()).unwrap();
///
/// // Runs the two ready task and returns.
/// // The empty task remains in the pool.
/// pool.run_until_stalled();
/// ```
///
/// This function will not block the calling thread and will return the moment
/// that there are no tasks left for which progress can be made;
/// remaining incomplete tasks in the pool can continue with further use of one
/// of the pool's run or poll methods. While the function is running, all tasks
/// in the pool will try to make progress.
Runs all tasks in the pool and returns if no more progress can be made
on any task.



let mut pool = LocalPool::new();
let spawner = pool.spawner().



Runs the two ready task and returns.
The empty task remains in the pool.

This function will not block the calling thread and will return the moment
that there are no tasks left for which progress can be made;
remaining incomplete tasks in the pool can continue with further use of one
of the pool's run or poll methods. While the function is running, all tasks
in the pool will try to make progress.
Runs all tasks in the pool and returns if no more progress can be made on any task . let mut pool = LocalPool :: new () ; let spawner = pool . spawner () . Runs the two ready task and returns . The empty task remains in the pool . This function will not block the calling thread and will return the moment that there are no tasks left for which progress can be made ; remaining incomplete tasks in the pool can continue with further use of one of the pool ' s run or poll methods . While the function is running all tasks in the pool will try to make progress .
pub fn run_until_stalled(&mut self) {
        run_executor(|cx| match self.poll_pool(cx) {
            // The pool is empty.
            Poll::Ready(()) => Poll::Ready(()),
            Poll::Pending => {
                if woken() {
                    Poll::Pending
                } else {
                    // We're stalled for now.
                    Poll::Ready(())
                }
            }
        });
    }
pub fn run_until_stalled ( & mut self ) { run_executor ( | cx | match self . poll_pool ( cx ) { // The pool is empty. Poll :: Ready ( ( ) ) => Poll :: Ready ( ( ) ) , Poll :: Pending => { if woken ( ) { Poll :: Pending } else { // We're stalled for now. Poll :: Ready ( ( ) ) } } } ) ; }
Runs all tasks in the pool and returns if no more progress can be made
on any task.
Runs all tasks in the pool and returns if no more progress can be made on any task .
&mut self
&mut self