Idempotent 提供了足够的信息，使其成为一个有用的约束

1. 它可以提供 T 或 T::Owning，并且会告诉你哪一个是哪个。

2. 它对 T 进行了约束，使其满足 T::Owning::Owning = T::Owning。这意味着你可以多次调用 into_owning() 并始终得到一个 T 或 T::Owning。

Idempotent<T> 通过 Change<T> 实现，它包含一个 T；Keep<T>，它包含一个 T::Owning；以及通过 ChangeOrKeep<T> 实现，它可能包含其中之一，运行时决定。在 Idempotent<T> 上调用 .to_owning() 或 .into_owning() 总是返回一个 Keep<T>。

示例

在这个示例中，我们将实现一个切片迭代器，它以相反的顺序返回切片的元素。最初，它会借用切片并在返回时克隆其元素。但它将实现 IntoOwning，这样在迭代过程中的任何时候，都可以将其转换为拥有 Vec 的迭代器。然后，它将从 Vec 的末尾弹出它返回的元素，而不进行克隆。

首先，我们声明我们的灵活迭代器

struct FlexIter<S, E> {
    inner: S,
    index: usize,
    _phantom: PhantomData<[E]>,
}

E 是切片元素的类型。尽管约束没有出现在结构声明中，但 S 将是 StaticCow<[E]> 的实现。具体来说，S 将是 Borrowed<'b, [E]>，它封装了一个 &'b [E]，或者它将是 Owned<[E]>，它封装了一个 Vec<E>。 index 比我们将返回的下一个元素的索引大一个，而 _phantom 是一个零大小对象，它必须存在以满足类型检查器，参数 E 必须出现在结构体字段中。

现在我们为 FlexIter 创建 ToOwning 和 IntoOwning 实例。

impl<S, E> ToOwning for FlexIter<S, E>
where
    S: ToOwning,
{
    type Owning = FlexIter<S::Owning, E>;

    fn to_owning(&self) -> Self::Owning {
        FlexIter {
            inner: self.inner.to_owning(),
            index: self.index.to_owning(),
            _phantom: self._phantom.to_owning()
        }
    }
}

impl<S, E> IntoOwning for FlexIter<S, E>
where
    S: IntoOwning,
{
    fn into_owning(self) -> Self::Owning {
        FlexIter {
            inner: self.inner.into_owning(),
            index: self.index.into_owning(),
            _phantom: self._phantom.into_owning()
        }
    }
}

您可以看到，这些实现完全是照搬的：我们提供了一个与 Self 相同但用 S::Owning 代替 S 的 Owning 类型，以及将相同的操作应用于每个字段的 to_owning 和 into_owning 方法。

现在我们提供了一个借用迭代器的构造函数，该构造函数实现了 StaticCow<[E]>，使用 Borrowed<'b, [E]>。

impl<'b, E> FlexIter<'b, Borrowed<'b, [E]>, E> {
    fn new(slice: &'b [E]) -> FlexIter<'b, Borrowed<'b, [E]>, E> {
        FlexIter {
            inner: Borrowed(slice),
            index: slice.len(),
            _phantom: CowPhantom::default(),
        }
    }
}

现在我们可以实现 Iterator

impl<S, E> Iterator for FlexIter<S, E>
where
    E: Clone,
    S: StaticCow<[E]>,
{
    type Item = E;
    fn next(&mut self) -> Option<Self::Item> {
        // This is here to show that we can also access `inner` generically
        // through its `Deref<Target=[E]>` implementation, without having to
        // match on `mut_if_owned()`.
        assert!(self.index <= self.inner.len());

        match self.inner.mut_if_owned() {
            // We're borrowing the slice, so we have to work inefficiently
            // by cloning its elements before we return them.
            MutIfOwned::Const(slice) => {
                if self.index == 0 {
                    None
                } else {
                    self.index -= 1;
                    Some(slice[self.index].clone())
                }
            }
            // We own the slice as a `Vec`, so we can pop elements off of it
            // without cloning.
            MutIfOwned::Mut(vec) => {
                // It's necessary to make sure we first truncate the vector
                // to `index`, because we may have already started iterating
                // before `.into_owned()` was called, and this may be our
                // first time calling `.next()` since we took ownership. Of
                // course we could have had our `into_owned` implementation
                // do this instead of doing it here.
                vec.truncate(self.index);
                let ret = vec.pop()?;
                self.index -= 1;
                Some(ret)
            }
        }
    }
}

现在让我们看看它的实际应用

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    let mut borrowing_iter = FlexIter::new(numbers.borrow());

    println!("Borrowing:");
    println!("{}", borrowing_iter.next().unwrap());
    println!("{}", borrowing_iter.next().unwrap());

    let owning_iter = borrowing_iter.into_owning();
    std::mem::drop(numbers);

    println!("Owning:");
    for item in owning_iter {
        println!("{}", item);
    }
}

运行此代码，我们得到预期的结果

Borrowing:
5
4
Owning:
3
2
1

此示例也可在 crate 源代码的 examples/flex_iter.rs 中找到。