OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

core: use assoc types in Iterator et al

This commit is contained in:
Jorge Aparicio 2014-12-29 16:18:41 -05:00
parent fc2ba13939
commit 41df05dd0e
7 changed files with 500 additions and 289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/libcore/char.rs
View File

@ -446,7 +446,9 @@ enum EscapeUnicodeState {
Done,
}
impl Iterator<char> for EscapeUnicode {
impl Iterator for EscapeUnicode {
type Item = char;
fn next(&mut self) -> Option<char> {
match self.state {
EscapeUnicodeState::Backslash => {
@ -501,7 +503,9 @@ enum EscapeDefaultState {
Unicode(EscapeUnicode),
}
impl Iterator<char> for EscapeDefault {
impl Iterator for EscapeDefault {
type Item = char;
fn next(&mut self) -> Option<char> {
match self.state {
EscapeDefaultState::Backslash(c) => {

578
src/libcore/iter.rs
View File

File diff suppressed because it is too large Load Diff

12
src/libcore/ops.rs
View File

@ -789,7 +789,9 @@ pub struct Range<Idx> {
// FIXME(#19391) needs a snapshot
//impl<Idx: Clone + Step<T=uint>> Iterator<Idx> for Range<Idx> {
impl<Idx: Clone + Step> Iterator<Idx> for Range<Idx> {
impl<Idx: Clone + Step> Iterator for Range<Idx> {
type Item = Idx;
#[inline]
fn next(&mut self) -> Option<Idx> {
if self.start < self.end {
@ -811,7 +813,7 @@ impl<Idx: Clone + Step> Iterator<Idx> for Range<Idx> {
}
}
impl<Idx: Clone + Step> DoubleEndedIterator<Idx> for Range<Idx> {
impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
#[inline]
fn next_back(&mut self) -> Option<Idx> {
if self.start < self.end {
@ -823,7 +825,7 @@ impl<Idx: Clone + Step> DoubleEndedIterator<Idx> for Range<Idx> {
}
}
impl<Idx: Clone + Step> ExactSizeIterator<Idx> for Range<Idx> {}
impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {}
/// A range which is only bounded below.
#[deriving(Copy)]
@ -833,7 +835,9 @@ pub struct RangeFrom<Idx> {
pub start: Idx,
}
impl<Idx: Clone + Step> Iterator<Idx> for RangeFrom<Idx> {
impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
type Item = Idx;
#[inline]
fn next(&mut self) -> Option<Idx> {
// Deliberately overflow so we loop forever.

38
src/libcore/option.rs
View File

@ -777,7 +777,9 @@ struct Item<A> {
opt: Option<A>
}
impl<A> Iterator<A> for Item<A> {
impl<A> Iterator for Item<A> {
type Item = A;
#[inline]
fn next(&mut self) -> Option<A> {
self.opt.take()
@ -792,32 +794,34 @@ impl<A> Iterator<A> for Item<A> {
}
}
impl<A> DoubleEndedIterator<A> for Item<A> {
impl<A> DoubleEndedIterator for Item<A> {
#[inline]
fn next_back(&mut self) -> Option<A> {
self.opt.take()
}
}
impl<A> ExactSizeIterator<A> for Item<A> {}
impl<A> ExactSizeIterator for Item<A> {}
/// An iterator over a reference of the contained item in an Option.
#[stable]
pub struct Iter<'a, A: 'a> { inner: Item<&'a A> }
impl<'a, A> Iterator<&'a A> for Iter<'a, A> {
impl<'a, A> Iterator for Iter<'a, A> {
type Item = &'a A;
#[inline]
fn next(&mut self) -> Option<&'a A> { self.inner.next() }
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
impl<'a, A> DoubleEndedIterator<&'a A> for Iter<'a, A> {
impl<'a, A> DoubleEndedIterator for Iter<'a, A> {
#[inline]
fn next_back(&mut self) -> Option<&'a A> { self.inner.next_back() }
}
impl<'a, A> ExactSizeIterator<&'a A> for Iter<'a, A> {}
impl<'a, A> ExactSizeIterator for Iter<'a, A> {}
#[stable]
impl<'a, A> Clone for Iter<'a, A> {
@ -830,37 +834,41 @@ impl<'a, A> Clone for Iter<'a, A> {
#[stable]
pub struct IterMut<'a, A: 'a> { inner: Item<&'a mut A> }
impl<'a, A> Iterator<&'a mut A> for IterMut<'a, A> {
impl<'a, A> Iterator for IterMut<'a, A> {
type Item = &'a mut A;
#[inline]
fn next(&mut self) -> Option<&'a mut A> { self.inner.next() }
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
impl<'a, A> DoubleEndedIterator<&'a mut A> for IterMut<'a, A> {
impl<'a, A> DoubleEndedIterator for IterMut<'a, A> {
#[inline]
fn next_back(&mut self) -> Option<&'a mut A> { self.inner.next_back() }
}
impl<'a, A> ExactSizeIterator<&'a mut A> for IterMut<'a, A> {}
impl<'a, A> ExactSizeIterator for IterMut<'a, A> {}
/// An iterator over the item contained inside an Option.
#[stable]
pub struct IntoIter<A> { inner: Item<A> }
impl<A> Iterator<A> for IntoIter<A> {
impl<A> Iterator for IntoIter<A> {
type Item = A;
#[inline]
fn next(&mut self) -> Option<A> { self.inner.next() }
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
impl<A> DoubleEndedIterator<A> for IntoIter<A> {
impl<A> DoubleEndedIterator for IntoIter<A> {
#[inline]
fn next_back(&mut self) -> Option<A> { self.inner.next_back() }
}
impl<A> ExactSizeIterator<A> for IntoIter<A> {}
impl<A> ExactSizeIterator for IntoIter<A> {}
/////////////////////////////////////////////////////////////////////////////
// FromIterator
@ -887,7 +895,7 @@ impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
/// ```
#[inline]
#[stable]
fn from_iter<I: Iterator<Option<A>>>(iter: I) -> Option<V> {
fn from_iter<I: Iterator<Item=Option<A>>>(iter: I) -> Option<V> {
// FIXME(#11084): This could be replaced with Iterator::scan when this
// performance bug is closed.
@ -896,7 +904,9 @@ impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
found_none: bool,
}
impl<T, Iter: Iterator<Option<T>>> Iterator<T> for Adapter<Iter> {
impl<T, Iter: Iterator<Item=Option<T>>> Iterator for Adapter<Iter> {
type Item = T;
#[inline]
fn next(&mut self) -> Option<T> {
match self.iter.next() {

32
src/libcore/result.rs
View File

@ -807,7 +807,9 @@ impl<T, E> AsSlice<T> for Result<T, E> {
#[stable]
pub struct Iter<'a, T: 'a> { inner: Option<&'a T> }
impl<'a, T> Iterator<&'a T> for Iter<'a, T> {
impl<'a, T> Iterator for Iter<'a, T> {
type Item = &'a T;
#[inline]
fn next(&mut self) -> Option<&'a T> { self.inner.take() }
#[inline]
@ -817,12 +819,12 @@ impl<'a, T> Iterator<&'a T> for Iter<'a, T> {
}
}
impl<'a, T> DoubleEndedIterator<&'a T> for Iter<'a, T> {
impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a T> { self.inner.take() }
}
impl<'a, T> ExactSizeIterator<&'a T> for Iter<'a, T> {}
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
impl<'a, T> Clone for Iter<'a, T> {
fn clone(&self) -> Iter<'a, T> { Iter { inner: self.inner } }
@ -832,7 +834,9 @@ impl<'a, T> Clone for Iter<'a, T> {
#[stable]
pub struct IterMut<'a, T: 'a> { inner: Option<&'a mut T> }
impl<'a, T> Iterator<&'a mut T> for IterMut<'a, T> {
impl<'a, T> Iterator for IterMut<'a, T> {
type Item = &'a mut T;
#[inline]
fn next(&mut self) -> Option<&'a mut T> { self.inner.take() }
#[inline]
@ -842,18 +846,20 @@ impl<'a, T> Iterator<&'a mut T> for IterMut<'a, T> {
}
}
impl<'a, T> DoubleEndedIterator<&'a mut T> for IterMut<'a, T> {
impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a mut T> { self.inner.take() }
}
impl<'a, T> ExactSizeIterator<&'a mut T> for IterMut<'a, T> {}
impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
/// An iterator over the value in a `Ok` variant of a `Result`.
#[stable]
pub struct IntoIter<T> { inner: Option<T> }
impl<T> Iterator<T> for IntoIter<T> {
impl<T> Iterator for IntoIter<T> {
type Item = T;
#[inline]
fn next(&mut self) -> Option<T> { self.inner.take() }
#[inline]
@ -863,12 +869,12 @@ impl<T> Iterator<T> for IntoIter<T> {
}
}
impl<T> DoubleEndedIterator<T> for IntoIter<T> {
impl<T> DoubleEndedIterator for IntoIter<T> {
#[inline]
fn next_back(&mut self) -> Option<T> { self.inner.take() }
}
impl<T> ExactSizeIterator<T> for IntoIter<T> {}
impl<T> ExactSizeIterator for IntoIter<T> {}
/////////////////////////////////////////////////////////////////////////////
// FromIterator
@ -894,7 +900,7 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
/// assert!(res == Ok(vec!(2u, 3u)));
/// ```
#[inline]
fn from_iter<I: Iterator<Result<A, E>>>(iter: I) -> Result<V, E> {
fn from_iter<I: Iterator<Item=Result<A, E>>>(iter: I) -> Result<V, E> {
// FIXME(#11084): This could be replaced with Iterator::scan when this
// performance bug is closed.
@ -903,7 +909,9 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
err: Option<E>,
}
impl<T, E, Iter: Iterator<Result<T, E>>> Iterator<T> for Adapter<Iter, E> {
impl<T, E, Iter: Iterator<Item=Result<T, E>>> Iterator for Adapter<Iter, E> {
type Item = T;
#[inline]
fn next(&mut self) -> Option<T> {
match self.iter.next() {
@ -941,7 +949,7 @@ pub fn fold<T,
V,
E,
F: FnMut(V, T) -> V,
Iter: Iterator<Result<T, E>>>(
Iter: Iterator<Item=Result<T, E>>>(
mut iterator: Iter,
mut init: V,
mut f: F)

60
src/libcore/slice.rs
View File

@ -647,7 +647,9 @@ impl<'a, T> Default for &'a [T] {
macro_rules! iterator {
(struct $name:ident -> $ptr:ty, $elem:ty) => {
#[experimental = "needs review"]
impl<'a, T> Iterator<$elem> for $name<'a, T> {
impl<'a, T> Iterator for $name<'a, T> {
type Item = $elem;
#[inline]
fn next(&mut self) -> Option<$elem> {
// could be implemented with slices, but this avoids bounds checks
@ -683,7 +685,7 @@ macro_rules! iterator {
}
#[experimental = "needs review"]
impl<'a, T> DoubleEndedIterator<$elem> for $name<'a, T> {
impl<'a, T> DoubleEndedIterator for $name<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<$elem> {
// could be implemented with slices, but this avoids bounds checks
@ -766,7 +768,7 @@ impl<'a,T> Copy for Iter<'a,T> {}
iterator!{struct Iter -> *const T, &'a T}
#[experimental = "needs review"]
impl<'a, T> ExactSizeIterator<&'a T> for Iter<'a, T> {}
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
#[stable]
impl<'a, T> Clone for Iter<'a, T> {
@ -774,7 +776,7 @@ impl<'a, T> Clone for Iter<'a, T> {
}
#[experimental = "needs review"]
impl<'a, T> RandomAccessIterator<&'a T> for Iter<'a, T> {
impl<'a, T> RandomAccessIterator for Iter<'a, T> {
#[inline]
fn indexable(&self) -> uint {
let (exact, _) = self.size_hint();
@ -860,14 +862,14 @@ impl<'a, T> IterMut<'a, T> {
iterator!{struct IterMut -> *mut T, &'a mut T}
#[experimental = "needs review"]
impl<'a, T> ExactSizeIterator<&'a mut T> for IterMut<'a, T> {}
impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
/// An internal abstraction over the splitting iterators, so that
/// splitn, splitn_mut etc can be implemented once.
trait SplitIter<E>: DoubleEndedIterator<E> {
trait SplitIter: DoubleEndedIterator {
/// Mark the underlying iterator as complete, extracting the remaining
/// portion of the slice.
fn finish(&mut self) -> Option<E>;
fn finish(&mut self) -> Option< <Self as Iterator>::Item>;
}
/// An iterator over subslices separated by elements that match a predicate
@ -892,7 +894,9 @@ impl<'a, T, P> Clone for Split<'a, T, P> where P: Clone + FnMut(&T) -> bool {
}
#[experimental = "needs review"]
impl<'a, T, P> Iterator<&'a [T]> for Split<'a, T, P> where P: FnMut(&T) -> bool {
impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
type Item = &'a [T];
#[inline]
fn next(&mut self) -> Option<&'a [T]> {
if self.finished { return None; }
@ -918,7 +922,7 @@ impl<'a, T, P> Iterator<&'a [T]> for Split<'a, T, P> where P: FnMut(&T) -> bool
}
#[experimental = "needs review"]
impl<'a, T, P> DoubleEndedIterator<&'a [T]> for Split<'a, T, P> where P: FnMut(&T) -> bool {
impl<'a, T, P> DoubleEndedIterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
#[inline]
fn next_back(&mut self) -> Option<&'a [T]> {
if self.finished { return None; }
@ -934,7 +938,7 @@ impl<'a, T, P> DoubleEndedIterator<&'a [T]> for Split<'a, T, P> where P: FnMut(&
}
}
impl<'a, T, P> SplitIter<&'a [T]> for Split<'a, T, P> where P: FnMut(&T) -> bool {
impl<'a, T, P> SplitIter for Split<'a, T, P> where P: FnMut(&T) -> bool {
#[inline]
fn finish(&mut self) -> Option<&'a [T]> {
if self.finished { None } else { self.finished = true; Some(self.v) }
@ -950,7 +954,7 @@ pub struct SplitMut<'a, T:'a, P> where P: FnMut(&T) -> bool {
finished: bool
}
impl<'a, T, P> SplitIter<&'a mut [T]> for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
impl<'a, T, P> SplitIter for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
#[inline]
fn finish(&mut self) -> Option<&'a mut [T]> {
if self.finished {
@ -963,7 +967,9 @@ impl<'a, T, P> SplitIter<&'a mut [T]> for SplitMut<'a, T, P> where P: FnMut(&T)
}
#[experimental = "needs review"]
impl<'a, T, P> Iterator<&'a mut [T]> for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
impl<'a, T, P> Iterator for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
type Item = &'a mut [T];
#[inline]
fn next(&mut self) -> Option<&'a mut [T]> {
if self.finished { return None; }
@ -996,7 +1002,7 @@ impl<'a, T, P> Iterator<&'a mut [T]> for SplitMut<'a, T, P> where P: FnMut(&T) -
}
#[experimental = "needs review"]
impl<'a, T, P> DoubleEndedIterator<&'a mut [T]> for SplitMut<'a, T, P> where
impl<'a, T, P> DoubleEndedIterator for SplitMut<'a, T, P> where
P: FnMut(&T) -> bool,
{
#[inline]
@ -1029,9 +1035,11 @@ struct GenericSplitN<I> {
}
#[experimental = "needs review"]
impl<E, I: SplitIter<E>> Iterator<E> for GenericSplitN<I> {
impl<T, I: SplitIter + Iterator<Item=T>> Iterator for GenericSplitN<I> {
type Item = T;
#[inline]
fn next(&mut self) -> Option<E> {
fn next(&mut self) -> Option<T> {
if self.count == 0 {
self.iter.finish()
} else {
@ -1075,9 +1083,11 @@ pub struct RSplitNMut<'a, T: 'a, P> where P: FnMut(&T) -> bool {
macro_rules! forward_iterator {
($name:ident: $elem:ident, $iter_of:ty) => {
impl<'a, $elem, P> Iterator<$iter_of> for $name<'a, $elem, P> where
impl<'a, $elem, P> Iterator for $name<'a, $elem, P> where
P: FnMut(&T) -> bool
{
type Item = $iter_of;
#[inline]
fn next(&mut self) -> Option<$iter_of> {
self.inner.next()
@ -1104,7 +1114,9 @@ pub struct Windows<'a, T:'a> {
size: uint
}
impl<'a, T> Iterator<&'a [T]> for Windows<'a, T> {
impl<'a, T> Iterator for Windows<'a, T> {
type Item = &'a [T];
#[inline]
fn next(&mut self) -> Option<&'a [T]> {
if self.size > self.v.len() {
@ -1140,7 +1152,9 @@ pub struct Chunks<'a, T:'a> {
}
#[experimental = "needs review"]
impl<'a, T> Iterator<&'a [T]> for Chunks<'a, T> {
impl<'a, T> Iterator for Chunks<'a, T> {
type Item = &'a [T];
#[inline]
fn next(&mut self) -> Option<&'a [T]> {
if self.v.len() == 0 {
@ -1167,7 +1181,7 @@ impl<'a, T> Iterator<&'a [T]> for Chunks<'a, T> {
}
#[experimental = "needs review"]
impl<'a, T> DoubleEndedIterator<&'a [T]> for Chunks<'a, T> {
impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a [T]> {
if self.v.len() == 0 {
@ -1183,7 +1197,7 @@ impl<'a, T> DoubleEndedIterator<&'a [T]> for Chunks<'a, T> {
}
#[experimental = "needs review"]
impl<'a, T> RandomAccessIterator<&'a [T]> for Chunks<'a, T> {
impl<'a, T> RandomAccessIterator for Chunks<'a, T> {
#[inline]
fn indexable(&self) -> uint {
self.v.len()/self.size + if self.v.len() % self.size != 0 { 1 } else { 0 }
@ -1213,7 +1227,9 @@ pub struct ChunksMut<'a, T:'a> {
}
#[experimental = "needs review"]
impl<'a, T> Iterator<&'a mut [T]> for ChunksMut<'a, T> {
impl<'a, T> Iterator for ChunksMut<'a, T> {
type Item = &'a mut [T];
#[inline]
fn next(&mut self) -> Option<&'a mut [T]> {
if self.v.len() == 0 {
@ -1241,7 +1257,7 @@ impl<'a, T> Iterator<&'a mut [T]> for ChunksMut<'a, T> {
}
#[experimental = "needs review"]
impl<'a, T> DoubleEndedIterator<&'a mut [T]> for ChunksMut<'a, T> {
impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a mut [T]> {
if self.v.len() == 0 {

61
src/libcore/str/mod.rs
View File

@ -37,7 +37,7 @@ use uint;
macro_rules! delegate_iter {
(exact $te:ty in $ti:ty) => {
delegate_iter!{$te in $ti}
impl<'a> ExactSizeIterator<$te> for $ti {
impl<'a> ExactSizeIterator for $ti {
#[inline]
fn rposition<P>(&mut self, predicate: P) -> Option<uint> where P: FnMut($te) -> bool{
self.0.rposition(predicate)
@ -49,7 +49,9 @@ macro_rules! delegate_iter {
}
};
($te:ty in $ti:ty) => {
impl<'a> Iterator<$te> for $ti {
impl<'a> Iterator for $ti {
type Item = $te;
#[inline]
fn next(&mut self) -> Option<$te> {
self.0.next()
@ -59,7 +61,7 @@ macro_rules! delegate_iter {
self.0.size_hint()
}
}
impl<'a> DoubleEndedIterator<$te> for $ti {
impl<'a> DoubleEndedIterator for $ti {
#[inline]
fn next_back(&mut self) -> Option<$te> {
self.0.next_back()
@ -67,7 +69,9 @@ macro_rules! delegate_iter {
}
};
(pattern $te:ty in $ti:ty) => {
impl<'a, P: CharEq> Iterator<$te> for $ti {
impl<'a, P: CharEq> Iterator for $ti {
type Item = $te;
#[inline]
fn next(&mut self) -> Option<$te> {
self.0.next()
@ -77,7 +81,7 @@ macro_rules! delegate_iter {
self.0.size_hint()
}
}
impl<'a, P: CharEq> DoubleEndedIterator<$te> for $ti {
impl<'a, P: CharEq> DoubleEndedIterator for $ti {
#[inline]
fn next_back(&mut self) -> Option<$te> {
self.0.next_back()
@ -85,7 +89,9 @@ macro_rules! delegate_iter {
}
};
(pattern forward $te:ty in $ti:ty) => {
impl<'a, P: CharEq> Iterator<$te> for $ti {
impl<'a, P: CharEq> Iterator for $ti {
type Item = $te;
#[inline]
fn next(&mut self) -> Option<$te> {
self.0.next()
@ -275,7 +281,9 @@ fn unwrap_or_0(opt: Option<&u8>) -> u8 {
}
}
impl<'a> Iterator<char> for Chars<'a> {
impl<'a> Iterator for Chars<'a> {
type Item = char;
#[inline]
fn next(&mut self) -> Option<char> {
// Decode UTF-8, using the valid UTF-8 invariant
@ -318,7 +326,7 @@ impl<'a> Iterator<char> for Chars<'a> {
}
}
impl<'a> DoubleEndedIterator<char> for Chars<'a> {
impl<'a> DoubleEndedIterator for Chars<'a> {
#[inline]
fn next_back(&mut self) -> Option<char> {
let w = match self.iter.next_back() {
@ -359,7 +367,9 @@ pub struct CharIndices<'a> {
iter: Chars<'a>,
}
impl<'a> Iterator<(uint, char)> for CharIndices<'a> {
impl<'a> Iterator for CharIndices<'a> {
type Item = (uint, char);
#[inline]
fn next(&mut self) -> Option<(uint, char)> {
let (pre_len, _) = self.iter.iter.size_hint();
@ -380,7 +390,7 @@ impl<'a> Iterator<(uint, char)> for CharIndices<'a> {
}
}
impl<'a> DoubleEndedIterator<(uint, char)> for CharIndices<'a> {
impl<'a> DoubleEndedIterator for CharIndices<'a> {
#[inline]
fn next_back(&mut self) -> Option<(uint, char)> {
match self.iter.next_back() {
@ -463,7 +473,9 @@ impl<'a, Sep> CharSplits<'a, Sep> {
}
}
impl<'a, Sep: CharEq> Iterator<&'a str> for CharSplits<'a, Sep> {
impl<'a, Sep: CharEq> Iterator for CharSplits<'a, Sep> {
type Item = &'a str;
#[inline]
fn next(&mut self) -> Option<&'a str> {
if self.finished { return None }
@ -495,8 +507,7 @@ impl<'a, Sep: CharEq> Iterator<&'a str> for CharSplits<'a, Sep> {
}
}
impl<'a, Sep: CharEq> DoubleEndedIterator<&'a str>
for CharSplits<'a, Sep> {
impl<'a, Sep: CharEq> DoubleEndedIterator for CharSplits<'a, Sep> {
#[inline]
fn next_back(&mut self) -> Option<&'a str> {
if self.finished { return None }
@ -537,7 +548,9 @@ for CharSplits<'a, Sep> {
}
}
impl<'a, Sep: CharEq> Iterator<&'a str> for CharSplitsN<'a, Sep> {
impl<'a, Sep: CharEq> Iterator for CharSplitsN<'a, Sep> {
type Item = &'a str;
#[inline]
fn next(&mut self) -> Option<&'a str> {
if self.count != 0 {
@ -864,7 +877,9 @@ pub struct SplitStr<'a> {
#[deprecated = "Type is now named `SplitStr`"]
pub type StrSplits<'a> = SplitStr<'a>;
impl<'a> Iterator<(uint, uint)> for MatchIndices<'a> {
impl<'a> Iterator for MatchIndices<'a> {
type Item = (uint, uint);
#[inline]
fn next(&mut self) -> Option<(uint, uint)> {
match self.searcher {
@ -878,7 +893,9 @@ impl<'a> Iterator<(uint, uint)> for MatchIndices<'a> {
}
}
impl<'a> Iterator<&'a str> for SplitStr<'a> {
impl<'a> Iterator for SplitStr<'a> {
type Item = &'a str;
#[inline]
fn next(&mut self) -> Option<&'a str> {
if self.finished { return None; }
@ -1672,23 +1689,27 @@ impl<'a> Default for &'a str {
fn default() -> &'a str { "" }
}
impl<'a> Iterator<&'a str> for Lines<'a> {
impl<'a> Iterator for Lines<'a> {
type Item = &'a str;
#[inline]
fn next(&mut self) -> Option<&'a str> { self.inner.next() }
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
impl<'a> DoubleEndedIterator<&'a str> for Lines<'a> {
impl<'a> DoubleEndedIterator for Lines<'a> {
#[inline]
fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }
}
impl<'a> Iterator<&'a str> for LinesAny<'a> {
impl<'a> Iterator for LinesAny<'a> {
type Item = &'a str;
#[inline]
fn next(&mut self) -> Option<&'a str> { self.inner.next() }
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
impl<'a> DoubleEndedIterator<&'a str> for LinesAny<'a> {
impl<'a> DoubleEndedIterator for LinesAny<'a> {
#[inline]
fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }
}