Introduce the std feature

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

Author: cuviper

Cargo.toml

@@ -14,7 +14,13 @@ readme = "README.md"
 [dependencies]
 
 [dependencies.num-integer]
-version = "0.1.32"
+version = "0.1.36"
+default-features = false
 
 [dependencies.num-traits]
-version = "0.1.32"
+version = "0.2.0"
+default-features = false
+
+[features]
+default = ["std"]
+std = []

README.md

@@ -22,6 +22,20 @@ and this to your crate root:
 extern crate num_iter;
 ```
 
+## 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-iter]
+version = "0.1.35"
+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-iter` crate is tested for rustc 1.8 and greater.

ci/test_full.sh

@@ -8,4 +8,6 @@ echo Testing num-iter 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,12 +16,16 @@
 
 #![doc(html_root_url = "https://docs.rs/num-iter/0.1")]
 
+#![cfg_attr(not(feature = "std"), no_std)]
+#[cfg(feature = "std")]
+extern crate core;
+
 extern crate num_traits as traits;
 extern crate num_integer as integer;
 
 use integer::Integer;
 use traits::{Zero, One, CheckedAdd, ToPrimitive};
-use std::ops::{Add, Sub};
+use core::ops::{Add, Sub};
 
 /// An iterator over the range [start, stop)
 #[derive(Clone)]
@@ -266,9 +270,10 @@ impl<A> Iterator for RangeStepInclusive<A>
 
 #[cfg(test)]
 mod tests {
-    use std::usize;
-    use std::ops::{Add, Mul};
-    use std::cmp::Ordering;
+    use core::usize;
+    use core::ops::{Add, Mul};
+    use core::cmp::Ordering;
+    use core::iter;
     use traits::{One, ToPrimitive};
 
     #[test]
@@ -321,10 +326,12 @@ mod tests {
             }
         }
 
-        assert!(super::range(0, 5).collect::<Vec<isize>>() == vec![0, 1, 2, 3, 4]);
-        assert!(super::range(-10, -1).collect::<Vec<isize>>() ==
-                vec![-10, -9, -8, -7, -6, -5, -4, -3, -2]);
-        assert!(super::range(0, 5).rev().collect::<Vec<isize>>() == vec![4, 3, 2, 1, 0]);
+        assert!(super::range(0, 5)
+                .eq([0, 1, 2, 3, 4].iter().cloned()));
+        assert!(super::range(-10, -1)
+                .eq([-10, -9, -8, -7, -6, -5, -4, -3, -2].iter().cloned()));
+        assert!(super::range(0, 5).rev()
+                .eq([4, 3, 2, 1, 0].iter().cloned()));
         assert_eq!(super::range(200, -5).count(), 0);
         assert_eq!(super::range(200, -5).rev().count(), 0);
         assert_eq!(super::range(200, 200).count(), 0);
@@ -338,43 +345,47 @@ mod tests {
 
     #[test]
     fn test_range_inclusive() {
-        assert!(super::range_inclusive(0, 5).collect::<Vec<isize>>() ==
-                vec![0, 1, 2, 3, 4, 5]);
-        assert!(super::range_inclusive(0, 5).rev().collect::<Vec<isize>>() ==
-                vec![5, 4, 3, 2, 1, 0]);
+        assert!(super::range_inclusive(0, 5)
+                .eq([0, 1, 2, 3, 4, 5].iter().cloned()));
+        assert!(super::range_inclusive(0, 5).rev()
+                .eq([5, 4, 3, 2, 1, 0].iter().cloned()));
         assert_eq!(super::range_inclusive(200, -5).count(), 0);
         assert_eq!(super::range_inclusive(200, -5).rev().count(), 0);
-        assert!(super::range_inclusive(200, 200).collect::<Vec<isize>>() == vec![200]);
-        assert!(super::range_inclusive(200, 200).rev().collect::<Vec<isize>>() == vec![200]);
+        assert!(super::range_inclusive(200, 200)
+                .eq(iter::once(200)));
+        assert!(super::range_inclusive(200, 200).rev()
+                .eq(iter::once(200)));
     }
 
     #[test]
     fn test_range_step() {
-        assert!(super::range_step(0, 20, 5).collect::<Vec<isize>>() ==
-                vec![0, 5, 10, 15]);
-        assert!(super::range_step(20, 0, -5).collect::<Vec<isize>>() ==
-                vec![20, 15, 10, 5]);
-        assert!(super::range_step(20, 0, -6).collect::<Vec<isize>>() ==
-                vec![20, 14, 8, 2]);
-        assert!(super::range_step(200u8, 255, 50).collect::<Vec<u8>>() ==
-                vec![200u8, 250]);
-        assert!(super::range_step(200, -5, 1).collect::<Vec<isize>>() == vec![]);
-        assert!(super::range_step(200, 200, 1).collect::<Vec<isize>>() == vec![]);
+        assert!(super::range_step(0, 20, 5)
+                .eq([0, 5, 10, 15].iter().cloned()));
+        assert!(super::range_step(20, 0, -5)
+                .eq([20, 15, 10, 5].iter().cloned()));
+        assert!(super::range_step(20, 0, -6)
+                .eq([20, 14, 8, 2].iter().cloned()));
+        assert!(super::range_step(200u8, 255, 50)
+                .eq([200u8, 250].iter().cloned()));
+        assert!(super::range_step(200, -5, 1)
+                .eq(iter::empty()));
+        assert!(super::range_step(200, 200, 1)
+                .eq(iter::empty()));
     }
 
     #[test]
     fn test_range_step_inclusive() {
-        assert!(super::range_step_inclusive(0, 20, 5).collect::<Vec<isize>>() ==
-                vec![0, 5, 10, 15, 20]);
-        assert!(super::range_step_inclusive(20, 0, -5).collect::<Vec<isize>>() ==
-                vec![20, 15, 10, 5, 0]);
-        assert!(super::range_step_inclusive(20, 0, -6).collect::<Vec<isize>>() ==
-                vec![20, 14, 8, 2]);
-        assert!(super::range_step_inclusive(200u8, 255, 50).collect::<Vec<u8>>() ==
-                vec![200u8, 250]);
-        assert!(super::range_step_inclusive(200, -5, 1).collect::<Vec<isize>>() ==
-                vec![]);
-        assert!(super::range_step_inclusive(200, 200, 1).collect::<Vec<isize>>() ==
-                vec![200]);
+        assert!(super::range_step_inclusive(0, 20, 5)
+                .eq([0, 5, 10, 15, 20].iter().cloned()));
+        assert!(super::range_step_inclusive(20, 0, -5)
+                .eq([20, 15, 10, 5, 0].iter().cloned()));
+        assert!(super::range_step_inclusive(20, 0, -6)
+                .eq([20, 14, 8, 2].iter().cloned()));
+        assert!(super::range_step_inclusive(200u8, 255, 50)
+                .eq([200u8, 250].iter().cloned()));
+        assert!(super::range_step_inclusive(200, -5, 1)
+                .eq(iter::empty()));
+        assert!(super::range_step_inclusive(200, 200, 1)
+                .eq(iter::once(200)));
     }
 }