我想在将文本文件的行传递给函数f之前对其进行预处理。我可以这样：
pub fn example0a<B: BufRead, F: Fn(&str)>(bufread: B, f: F) {
let name = Regex::new("John Doe").unwrap();
for line in bufread.lines() {
let line = line.unwrap();
let pre_processed_line = name.replace_all(&line, "XXX");
f(&pre_processed_line);
}
}
但是我需要使用for_each方法生成一个对象，我可以直接将f传递给该对象。我的第一个想法是使用map方法生成一个迭代器：
// does not compile
pub fn example0b<B: BufRead>(bufread: B) -> impl Iterator {
let name = Regex::new("John Doe").unwrap();
bufread.lines().map(move |line| {
let line = line.unwrap();
let pre_processed_line = name.replace_all(&line, "XXX");
&pre_processed_line as &str;
})
}
这不会编译，因为line以及pre_processed_line的生存期不足以使其从迭代器的next方法中返回。一种选择是返回pre_processed_line.to_string()，但这不好，因为它会克隆所有尚未被replace_all修改过的行，我想避免这种情况。
我决定实现一个包含BufRead和预处理功能的结构，并提供一个for_each方法。我旨在使它尽可能通用，因此实际上，只要预处理函数可以将其转换为&str，它就可以接受任何类型的任何迭代器。
pub struct TransformedStrStream<S, FT>
where
S: Iterator,
FT: FnMut(S::Item, &mut FnMut(&str)),
{
source: S,
transf: FT,
}
impl<S, FT> TransformedStrStream<S, FT>
where
S: Iterator,
FT: FnMut(S::Item, &mut FnMut(&str)),
{
pub fn for_each<F>(self, mut f: F)
where
F: FnMut(&str),
{
let source = self.source;
let mut transf = self.transf;
source.for_each(move |line| transf(line, &mut f));
}
}
我可以用类似于上面示例的方式实例化该结构：
pub fn example1<B: BufRead>(bufread: B, name: Regex) {
let _ = TransformedStrStream {
source: bufread.lines(),
transf: move |line, f| {
let line = line.unwrap();
let repl = name.replace_all(&line, "XXX");
f(&repl as &str)
},
};
}
我认为上面的结构是一个很好的抽象，可以进一步抽象以生成任何类型的值（而不是&str）。
我试图用类型参数&str代替T：
pub struct TransformedStream<S, FT, T>
where
S: Iterator,
FT: FnMut(S::Item, &mut FnMut(T)),
{
source: S,
transf: FT,
phantom: PhantomData<T>,
}
impl<S, FT, T> TransformedStream<S, FT, T>
where
S: Iterator,
FT: FnMut(S::Item, &mut FnMut(T)),
{
pub fn for_each<F>(self, mut f: F)
where
F: FnMut(T),
{
let source = self.source;
let mut transf = self.transf;
source.for_each(move |line| transf(line, &mut f));
}
}
不幸的是，我上面的示例不再编译了：
pub fn example2<B: BufRead>(bufread: B, name: Regex) {
let _ = TransformedStream {
source: bufread.lines(),
transf: move |line, f| {
let line = line.unwrap();
let repl = name.replace_all(&line, "XXX");
f(&repl as &str)
},
phantom: PhantomData,
};
}
error[E0597]: `line` does not live long enough
--> src/lib.rs:37:42
|
37 | let repl = name.replace_all(&line, "XXX");
| ^^^^ borrowed value does not live long enough
38 | f(&repl as &str)
39 | },
| - `line` dropped here while still borrowed
40 | phantom: PhantomData,
41 | };
| - borrowed value needs to live until here
error[E0597]: `repl` does not live long enough
--> src/lib.rs:38:16
|
38 | f(&repl as &str)
| ^^^^ borrowed value does not live long enough
39 | },
| - `repl` dropped here while still borrowed
40 | phantom: PhantomData,
41 | };
| - borrowed value needs to live until here
我认为line和repl的生存时间足以被f处理，就像&str版本一样。对于上面的迭代器示例，使用repl.to_string()可以满足编译器的要求，但是我不想克隆每一行。
我的直觉是问题来自PhantomData<T>，我必须将其添加到结构中才能满足编译器的要求。是否像我有一个类型为T的字段一样，约束T的生存期（生存时间与包含的struct一样长）？我试图用PhantomData<*const T>代替它，我认为这可能不会限制生命周期，但是并不能解决我的问题...
为什么第二个版本不能编译？我该如何运作？
答案 0 :(得分：2)
使用T代替&T。它是对原始&str版本的更直接的翻译，因此您可以确定更改后可以使用。确实如此：
pub struct TransformedStream<S, FT, T>
where
S: Iterator,
T: ?Sized,
FT: FnMut(S::Item, &mut FnMut(&T)),
{
source: S,
transf: FT,
phantom: PhantomData<*const T>,
}
impl<S, FT, T> TransformedStream<S, FT, T>
where
S: Iterator,
T: ?Sized,
FT: FnMut(S::Item, &mut FnMut(&T)),
{
pub fn for_each<F> (self, mut f: F) where F: FnMut(&T) {
let source = self.source;
let mut transf = self.transf;
source.for_each(move |line| transf(line, &mut f));
}
}