Created a trait and macro for implementing measurements the same way.

Author: James O'Cull

src/length/mod.rs

@@ -1,4 +1,4 @@
-mod traits;
+use super::measurement::*;
 
 // Constants, metric
 const METER_NANOMETER_FACTOR: f64 = 1000000000.0;
@@ -132,3 +132,15 @@ impl Length {
         self.meters * METER_MILE_FACTOR
     }
 }
+
+impl Measurement for Length {
+    fn get_base_units(&self) -> f64 {
+        self.meters
+    }
+    
+    fn from_base_units(units: f64) -> Self {
+        Self::from_meters(units)
+    }
+}
+
+implement_measurement! { Length }

src/length/traits.rs

@@ -1,5 +1,30 @@
-#[cfg(test)]
-mod tests;
+/// The `Measurement` trait and the `implement_measurement!` macro
+/// provides a common way for various measurements to be implemented.
+///
+/// # Example
+/// ```
+/// #[macro_use]
+/// use measurements::measurement::*;
+/// 
+/// struct Cubits {
+///     forearms: f64
+/// }
+/// 
+/// impl Measurement for Cubits {
+///     fn get_base_units(&self) -> f64 {
+///         self.forearms
+///     }
+///     
+///     fn from_base_units(units: f64) -> Self {
+///         Cubits { forearms: units }
+///     }
+/// }
+///
+/// // Invoke the macro to automatically implement Add, Sub, etc...
+/// // implement_measurement! { Cubits } // TODO: Fix doc tests to make this work...
+/// ```
+#[macro_use]
+pub mod measurement;
 
 /// The `Length` struct can be used to deal with lengths in a common way.
 /// Common metric and imperial units are supported.
@@ -31,3 +56,7 @@ pub mod length;
 
 #[allow(dead_code)]
 pub mod temperature;
+
+#[cfg(test)]
+#[macro_use]
+mod tests;

src/lib.rs

@@ -0,0 +1,87 @@
+pub trait Measurement {
+    fn get_base_units(&self) -> f64;
+    fn from_base_units(units: f64) -> Self;
+}
+
+#[macro_export]
+macro_rules! implement_measurement {
+    ($($t:ty)*) => ($(
+        // TODO: Find a better way to reference these...
+        use std::ops::{Add,Sub,Div,Mul};
+        use std::cmp::{Eq, PartialEq};
+        use std::cmp::{PartialOrd, Ordering};
+
+        impl Add for $t {
+            type Output = Self;
+            
+            fn add(self, rhs: Self) -> Self {
+                Self::from_base_units(self.get_base_units() + rhs.get_base_units())
+            }
+        }
+
+        impl Sub for $t {
+            type Output = Self;
+            
+            fn sub(self, rhs: Self) -> Self {
+                Self::from_base_units(self.get_base_units() - rhs.get_base_units())
+            }
+        }
+
+        /// 
+        /// Dividing a `$t` by another `$` returns a ratio.
+        /// 
+        impl Div<$t> for $t {
+            type Output = f64;
+            
+            fn div(self, rhs: Self) -> f64 {
+                self.get_base_units() / rhs.get_base_units()
+            }
+        }
+
+        /// 
+        /// Dividing a `$` by a factor returns a new portion of the measurement.
+        /// 
+        impl Div<f64> for $t {
+            type Output = Self;
+            
+            fn div(self, rhs: f64) -> Self {
+                Self::from_base_units(self.get_base_units() / rhs)
+            }
+        }
+
+        /// 
+        /// Multiplying a `$t` by another `$t` returns the product of those measurements.
+        /// 
+        impl Mul<$t> for $t {
+            type Output = Self;
+            
+            fn mul(self, rhs: Self) -> Self {
+                Self::from_base_units(self.get_base_units() * rhs.get_base_units())
+            }
+        }
+
+        /// 
+        /// Multiplying a `$t` by a factor increases (or decreases) that measurement a number of times.
+        /// 
+        impl Mul<f64> for $t {
+            type Output = Self;
+            
+            fn mul(self, rhs: f64) -> Self {
+                Self::from_base_units(self.get_base_units() * rhs)
+            }
+        }
+
+        impl Eq for $t { }
+        impl PartialEq for $t {
+            fn eq(&self, other: &Self) -> bool {
+                self.get_base_units() == other.get_base_units()
+            }
+        }
+
+        impl PartialOrd for $t {
+            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+                self.get_base_units().partial_cmp(&other.get_base_units())
+            }
+        }
+    )*)
+}

src/measurement/mod.rs

@@ -1,4 +1,4 @@
-mod traits;
+use super::measurement::*;
 
 /// The `Temperature` struct can be used to deal with temperatures in a common way.
 #[derive(Copy, Clone, Debug)]
@@ -39,3 +39,15 @@ impl Temperature {
         (self.kelvin - 273.15) * 1.8 + 491.67
     }
 }
+
+impl Measurement for Temperature {
+    fn get_base_units(&self) -> f64 {
+        self.kelvin
+    }
+    
+    fn from_base_units(units: f64) -> Self {
+        Self::from_kelvin(units)
+    }
+}
+
+implement_measurement! { Temperature }