use crate::NonZeroUnsigned;

use typenum::{NInt, PInt, Z0};

pub trait Sealed {

    const F64: f64;

}

impl Sealed for Z0 {

    const F64: f64 = 0_f64;

}

impl<U> Sealed for PInt<U>

where

    U: NonZeroUnsigned,

{

    const F64: f64 = U::F64;

}

impl<U> Sealed for NInt<U>

where

    U: NonZeroUnsigned,

{

    const F64: f64 = -U::F64;

}

/// Type-level integers.

///

/// # Examples

///

/// This trait is basically implemented for types that implement [typenum]'s `Integer`.

///

/// ```

/// use typerat::*;

/// use typenum::{PInt, UInt, UTerm};

///

/// fn to_i8_typenum<I: typenum::Integer>() -> i8 {

///     I::to_i8()

/// }

///

/// fn to_i8_typerat<I: Integer>() -> i8 {

///     I::to_i8()

/// }

///

/// assert_eq!(to_i8_typenum::<Z0>(), 0_i8);

/// assert_eq!(to_i8_typerat::<Z0>(), 0_i8);

///

/// assert_eq!(to_i8_typenum::<P1>(), 1_i8);

/// assert_eq!(to_i8_typerat::<P1>(), 1_i8);

///

/// assert_eq!(to_i8_typenum::<N1>(), -1_i8);

/// assert_eq!(to_i8_typerat::<N1>(), -1_i8);

/// ```

///

/// Unlike [typenum], compile time unsigned integers with leading zeros are not allowed.

///

/// ```

/// # use typerat::*;

/// # use typenum::{PInt, UInt, UTerm};

/// #

/// # fn to_i8_typenum<I: typenum::Integer>() -> i8 {

/// #     I::to_i8()

/// # }

/// #

/// assert_eq!(to_i8_typenum::<PInt<UInt<UTerm, B0>>>(), 0_i8);

/// ```

///

/// ```compile_fail

/// # use typerat::*;

/// # use typenum::{PInt, UInt, UTerm};

/// #

/// # fn to_i8_typerat<I: Integer>() -> i8 {

/// #     I::to_i8()

/// # }

/// #

/// assert_eq!(to_i8_typerat::<PInt<UInt<UTerm, B0>>>(), 0_i8);

/// ```

///

/// [typenum]: https://crates.io/crates/typenum

pub trait Integer: typenum::Integer + Sealed {}

impl Integer for Z0 {}

impl<U> Integer for PInt<U> where U: NonZeroUnsigned {}

impl<U> Integer for NInt<U> where U: NonZeroUnsigned {}

#[cfg(test)]

mod tests {

    use super::*;

    use typenum::consts::*;

    use typenum::UInt;

    #[test]

}