Associated constants are now in the language proper.

The feature gate is no longer required and the constants can be used.
This commit is contained in:
2018-01-05 00:08:54 -05:00
parent 3725a5d9d0
commit 1250e46066
5 changed files with 99 additions and 55 deletions

View File

@ -4,19 +4,11 @@ use std::{u8, u16, u32, u64, usize, i8, i16, i32, i64, isize, f32, f64};
/// Primitive types that have upper and lower bounds.
pub trait Bounded
{
// TODO: I would love for this to be associated consts, but
// they are not currently working inside macros.
// It causes rust's stack to explode.
// Check this on later versions of rustc.
//
// Last version checked: rustc v1.3.0
/// The minimum value for this type.
//const MIN: Self;
fn min_value() -> Self;
const MIN: Self;
/// The maximum value for this type.
//const MAX: Self;
fn max_value() -> Self;
const MAX: Self;
}
@ -28,34 +20,83 @@ macro_rules! bounded_trait_impl
{
impl Bounded for $T
{
//const MIN: $T = $minVal;
fn min_value() -> $T
{
$minVal
}
const MIN: $T = $minVal;
//const MAX: $T = $maxVal;
fn max_value() -> $T
{
$maxVal
}
const MAX: $T = $maxVal;
}
}
}
// Implement the Bounded for all the primitive types.
bounded_trait_impl!(u8, u8::MIN, u8::MAX);
bounded_trait_impl!(u16, u16::MIN, u16::MAX);
bounded_trait_impl!(u32, u32::MIN, u32::MAX);
bounded_trait_impl!(u64, u64::MIN, u64::MAX);
bounded_trait_impl!(usize, usize::MIN, usize::MAX);
bounded_trait_impl!(u8, 0u8, !0u8);
bounded_trait_impl!(u16, 0u16, !0u16);
bounded_trait_impl!(u32, 0u32, !0u32);
bounded_trait_impl!(u64, 0u64, !0u64);
bounded_trait_impl!(usize, 0usize, !0usize);
bounded_trait_impl!(i8, i8::MIN, i8::MAX);
bounded_trait_impl!(i16, i16::MIN, i16::MAX);
bounded_trait_impl!(i32, i32::MIN, i32::MAX);
bounded_trait_impl!(i64, i64::MIN, i64::MAX);
bounded_trait_impl!(isize, isize::MIN, isize::MAX);
bounded_trait_impl!(i8, (!0i8 ^ (!0u8 >> 1u8) as i8),
!(!0i8 ^ (!0u8 >> 1u8) as i8));
bounded_trait_impl!(i16, (!0i16 ^ (!0u16 >> 1u16) as i16),
!(!0i16 ^ (!0u16 >> 1u16) as i16));
bounded_trait_impl!(i32, (!0i32 ^ (!0u32 >> 1u32) as i32),
!(!0i32 ^ (!0u32 >> 1u32) as i32));
bounded_trait_impl!(i64, (!0i64 ^ (!0u64 >> 1u64) as i64),
!(!0i64 ^ (!0u64 >> 1u64) as i64));
bounded_trait_impl!(isize, (!0isize ^ (!0usize >> 1usize) as isize),
!(!0isize ^ (!0usize >> 1usize) as isize));
bounded_trait_impl!(f32, f32::MIN, f32::MAX);
bounded_trait_impl!(f64, f64::MIN, f64::MAX);
bounded_trait_impl!(f32, -3.40282347e+38f32, 3.40282347e+38f32);
bounded_trait_impl!(f64, -1.7976931348623157e+308f64,
1.7976931348623157e+308f64);
#[cfg(test)]
mod tests
{
macro_rules! bounds_test
{
($T: ident, $func_name: ident, $minVal: expr, $maxVal: expr) =>
{
#[test]
fn $func_name()
{
use bounded::Bounded;
assert_eq!($T::MIN, $minVal);
assert_eq!($T::MAX, $maxVal);
}
}
}
bounds_test!(u8, min_max_u8, 0u8, !0u8);
bounds_test!(u16, min_max_u16, 0u16, !0u16);
bounds_test!(u32, min_max_u32, 0u32, !0u32);
bounds_test!(u64, min_max_u64, 0u64, !0u64);
bounds_test!(usize, min_max_usize, 0usize, !0usize);
bounds_test!(i8, min_max_i8,
-1i8 << (((::std::mem::size_of::<i8>() as i8)*8i8)-1i8),
!(-1i8 << (((::std::mem::size_of::<i8>() as i8)*8i8)-1i8)));
bounds_test!(i16, min_max_i16,
-1i16 << (((::std::mem::size_of::<i16>() as i16)*8i16)-1i16),
!(-1i16 << (((::std::mem::size_of::<i16>() as i16)*8i16)-1i16)));
bounds_test!(i32, min_max_i32,
-1i32 << (((::std::mem::size_of::<i32>() as i32)*8i32)-1i32),
!(-1i32 << (((::std::mem::size_of::<i32>() as i32)*8i32)-1i32)));
bounds_test!(i64, min_max_i64,
-1i64 << (((::std::mem::size_of::<i64>() as i64)*8i64)-1i64),
!(-1i64 << (((::std::mem::size_of::<i64>() as i64)*8i64)-1i64)));
bounds_test!(isize, min_max_isize,
-1isize << (((::std::mem::size_of::<isize>() as isize)*8isize)-1isize),
!(-1isize << (((::std::mem::size_of::<isize>() as isize)*8isize)-1isize)));
bounds_test!(f32, min_max_f32,
-3.40282347e+38f32, 3.40282347e+38f32);
bounds_test!(f64, min_max_f64,
-1.7976931348623157e+308f64,
1.7976931348623157e+308f64);
}