Function futures::future::loop_fn [] [src]

pub fn loop_fn<S, T, A, F>(initial_state: S, func: F) -> LoopFn<A, F> where F: FnMut(S) -> A, A: IntoFuture<Item=Loop<T, S>>

Creates a new future implementing a tail-recursive loop.

The loop function is immediately called with initial_state and should return a value that can be converted to a future. On successful completion, this future should output a Loop<T, S> to indicate the status of the loop.

Loop::Break(T) halts the loop and completes the future with output T.

Loop::Continue(S) reinvokes the loop function with state S. The returned future will be subsequently polled for a new Loop<T, S> value.


use futures::future::{ok, loop_fn, Future, FutureResult, Loop};
use std::io::Error;

struct Client {
    ping_count: u8,

impl Client {
    fn new() -> Self {
        Client { ping_count: 0 }

    fn send_ping(self) -> FutureResult<Self, Error> {
        ok(Client { ping_count: self.ping_count + 1 })

    fn receive_pong(self) -> FutureResult<(Self, bool), Error> {
        let done = self.ping_count >= 5;
        ok((self, done))

let ping_til_done = loop_fn(Client::new(), |client| {
        .and_then(|client| client.receive_pong())
        .and_then(|(client, done)| {
            if done {
            } else {