      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
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105

    /// A macro for extracting the successful type of a `Poll<T, E>`.
    ///
    /// This macro bakes propagation of both errors and `NotReady` signals by
    /// returning early.
    #[macro_export]
    macro_rules! try_ready {
        ($e:expr) => (match $e {
            Ok($crate::Async::Ready(t)) => t,
            Ok($crate::Async::NotReady) => return Ok($crate::Async::NotReady),
            Err(e) => return Err(From::from(e)),
        })
    }

    /// Return type of the `Future::poll` method, indicates whether a future's value
    /// is ready or not.
    ///
    /// * `Ok(Async::Ready(t))` means that a future has successfully resolved
    /// * `Ok(Async::NotReady)` means that a future is not ready to complete yet
    /// * `Err(e)` means that a future has completed with the given failure
    pub type Poll<T, E> = Result<Async<T>, E>;

    /// Return type of future, indicating whether a value is ready or not.
    #[derive(Copy, Clone, Debug, PartialEq)]
    pub enum Async<T> {
        /// Represents that a value is immediately ready.
        Ready(T),

        /// Represents that a value is not ready yet, but may be so later.
        NotReady,
    }

    impl<T> Async<T> {
        /// Change the success value of this `Async` with the closure provided
        pub fn map<F, U>(self, f: F) -> Async<U>
            where F: FnOnce(T) -> U
        {
            match self {
                Async::Ready(t) => Async::Ready(f(t)),
                Async::NotReady => Async::NotReady,
            }
        }

        /// Returns whether this is `Async::Ready`
        pub fn is_ready(&self) -> bool {
            match *self {
                Async::Ready(_) => true,
                Async::NotReady => false,
            }
        }

        /// Returns whether this is `Async::NotReady`
        pub fn is_not_ready(&self) -> bool {
            !self.is_ready()
        }
    }

    impl<T> From<T> for Async<T> {
        fn from(t: T) -> Async<T> {
            Async::Ready(t)
        }
    }

    /// The result of an asynchronous attempt to send a value to a sink.
    #[derive(Copy, Clone, Debug, PartialEq)]
    pub enum AsyncSink<T> {
        /// The `start_send` attempt succeeded, so the sending process has
        /// *started*; you must use `Sink::poll_complete` to drive the send
        /// to completion.
        Ready,

        /// The `start_send` attempt failed due to the sink being full. The value
        /// being sent is returned, and the current `Task` will be automatically
        /// notified again once the sink has room.
        NotReady(T),
    }

    impl<T> AsyncSink<T> {
        /// Change the NotReady value of this `AsyncSink` with the closure provided
        pub fn map<F, U>(self, f: F) -> AsyncSink<U>
            where F: FnOnce(T) -> U,
        {
            match self {
                AsyncSink::Ready => AsyncSink::Ready,
                AsyncSink::NotReady(t) => AsyncSink::NotReady(f(t)),
            }
        }

        /// Returns whether this is `AsyncSink::Ready`
        pub fn is_ready(&self) -> bool {
            match *self {
                AsyncSink::Ready => true,
                AsyncSink::NotReady(_) => false,
            }
        }

        /// Returns whether this is `AsyncSink::NotReady`
        pub fn is_not_ready(&self) -> bool {
            !self.is_ready()
        }
    }

    /// Return type of the `Sink::start_send` method, indicating the outcome of a
    /// send attempt. See `AsyncSink` for more details.
    pub type StartSend<T, E> = Result<AsyncSink<T>, E>;

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