     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

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

    /// A stream which emits single element and then EOF.
    ///
    /// This stream will never block and is always ready.
    #[derive(Debug)]
    #[must_use = "streams do nothing unless polled"]
    pub struct Once<T, E>(Option<Result<T, E>>);

    /// Creates a stream of single element
    ///
    /// ```rust
    /// use futures::*;
    ///
    /// let mut stream = stream::once::<(), _>(Err(17));
    /// assert_eq!(Err(17), stream.poll());
    /// assert_eq!(Ok(Async::Ready(None)), stream.poll());
    /// ```
    pub fn once<T, E>(item: Result<T, E>) -> Once<T, E> {
        Once(Some(item))
    }

    impl<T, E> Stream for Once<T, E> {
        type Item = T;
        type Error = E;

        fn poll(&mut self) -> Poll<Option<T>, E> {
            match self.0.take() {
                Some(Ok(e)) => Ok(Async::Ready(Some(e))),
                Some(Err(e)) => Err(e),
                None => Ok(Async::Ready(None)),
            }
        }
    }

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