exhaust 0.2.6

//! Macros to generate particular `Exhaust` implementation styles.
//!
//! These are not public; they are intended to be freely modified as suits
//! the use cases that come up internally.

macro_rules! factory_is_self {
    () => {
        type Factory = Self;

        fn from_factory(factory: Self::Factory) -> Self {
            factory
        }
    };
}
pub(crate) use factory_is_self;

/// Delegate the `type Iter`, `type Factory`, and `from_factory` to another type.
/// Use this macro inside an `impl Exhaust`, and implement `from_factory()` to convert
/// from `$delegate`’s factory to `Self` (usually using `$delegate::from_factory()`).
macro_rules! delegate_factory_and_iter {
    ($delegate:ty) => {
        type Iter = <$delegate as $crate::Exhaust>::Iter;
        type Factory = <$delegate as $crate::Exhaust>::Factory;

        fn exhaust_factories() -> Self::Iter {
            <$delegate as $crate::Exhaust>::exhaust_factories()
        }
    };
}
pub(crate) use delegate_factory_and_iter;

/// Implementation for types with exactly one value.
macro_rules! impl_singleton {
    // if Default is implemented
    ([$($generics:tt)*], $self:ty) => {
        impl<$($generics)*> $crate::Exhaust for $self {
            type Iter = ::core::iter::Once<()>;
            type Factory = ();
            fn exhaust_factories() -> Self::Iter {
                ::core::iter::once(())
            }
            fn from_factory((): Self::Factory) -> Self {
                ::core::default::Default::default()
            }
        }
    };
    // if Default is not implemented
    ([$($generics:tt)*], $self:ty, $ctor:expr) => {
        impl<$($generics)*> $crate::Exhaust for $self {
            type Iter = ::core::iter::Once<()>;
            type Factory = ();
            fn exhaust_factories() -> Self::Iter {
                ::core::iter::once(())
            }
            fn from_factory((): Self::Factory) -> Self {
                $ctor
            }
        }
    };
}
pub(crate) use impl_singleton;

/// Implement `Exhaust` for `$self` by iterating over the given array.
/// The array must have no more than `u8::MAX - 1` (254) elements.
macro_rules! impl_via_array {
    ($self:ty, $array:expr) => {
        // block to hide the non-uniquely named items
        const _: () = {
            impl $crate::Exhaust for $self {
                type Iter = ExhaustIter;
                fn exhaust_factories() -> Self::Iter {
                    #![allow(clippy::cast_possible_truncation)]
                    const {
                        assert!(VALUES.len() < u8::MAX as usize);
                        ExhaustIter {
                            index_iter: 0..{ VALUES.len() as u8 },
                        }
                    }
                }
                $crate::patterns::factory_is_self!();
            }

            const VALUES: &[$self; $array.len()] = &$array;

            // Opaque iterator struct for this particular `Exhaust` implementation.
            // Public-in-private type as a substitute for associated type `impl Iterator`.
            #[derive(Clone, Debug)] // TODO: custom Debug
            pub struct ExhaustIter {
                // Indices into `VALUES` to produce.
                index_iter: ::core::ops::Range<u8>,
            }

            // Note: We could easily decide that the factory is a `u8` instead of doing
            // `factory_is_self` style, but we want to offer `factory_is_self` since it
            // is the maximally flexible option.

            impl Iterator for ExhaustIter {
                type Item = $self;
                #[inline]
                fn next(&mut self) -> Option<Self::Item> {
                    match self.index_iter.next() {
                        Some(index) => Some(VALUES[usize::from(index)]),
                        None => None,
                    }
                }

                #[inline]
                fn size_hint(&self) -> (usize, Option<usize>) {
                    self.index_iter.size_hint()
                }
            }
            impl DoubleEndedIterator for ExhaustIter {
                #[inline]
                fn next_back(&mut self) -> Option<Self::Item> {
                    match self.index_iter.next_back() {
                        Some(index) => Some(VALUES[usize::from(index)]),
                        None => None,
                    }
                }
            }
            impl ::core::iter::FusedIterator for ExhaustIter {}
            impl ::core::iter::ExactSizeIterator for ExhaustIter where
                // this bound is not necessary but proves we are correct to have this impl
                ::core::ops::Range<u8>: ::core::iter::ExactSizeIterator
            {
            }
        };
    };
}
pub(crate) use impl_via_array;

macro_rules! impl_via_range {
    ($self:ty, $start:expr, $end:expr) => {
        impl $crate::Exhaust for $self {
            type Iter = ::core::ops::RangeInclusive<$self>;
            fn exhaust_factories() -> Self::Iter {
                (($start)..=($end))
            }
            $crate::patterns::factory_is_self!();
        }
    };
}
pub(crate) use impl_via_range;

/// Implement [`Exhaust`] for a 'newtype' that has one generic field that must also implement
/// [`Exhaust`].
///
/// As an easier to implement syntax, generic bounds must be written inside of square brackets:
/// `impl_newtype_generic!(T: [Foo], Bar, Bar::new)`
macro_rules! impl_newtype_generic {
    ($tvar:ident : [ $( $bounds:tt )* ] , $container:ty, $wrap_fn:expr) => {
        impl<$tvar: $crate::Exhaust> $crate::Exhaust for $container
        where
            $tvar: $( $bounds )*
        {
            type Iter = <$tvar as $crate::Exhaust>::Iter;
            fn exhaust_factories() -> Self::Iter {
                <$tvar as $crate::Exhaust>::exhaust_factories()
            }

            type Factory = <$tvar as $crate::Exhaust>::Factory;
            fn from_factory(factory: Self::Factory) -> Self {
                $wrap_fn(<$tvar as $crate::Exhaust>::from_factory(factory))
            }
        }
    };
}
pub(crate) use impl_newtype_generic;

/// Implement [`Iterator`] and [`DoubleEndedIterator`] for a newtype
/// to forward to its `.0` field and call a function to map each item.
///
/// The function expression will be evaluated at each call site,
/// so a named function should be preferred over a closure.
macro_rules! impl_iterator_for_newtype {
    (
        [$($generics:tt)*] for $iterator_type:ty {
            type Item = $item_type:ty;
            fn mapper = $mapping_function:expr;
            double_ended_where [$($double_ended_bounds:tt)*];
        }
    ) => {
        $crate::patterns::impl_iterator_for_newtype!([$($generics)*] for $iterator_type {
            type Item = $item_type;
            fn mapper = $mapping_function;
            not_double_ended;
        });

        impl<$($generics)*> DoubleEndedIterator for $iterator_type
        where $($double_ended_bounds)* {
            fn next_back(&mut self) -> Option<Self::Item> {
                self.0.next_back().map($mapping_function)
            }

            fn rfold<B, F>(self, init: B, mut f: F) -> B
            where
                Self: Sized,
                F: FnMut(B, Self::Item) -> B,
            {
                self.0.rfold(init, |state, inner_item| {
                    f(state, ($mapping_function)(inner_item))
                })
            }

            fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
                self.0.nth_back(n).map($mapping_function)
            }
        }
    };
    (
        [$($generics:tt)*] for $iterator_type:ty {
            type Item = $item_type:ty;
            fn mapper = $mapping_function:expr;
            not_double_ended;
        }
    ) => {
        impl<$($generics)*> Iterator for $iterator_type {
            type Item = $item_type;

            #[inline]
            fn next(&mut self) -> Option<Self::Item> {
                self.0.next().map($mapping_function)
            }

            #[inline]
            fn size_hint(&self) -> (usize, Option<usize>) {
                self.0.size_hint()
            }

            fn fold<B, F>(self, init: B, mut f: F) -> B
            where
                Self: Sized,
                F: FnMut(B, Self::Item) -> B,
            {
                self.0.fold(init, |state, inner_item| {
                    f(state, ($mapping_function)(inner_item))
                })
            }

            // Ideally we would forward `try_fold()`, but that is not possible until the `Try` trait
            // is stabilized.

            fn nth(&mut self, n: usize) -> Option<Self::Item> {
                self.0.nth(n).map($mapping_function)
            }

            fn last(self) -> Option<Self::Item> {
                self.0.last().map($mapping_function)
            }
        }
    };
}
pub(crate) use impl_iterator_for_newtype;