Merge c58ae9cfad into aa7c15e0e9

Cargo.toml

@@ -8,7 +8,7 @@ categories = [ "algorithms", "science" ]
 license = "MIT/Apache-2.0"
 repository = "https://github.com/rust-num/num-traits"
 name = "num-traits"
-version = "0.1.41"
+version = "0.2.0"
 readme = "README.md"
 
 [dependencies]

src/bounds.rs

@@ -5,21 +5,25 @@ use std::num::Wrapping;
 
 /// Numbers which have upper and lower bounds
 pub trait Bounded {
-    // FIXME (#5527): These should be associated constants
     /// returns the smallest finite number this type can represent
-    fn min_value() -> Self;
+    const MIN: Self;
+    #[inline]
+    fn min_value() -> Self where Self: Sized {
+        Self::MIN
+    }
     /// returns the largest finite number this type can represent
-    fn max_value() -> Self;
+    const MAX: Self;
+    #[inline]
+    fn max_value() -> Self where Self: Sized {
+        Self::MAX
+    }
 }
 
 macro_rules! bounded_impl {
     ($t:ty, $min:expr, $max:expr) => {
         impl Bounded for $t {
-            #[inline]
+            const MIN: $t = $min;
-            fn min_value() -> $t { $min }
+            const MAX: $t = $max;
-
-            #[inline]
-            fn max_value() -> $t { $max }
         }
     }
 }
@@ -37,8 +41,9 @@ bounded_impl!(i32,   i32::MIN,   i32::MAX);
 bounded_impl!(i64,   i64::MIN,   i64::MAX);
 
 impl<T: Bounded> Bounded for Wrapping<T> {
-    fn min_value() -> Self { Wrapping(T::min_value()) }
+
-    fn max_value() -> Self { Wrapping(T::max_value()) }
+    const MIN: Self = Wrapping(T::MIN);
+    const MAX: Self = Wrapping(T::MAX);
 }
 
 bounded_impl!(f32, f32::MIN, f32::MAX);
@@ -61,14 +66,8 @@ macro_rules! for_each_tuple {
 macro_rules! bounded_tuple {
     ( $($name:ident)* ) => (
         impl<$($name: Bounded,)*> Bounded for ($($name,)*) {
-            #[inline]
+            const MIN: Self = ($($name::MIN,)*);
-            fn min_value() -> Self {
+            const MAX: Self = ($($name::MAX,)*);
-                ($($name::min_value(),)*)
-            }
-            #[inline]
-            fn max_value() -> Self {
-                ($($name::max_value(),)*)
-            }
         }
     );
 }

src/identities.rs

@@ -17,8 +17,12 @@ pub trait Zero: Sized + Add<Self, Output = Self> {
     /// This function should return the same result at all times regardless of
     /// external mutable state, for example values stored in TLS or in
     /// `static mut`s.
-    // FIXME (#5527): This should be an associated constant
+    const ZERO: Self;
-    fn zero() -> Self;
+    
+    #[inline]
+    fn zero() -> Self {
+        Self::ZERO
+    }
 
     /// Returns `true` if `self` is equal to the additive identity.
     #[inline]
@@ -28,6 +32,7 @@ pub trait Zero: Sized + Add<Self, Output = Self> {
 macro_rules! zero_impl {
     ($t:ty, $v:expr) => {
         impl Zero for $t {
+            const ZERO: $t = $v;
             #[inline]
             fn zero() -> $t { $v }
             #[inline]
@@ -52,12 +57,12 @@ zero_impl!(f32, 0.0f32);
 zero_impl!(f64, 0.0f64);
 
 impl<T: Zero> Zero for Wrapping<T> where Wrapping<T>: Add<Output=Wrapping<T>> {
+    
+
     fn is_zero(&self) -> bool {
         self.0.is_zero()
     }
-    fn zero() -> Self {
+    const ZERO: Self = Wrapping(T::ZERO);
-        Wrapping(T::zero())
-    }
 }
 
 
@@ -77,13 +82,18 @@ pub trait One: Sized + Mul<Self, Output = Self> {
     /// This function should return the same result at all times regardless of
     /// external mutable state, for example values stored in TLS or in
     /// `static mut`s.
-    // FIXME (#5527): This should be an associated constant
+    const ONE: Self;
-    fn one() -> Self;
+
+    #[inline]
+    fn one() -> Self {
+        Self::ONE
+    }
 }
 
 macro_rules! one_impl {
     ($t:ty, $v:expr) => {
         impl One for $t {
+            const ONE: $t = $v;
             #[inline]
             fn one() -> $t { $v }
         }
@@ -106,9 +116,7 @@ one_impl!(f32, 1.0f32);
 one_impl!(f64, 1.0f64);
 
 impl<T: One> One for Wrapping<T> where Wrapping<T>: Mul<Output=Wrapping<T>> {
-    fn one() -> Self {
+    const ONE: Self = Wrapping(T::ONE);
-        Wrapping(T::one())
-    }
 }
 
 // Some helper functions provided for backwards compatibility.