# 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.

# Examples

    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| {
        client.send_ping()
            .and_then(|client| client.receive_pong())
            .and_then(|(client, done)| {
                if done {
                    Ok(Loop::Break(client))
                } else {
                    Ok(Loop::Continue(client))
                }
            })
    });

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)