Merge #463

463: rename rayon::iter::internal to rayon::iter::plumbing r=cuviper a=lvillani

This should fix #415.

src/collections/binary_heap.rs

@@ -5,7 +5,7 @@
 use std::collections::BinaryHeap;
 
 use iter::*;
-use iter::internal::*;
+use iter::plumbing::*;
 
 use vec;
 

src/collections/btree_map.rs

@@ -5,7 +5,7 @@
 use std::collections::BTreeMap;
 
 use iter::*;
-use iter::internal::*;
+use iter::plumbing::*;
 
 use vec;
 

src/collections/btree_set.rs

@@ -5,7 +5,7 @@
 use std::collections::BTreeSet;
 
 use iter::*;
-use iter::internal::*;
+use iter::plumbing::*;
 
 use vec;
 

src/collections/hash_map.rs

@@ -6,7 +6,7 @@ use std::collections::HashMap;
 use std::hash::{Hash, BuildHasher};
 
 use iter::*;
-use iter::internal::*;
+use iter::plumbing::*;
 
 use vec;
 

src/collections/hash_set.rs

@@ -6,7 +6,7 @@ use std::collections::HashSet;
 use std::hash::{Hash, BuildHasher};
 
 use iter::*;
-use iter::internal::*;
+use iter::plumbing::*;
 
 use vec;
 

src/collections/linked_list.rs

@@ -5,7 +5,7 @@
 use std::collections::LinkedList;
 
 use iter::*;
-use iter::internal::*;
+use iter::plumbing::*;
 
 use vec;
 

src/collections/vec_deque.rs

@@ -5,7 +5,7 @@
 use std::collections::VecDeque;
 
 use iter::*;
-use iter::internal::*;
+use iter::plumbing::*;
 
 use slice;
 use vec;

src/iter/chain.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 use std::cmp;
 use std::iter;

src/iter/cloned.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 use std::iter;

src/iter/collect/consumer.rs

@@ -1,4 +1,4 @@
-use super::super::internal::*;
+use super::super::plumbing::*;
 use super::super::noop::*;
 use std::ptr;
 use std::slice;

src/iter/collect/test.rs

@@ -5,7 +5,7 @@
 // try to drive the "collect consumer" incorrectly. These should
 // result in panics.
 
-use iter::internal::*;
+use iter::plumbing::*;
 use super::Collect;
 
 /// Promises to produce 2 items, but then produces 3.  Does not do any

src/iter/empty.rs

@@ -1,4 +1,4 @@
-use iter::internal::*;
+use iter::plumbing::*;
 use iter::*;
 
 use std;

src/iter/enumerate.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 use std::iter;
 use std::ops::Range;

src/iter/filter.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 use std::fmt::{self, Debug};

src/iter/filter_map.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 use std::fmt::{self, Debug};

src/iter/find.rs

@@ -1,5 +1,5 @@
 use std::sync::atomic::{AtomicBool, Ordering};
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 pub fn find<I, P>(pi: I, find_op: P) -> Option<I::Item>

src/iter/find_first_last/mod.rs

@@ -1,6 +1,6 @@
 use std::cell::Cell;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 #[cfg(test)]

src/iter/flat_map.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 use std::fmt::{self, Debug};

src/iter/flatten.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 /// `Flatten` turns each element to an iterator, then flattens these iterators

src/iter/fold.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 use std::fmt::{self, Debug};

src/iter/for_each.rs

@@ -1,5 +1,5 @@
 use super::ParallelIterator;
-use super::internal::*;
+use super::plumbing::*;
 use super::noop::*;
 
 pub fn for_each<I, F, T>(pi: I, op: &F)

src/iter/inspect.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 use std::fmt::{self, Debug};

src/iter/interleave.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 use std::cmp;
 use std::iter::Fuse;

src/iter/interleave_shortest.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 /// `InterleaveShortest` is an iterator that works similarly to

src/iter/intersperse.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 use std::cell::Cell;
 use std::iter::Fuse;

src/iter/len.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 use std::cmp;
 

src/iter/map.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 use std::fmt::{self, Debug};

src/iter/map_with.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 use std::fmt::{self, Debug};

src/iter/mod.rs

@@ -6,14 +6,14 @@
 //!
 //! The submodules of this module mostly just contain implementaton
 //! details of little interest to an end-user. If you'd like to read
-//! the code itself, the `internal` module and `README.md` file are a
+//! the code itself, the `plumbing` module and `README.md` file are a
 //! good place to start.
 
 pub use either::Either;
 use std::cmp::{self, Ordering};
 use std::iter::{Sum, Product};
 use std::ops::Fn;
-use self::internal::*;
+use self::plumbing::*;
 
 // There is a method to the madness here:
 //
@@ -42,7 +42,7 @@ pub use self::flat_map::FlatMap;
 mod flatten;
 pub use self::flatten::Flatten;
 mod from_par_iter;
-pub mod internal;
+pub mod plumbing;
 mod for_each;
 mod fold;
 pub use self::fold::{Fold, FoldWith};

src/iter/noop.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 
 pub struct NoopConsumer;
 

src/iter/once.rs

@@ -1,4 +1,4 @@
-use iter::internal::*;
+use iter::plumbing::*;
 use iter::*;
 
 /// Creates a parallel iterator that produces an element exactly once.

src/iter/internal.rs → src/iter/plumbing.rs

@@ -1,7 +1,6 @@
-//! Internal traits and functions used to implement parallel
-//! iteration. These should be considered highly unstable: users of
-//! parallel iterators should not need to interact with them directly.
-//! See `README.md` for a high-level overview.
+//! Traits and functions used to implement parallel iteration.  These are
+//! low-level details -- users of parallel iterators should not need to
+//! interact with them directly.  See `README.md` for a high-level overview.
 
 use join_context;
 

src/iter/product.rs

@@ -1,5 +1,5 @@
 use super::ParallelIterator;
-use super::internal::*;
+use super::plumbing::*;
 
 use std::iter::{self, Product};
 use std::marker::PhantomData;

src/iter/reduce.rs

@@ -1,5 +1,5 @@
 use super::ParallelIterator;
-use super::internal::*;
+use super::plumbing::*;
 
 pub fn reduce<PI, R, ID, T>(pi: PI, identity: ID, reduce_op: R) -> T
     where PI: ParallelIterator<Item = T>,

src/iter/repeat.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 use std::iter;
 use std::usize;

src/iter/rev.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 use std::iter;
 

src/iter/skip.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 use super::noop::NoopConsumer;
 use std::cmp::min;

src/iter/splitter.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 use std::fmt::{self, Debug};

src/iter/sum.rs

@@ -1,5 +1,5 @@
 use super::ParallelIterator;
-use super::internal::*;
+use super::plumbing::*;
 
 use std::iter::{self, Sum};
 use std::marker::PhantomData;

src/iter/take.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 use std::cmp::min;
 

src/iter/unzip.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 /// This trait abstracts the different ways we can "unzip" one parallel

src/iter/while_some.rs

@@ -1,5 +1,5 @@
 use std::sync::atomic::{AtomicBool, Ordering};
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 /// `WhileSome` is an iterator that yields the `Some` elements of an iterator,

src/iter/zip.rs

@@ -1,4 +1,4 @@
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 use std::cmp;
 use std::iter;

src/iter/zip_eq.rs

@@ -1,5 +1,5 @@
 
-use super::internal::*;
+use super::plumbing::*;
 use super::*;
 
 /// An [`IndexedParallelIterator`] that iterates over two parallel iterators of equal

src/option.rs

@@ -3,7 +3,7 @@
 //! unless you have need to name one of the iterator types.
 
 use iter::*;
-use iter::internal::*;
+use iter::plumbing::*;
 use std;
 use std::sync::atomic::{AtomicBool, Ordering};
 

src/par_either.rs

@@ -1,5 +1,5 @@
 use iter::*;
-use iter::internal::*;
+use iter::plumbing::*;
 use iter::Either::{Left, Right};
 
 /// `Either<L, R>` is a parallel iterator if both `L` and `R` are parallel iterators.

src/range.rs

@@ -14,7 +14,7 @@
 //! ```
 
 use iter::*;
-use iter::internal::*;
+use iter::plumbing::*;
 use std::ops::Range;
 
 /// Parallel iterator over a range, implemented for all integer types.

src/result.rs

@@ -3,7 +3,7 @@
 //! unless you have need to name one of the iterator types.
 
 use iter::*;
-use iter::internal::*;
+use iter::plumbing::*;
 use std::sync::Mutex;
 
 use option;

src/slice/mod.rs

@@ -8,7 +8,7 @@ mod quicksort;
 mod test;
 
 use iter::*;
-use iter::internal::*;
+use iter::plumbing::*;
 use self::mergesort::par_mergesort;
 use self::quicksort::par_quicksort;
 use split_producer::*;

src/split_producer.rs

@@ -2,7 +2,7 @@
 //!
 //! This module is private, so these items are effectively `pub(super)`
 
-use iter::internal::{UnindexedProducer, Folder};
+use iter::plumbing::{UnindexedProducer, Folder};
 
 /// Common producer for splitting on a predicate.
 pub struct SplitProducer<'p, P: 'p, V> {

src/str.rs

@@ -13,7 +13,7 @@
 //! [`par_split_terminator()`]: trait.ParallelString.html#method.par_split_terminator
 
 use iter::*;
-use iter::internal::*;
+use iter::plumbing::*;
 use split_producer::*;
 
 
@@ -107,7 +107,7 @@ impl ParallelString for str {
 /// would be nicer to have its basic existence and implementors public while
 /// keeping all of the methods private.
 mod private {
-    use iter::internal::Folder;
+    use iter::plumbing::Folder;
 
     /// Pattern-matching trait for `ParallelString`, somewhat like a mix of
     /// `std::str::pattern::{Pattern, Searcher}`.