Introduce the std feature

So far, it only toggles whether to build with `#![no_std]`.

Author: cuviper

Cargo.toml

@@ -12,4 +12,9 @@ version = "0.1.35"
 readme = "README.md"
 
 [dependencies.num-traits]
-version = "0.1.32"
+version = "0.2.0"
+default-features = false
+
+[features]
+default = ["std"]
+std = ["num-traits/std"]

README.md

@@ -22,6 +22,20 @@ and this to your crate root:
 extern crate num_integer;
 ```
 
+## Features
+
+This crate can be used without the standard library (`#![no_std]`) by disabling
+the default `std` feature.  Use this in `Cargo.toml`:
+
+```toml
+[dependencies.num-integer]
+version = "0.1.36"
+default-features = false
+```
+
+There is no functional difference with and without `std` at this time, but
+there may be in the future.
+
 ## Compatibility
 
 The `num-integer` crate is tested for rustc 1.8 and greater.

ci/test_full.sh

@@ -8,4 +8,6 @@ echo Testing num-integer on rustc ${TRAVIS_RUST_VERSION}
 cargo build --verbose
 cargo test --verbose
 
-# We have no features to test...
+# test `no_std`
+cargo build --verbose --no-default-features
+cargo test --verbose --no-default-features

src/lib.rs

@@ -16,9 +16,14 @@
 
 #![doc(html_root_url = "https://docs.rs/num-integer/0.1")]
 
+#![cfg_attr(not(feature = "std"), no_std)]
+#[cfg(feature = "std")]
+extern crate core;
+
 extern crate num_traits as traits;
 
-use std::ops::Add;
+use core::ops::Add;
+use core::mem;
 
 use traits::{Num, Signed};
 
@@ -271,7 +276,7 @@ macro_rules! impl_integer_for_isize {
 
                 while m != 0 {
                     m >>= m.trailing_zeros();
-                    if n > m { ::std::mem::swap(&mut n, &mut m) }
+                    if n > m { mem::swap(&mut n, &mut m) }
                     m -= n;
                 }
 
@@ -316,6 +321,7 @@ macro_rules! impl_integer_for_isize {
         #[cfg(test)]
         mod $test_mod {
             use Integer;
+            use core::mem;
 
             /// Checks that the division rule holds for:
             ///
@@ -393,7 +399,7 @@ macro_rules! impl_integer_for_isize {
             fn test_gcd_cmp_with_euclidean() {
                 fn euclidean_gcd(mut m: $T, mut n: $T) -> $T {
                     while m != 0 {
-                        ::std::mem::swap(&mut m, &mut n);
+                        mem::swap(&mut m, &mut n);
                         m %= n;
                     }
 
@@ -530,7 +536,7 @@ macro_rules! impl_integer_for_usize {
 
                 while m != 0 {
                     m >>= m.trailing_zeros();
-                    if n > m { ::std::mem::swap(&mut n, &mut m) }
+                    if n > m { mem::swap(&mut n, &mut m) }
                     m -= n;
                 }
 
@@ -577,6 +583,7 @@ macro_rules! impl_integer_for_usize {
         #[cfg(test)]
         mod $test_mod {
             use Integer;
+            use core::mem;
 
             #[test]
             fn test_div_mod_floor() {
@@ -604,7 +611,7 @@ macro_rules! impl_integer_for_usize {
             fn test_gcd_cmp_with_euclidean() {
                 fn euclidean_gcd(mut m: $T, mut n: $T) -> $T {
                     while m != 0 {
-                        ::std::mem::swap(&mut m, &mut n);
+                        mem::swap(&mut m, &mut n);
                         m %= n;
                     }
                     n
@@ -821,9 +828,10 @@ fn test_iter_binomial() {
     macro_rules! check_simple {
         ($t:ty) => { {
             let n: $t = 3;
-            let c: Vec<_> = IterBinomial::new(n).collect();
-            let expected = vec![1, 3, 3, 1];
-            assert_eq!(c, expected);
+            let expected = [1, 3, 3, 1];
+            for (b, &e) in IterBinomial::new(n).zip(&expected) {
+                assert_eq!(b, e);
+            }
         } }
     }
 
@@ -839,9 +847,8 @@ fn test_iter_binomial() {
     macro_rules! check_binomial {
         ($t:ty, $n:expr) => { {
             let n: $t = $n;
-            let c: Vec<_> = IterBinomial::new(n).collect();
             let mut k: $t = 0;
-            for b in c {
+            for b in IterBinomial::new(n) {
                 assert_eq!(b, binomial(n, k));
                 k += 1;
             }