iter-trait 0.3.1

Iter trait for collectons.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

//! Base iterator traits.

cfg_if! {
    if #[cfg(feature = "std")] {
        use std::iter::FromIterator;
    } else {
        use core::iter::FromIterator;
    }
}

use refs::{Ref, RefMut};

/// A trait for iterable collections which contain data of a given type.
///
/// In most cases, you shouldn't implement this trait directly; instead, you should implement
/// `IntoIterator`, which will in turn implement this trait.
///
/// The only exception is dynamically-sized types, which cannot implement `IntoIterator`. Instead,
/// you should implement this trait to indicate what type of data is inside the collection.
pub trait HasData {
    /// The type of the data inside this collection.
    type Item;
}
impl<T: IntoIterator> HasData for T {
    type Item = <T as IntoIterator>::Item;
}

/// A trait for collections which can be iterated by reference.
///
/// In most cases, you shouldn't implement this trait directly; instead, you should implement
/// `IntoIterator` for a reference of this type, which will in turn implement this trait.
pub trait Iter<'a>: 'a + HasData {
    /// Type of the references to the data in the collection.
    ///
    /// Although this might just be `&'a Item`, it can also be more complicated. For example, an
    /// iterator with `Item = (usize, T)` might use `(usize, &'a T)` for this instead.
    ///
    /// For more information, see the `Ref` trait.
    type ItemRef: Ref<'a, Self::Item>;

    /// Type of the iterator over references.
    type IterRef: Iterator<Item = Self::ItemRef>;

    /// Constructs an iterator over references to the data in this collection.
    fn iter(&'a self) -> Self::IterRef;
}
impl<'a, T: 'a + HasData> Iter<'a> for T
where
    &'a T: IntoIterator,
    <&'a T as IntoIterator>::Item: Ref<'a, T::Item>,
{
    type ItemRef = <&'a Self as IntoIterator>::Item;
    type IterRef = <&'a Self as IntoIterator>::IntoIter;
    fn iter(&'a self) -> Self::IterRef {
        self.into_iter()
    }
}

/// A trait for collections which can be iterated by mutable reference.
///
/// In most cases, you shouldn't implement this trait directly; instead, you should implement
/// `IntoIterator` for a mutable reference of this type, which will in turn implement this trait.
pub trait IterMut<'a>: Iter<'a> {
    /// Type of the mutable references to the data in the collection.
    ///
    /// Although this might just be `&'a Item`, it can also be more complicated. For example, an
    /// iterator with `Item = (usize, T)` might use `(usize, &'a mut T)` for this instead.
    ///
    /// For more information, see the `RefMut` trait.
    type ItemMut: RefMut<'a, Self::Item>;

    /// Type of the iterator over mutable references.
    type IterMut: Iterator<Item = Self::ItemMut>;

    /// Constructs an iterator over mutable references to the data in this collection.
    fn iter_mut(&'a mut self) -> Self::IterMut;
}
impl<'a, T: 'a + Iter<'a>> IterMut<'a> for T
where
    &'a mut T: IntoIterator,
    <&'a mut T as IntoIterator>::Item: RefMut<'a, T::Item>,
{
    type ItemMut = <&'a mut Self as IntoIterator>::Item;
    type IterMut = <&'a mut Self as IntoIterator>::IntoIter;
    fn iter_mut(&'a mut self) -> Self::IterMut {
        self.into_iter()
    }
}

/// A trait for collections which can be converted to and from iterators over data.
pub trait IterOwned
    : HasData
    + IntoIterator<Item = <Self as HasData>::Item>
    + FromIterator<<Self as HasData>::Item>
    + Extend<<Self as HasData>::Item>
{}
impl<T> IterOwned for T
where
    T: HasData,
    T: IntoIterator<Item = <T as HasData>::Item>,
    T: FromIterator<<T as HasData>::Item>,
    T: Extend<<T as HasData>::Item>,
{}