use super::assert_future;

use core::marker;

use core::pin::Pin;

use futures_core::future::{FusedFuture, Future};

use futures_core::task::{Context, Poll};

/// Future for the [`pending()`] function.

#[derive(Debug)]

#[must_use = "futures do nothing unless you `.await` or poll them"]

pub struct Pending<T> {

    _data: marker::PhantomData<T>,

}

impl<T> FusedFuture for Pending<T> {

    fn is_terminated(&self) -> bool {

        true

    }

}

/// Creates a future which never resolves, representing a computation that never

/// finishes.

///

/// The returned future will forever return [`Poll::Pending`].

///

/// # Examples

///

/// ```ignore

/// # futures::executor::block_on(async {

/// use futures::future;

///

/// let future = future::pending();

/// let () = future.await;

/// unreachable!();

/// # });

/// ```

#[cfg_attr(docsrs, doc(alias = "never"))]

pub fn pending<T>() -> Pending<T> {

    assert_future::<T, _>(Pending { _data: marker::PhantomData })

}

impl<T> Future for Pending<T> {

    type Output = T;

    fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<T> {

        Poll::Pending

    }

}

impl<T> Unpin for Pending<T> {}

impl<T> Clone for Pending<T> {

    fn clone(&self) -> Self {

        pending()

    }

}