     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
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59

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

    /// An adapter for merging the output of two streams.
    ///
    /// The merged stream produces items from one or both of the underlying
    /// streams as they become available. Errors, however, are not merged: you
    #[derive(Debug)]
    /// get at most one error at a time.
    #[must_use = "streams do nothing unless polled"]
    pub struct Zip<S1: Stream, S2: Stream> {
        stream1: Fuse<S1>,
        stream2: Fuse<S2>,
        queued1: Option<S1::Item>,
        queued2: Option<S2::Item>,
    }

    pub fn new<S1, S2>(stream1: S1, stream2: S2) -> Zip<S1, S2>
        where S1: Stream, S2: Stream<Error = S1::Error>
    {
        Zip {
            stream1: stream1.fuse(),
            stream2: stream2.fuse(),
            queued1: None,
            queued2: None,
        }
    }

    impl<S1, S2> Stream for Zip<S1, S2>
        where S1: Stream, S2: Stream<Error = S1::Error>
    {
        type Item = (S1::Item, S2::Item);
        type Error = S1::Error;

        fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
            if self.queued1.is_none() {
                match self.stream1.poll()? {
                    Async::Ready(Some(item1)) => self.queued1 = Some(item1),
                    Async::Ready(None) | Async::NotReady => {}
                }
            }
            if self.queued2.is_none() {
                match self.stream2.poll()? {
                    Async::Ready(Some(item2)) => self.queued2 = Some(item2),
                    Async::Ready(None) | Async::NotReady => {}
                }
            }

            if self.queued1.is_some() && self.queued2.is_some() {
                let pair = (self.queued1.take().unwrap(),
                            self.queued2.take().unwrap());
                Ok(Async::Ready(Some(pair)))
            } else if self.stream1.is_done() || self.stream2.is_done() {
                Ok(Async::Ready(None))
            } else {
                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`)