# Function futures::stream::unfold [−] [src]

    pub fn unfold<T, F, Fut, It>(init: T, f: F) -> Unfold<T, F, Fut> where
        F: FnMut(T) -> Fut,
        Fut: IntoFuture<Item = Option<(It, T)>>,

Creates a `Stream` from a seed and a closure returning a `Future`.

This function is the dual for the `Stream::fold()` adapter: while `Stream::fold()` reduces a `Stream` to one single value, `unfold()` creates a `Stream` from a seed value.

`unfold()` will call the provided closure with the provided seed, then wait for the returned `Future` to complete with `(a, b)`. It will then yield the value `a`, and use `b` as the next internal state.

If the future returns `None` instead of `Some`, then the `unfold()` will stop producing items and return `Ok(Async::Ready(None))` in future calls to `poll()`.

In case of error generated by the returned `Future`, the error will be returned by the `Stream`. The `Stream` will then yield `Ok(Async::Ready(None))` in future calls to `poll()`.

This function can typically be used when wanting to go from the "world of futures" to the "world of streams": the provided closure can build a `Future` using other library functions working on futures, and `unfold()` will turn it into a `Stream` by repeating the operation.

# Example

    use futures::stream::{self, Stream};
    use futures::future::{self, Future};

    let mut stream = stream::unfold(0, |state| {
        future::ok::<_, u32>(
            if state <= 2 {
                let next_state = state + 1;
                let yielded = state  * 2;
                Some((yielded, next_state))
            } else {
                None
            }
        )
    });

    let result = stream.collect().wait();
    assert_eq!(result, Ok(vec![0, 2, 4]));

# 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`)