Rust 中可恢复的延续传递样式迭代器减少

Question

我正在尝试编写一个可以随时恢复的延续传递式"reduce"函数。我有一个版本在工作，但在这里，如果我希望它能够利用某种状态的借用，我需要显式编写函数的新版本。 鲁斯特游乐场链接

fn reduce_async_with_store<'a, I, A, F, C>(
store: &mut Store,
mut iterator: I,
accumulator: A,
mut f: F,
continuation: C,
) where
I: Iterator + 'a,
F: FnMut(&mut Store, I::Item, A, Box<dyn FnOnce(&mut Store, A) + 'a>) + Clone + 'a,
C: FnOnce(&mut Store, A) + 'a,
{
match iterator.next() {
None => continuation(store, accumulator),
Some(item) => {
let next: Box<dyn FnOnce(&mut Store, A) + 'a> = {
let f = f.clone();
Box::new(move |store, accumulator| {
reduce_async_with_store(store, iterator, accumulator, f, continuation)
})
};
f(store, item, accumulator, next);
}
}
}
fn some_operation(state: &mut Store, continuation: Box<dyn FnOnce(&mut Store) + 'static>) {
let mut new_state = Store { foo: state.foo };
continuation(&mut new_state);
}
#[derive(Debug)]
pub struct Store {
foo: u8,
}
fn main() {
let mut some_state = Store { foo: 0 };
let arr = vec![1u8, 2u8, 3u8];
reduce_async_with_store(
&mut some_state,
arr.into_iter(),
Vec::new(),
|store, item, mut acc, continuation| {
println!("Item: {}", item);
store.foo += item;
acc.push(item);
some_operation(
store,
Box::new(move |stor| {
continuation(stor, acc);
}),
);
},
|store, acc| {
println!("Done!! {:?} {:?}", store, acc);
},
)
}

这是我想编写的这个函数的版本，我可以在其中将Store作为累加器的一部分传入，然后将其取出 - 但是，如果我这样做，我会得到cannot infer an appropriate lifetime due to conflicting requirements.

鲁斯特游乐场链接

fn reduce_async<'a, I, A, F, C>(mut iterator: I, accumulator: A, mut f: F, continuation: C)
where
I: Iterator + 'a,
F: FnMut(I::Item, A, Box<dyn FnOnce(A) + 'a>) + Clone + 'a,
C: FnOnce(A) + 'a,
{
match iterator.next() {
None => continuation(accumulator),
Some(item) => {
let next: Box<dyn FnOnce(A) + 'a> = {
let f = f.clone();
Box::new(move |accumulator| reduce_async(iterator, accumulator, f, continuation))
};
f(item, accumulator, next);
}
}
}
fn some_operation(state: &mut Store, continuation: Box<dyn FnOnce(&mut Store) + 'static>) {
let mut new_state = Store { foo: state.foo };
continuation(&mut new_state);
}
#[derive(Debug)]
pub struct Store {
foo: u8,
}
fn main() {
let mut some_state = Store { foo: 0 };
let arr = vec![1u8, 2u8, 3u8];
reduce_async(
arr.into_iter(),
(&mut some_state, Vec::new()),
|item, mut acc, continuation| {
let (store, vec) = acc;
println!("Item: {}", item);
store.foo += item;
vec.push(item);
some_operation(
store,
Box::new(move |store| {
continuation((store, vec));
}),
);
},
|(store, vec)| {
println!("Done!! {:?} {:?}", store, vec);
},
)
}

我怎样才能编写这个非专业版本的函数，并在尊重 Rust 的生命周期的同时传递&mut Store之类的东西？

即使我没有指定&mut Store的显式生命周期，我的第一个带有reduce_async_with_store的示例是如何被允许的，并且它可以一直存在到'static年？

some_operation采用盒装闭包，因为这就是我调用的第三方 API 函数所采用的。我想最终用异步迭代器替换这段代码，但我使用的库还不支持未来。

Answer 1

让我们从some_operation开始; 检查常规函数总是比检查闭包更容易，因为编译器只检查它们的签名。

放回被忽略的一生，它看起来像：

fn some_operation<'s>(state: &'s mut Store, continuation: Box<dyn for<'r> FnOnce(&'r mut Store) + 'static>) {
let mut new_state = Store { foo: state.foo };
continuation(&mut new_state);
}

涉及两个不同的生命周期：'s和'r- 它们之间没有联系。

现在让我们看看这里：

Box::new(move |store| {
continuation((store, vec));
}),

continuation类型应根据reduce_async的签名进行Box<dyn FnOnce(A) + 'a>。单态化后的A类型是什么？传递给函数的参数是一个元组：

(&mut some_state, Vec::new()),

第一个元素具有某些'state的类型&'state mut State，第二个元素具有Vec<u8>。重温some_operation的签名：第一个参数是&'s mut State，所以我们在这里选择了'state = 's。然后我们使用类型为&'r mut State的参数调用闭包。

回到主过程，我们尝试从(&'r mut State, Vec<u8>)类型的值构建累加器，该值与(&'state mut State, Vec<u8>)不同。

这就是编译器试图解释的内容:)让我们通过更改some_operation的签名来检查此解释：

fn some_operation<'s>(state: &'s mut Store, continuation: Box<dyn FnOnce(&'s mut Store) + 's>) {
continuation(state);
}

在这里，我们明确标记两个生命周期应该相同，现在代码编译没有任何错误。

请注意，您的第一个代码片段中没有问题，因为每次调用reduce_async_with_store时store: &mut Store参数的生存期都不同！在第二个代码段中，它被固定为'state.

在我看来，最简单的解决方法是完全摆脱可变引用并通过转让所有权来传递Store。

铁锈游乐场链接

fn reduce_async<'a, I, A, F, C>(mut iterator: I, accumulator: A, mut f: F, continuation: C)
where
I: Iterator + 'a,
F: FnMut(I::Item, A, Box<dyn FnOnce(A) + 'a>) + Clone + 'a,
C: FnOnce(A) + 'a,
{
match iterator.next() {
None => continuation(accumulator),
Some(item) => {
let next: Box<dyn FnOnce(A) + 'a> = {
let f = f.clone();
Box::new(move |accumulator| reduce_async(iterator, accumulator, f, continuation))
};
f(item, accumulator, next);
}
}
}
fn some_operation(state: Store, continuation: Box<dyn FnOnce(Store) + 'static>) {
let new_state = Store { foo: state.foo };
continuation(new_state);
}
#[derive(Debug)]
pub struct Store {
foo: u8,
}
fn main() {
let some_state = Store { foo: 0 };
let arr = vec![1u8, 2u8, 3u8];
reduce_async(
arr.into_iter(),
(some_state, Vec::new()),
|item, acc, continuation| {
let (mut store, mut vec) = acc;
println!("Item: {}", item);
store.foo += item;
vec.push(item);
some_operation(
store,
Box::new(move |store| {
continuation((store, vec));
}),
);
},
|(store, vec)| {
println!("Done!! {:?} {:?}", store, vec);
},
)
}

请记住，延续调用不是尾递归的，因此堆栈将在每次迭代时增长。你在这里可能需要一个蹦床。