如何将Rust重试循环改写为闭包？避免使用mut变量

我编写了如下Rust代码，用于重试调用some_func()：

let mut result = some_func();
for s in some_iterator {
    if result.is_ok() {
        break;
    }
    thread::sleep(time::Duration::from_millis(10));
    result = some_func();
}
// use result

此处必须将result声明为mut，才能在重试过程中更新它。请问是否可以运用函数式编程技巧，避免将result声明为mut？

我曾考虑过以下实现方案，但并不理想，因为它会遍历some_iterator的所有元素，这不符合我的需求：

let result = some_iterator.fold(some_func(), |result, x| {
    if result.is_ok() {
        return result; 
    }
    // sleep and retry 
});

当然可以，以下两种函数式方案都能满足需求，且成功后立即停止迭代，不会遍历所有元素：

方案一：使用try_fold #

try_fold支持提前终止迭代，当闭包返回包含成功结果的Ok(result)时，会直接终止并返回该结果：

use std::thread;
use std::time;

let result = some_iterator.try_fold(some_func(), |result, _| {
    if result.is_ok() {
        Ok(result)
    } else {
        thread::sleep(time::Duration::from_millis(10));
        Ok(some_func())
    }
}).unwrap_or_else(|_| unreachable!());

方案二：使用iter::successors #

通过successors生成包含重试结果的迭代器，取第一个成功的结果；如果需要限制重试次数，可以结合take：

use std::iter;
use std::thread;
use std::time;

// 无次数限制的重试（直到成功）
let result = iter::successors(Some(some_func()), |prev| {
    if prev.is_ok() {
        None
    } else {
        thread::sleep(time::Duration::from_millis(10));
        Some(some_func())
    }
}).last().unwrap();

// 限制重试次数（与原代码的some_iterator长度一致）
let max_retries = some_iterator.count();
let result = iter::successors(Some(some_func()), |prev| {
    if prev.is_ok() {
        None
    } else {
        thread::sleep(time::Duration::from_millis(10));
        Some(some_func())
    }
}).take(max_retries + 1) // 包含初始调用+max_retries次重试
.last().unwrap();

这两种方式都无需声明mut的result变量，完全通过函数式迭代器方法实现重试逻辑，且符合“成功即停止”的需求。

内容的提问来源于stack exchange，提问作者User12547645