Question

我希望使用Peekable作为新cautious_take_while操作的基础，该操作与take_while中的IteratorExt类似，但不会消耗第一个失败的项目。（还有一个问题是这是否是一个好主意，以及是否有更好的方法来实现Rust的这一目标 - 我很乐意在这个方向上提示，但主要是我在这里试图了解我的代码在哪里破坏。

我尝试启用的API基本上是：

let mut chars = "abcdefg.".chars().peekable();

let abc : String = chars.by_ref().cautious_take_while(|&x| x != 'd');
let defg : String = chars.by_ref().cautious_take_while(|&x| x != '.');

// yielding (abc = "abc", defg = "defg")

我在creating a MCVE here采取了行动，但我得到了：

：10：5：10：19错误：无法摆脱借来的内容：10 chars.by_ref（）。cautious_take_while（|＆amp; x | x！=＆＃39;。＆＃39;）;

据我所知，我在功能签名方面遵循与Rust自己TakeWhile相同的模式，但我看到的不同的行为与借用检查员。有人可以指出我做错了吗？

Answer 1

by_ref()的有趣之处在于它返回了对自身的可变引用：

pub trait IteratorExt: Iterator + Sized {
    fn by_ref(&mut self) -> &mut Self { self }
}

它的工作原理是因为指向Iterator 类型的可变指针实现了Iterator特征。智能！

impl<'a, I> Iterator for &'a mut I where I: Iterator, I: ?Sized { ... }

标准take_while功能有效，因为它使用的特性Iterator会自动解析为&mut Peekable<T>。

但是你的代码不起作用，因为Peekable是一个结构，而不是一个特征，所以你的CautiousTakeWhileable必须指定类型，并且你试图取得它的所有权，但你不能，因为你有一个可变的指针。

解决方案，不要Peekable<T>而是&mut Peekable<T>。您还需要指定生命周期：

impl <'a, T: Iterator, P> Iterator for CautiousTakeWhile<&'a mut Peekable<T>, P>
where P: FnMut(&T::Item) -> bool {
     //...
}

impl <'a, T: Iterator> CautiousTakeWhileable for &'a mut Peekable<T> {
    fn cautious_take_while<P>(self, f: P) -> CautiousTakeWhile<&'a mut Peekable<T>, P>
     where P: FnMut(&T::Item) -> bool {
        CautiousTakeWhile{inner: self, condition: f,}
    }
}

此解决方案的一个奇怪的副作用是现在不需要by_ref，因为cautious_take_while()采用可变引用，因此它不会窃取所有权。 by_ref()需要take_while()来电，因为它可以Peekable<T>或&mut Peekable<T>，默认为第一个。通过by_ref()调用，它将解析为第二个。

现在我终于明白了，我认为改变struct CautiousTakeWhile的定义以将可窥探的位包含在结构本身中可能是个好主意。困难在于，如果我正确的话，必须手动指定生命周期。类似的东西：

struct CautiousTakeWhile<'a, T: Iterator + 'a, P> 
    where T::Item : 'a {
    inner: &'a mut Peekable<T>,
    condition: P,
}
trait CautiousTakeWhileable<'a, T>: Iterator {
    fn cautious_take_while<P>(self, P) -> CautiousTakeWhile<'a, T, P> where
        P: FnMut(&Self::Item) -> bool;
}

其余的或多或少是直截了当的。

Answer 2

这是一个棘手的问题！我会带着代码的肉，然后尝试解释它（如果我理解它......）。它也是丑陋的，没有版本的版本，因为我想减少偶然的复杂性。

use std::iter::Peekable;

fn main() {
    let mut chars = "abcdefg.".chars().peekable();

    let abc: String = CautiousTakeWhile{inner: chars.by_ref(), condition: |&x| x != 'd'}.collect();
    let defg: String = CautiousTakeWhile{inner: chars.by_ref(), condition: |&x| x != '.'}.collect();
    println!("{}, {}", abc, defg);
}

struct CautiousTakeWhile<'a, I, P> //'
    where I::Item: 'a, //'
          I: Iterator + 'a, //'
          P: FnMut(&I::Item) -> bool,
{
    inner: &'a mut Peekable<I>, //'
    condition: P,
}

impl<'a, I, P> Iterator for CautiousTakeWhile<'a, I, P>
    where I::Item: 'a, //'
          I: Iterator + 'a, //'
          P: FnMut(&I::Item) -> bool
{
    type Item = I::Item;

    fn next(&mut self) -> Option<I::Item> {
        let return_next =
            match self.inner.peek() {
                Some(ref v) => (self.condition)(v),
                _ => false,
            };
        if return_next { self.inner.next() } else { None }
    }
}

实际上，Rodrigo seems to have a good explanation，所以我会推迟，除非你希望我解释具体的事情。

实施＆＃34;谨慎＆＃34; take_while使用Peekable

2 个答案: