std::iter::from_fn - Rust
Description: API documentation for the Rust `from_fn` fn in crate `std`.
Keywords: rust, rustlang, rust-lang, from_fn

# 1.34.0[−][src]Function std::iter::from_fn

ⓘImportant traits for FromFn<F>

### Important traits for FromFn<F>

`impl<T, F> Iterator for FromFn<F> where
F: FnMut() -> Option<T>, type Item = T;`

    pub fn from_fn<T, F>(f: F) -> FromFn<F> where
        F: FnMut() -> Option<T>,

Creates a new iterator where each iteration calls the provided closure `F: FnMut() -> Option<T>`.

This allows creating a custom iterator with any behavior without using the more verbose syntax of creating a dedicated type and implementing the `Iterator` trait for it.

Note that the `FromFn` iterator doesn’t make assumptions about the behavior of the closure, and therefore conservatively does not implement `FusedIterator`, or override `Iterator::size_hint` from its default `(0, None)`.

The closure can use captures and its environment to track state across iterations. Depending on how the iterator is used, this may require specifying the `move` keyword on the closure.

# Examples

Let’s re-implement the counter iterator from module-level documentation:

    let mut count = 0;
    let counter = std::iter::from_fn(move || {
        // Increment our count. This is why we started at zero.
        count += 1;

        // Check to see if we've finished counting or not.
        if count < 6 {
            Some(count)
        } else {
            None
        }
    });
    assert_eq!(counter.collect::<Vec<_>>(), &[1, 2, 3, 4, 5]);Run

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

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)