      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
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125

    //! Asynchronous values.
    //!
    //! This module contains:
    //!
    //! - The [`Future`] trait.
    //! - The [`FutureExt`] and [`TryFutureExt`] trait, which provides adapters for
    //!   chaining and composing futures.
    //! - Top-level future combinators like [`lazy`](lazy()) which creates a future
    //!   from a closure that defines its return value, and [`ready`](ready()),
    //!   which constructs a future with an immediate defined value.

    #[doc(no_inline)]
    pub use core::future::Future;

    #[cfg(feature = "alloc")]
    pub use futures_core::future::{BoxFuture, LocalBoxFuture};
    pub use futures_core::future::{FusedFuture, TryFuture};
    pub use futures_task::{FutureObj, LocalFutureObj, UnsafeFutureObj};

    // Extension traits and combinators
    #[allow(clippy::module_inception)]
    mod future;
    pub use self::future::{
        Flatten, Fuse, FutureExt, Inspect, IntoStream, Map, NeverError, Then, UnitError, MapInto,
    };

    #[deprecated(note = "This is now an alias for [Flatten](Flatten)")]
    pub use self::future::FlattenStream;

    #[cfg(feature = "std")]
    pub use self::future::CatchUnwind;

    #[cfg(feature = "channel")]
    #[cfg_attr(docsrs, doc(cfg(feature = "channel")))]
    #[cfg(feature = "std")]
    pub use self::future::{Remote, RemoteHandle};

    #[cfg(feature = "std")]
    pub use self::future::{Shared, WeakShared};

    mod try_future;
    pub use self::try_future::{
        AndThen, ErrInto, OkInto, InspectErr, InspectOk, IntoFuture, MapErr, MapOk, OrElse, TryFlattenStream,
        TryFutureExt, UnwrapOrElse, MapOkOrElse, TryFlatten,
    };

    #[cfg(feature = "sink")]
    #[cfg_attr(docsrs, doc(cfg(feature = "sink")))]
    pub use self::try_future::FlattenSink;

    // Primitive futures

    mod lazy;
    pub use self::lazy::{lazy, Lazy};

    mod pending;
    pub use self::pending::{pending, Pending};

    mod maybe_done;
    pub use self::maybe_done::{maybe_done, MaybeDone};

    mod try_maybe_done;
    pub use self::try_maybe_done::{try_maybe_done, TryMaybeDone};

    mod option;
    pub use self::option::OptionFuture;

    mod poll_fn;
    pub use self::poll_fn::{poll_fn, PollFn};

    mod ready;
    pub use self::ready::{err, ok, ready, Ready};

    mod join;
    pub use self::join::{join, join3, join4, join5, Join, Join3, Join4, Join5};

    #[cfg(feature = "alloc")]
    mod join_all;
    #[cfg(feature = "alloc")]
    pub use self::join_all::{join_all, JoinAll};

    mod select;
    pub use self::select::{select, Select};

    #[cfg(feature = "alloc")]
    mod select_all;
    #[cfg(feature = "alloc")]
    pub use self::select_all::{select_all, SelectAll};

    mod try_join;
    pub use self::try_join::{
        try_join, try_join3, try_join4, try_join5, TryJoin, TryJoin3, TryJoin4, TryJoin5,
    };

    #[cfg(feature = "alloc")]
    mod try_join_all;
    #[cfg(feature = "alloc")]
    pub use self::try_join_all::{try_join_all, TryJoinAll};

    mod try_select;
    pub use self::try_select::{try_select, TrySelect};

    #[cfg(feature = "alloc")]
    mod select_ok;
    #[cfg(feature = "alloc")]
    pub use self::select_ok::{select_ok, SelectOk};

    mod either;
    pub use self::either::Either;

    cfg_target_has_atomic! {
        #[cfg(feature = "alloc")]
        mod abortable;
        #[cfg(feature = "alloc")]
        pub use self::abortable::{abortable, Abortable, AbortHandle, AbortRegistration, Aborted};
    }

    // Just a helper function to ensure the futures we're returning all have the
    // right implementations.
    pub(crate) fn assert_future<T, F>(future: F) -> F
    where
        F: Future<Output = T>,
    {
        future
    }