This breaks all implementors of FromIterator, as they must now accept IntoIterator instead of Iterator. The fix for this is generally trivial (change the bound, and maybe call into_iter() on the argument to get the old argument).
Users of FromIterator should be unaffected because Iterators are IntoIterator.
[breaking-change]
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Ord> FromIterator<T> for BinaryHeap<T> {
- fn from_iter<Iter: Iterator<Item=T>>(iter: Iter) -> BinaryHeap<T> {
- BinaryHeap::from_vec(iter.collect())
+ fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> BinaryHeap<T> {
+ BinaryHeap::from_vec(iter.into_iter().collect())
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl FromIterator<bool> for BitVec {
- fn from_iter<I:Iterator<Item=bool>>(iterator: I) -> BitVec {
- let mut ret = BitVec::new();
- ret.extend(iterator);
+ fn from_iter<I: IntoIterator<Item=bool>>(iter: I) -> BitVec {
+ let mut ret = Bitv::new();
+ ret.extend(iter);
ret
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl FromIterator<usize> for BitSet {
- fn from_iter<I:Iterator<Item=usize>>(iterator: I) -> BitSet {
- let mut ret = BitSet::new();
- ret.extend(iterator);
+ fn from_iter<I: IntoIterator<Item=usize>>(iter: I) -> BitSet {
+ let mut ret = BitvSet::new();
+ ret.extend(iter);
ret
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<K: Ord, V> FromIterator<(K, V)> for BTreeMap<K, V> {
- fn from_iter<T: Iterator<Item=(K, V)>>(iter: T) -> BTreeMap<K, V> {
+ fn from_iter<T: IntoIterator<Item=(K, V)>>(iter: T) -> BTreeMap<K, V> {
let mut map = BTreeMap::new();
map.extend(iter);
map
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Ord> FromIterator<T> for BTreeSet<T> {
- fn from_iter<Iter: Iterator<Item=T>>(iter: Iter) -> BTreeSet<T> {
+ fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> BTreeSet<T> {
let mut set = BTreeSet::new();
set.extend(iter);
set
}
impl<E:CLike> FromIterator<E> for EnumSet<E> {
- fn from_iter<I:Iterator<Item=E>>(iterator: I) -> EnumSet<E> {
+ fn from_iter<I: IntoIterator<Item=E>>(iter: I) -> EnumSet<E> {
let mut ret = EnumSet::new();
- ret.extend(iterator);
+ ret.extend(iter);
ret
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<A> FromIterator<A> for LinkedList<A> {
- fn from_iter<T: I
terator<Item=A>>(iterator: T) -> LinkedList<A> {
- let mut ret = LinkedList::new();
- ret.extend(iterator);
+ fn from_iter<T: I
ntoIterator<Item=A>>(iter: T) -> LinkedList<A> {
+ let mut ret = DList::new();
+ ret.extend(iter);
ret
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl FromIterator<char> for String {
- fn from_iter<I:Iterator<Item=char>>(iterator: I) -> String {
+ fn from_iter<I: IntoIterator<Item=char>>(iter: I) -> String {
let mut buf = String::new();
- buf.extend(iterator);
+ buf.extend(iter);
buf
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> FromIterator<&'a str> for String {
- fn from_iter<I:Iterator<Item=&'a str>>(iterator: I) -> String {
+ fn from_iter<I: IntoIterator<Item=&'a str>>(iter: I) -> String {
let mut buf = String::new();
- buf.extend(iterator);
+ buf.extend(iter);
buf
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> FromIterator<T> for Vec<T> {
#[inline]
- fn from_iter<I:Iterator<Item=T>>(mut iterator: I) -> Vec<T> {
+ fn from_iter<I: IntoIterator<Item=T>>(iterable: I) -> Vec<T> {
+ let mut iterator = iterable.into_iter();
let (lower, _) = iterator.size_hint();
let mut vector = Vec::with_capacity(lower);
#[unstable(feature = "collections")]
impl<'a, T> FromIterator<T> for CowVec<'a, T> where T: Clone {
- fn from_iter<I: Iterator<Item=T>>(it: I) -> CowVec<'a, T> {
+ fn from_iter<I: IntoIterator<Item=T>>(it: I) -> CowVec<'a, T> {
Cow::Owned(FromIterator::from_iter(it))
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<A> FromIterator<A> for VecDeque<A> {
- fn from_iter<T: Iterator<Item=A>>(iterator: T) -> VecDeque<A> {
+ fn from_iter<T: IntoIterator<Item=A>>(iterable: T) -> VecDeque<A> {
+ let iterator = iterable.into_iter();
let (lower, _) = iterator.size_hint();
let mut deq = VecDeque::with_capacity(lower);
deq.extend(iterator);
#[stable(feature = "rust1", since = "1.0.0")]
impl<V> FromIterator<(usize, V)> for VecMap<V> {
- fn from_iter<Iter: Iterator<Item=(usize, V)>>(iter: Iter) -> VecMap<V> {
+ fn from_iter<I: IntoIterator<Item=(usize, V)>>(iter: I) -> VecMap<V> {
let mut map = VecMap::new();
map.extend(iter);
map
#[rustc_on_unimplemented="a collection of type `{Self}` cannot be \
built from an iterator over elements of type `{A}`"]
pub trait FromIterator<A> {
- /// Build a container with elements from an external iterator.
+ /// Build a container with elements from something iterable.
#[stable(feature = "rust1", since = "1.0.0")]
- fn from_iter<T: Iterator<Item=A>>(iterator: T) -> Self;
+ fn from_iter<T: IntoIterator<Item=A>>(iterator: T) -> Self;
}
/// Conversion into an `Iterator`
use cmp::{Eq, Ord};
use default::Default;
use iter::{ExactSizeIterator};
-use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator};
+use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator, IntoIterator};
use mem;
use ops::{Deref, FnOnce};
use result::Result::{Ok, Err};
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn from_iter<I: Iterator<Item=Option<A>>>(iter: I) -> Option<V> {
+ fn from_iter<I: I
ntoIterator<Item=Option<A>>>(iter: I) -> Option<V> {
// FIXME(#11084): This could be replaced with Iterator::scan when this
// performance bug is closed.
}
}
- let mut adapter = Adapter { iter: iter, found_none: false };
+ let mut adapter = Adapter { iter: iter.into_iter(), found_none: false };
let v: V = FromIterator::from_iter(adapter.by_ref());
if adapter.found_none {
use clone::Clone;
use fmt;
-use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator, ExactSizeIterator};
+use iter::{Iterator, IteratorExt, DoubleEndedIterator,
+ FromIterator, ExactSizeIterator, IntoIterator};
use ops::{FnMut, FnOnce};
use option::Option::{self, None, Some};
use slice::AsSlice;
/// assert!(res == Ok(vec!(2, 3)));
/// ```
#[inline]
- fn from_iter<I: Iterator<Item=Result<A, E>>>(iter: I) -> Result<V, E> {
+ fn from_iter<I: I
ntoIterator<Item=Result<A, E>>>(iter: I) -> Result<V, E> {
// FIXME(#11084): This could be replaced with Iterator::scan when this
// performance bug is closed.
}
}
- let mut adapter = Adapter { iter: iter, err: None };
+ let mut adapter = Adapter { iter: iter.into_iter(), err: None };
let v: V = FromIterator::from_iter(adapter.by_ref());
match adapter.err {
use middle::ty;
use std::cmp::Ordering;
use std::fmt;
-use std::iter::{range_inclusive, AdditiveIterator, FromIterator, repeat};
+use std::iter::{range_inclusive, AdditiveIterator, FromIterator, IntoIterator, repeat};
use std::num::Float;
use std::slice;
use syntax::ast::{self, DUMMY_NODE_ID, NodeId, Pat};
}
impl<'a> FromIterator<Vec<&'a Pat>> for Matrix<'a> {
- fn from_iter<T: Iterator<Item=Vec<&'a Pat>>>(iterator: T) -> Matrix<'a> {
- Matrix(iterator.collect())
+ fn from_iter<T: IntoIterator<Item=Vec<&'a Pat>>>(iter: T) -> Matrix<'a> {
+ Matrix(iter.into_iter().collect())
}
}
S: HashState<Hasher=H> + Default,
H: hash::Hasher<Output=u64>
{
- fn from_iter<T: Iterator<Item=(K, V)>>(iter: T) -> HashMap<K, V, S> {
+ fn from_iter<T: IntoIterator<Item=(K, V)>>(iterable: T) -> HashMap<K, V, S> {
+ let iter = iterable.into_iter();
let lower = iter.size_hint().0;
let mut map = HashMap::with_capacity_and_hash_state(lower,
Default::default());
S: HashState<Hasher=H> + Default,
H: hash::Hasher<Output=u64>
{
- fn from_iter<I: Iterator<Item=T>>(iter: I) -> HashSet<T, S> {
+ fn from_iter<I: IntoIterator<Item=T>>(iterable: I) -> HashSet<T, S> {
+ let iter = iterable.into_iter();
let lower = iter.size_hint().0;
let mut set = HashSet::with_capacity_and_hash_state(lower, Default::default());
set.extend(iter);
}
impl<'a, P: ?Sized + 'a> iter::FromIterator<&'a P> for PathBuf where P: AsPath {
- fn from_iter<I: Iterator<Item = &'a P>>(iter: I) -> PathBuf {
+ fn from_iter<I: IntoIterator<Item = &'a P>>(iter: I) -> PathBuf {
let mut buf = PathBuf::new("");
buf.extend(iter);
buf
/// This replaces surrogate code point pairs with supplementary code points,
/// like concatenating ill-formed UTF-16 strings effectively would.
impl FromIterator<CodePoint> for Wtf8Buf {
- fn from_iter<T: Iterator<Item=CodePoint>>(iterator: T) -> Wtf8Buf {
+ fn from_iter<T: IntoIterator<Item=CodePoint>>(iter: T) -> Wtf8Buf {
let mut string = Wtf8Buf::new();
- string.extend(iterator);
+ string.extend(iter);
string
}
}
use std::default::Default;
use std::fmt;
-use std::iter::FromIterator;
+use std::iter::{IntoIterator, FromIterator};
use std::ops::Deref;
use std::vec;
use serialize::{Encodable, Decodable, Encoder, Decoder};
}
impl<T> FromIterator<T> for OwnedSlice<T> {
- fn from_iter<I: Iterator<Item=T>>(iter: I) -> OwnedSlice<T> {
- OwnedSlice::from_vec(iter.collect())
+ fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> OwnedSlice<T> {
+ OwnedSlice::from_vec(iter.into_iter().collect())
}
}
}
impl<T> FromIterator<T> for SmallVector<T> {
- fn from_iter<I: Iterator<Item=T>>(iter: I) -> SmallVector<T> {
+ fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> SmallVector<T> {
let mut v = SmallVector::zero();
v.extend(iter);
v
projects / rust.git / commitdiff