:sparkles: Numeric trait

src/lib.rs

@@ -1,3 +1,3 @@
-pub use self::traits::Float;
+pub use self::traits::{Float, Numeric};
 
 mod traits;

src/traits/float.rs

@@ -1,4 +1,4 @@
-/// Marker trait because certain operations only make sense on floating point types.
+/// Marker trait, because certain operations only make sense on floating point types.
 pub trait Float {}
 
 impl Float for f32 {}

src/traits/mod.rs

@@ -1,3 +1,5 @@
 pub use self::float::Float;
+pub use self::numeric::Numeric;
 
 mod float;
+mod numeric;

src/traits/numeric.rs

@@ -0,0 +1,197 @@
+use std::fmt::{Debug, Display};
+use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
+
+/// Trait representing all numeric primitives.
+pub trait Numeric:
+Sized + Copy + Clone + Debug + Display +
+Add<Output=Self> + AddAssign + Sub<Output=Self> + SubAssign +
+Mul<Output=Self> + MulAssign + Div<Output=Self> + DivAssign +
+PartialEq + PartialOrd {
+    /// Function returning the 0 value for the given type.
+    fn zero() -> Self;
+
+    /// Function returning the 1 value for the given type.
+    fn one() -> Self;
+}
+
+impl Numeric for f32 {
+    fn zero() -> Self {
+        0.0
+    }
+
+    fn one() -> Self {
+        1.0
+    }
+}
+
+impl Numeric for f64 {
+    fn zero() -> Self {
+        0.0
+    }
+
+    fn one() -> Self {
+        1.0
+    }
+}
+
+impl Numeric for i8 {
+    fn zero() -> Self {
+        0
+    }
+
+    fn one() -> Self {
+        1
+    }
+}
+
+impl Numeric for i16 {
+    fn zero() -> Self {
+        0
+    }
+
+    fn one() -> Self {
+        1
+    }
+}
+
+impl Numeric for i32 {
+    fn zero() -> Self {
+        0
+    }
+
+    fn one() -> Self {
+        1
+    }
+}
+
+impl Numeric for i64 {
+    fn zero() -> Self {
+        0
+    }
+
+    fn one() -> Self {
+        1
+    }
+}
+
+impl Numeric for i128 {
+    fn zero() -> Self {
+        0
+    }
+
+    fn one() -> Self {
+        1
+    }
+}
+
+impl Numeric for isize {
+    fn zero() -> Self {
+        0
+    }
+
+    fn one() -> Self {
+        1
+    }
+}
+
+impl Numeric for u8 {
+    fn zero() -> Self {
+        0
+    }
+
+    fn one() -> Self {
+        1
+    }
+}
+
+impl Numeric for u16 {
+    fn zero() -> Self {
+        0
+    }
+
+    fn one() -> Self {
+        1
+    }
+}
+
+impl Numeric for u32 {
+    fn zero() -> Self {
+        0
+    }
+
+    fn one() -> Self {
+        1
+    }
+}
+
+impl Numeric for u64 {
+    fn zero() -> Self {
+        0
+    }
+
+    fn one() -> Self {
+        1
+    }
+}
+
+impl Numeric for u128 {
+    fn zero() -> Self {
+        0
+    }
+
+    fn one() -> Self {
+        1
+    }
+}
+
+impl Numeric for usize {
+    fn zero() -> Self {
+        0
+    }
+
+    fn one() -> Self {
+        1
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::Numeric;
+
+    #[test]
+    fn floats_are_numeric() {
+        assert_eq!(f32::zero(), 0.0);
+        assert_eq!(f32::one(), 1.0);
+        assert_eq!(f64::zero(), 0.0);
+        assert_eq!(f64::one(), 1.0);
+    }
+
+    #[test]
+    fn integers_are_numeric() {
+        assert_eq!(i8::zero(), 0);
+        assert_eq!(i8::one(), 1);
+        assert_eq!(i16::zero(), 0);
+        assert_eq!(i16::one(), 1);
+        assert_eq!(i32::zero(), 0);
+        assert_eq!(i32::one(), 1);
+        assert_eq!(i64::zero(), 0);
+        assert_eq!(i64::one(), 1);
+        assert_eq!(i128::zero(), 0);
+        assert_eq!(i128::one(), 1);
+        assert_eq!(isize::zero(), 0);
+        assert_eq!(isize::one(), 1);
+
+        assert_eq!(u8::zero(), 0);
+        assert_eq!(u8::one(), 1);
+        assert_eq!(u16::zero(), 0);
+        assert_eq!(u16::one(), 1);
+        assert_eq!(u32::zero(), 0);
+        assert_eq!(u32::one(), 1);
+        assert_eq!(u64::zero(), 0);
+        assert_eq!(u64::one(), 1);
+        assert_eq!(u128::zero(), 0);
+        assert_eq!(u128::one(), 1);
+        assert_eq!(usize::zero(), 0);
+        assert_eq!(usize::one(), 1);
+    }
+}