# iter_ok.rs.html -- source
Source to the Rust file `/Users/travis/.cargo/registry/src/github.com-1ecc6299db9ec823/futures-0.1.20/src/stream/iter_ok.rs`.
Keywords: rust, rustlang, rust-lang

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48

    use core::marker;

    use {Async, Poll};
    use stream::Stream;

    /// A stream which is just a shim over an underlying instance of `Iterator`.
    ///
    /// This stream will never block and is always ready.
    #[derive(Debug)]
    #[must_use = "streams do nothing unless polled"]
    pub struct IterOk<I, E> {
        iter: I,
        _marker: marker::PhantomData<fn() -> E>,
    }

    /// Converts an `Iterator` into a `Stream` which is always ready
    /// to yield the next value.
    ///
    /// Iterators in Rust don't express the ability to block, so this adapter
    /// simply always calls `iter.next()` and returns that.
    ///
    /// ```rust
    /// use futures::*;
    ///
    /// let mut stream = stream::iter_ok::<_, ()>(vec![17, 19]);
    /// assert_eq!(Ok(Async::Ready(Some(17))), stream.poll());
    /// assert_eq!(Ok(Async::Ready(Some(19))), stream.poll());
    /// assert_eq!(Ok(Async::Ready(None)), stream.poll());
    /// ```
    pub fn iter_ok<I, E>(i: I) -> IterOk<I::IntoIter, E>
        where I: IntoIterator,
    {
        IterOk {
            iter: i.into_iter(),
            _marker: marker::PhantomData,
        }
    }

    impl<I, E> Stream for IterOk<I, E>
        where I: Iterator,
    {
        type Item = I::Item;
        type Error = E;

        fn poll(&mut self) -> Poll<Option<I::Item>, E> {
            Ok(Async::Ready(self.iter.next()))
        }
    }

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