mod usestate;
pub use usestate::{use_state, UseState};

mod useref;
pub use useref::*;

mod use_shared_state;
pub use use_shared_state::*;

mod usecoroutine;
pub use usecoroutine::*;

mod usefuture;
pub use usefuture::*;

mod usesuspense;
pub use usesuspense::*;

#[macro_export]
macro_rules! to_owned {
    ($($es:ident),+) => {$(
        #[allow(unused_mut)]
        let mut $es = $es.to_owned();
    )*}
}

/// Calls `for_async` on the series of paramters.
///
/// If the type is Clone, then it will be cloned. However, if the type is not `clone`
/// then it must have a `for_async` method for Rust to lower down into.
///
/// See: how use_state implements `for_async` but *not* through the trait.
#[macro_export]
macro_rules! for_async {
    ($($es:ident),+) => {$(
        #[allow(unused_mut)]
        let mut $es = $es.for_async();
    )*}
}

/// This is a marker trait that uses decoherence.
///
/// It is *not* meant for hooks to actually implement, but rather defer to their
/// underlying implementation if they *don't* implement the trait.
///
///
pub trait AsyncHook {
    type Output;
    fn for_async(self) -> Self::Output;
}

impl<T> AsyncHook for T
where
    T: ToOwned<Owned = T>,
{
    type Output = T;
    fn for_async(self) -> Self::Output {
        self
    }
}