Merge #416

416: Migration to 2018 edition. r=jswrenn a=orium



Co-authored-by: Diogo Sousa <[email protected]>

Author: bors[bot]

Cargo.toml

@@ -13,6 +13,8 @@ keywords = ["iterator", "data-structure", "zip", "product", "group-by"]
 categories = ["algorithms", "rust-patterns"]
 exclude = ["/bors.toml"]
 
+edition = "2018"
+
 [package.metadata.release]
 no-dev-version = true
 

README.rst

@@ -27,8 +27,6 @@ How to use in your crate:
 
 .. code:: rust
 
-    #[macro_use] extern crate itertools;
-
     use itertools::Itertools;
 
 How to contribute

benches/bench1.rs

@@ -1,17 +1,15 @@
-extern crate criterion;
-#[macro_use] extern crate itertools;
-
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use itertools::Itertools;
 use itertools::free::cloned;
+use itertools::iproduct;
 
 use std::iter::repeat;
 use std::cmp;
 use std::ops::{Add, Range};
 
 mod extra;
 
-use extra::ZipSlices;
+use crate::extra::ZipSlices;
 
 fn slice_iter(c: &mut Criterion) {
     let xs: Vec<_> = repeat(1i32).take(20).collect();

benches/combinations_with_replacement.rs

@@ -1,6 +1,3 @@
-extern crate criterion;
-extern crate itertools;
-
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use itertools::Itertools;
 

benches/fold_specialization.rs

@@ -1,6 +1,3 @@
-extern crate criterion;
-extern crate itertools;
-
 use criterion::{criterion_group, criterion_main, Criterion};
 use itertools::Itertools;
 

benches/tree_fold1.rs

@@ -1,6 +1,3 @@
-extern crate criterion;
-extern crate itertools;
-
 use criterion::{criterion_group, criterion_main, Criterion};
 use itertools::{Itertools, cloned};
 

benches/tuple_combinations.rs

@@ -1,6 +1,3 @@
-extern crate criterion;
-extern crate itertools;
-
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use itertools::Itertools;
 

benches/tuples.rs

@@ -1,6 +1,3 @@
-extern crate criterion;
-extern crate itertools;
-
 use criterion::{criterion_group, criterion_main, Criterion};
 use itertools::Itertools;
 

examples/iris.rs

@@ -3,10 +3,6 @@
 /// and does some simple manipulations.
 ///
 /// Iterators and itertools functionality are used throughout.
-///
-///
-
-extern crate itertools;
 
 use itertools::Itertools;
 use std::collections::HashMap;

src/adaptors/mod.rs

@@ -12,7 +12,7 @@ use std::fmt;
 use std::mem::replace;
 use std::iter::{Fuse, Peekable, FromIterator};
 use std::marker::PhantomData;
-use size_hint;
+use crate::size_hint;
 
 /// An iterator adaptor that alternates elements from two iterators until both
 /// run out.

src/adaptors/multi_product.rs

@@ -1,7 +1,7 @@
 #![cfg(feature = "use_std")]
 
-use size_hint;
-use Itertools;
+use crate::size_hint;
+use crate::Itertools;
 
 #[derive(Clone)]
 /// An iterator adaptor that iterates over the cartesian product of

src/concat_impl.rs

@@ -1,4 +1,4 @@
-use Itertools;
+use crate::Itertools;
 
 /// Combine all an iterator's elements into one element by using `Extend`.
 ///

src/diff.rs

@@ -5,8 +5,8 @@
 //! describes the difference between two non-`Clone` iterators `I` and `J` after breaking ASAP from
 //! a lock-step comparison.
 
-use free::put_back;
-use structs::PutBack;
+use crate::free::put_back;
+use crate::structs::PutBack;
 
 /// A type returned by the [`diff_with`](./fn.diff_with.html) function.
 ///

src/either_or_both.rs

@@ -1,4 +1,4 @@
-use EitherOrBoth::*;
+use crate::EitherOrBoth::*;
 
 use either::Either;
 

src/exactly_one_err.rs

@@ -1,6 +1,6 @@
 use std::iter::ExactSizeIterator;
 
-use size_hint;
+use crate::size_hint;
 
 /// Iterator returned for the error case of `IterTools::exactly_one()`
 /// This iterator yields exactly the same elements as the input iterator.

src/free.rs

@@ -10,23 +10,23 @@ use std::iter::{self, Zip};
 type VecIntoIter<T> = ::std::vec::IntoIter<T>;
 
 #[cfg(feature = "use_std")]
-use Itertools;
+use crate::Itertools;
 
-pub use adaptors::{
+pub use crate::adaptors::{
     interleave,
     merge,
     put_back,
 };
 #[cfg(feature = "use_std")]
-pub use put_back_n_impl::put_back_n;
+pub use crate::put_back_n_impl::put_back_n;
 #[cfg(feature = "use_std")]
-pub use multipeek_impl::multipeek;
+pub use crate::multipeek_impl::multipeek;
 #[cfg(feature = "use_std")]
-pub use kmerge_impl::kmerge;
-pub use zip_eq_impl::zip_eq;
-pub use merge_join::merge_join_by;
+pub use crate::kmerge_impl::kmerge;
+pub use crate::zip_eq_impl::zip_eq;
+pub use crate::merge_join::merge_join_by;
 #[cfg(feature = "use_std")]
-pub use rciter_impl::rciter;
+pub use crate::rciter_impl::rciter;
 
 /// Iterate `iterable` with a running index.
 ///

src/kmerge_impl.rs

@@ -1,6 +1,5 @@
-
-use size_hint;
-use Itertools;
+use crate::size_hint;
+use crate::Itertools;
 
 use std::mem::replace;
 use std::fmt;

src/lib.rs

@@ -47,8 +47,6 @@
 //! [`Iterator`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html
 #![doc(html_root_url="https://docs.rs/itertools/0.8/")]
 
-extern crate either;
-
 #[cfg(not(feature = "use_std"))]
 extern crate core as std;
 
@@ -77,7 +75,7 @@ pub use std::iter as __std_iter;
 
 /// The concrete iterator types.
 pub mod structs {
-    pub use adaptors::{
+    pub use crate::adaptors::{
         Dedup,
         DedupBy,
         Interleave,
@@ -97,75 +95,75 @@ pub mod structs {
         Update,
     };
     #[allow(deprecated)]
-    pub use adaptors::Step;
+    pub use crate::adaptors::Step;
     #[cfg(feature = "use_std")]
-    pub use adaptors::MultiProduct;
+    pub use crate::adaptors::MultiProduct;
     #[cfg(feature = "use_std")]
-    pub use combinations::Combinations;
+    pub use crate::combinations::Combinations;
     #[cfg(feature = "use_std")]
-    pub use combinations_with_replacement::CombinationsWithReplacement;
-    pub use cons_tuples_impl::ConsTuples;
-    pub use exactly_one_err::ExactlyOneError;
-    pub use format::{Format, FormatWith};
+    pub use crate::combinations_with_replacement::CombinationsWithReplacement;
+    pub use crate::cons_tuples_impl::ConsTuples;
+    pub use crate::exactly_one_err::ExactlyOneError;
+    pub use crate::format::{Format, FormatWith};
     #[cfg(feature = "use_std")]
-    pub use groupbylazy::{IntoChunks, Chunk, Chunks, GroupBy, Group, Groups};
-    pub use intersperse::Intersperse;
+    pub use crate::groupbylazy::{IntoChunks, Chunk, Chunks, GroupBy, Group, Groups};
+    pub use crate::intersperse::Intersperse;
     #[cfg(feature = "use_std")]
-    pub use kmerge_impl::{KMerge, KMergeBy};
-    pub use merge_join::MergeJoinBy;
+    pub use crate::kmerge_impl::{KMerge, KMergeBy};
+    pub use crate::merge_join::MergeJoinBy;
     #[cfg(feature = "use_std")]
-    pub use multipeek_impl::MultiPeek;
-    pub use pad_tail::PadUsing;
-    pub use peeking_take_while::PeekingTakeWhile;
+    pub use crate::multipeek_impl::MultiPeek;
+    pub use crate::pad_tail::PadUsing;
+    pub use crate::peeking_take_while::PeekingTakeWhile;
     #[cfg(feature = "use_std")]
-    pub use permutations::Permutations;
-    pub use process_results_impl::ProcessResults;
+    pub use crate::permutations::Permutations;
+    pub use crate::process_results_impl::ProcessResults;
     #[cfg(feature = "use_std")]
-    pub use put_back_n_impl::PutBackN;
+    pub use crate::put_back_n_impl::PutBackN;
     #[cfg(feature = "use_std")]
-    pub use rciter_impl::RcIter;
-    pub use repeatn::RepeatN;
+    pub use crate::rciter_impl::RcIter;
+    pub use crate::repeatn::RepeatN;
     #[allow(deprecated)]
-    pub use sources::{RepeatCall, Unfold, Iterate};
+    pub use crate::sources::{RepeatCall, Unfold, Iterate};
     #[cfg(feature = "use_std")]
-    pub use tee::Tee;
-    pub use tuple_impl::{TupleBuffer, TupleWindows, Tuples};
+    pub use crate::tee::Tee;
+    pub use crate::tuple_impl::{TupleBuffer, TupleWindows, Tuples};
     #[cfg(feature = "use_std")]
-    pub use unique_impl::{Unique, UniqueBy};
-    pub use with_position::WithPosition;
-    pub use zip_eq_impl::ZipEq;
-    pub use zip_longest::ZipLongest;
-    pub use ziptuple::Zip;
+    pub use crate::unique_impl::{Unique, UniqueBy};
+    pub use crate::with_position::WithPosition;
+    pub use crate::zip_eq_impl::ZipEq;
+    pub use crate::zip_longest::ZipLongest;
+    pub use crate::ziptuple::Zip;
 }
 
 /// Traits helpful for using certain `Itertools` methods in generic contexts.
 pub mod traits {
-    pub use ::tuple_impl::HomogeneousTuple;
+    pub use crate::tuple_impl::HomogeneousTuple;
 }
 
 #[allow(deprecated)]
-pub use structs::*;
-pub use concat_impl::concat;
-pub use cons_tuples_impl::cons_tuples;
-pub use diff::diff_with;
-pub use diff::Diff;
+pub use crate::structs::*;
+pub use crate::concat_impl::concat;
+pub use crate::cons_tuples_impl::cons_tuples;
+pub use crate::diff::diff_with;
+pub use crate::diff::Diff;
 #[cfg(feature = "use_std")]
-pub use kmerge_impl::{kmerge_by};
-pub use minmax::MinMaxResult;
-pub use peeking_take_while::PeekingNext;
-pub use process_results_impl::process_results;
-pub use repeatn::repeat_n;
+pub use crate::kmerge_impl::{kmerge_by};
+pub use crate::minmax::MinMaxResult;
+pub use crate::peeking_take_while::PeekingNext;
+pub use crate::process_results_impl::process_results;
+pub use crate::repeatn::repeat_n;
 #[allow(deprecated)]
-pub use sources::{repeat_call, unfold, iterate};
-pub use with_position::Position;
-pub use ziptuple::multizip;
+pub use crate::sources::{repeat_call, unfold, iterate};
+pub use crate::with_position::Position;
+pub use crate::ziptuple::multizip;
 mod adaptors;
 mod either_or_both;
-pub use either_or_both::EitherOrBoth;
+pub use crate::either_or_both::EitherOrBoth;
 #[doc(hidden)]
 pub mod free;
 #[doc(inline)]
-pub use free::*;
+pub use crate::free::*;
 mod concat_impl;
 mod cons_tuples_impl;
 #[cfg(feature = "use_std")]
@@ -217,7 +215,8 @@ mod ziptuple;
 /// from iterators `(I, J, ..., M)` with element types `I::Item = A`, `J::Item = B`, etc.
 ///
 /// ```
-/// #[macro_use] extern crate itertools;
+/// # use itertools::iproduct;
+/// #
 /// # fn main() {
 /// // Iterate over the coordinates of a 4 x 4 x 4 grid
 /// // from (0, 0, 0), (0, 0, 1), .., (0, 1, 0), (0, 1, 1), .. etc until (3, 3, 3)
@@ -226,14 +225,6 @@ mod ziptuple;
 /// }
 /// # }
 /// ```
-///
-/// **Note:** To enable the macros in this crate, use the `#[macro_use]`
-/// attribute when importing the crate:
-///
-/// ```
-/// #[macro_use] extern crate itertools;
-/// # fn main() { }
-/// ```
 macro_rules! iproduct {
     (@flatten $I:expr,) => (
         $I
@@ -274,7 +265,8 @@ macro_rules! iproduct {
 /// [`multizip`]: fn.multizip.html
 ///
 /// ```
-/// #[macro_use] extern crate itertools;
+/// # use itertools::izip;
+/// #
 /// # fn main() {
 ///
 /// // iterate over three sequences side-by-side
@@ -288,14 +280,6 @@ macro_rules! iproduct {
 /// assert_eq!(results, [0 + 3, 10 + 7, 29, 36]);
 /// # }
 /// ```
-///
-/// **Note:** To enable the macros in this crate, use the `#[macro_use]`
-/// attribute when importing the crate:
-///
-/// ```
-/// #[macro_use] extern crate itertools;
-/// # fn main() { }
-/// ```
 macro_rules! izip {
     // @closure creates a tuple-flattening closure for .map() call. usage:
     // @closure partial_pattern => partial_tuple , rest , of , iterators
@@ -2467,7 +2451,7 @@ pub trait Itertools : Iterator {
     fn position_minmax(self) -> MinMaxResult<usize>
         where Self: Sized, Self::Item: PartialOrd
     {
-        use MinMaxResult::{NoElements, OneElement, MinMax};
+        use crate::MinMaxResult::{NoElements, OneElement, MinMax};
         match minmax::minmax_impl(self.enumerate(), |_| (), |x, y, _, _| x.1 < y.1) {
             NoElements => NoElements,
             OneElement(x) => OneElement(x.0),
@@ -2513,7 +2497,7 @@ pub trait Itertools : Iterator {
     fn position_minmax_by_key<K, F>(self, mut key: F) -> MinMaxResult<usize>
         where Self: Sized, K: PartialOrd, F: FnMut(&Self::Item) -> K
     {
-        use MinMaxResult::{NoElements, OneElement, MinMax};
+        use crate::MinMaxResult::{NoElements, OneElement, MinMax};
         match self.enumerate().minmax_by_key(|e| key(&e.1)) {
             NoElements => NoElements,
             OneElement(x) => OneElement(x.0),
@@ -2556,7 +2540,7 @@ pub trait Itertools : Iterator {
     fn position_minmax_by<F>(self, mut compare: F) -> MinMaxResult<usize>
         where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering
     {
-        use MinMaxResult::{NoElements, OneElement, MinMax};
+        use crate::MinMaxResult::{NoElements, OneElement, MinMax};
         match self.enumerate().minmax_by(|x, y| compare(&x.1, &y.1)) {
             NoElements => NoElements,
             OneElement(x) => OneElement(x.0),

src/merge_join.rs

@@ -3,7 +3,7 @@ use std::iter::Fuse;
 use std::fmt;
 
 use super::adaptors::{PutBack, put_back};
-use either_or_both::EitherOrBoth;
+use crate::either_or_both::EitherOrBoth;
 
 /// Return an iterator adaptor that merge-joins items from the two base iterators in ascending order.
 ///