Introduce ToInt type operator

The ToInt type operator return arbitrary integer types,
including {i,u}{8,16,32,64} types.

src/int.rs

@@ -34,7 +34,7 @@ use consts::{N1, P1, U0, U1};
 use private::{Internal, InternalMarker};
 use private::{PrivateDivInt, PrivateIntegerAdd, PrivateRem};
 use uint::{UInt, Unsigned};
-use {Cmp, Equal, Greater, Less, NonZero, Pow, PowerOfTwo};
+use {Cmp, Equal, Greater, Less, NonZero, Pow, PowerOfTwo, ToInt};
 
 pub use marker_traits::Integer;
 
@@ -1177,14 +1177,165 @@ where
     }
 }
 
+// -----------------------------------------
+// ToInt
+
+impl ToInt<i8> for Z0 {
+    fn to_int() -> i8 {
+        Self::I8
+    }
+}
+
+impl ToInt<i16> for Z0 {
+    fn to_int() -> i16 {
+        Self::I16
+    }
+}
+
+impl ToInt<i32> for Z0 {
+    fn to_int() -> i32 {
+        Self::I32
+    }
+}
+
+impl ToInt<i64> for Z0 {
+    fn to_int() -> i64 {
+        Self::I64
+    }
+}
+
+// negative numbers
+
+impl<U> ToInt<i8> for NInt<U>
+where
+    U: Unsigned + NonZero,
+{
+    fn to_int() -> i8 {
+        Self::I8
+    }
+}
+
+impl<U> ToInt<i16> for NInt<U>
+where
+    U: Unsigned + NonZero,
+{
+    fn to_int() -> i16 {
+        Self::I16
+    }
+}
+
+impl<U> ToInt<i32> for NInt<U>
+where
+    U: Unsigned + NonZero,
+{
+    fn to_int() -> i32 {
+        Self::I32
+    }
+}
+
+impl<U> ToInt<i64> for NInt<U>
+where
+    U: Unsigned + NonZero,
+{
+    fn to_int() -> i64 {
+        Self::I64
+    }
+}
+
+// positive numbers
+
+impl<U> ToInt<i8> for PInt<U>
+where
+    U: Unsigned + NonZero,
+{
+    fn to_int() -> i8 {
+        Self::I8
+    }
+}
+
+impl<U> ToInt<i16> for PInt<U>
+where
+    U: Unsigned + NonZero,
+{
+    fn to_int() -> i16 {
+        Self::I16
+    }
+}
+
+impl<U> ToInt<i32> for PInt<U>
+where
+    U: Unsigned + NonZero,
+{
+    fn to_int() -> i32 {
+        Self::I32
+    }
+}
+
+impl<U> ToInt<i64> for PInt<U>
+where
+    U: Unsigned + NonZero,
+{
+    fn to_int() -> i64 {
+        Self::I64
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use consts::*;
+    use type_operators::ToInt;
     use Integer;
 
     #[test]
     fn to_ix_min() {
         assert_eq!(N128::to_i8(), ::core::i8::MIN);
         assert_eq!(N32768::to_i16(), ::core::i16::MIN);
     }
+
+    #[test]
+    fn int_toint_test() {
+        // i8
+        assert_eq!(0_i8, Z0::to_int());
+        assert_eq!(1_i8, P1::to_int());
+        assert_eq!(2_i8, P2::to_int());
+        assert_eq!(3_i8, P3::to_int());
+        assert_eq!(4_i8, P4::to_int());
+        assert_eq!(-1_i8, N1::to_int());
+        assert_eq!(-2_i8, N2::to_int());
+        assert_eq!(-3_i8, N3::to_int());
+        assert_eq!(-4_i8, N4::to_int());
+
+        // i16
+        assert_eq!(0_i16, Z0::to_int());
+        assert_eq!(1_i16, P1::to_int());
+        assert_eq!(2_i16, P2::to_int());
+        assert_eq!(3_i16, P3::to_int());
+        assert_eq!(4_i16, P4::to_int());
+        assert_eq!(-1_i16, N1::to_int());
+        assert_eq!(-2_i16, N2::to_int());
+        assert_eq!(-3_i16, N3::to_int());
+        assert_eq!(-4_i16, N4::to_int());
+
+        // i32
+        assert_eq!(0_i32, Z0::to_int());
+        assert_eq!(1_i32, P1::to_int());
+        assert_eq!(2_i32, P2::to_int());
+        assert_eq!(3_i32, P3::to_int());
+        assert_eq!(4_i32, P4::to_int());
+        assert_eq!(-1_i32, N1::to_int());
+        assert_eq!(-2_i32, N2::to_int());
+        assert_eq!(-3_i32, N3::to_int());
+        assert_eq!(-4_i32, N4::to_int());
+
+        // i64
+        assert_eq!(0_i64, Z0::to_int());
+        assert_eq!(1_i64, P1::to_int());
+        assert_eq!(2_i64, P2::to_int());
+        assert_eq!(3_i64, P3::to_int());
+        assert_eq!(4_i64, P4::to_int());
+        assert_eq!(-1_i64, N1::to_int());
+        assert_eq!(-2_i64, N2::to_int());
+        assert_eq!(-3_i64, N3::to_int());
+        assert_eq!(-4_i64, N4::to_int());
+    }
 }

src/type_operators.rs

@@ -1,5 +1,4 @@
 //! Useful **type operators** that are not defined in `core::ops`.
-//!
 
 use private::{Internal, InternalMarker};
 use {Bit, NInt, NonZero, PInt, UInt, UTerm, Unsigned, Z0};
@@ -558,3 +557,13 @@ pub trait Gcd<Rhs> {
     /// The greatest common divisor.
     type Output;
 }
+
+/// A **type operator** for taking a concrete integer value from a type.
+///
+/// It returns arbitrary integer value without explicitly specifying the
+/// type. It is useful when you pass the values to methods that accept
+/// distinct types without runtime casting.
+pub trait ToInt<T> {
+    /// Method returning the concrete value for the type.
+    fn to_int() -> T;
+}