Added custom FromLossy trait implementation to work around lack of lossy conversions

See: rust-lang/rfcs#2484

Note due to blanket-trait limitations, we can really only implement this
for new types in the current crate

Author: geky

examples/crc.rs

@@ -15,6 +15,7 @@
 
 use std::iter;
 use std::convert::TryFrom;
+use gf256::traits::FromLossy;
 use gf256::*;
 
 /// This is a common polynomial for 32-bit CRCs, normally the highest
@@ -173,7 +174,7 @@ pub fn barret_crc(data: &[u8]) -> u32 {
     for b in data {
         crc = crc ^ (p32::from(b.reverse_bits()) << 24);
         let q = (p64::from(crc >> 24)*BARRET_CONSTANT) >> 32;
-        crc = p32::try_from((q*POLYNOMIAL) & 0xffffffffu64).unwrap() + (crc << 8);
+        crc = p32::from_lossy(q*POLYNOMIAL) + (crc << 8);
     }
 
     u32::from(crc).reverse_bits() ^ 0xffffffff
@@ -196,13 +197,13 @@ pub fn word_barret_crc(data: &[u8]) -> u32 {
         let word = <[u8; 4]>::try_from(word).unwrap();
         crc = crc ^ p32::from_le_bytes(word).reverse_bits();
         let q = (p64::from(crc)*BARRET_CONSTANT) >> 32;
-        crc = p32::try_from((q*POLYNOMIAL) & 0xffffffffu64).unwrap();
+        crc = p32::from_lossy(q*POLYNOMIAL);
     }
 
     for b in words.remainder() {
         crc = crc ^ (p32::from(b.reverse_bits()) << 24);
         let q = (p64::from(crc >> 24)*BARRET_CONSTANT) >> 32;
-        crc = p32::try_from((q*POLYNOMIAL) & 0xffffffffu64).unwrap() + (crc << 8);
+        crc = p32::from_lossy(q*POLYNOMIAL) + (crc << 8);
     }
 
     u32::from(crc).reverse_bits() ^ 0xffffffff

gf256-macros/src/p.rs

@@ -3,13 +3,15 @@
 use std::mem::size_of;
 use std::ops::*;
 use std::iter::*;
-use std::convert::TryFrom;
 use std::num::TryFromIntError;
 use std::num::ParseIntError;
 use std::fmt;
 use std::str::FromStr;
+use __crate::traits::TryFrom;
+use __crate::traits::FromLossy;
 use __crate::internal::cfg_if::cfg_if;
 
+
 /// A type representing a gf(2) polynomial
 #[allow(non_camel_case_types)]
 #[derive(Default, Copy, Clone, Eq, PartialEq, Hash)]
@@ -685,6 +687,70 @@ impl TryFrom<__crate::p128> for __p {
     }
 }
 
+#[cfg(__if(__width < 16))]
+impl FromLossy<u16> for __p {
+    #[inline]
+    fn from_lossy(x: u16) -> __p {
+        __p(x as __u)
+    }
+}
+
+#[cfg(__if(__width < 32))]
+impl FromLossy<u32> for __p {
+    #[inline]
+    fn from_lossy(x: u32) -> __p {
+        __p(x as __u)
+    }
+}
+
+#[cfg(__if(__width < 64))]
+impl FromLossy<u64> for __p {
+    #[inline]
+    fn from_lossy(x: u64) -> __p {
+        __p(x as __u)
+    }
+}
+
+#[cfg(__if(__width < 128))]
+impl FromLossy<u128> for __p {
+    #[inline]
+    fn from_lossy(x: u128) -> __p {
+        __p(x as __u)
+    }
+}
+
+#[cfg(__if(__width < 16))]
+impl FromLossy<__crate::p16> for __p {
+    #[inline]
+    fn from_lossy(x: __crate::p16) -> __p {
+        __p(x.0 as __u)
+    }
+}
+
+#[cfg(__if(__width < 32))]
+impl FromLossy<__crate::p32> for __p {
+    #[inline]
+    fn from_lossy(x: __crate::p32) -> __p {
+        __p(x.0 as __u)
+    }
+}
+
+#[cfg(__if(__width < 64))]
+impl FromLossy<__crate::p64> for __p {
+    #[inline]
+    fn from_lossy(x: __crate::p64) -> __p {
+        __p(x.0 as __u)
+    }
+}
+
+#[cfg(__if(__width < 128))]
+impl FromLossy<__crate::p128> for __p {
+    #[inline]
+    fn from_lossy(x: __crate::p128) -> __p {
+        __p(x.0 as __u)
+    }
+}
+
 
 //// Conversions from __p ////
 
@@ -763,6 +829,155 @@ impl TryFrom<__p> for u64 {
     }
 }
 
+#[cfg(__if(__width > 8))]
+impl FromLossy<__p> for u8 {
+    #[inline]
+    fn from_lossy(x: __p) -> u8 {
+        x.0 as u8
+    }
+}
+
+#[cfg(__if(__width > 16))]
+impl FromLossy<__p> for u16 {
+    #[inline]
+    fn from_lossy(x: __p) -> u16 {
+        x.0 as u16
+    }
+}
+
+#[cfg(__if(__width > 32))]
+impl FromLossy<__p> for u32 {
+    #[inline]
+    fn from_lossy(x: __p) -> u32 {
+        x.0 as u32
+    }
+}
+
+#[cfg(__if(__width > 64))]
+impl FromLossy<__p> for u64 {
+    #[inline]
+    fn from_lossy(x: __p) -> u64 {
+        x.0 as u64
+    }
+}
+
+#[cfg(__if(__width < 16))]
+impl From<__p> for i16 {
+    #[inline]
+    fn from(x: __p) -> i16 {
+        i16::from(x.0)
+    }
+}
+
+#[cfg(__if(__width < 32))]
+impl From<__p> for i32 {
+    #[inline]
+    fn from(x: __p) -> i32 {
+        i32::from(x.0)
+    }
+}
+
+#[cfg(__if(__width < 64))]
+impl From<__p> for i64 {
+    #[inline]
+    fn from(x: __p) -> i64 {
+        i64::from(x.0)
+    }
+}
+
+#[cfg(__if(__width < 128))]
+impl From<__p> for i128 {
+    #[inline]
+    fn from(x: __p) -> i128 {
+        i128::from(x.0)
+    }
+}
+
+#[cfg(__if(__width >= 8))]
+impl TryFrom<__p> for i8 {
+    type Error = TryFromIntError;
+    #[inline]
+    fn try_from(x: __p) -> Result<i8, Self::Error> {
+        i8::try_from(x.0)
+    }
+}
+
+#[cfg(__if(__width >= 16))]
+impl TryFrom<__p> for i16 {
+    type Error = TryFromIntError;
+    #[inline]
+    fn try_from(x: __p) -> Result<i16, Self::Error> {
+        i16::try_from(x.0)
+    }
+}
+
+#[cfg(__if(__width >= 32))]
+impl TryFrom<__p> for i32 {
+    type Error = TryFromIntError;
+    #[inline]
+    fn try_from(x: __p) -> Result<i32, Self::Error> {
+        i32::try_from(x.0)
+    }
+}
+
+#[cfg(__if(__width >= 64))]
+impl TryFrom<__p> for i64 {
+    type Error = TryFromIntError;
+    #[inline]
+    fn try_from(x: __p) -> Result<i64, Self::Error> {
+        i64::try_from(x.0)
+    }
+}
+
+#[cfg(__if(__width >= 128))]
+impl TryFrom<__p> for i128 {
+    type Error = TryFromIntError;
+    #[inline]
+    fn try_from(x: __p) -> Result<i128, Self::Error> {
+        i128::try_from(x.0)
+    }
+}
+
+#[cfg(__if(__width >= 8))]
+impl FromLossy<__p> for i8 {
+    #[inline]
+    fn from_lossy(x: __p) -> i8 {
+        x.0 as i8
+    }
+}
+
+#[cfg(__if(__width >= 16))]
+impl FromLossy<__p> for i16 {
+    #[inline]
+    fn from_lossy(x: __p) -> i16 {
+        x.0 as i16
+    }
+}
+
+#[cfg(__if(__width >= 32))]
+impl FromLossy<__p> for i32 {
+    #[inline]
+    fn from_lossy(x: __p) -> i32 {
+        x.0 as i32
+    }
+}
+
+#[cfg(__if(__width >= 64))]
+impl FromLossy<__p> for i64 {
+    #[inline]
+    fn from_lossy(x: __p) -> i64 {
+        x.0 as i64
+    }
+}
+
+#[cfg(__if(__width >= 128))]
+impl FromLossy<__p> for i128 {
+    #[inline]
+    fn from_lossy(x: __p) -> i128 {
+        x.0 as i128
+    }
+}
+
 
 //// Negate ////
 

src/lib.rs

@@ -1,10 +1,13 @@
 
 
+/// Common traits
+pub mod traits;
+
+/// Polynomial types
+pub mod p;
+pub use p::*;
+
 /// re-exported for proc_macros
 pub mod internal {
     pub use cfg_if;
 }
-
-mod p;
-pub use p::*;
-

src/traits.rs

@@ -0,0 +1,50 @@
+//! Common traits
+//!
+//! Currently just a workaround for FromLossy/IntoLossy traits
+//!
+
+// TryFrom/TryInto forwarded for convenience
+pub use std::convert::TryFrom;
+pub use std::convert::TryInto;
+
+/// A From trait for conversions which may lose precision
+///
+/// Note this is just a temporary workaround. Once [RFC2484] is implemented
+/// these traits should go away.
+///
+/// [RFC2484]: https://github.com/rust-lang/rfcs/pull/2484
+///
+pub trait FromLossy<T> {
+    fn from_lossy(t: T) -> Self;
+}
+
+/// An Into trait for conversions which may lose precision
+///
+/// This is similar to Into, but for FromLossy
+///
+pub trait IntoLossy<T> {
+    fn into_lossy(self) -> T;
+}
+
+/// IntoLossy is the inverse of FromLossy
+impl<T, U> IntoLossy<T> for U
+where
+    T: FromLossy<U>
+{
+    #[inline]
+    fn into_lossy(self) -> T {
+        T::from_lossy(self)
+    }
+}
+
+/// All types that provide From provide FromLossy
+impl<T, U> FromLossy<T> for U
+where
+    U: From<T>
+{
+    #[inline]
+    fn from_lossy(t: T) -> Self {
+        Self::from(t)
+    }
+}
+