     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

    // This should really be in the stream module,
    // but `pub(crate)` isn't available until Rust 1.18,
    // and pre-1.18 there isn't a really good way to have a sub-module
    // available to the crate, but not without it.
    use core::marker::PhantomData;

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

    /// A stream combinator used to convert a `Stream<Item=T,Error=E>`
    /// to a `Stream<Item=Result<T,E>>`.
    ///
    /// A poll on this stream will never return an `Err`. As such the
    /// actual error type is parameterized, so it can match whatever error
    /// type is needed.
    ///
    /// This structure is produced by the `Stream::results` method.
    #[derive(Debug)]
    #[must_use = "streams do nothing unless polled"]
    pub struct Results<S: Stream, E> {
        inner: S,
        phantom: PhantomData<E>
    }

    pub fn new<S, E>(s: S) -> Results<S, E> where S: Stream {
        Results {
            inner: s,
            phantom: PhantomData
        }
    }

    impl<S: Stream, E> Stream for Results<S, E> {
        type Item = Result<S::Item, S::Error>;
        type Error = E;

        fn poll(&mut self) -> Poll<Option<Result<S::Item, S::Error>>, E> {
            match self.inner.poll() {
                Ok(Async::Ready(Some(item))) => Ok(Async::Ready(Some(Ok(item)))),
                Err(e) => Ok(Async::Ready(Some(Err(e)))),
                Ok(Async::Ready(None)) => Ok(Async::Ready(None)),
                Ok(Async::NotReady) => Ok(Async::NotReady)
            }
        }
    }

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