Merge #48

48: Let new_raw, numer, and denom be const in Rust 1.31+ r=cuviper a=cuviper

Fixes #32.

Co-authored-by: Josh Stone <[email protected]>

Author: bors[bot]

build.rs

@@ -4,11 +4,17 @@ use std::env;
 
 fn main() {
     let ac = autocfg::new();
+
     if ac.probe_type("i128") {
         println!("cargo:rustc-cfg=has_i128");
     } else if env::var_os("CARGO_FEATURE_I128").is_some() {
         panic!("i128 support was not detected!");
     }
 
+    // autocfg doesn't have a direct way to probe for `const fn` yet.
+    if ac.probe_rustc_version(1, 31) {
+        autocfg::emit("has_const_fn");
+    }
+
     autocfg::rerun_path(file!());
 }

src/lib.rs

@@ -68,6 +68,42 @@ pub type Rational64 = Ratio<i64>;
 /// Alias for arbitrary precision rationals.
 pub type BigRational = Ratio<BigInt>;
 
+macro_rules! maybe_const {
+    ($( $(#[$attr:meta])* pub fn $name:ident $args:tt -> $ret:ty $body:block )*) => {$(
+        #[cfg(has_const_fn)]
+        $(#[$attr])* pub const fn $name $args -> $ret $body
+
+        #[cfg(not(has_const_fn))]
+        $(#[$attr])* pub fn $name $args -> $ret $body
+    )*}
+}
+
+/// These method are `const` for Rust 1.31 and later.
+impl<T> Ratio<T> {
+    maybe_const! {
+        /// Creates a `Ratio` without checking for `denom == 0` or reducing.
+        #[inline]
+        pub fn new_raw(numer: T, denom: T) -> Ratio<T> {
+            Ratio {
+                numer: numer,
+                denom: denom,
+            }
+        }
+
+        /// Gets an immutable reference to the numerator.
+        #[inline]
+        pub fn numer(&self) -> &T {
+            &self.numer
+        }
+
+        /// Gets an immutable reference to the denominator.
+        #[inline]
+        pub fn denom(&self) -> &T {
+            &self.denom
+        }
+    }
+}
+
 impl<T: Clone + Integer> Ratio<T> {
     /// Creates a new `Ratio`. Fails if `denom` is zero.
     #[inline]
@@ -86,33 +122,12 @@ impl<T: Clone + Integer> Ratio<T> {
         Ratio::new_raw(t, One::one())
     }
 
-    /// Creates a `Ratio` without checking for `denom == 0` or reducing.
-    #[inline]
-    pub fn new_raw(numer: T, denom: T) -> Ratio<T> {
-        Ratio {
-            numer: numer,
-            denom: denom,
-        }
-    }
-
     /// Converts to an integer, rounding towards zero.
     #[inline]
     pub fn to_integer(&self) -> T {
         self.trunc().numer
     }
 
-    /// Gets an immutable reference to the numerator.
-    #[inline]
-    pub fn numer<'a>(&'a self) -> &'a T {
-        &self.numer
-    }
-
-    /// Gets an immutable reference to the denominator.
-    #[inline]
-    pub fn denom<'a>(&'a self) -> &'a T {
-        &self.denom
-    }
-
     /// Returns true if the rational number is an integer (denominator is 1).
     #[inline]
     pub fn is_integer(&self) -> bool {
@@ -2071,4 +2086,19 @@ mod test {
         r.set_one();
         assert!(r.is_one());
     }
+
+    #[cfg(has_const_fn)]
+    #[test]
+    fn test_const() {
+        const N: Ratio<i32> = Ratio::new_raw(123, 456);
+        const N_NUMER: &i32 = N.numer();
+        const N_DENOM: &i32 = N.denom();
+
+        assert_eq!(N_NUMER, &123);
+        assert_eq!(N_DENOM, &456);
+
+        let r = N.reduced();
+        assert_eq!(r.numer(), &(123 / 3));
+        assert_eq!(r.denom(), &(456 / 3));
+    }
 }