supply 0.2.0

//! `'static` tags for types.
//!
//! Each type may have many tags, but each tag names on type.
//! The types named may contain an arbitrary number of lifetimes.
//!
//! Types that should be tags should implement the [`WithLt`] trait.
//! Types that are tagged by a specific tag should implement the [`Tagged`] trait.
//! Bounds for tags/tagged types should use [`Reify`] or [`ReifySized`].

mod tag_type_id;
mod tagged;

use core::marker::PhantomData;

pub use tag_type_id::TagTypeId;

use crate::lt_list::{Cons, FirstN, Hole, Inv, LtHoleList, LtList, Prefix};

/// Types with an associated `'static` tag.
///
/// All [`WithLt`] implementers are required to also implement this trait.
/// As a result [`Self::Tag`] may not reify to `Self` if `Self` is a tag.
/// Additionally, all implementers of this trait implement [`Reify`].
pub trait Tagged {
    /// The tag type.
    ///
    /// This can be used with [`Reify`] to construct a type with lifetimes.
    type Tag: ?Sized + Tag + Tagged<Tag = Self::Tag> + 'static;
}

pub trait Tag {
    /// The structure of the lifetimes the tag needs.
    ///
    /// This will be used by the blanket [`Reify`] implementation to strip
    /// the needed lifetimes from a lifetime list to reify the tag.
    type LifetimesTag: LtHoleList + 'static;
}

/// [`Tagged`] but reified with some lifetimes `L`.
///
/// The lifetimes in `L` are used to get the reified type and the lifetime list for
/// the reified type. The lifetimes are chosen via [`Tag::LifetimesTag`].
///
/// If you need a sized [`Self::Reified`] then bound on [`ReifySized`] instead.
///
/// This trait **cannot** be manually implemented. To have it be implemented on a type,
/// implement [`Tagged`] and this trait will automatically be implemented when possible.
pub trait Reify<L: LtList>: reify_seal::Sealed<L> + Tagged<Tag = Self::UsedTag> {
    /// The type that was tagged, with it's lifetimes.
    type Reified: ?Sized;

    /// The lifetime list used to reify the type.
    ///
    /// This is some subset of lifetimes from `L`.
    type Lifetimes: LtList + Prefix<L>;

    /// The tag for [`Self::Reified`].
    ///
    /// This is known to reify using [`WithLt`] into [`Self::Reified`].
    ///
    /// This is taken directly from [`Tagged::Tag`].
    type UsedTag: ?Sized
        + Tagged<Tag = Self::UsedTag>
        + Tag<LifetimesTag = Self::UsedLifetimesTag>
        + WithLt<Self::Lifetimes, Reified = Self::Reified>
        + 'static;

    /// The structure of lifetimes for [`Reify::Lifetimes`].
    ///
    /// This is known to reify from the lifetimes in [`Reify::Lifetimes`].
    ///
    /// This is taken directly from [`Tag::LifetimesTag`].
    type UsedLifetimesTag: FirstN<Self::Lifetimes, Lifetimes = Self::Lifetimes>
        + FirstN<L, Lifetimes = Self::Lifetimes>
        + 'static;
}

pub trait ReifySized<L: LtList>: Reify<L, Reified = Self::SizedReified> {
    type SizedReified;
}

impl<L: LtList, T: ?Sized + Reify<L>> ReifySized<L> for T
where
    T::Reified: Sized,
{
    type SizedReified = T::Reified;
}

type LifetimesOf<T, L> = <T as FirstN<L>>::Lifetimes;

impl<T, L> Reify<L> for T
where
    T: ?Sized + Tagged,
    L: LtList,
    LifetimesTagOf<T::Tag>: FirstN<L>,
    LifetimesTagOf<T::Tag>: FirstN<
        LifetimesOf<LifetimesTagOf<T::Tag>, L>,
        Lifetimes = LifetimesOf<LifetimesTagOf<T::Tag>, L>,
    >,
    T::Tag: WithLt<LifetimesOf<LifetimesTagOf<T::Tag>, L>>,
{
    type Reified = ReifiedOf<T::Tag, LifetimesOf<LifetimesTagOf<T::Tag>, L>>;

    type Lifetimes = LifetimesOf<LifetimesTagOf<T::Tag>, L>;

    type UsedTag = T::Tag;

    type UsedLifetimesTag = LifetimesTagOf<T::Tag>;
}

mod reify_seal {
    use super::*;

    pub trait Sealed<L: LtList> {}

    impl<L, T> Sealed<L> for T
    where
        T: ?Sized + Tagged,
        L: LtList,
        LifetimesTagOf<T::Tag>: FirstN<L>,
        LifetimesTagOf<T::Tag>: FirstN<
            LifetimesOf<LifetimesTagOf<T::Tag>, L>,
            Lifetimes = LifetimesOf<LifetimesTagOf<T::Tag>, L>,
        >,
        T::Tag: WithLt<LifetimesOf<LifetimesTagOf<T::Tag>, L>>,
    {
    }
}

/// Get the [`Tagged::Tag`] of a type.
pub type TagOf<T> = <T as Tagged>::Tag;

pub type LifetimesTagOf<T> = <T as Tag>::LifetimesTag;

// pub type SizedReifiedOf<L, T> = <T as Tag<L>>::SizedReified;

pub type ReifiedOf<T, L> = <T as WithLt<L>>::Reified;

// /// A `'static` type tag.
// ///
// /// The difference between this trait and [`MaybeSizedTag`] is
// /// [`Self::SizedReified`] (and by extension [`MaybeSizedTag::Reified`])
// /// is known to implement [`Sized`].
// ///
// /// If you need to implement a custom tag, then implement [`MaybeSizedTag`] instead.
// /// The type will then automatically implement this trait also.
// pub trait Tag<L: LtList>: MaybeSizedTag<L, Reified = Self::SizedReified> {
//     /// Same type as [`MaybeSizedTag::Reified`].
//     type SizedReified;
// }

/// Add `L` lifetimes to get a new type.
///
/// This is designed for use on tags that are `'static`. Tags should implement this trait.
/// However, bounds should usually be for ...
pub trait WithLt<L: LtList>: Tag + Tagged<Tag = Self> + 'static {
    /// The type when given lifetimes from the `L` lifetime list.
    ///
    /// As example if `Self = Ref<str>` then `Reified = &'a str` when `L = Lt1<'a>`.
    /// The `'a` lifetime is "added" to the type.
    type Reified: ?Sized;
}

// Auto impl Tag when possible.
// impl<T: ?Sized + MaybeSizedTag<L>, L: LtList> Tag<L> for T
// where
//     T::Reified: Sized,
// {
//     type SizedReified = T::Reified;
// }

/// A tag configurable for any type.
#[allow(clippy::type_complexity)]
pub struct DynTag<LT, T: ?Sized>(PhantomData<(fn() -> *const T, LT)>);

pub trait TagDef<L: LtList>: 'static {
    type T: ?Sized;
}

// impl<L: LtList, T: ?Sized> TagDef<L> for dyn MaybeSizedTag<L, Reified = T> {
//     type T = T;
// }

// impl<L: LtList, Def: ?Sized + MaybeSizedTag<L>> MaybeSizedTag<L> for DynTag<Def> {
//     type Reified = Def::Reified;
// }

impl<Def: ?Sized + TagDef<L>, L: LtList, LT: FirstN<L, Lifetimes = L> + 'static> WithLt<L>
    for DynTag<LT, Def>
{
    type Reified = Def::T;
}

impl<Def: ?Sized + 'static, LT: LtHoleList + 'static> Tagged for DynTag<LT, Def> {
    type Tag = Self;
}

impl<Def: ?Sized + 'static, LT: LtHoleList + 'static> Tag for DynTag<LT, Def> {
    type LifetimesTag = LT;
}

/// Tag for `'static` type `T`.
///
/// The type `T` can be non-`Sized`.
pub type Static<T> = tag_for!(T);

/// Tag that adds a needed lifetime.
///
/// Tags like [`Ref`] and [`Mut`] use the first lifetime of the
/// provided `L` lifetime list. However this sharing is not always wanted.
///
/// ```ignore
///                       <'a, 'b, 'c>
///               &str -> &'a          str
///        AddLt<&str> ->     &'b      str
/// AddLt<AddLt<&str>> ->         &'c  str
/// ```
pub struct AddLt<T: ?Sized>(PhantomData<fn() -> *const T>);

impl<T: ?Sized + WithLt<L::Tail>, L: LtList> WithLt<L> for AddLt<T> {
    type Reified = T::Reified;
}

impl<T: ?Sized + Tagged> Tagged for AddLt<T> {
    type Tag = AddLt<T::Tag>;
}

impl<T: ?Sized + Tag> Tag for AddLt<T> {
    type LifetimesTag = Cons<Hole, T::LifetimesTag>;
}

/// Tag for `&T` that uses the first lifetime given in `L`.
pub struct Ref<T: ?Sized>(PhantomData<fn() -> T>);

impl<'r, T: ?Sized + WithLt<L>, L: LtList<Head = Inv<'r>>> WithLt<L> for Ref<T>
where
    T::Reified: 'r,
{
    type Reified = &'r T::Reified;
}

impl<T: ?Sized + Tagged> Tagged for Ref<T> {
    type Tag = Ref<T::Tag>;
}

impl<T: ?Sized + Tag> Tag for Ref<T> {
    type LifetimesTag = T::LifetimesTag;
}

/// Tag for `&mut T` that uses the first lifetime given in `L`.
pub struct Mut<T: ?Sized>(PhantomData<fn() -> T>);

impl<'r, T: ?Sized + WithLt<L>, L: LtList<Head = Inv<'r>>> WithLt<L> for Mut<T>
where
    T::Reified: 'r,
{
    type Reified = &'r mut T::Reified;
}

impl<T: ?Sized + Tagged> Tagged for Mut<T> {
    type Tag = Mut<T::Tag>;
}

impl<T: ?Sized + Tag> Tag for Mut<T> {
    type LifetimesTag = T::LifetimesTag;
}

#[doc(hidden)]
#[macro_export]
macro_rules! tag_for {
    (<$l0:lifetime, $l1:lifetime, $l2:lifetime $(,)?> $type:ty) => {
        $crate::tag::DynTag<$crate::lt_list::LtH3, dyn for<$l0, $l1, $l2> $crate::tag::TagDef<$crate::lt_list::Lt3<$l0, $l1, $l2>, T = $type>>
    };
    (<$l0:lifetime, $l1:lifetime $(,)?> $type:ty) => {
        $crate::tag::DynTag<$crate::lt_list::LtH2, dyn for<$l0, $l1> $crate::tag::TagDef<$crate::lt_list::Lt2<$l0, $l1>, T = $type>>
    };
    (<$l0:lifetime $(,)?> $type:ty) => {
        $crate::tag::DynTag<$crate::lt_list::LtH1, dyn for<$l0> $crate::tag::TagDef<$crate::lt_list::Lt1<$l0>, T = $type>>
    };
    ($type:ty) => {
        $crate::tag::DynTag<$crate::lt_list::LtH0, dyn $crate::tag::TagDef<$crate::lt_list::Lt0, T = $type>>
    };
}
#[doc(inline)]
pub use tag_for;

#[doc(hidden)]
#[macro_export]
macro_rules! impl_tagged {
    (
        $vis:vis struct $name:ident< $($tail:tt)*
    ) => {
        $crate::impl_tagged! {
            @scan_generic
            {
                $vis struct $name
            }
            ()
            ()
            ()
            ()
            ()
            {$($tail)*}
        }
    };
    (
            @scan_generic
            {$($struct:tt)*}
            ($($generics:tt)*)
            ($($reify_generics:tt)*)
            ($($lt_generics:tt)*)
            ($($tag_generics:tt)*)
            ($($const_generics:tt)*)
            {$(,)? $generic:ident $(,)? $($tail:tt)*}
    ) => {
        $crate::impl_tagged! {
            @scan_generic
            {$($struct)*}
            ($($generics)* $generic,)
            ($($reify_generics)* $generic::Reified,)
            ($($lt_generics)*)
            ($($tag_generics)* $generic,)
            ($($const_generics)*)
            {$($tail)*}
        }
    };
    (
            @scan_generic
            {$($struct:tt)*}
            ($($generics:tt)*)
            ($($reify_generics:tt)*)
            ($($lt_generics:tt)*)
            ($($tag_generics:tt)*)
            ($($const_generics:tt)*)
            {$(,)? $lt:lifetime $($tail:tt)*}
    ) => {
        $crate::impl_tagged! {
            @scan_generic
            {$($struct)*}
            ($($generics)* $lt,)
            ($($reify_generics)* $lt,)
            ($($lt_generics)* $lt,)
            ($($tag_generics)*)
            ($($const_generics)*)
            {$($tail)*}
        }
    };
    (
            @scan_generic
            {
                $vis:vis struct $name:ident
            }
            ($($generics:tt)*)
            ($($reify_generics:tt)*)
            ($($lt_generic:lifetime,)*)
            ($($tag_generic:ident,)*)
            ($($const_generics:tt)*)
            {$(,)? > $(where $($where:tt)*)?}
    ) => {
        const _: () = {
            $vis struct Tag<$($tag_generic: ?Sized)*>(::core::marker::PhantomData<fn() -> ($(*const $tag_generic,)*)>);

            impl<$($generics)*> Tagged for $name<$($generics)*>
            where
                $($tag_generic: Tagged,)*
            {
                type Tag = Tag<$($tag_generic::Tag)*>;
            }

            impl<$($lt_generic,)* $($tag_generic,)* L: LtList> WithLt<$crate::impl_tagged!(@lifetime $($lt_generic,)* L)> for Tag<$($tag_generic,)*>
            where
                $($tag_generic: ?Sized + WithLt<L>,)*
                $($tag_generic::Reified: Sized,)*
                $($($where)*)?
            {
                type Reified = $name<$($reify_generics)*>;
            }

            impl<$($tag_generic: ?Sized + Tagged,)*> Tagged for Tag<$($tag_generic,)*> {
                type Tag = Tag<$($tag_generic::Tag)*>;
            }

            impl<$($tag_generic: ?Sized + supply::tag::Tag,)*> supply::tag::Tag for Tag<$($tag_generic,)*> {
                type LifetimesTag = $crate::impl_tagged!(@lifetime_tag $($lt_generic,)* <($($tag_generic::LifetimesTag,)*) as supply::lt_list::Longest>::Holes);
            }
        };
    };
    (
        @lifetime $l0:lifetime, $L:ty
    ) => {
        $crate::lt_list::Lt1<$l0, $L>
    };
    (
        @lifetime_tag $l0:lifetime, $L:ty
    ) => {
        $crate::lt_list::LtH0<$L>
    };
    (
        @lifetime $L:ty
    ) => {
        $L
    };
    (
        @lifetime_tag $L:ty
    ) => {
        $L
    };
}
#[doc(inline)]
pub use impl_tagged;