“上下文"和“上下文"有什么区别?和“with_context"无论如何? [英] What is the difference between "context" and "with_context" in anyhow?
问题描述
这是关于 anyhow Context 的文档:
This is the documentation for anyhow's Context:
/// Wrap the error value with additional context.
fn context<C>(self, context: C) -> Result<T, Error>
where
C: Display + Send + Sync + 'static;
/// Wrap the error value with additional context that is evaluated lazily
/// only once an error does occur.
fn with_context<C, F>(self, f: F) -> Result<T, Error>
where
C: Display + Send + Sync + 'static,
F: FnOnce() -> C;
在实践中,区别在于 with_context
需要一个闭包,如 anyhow 的 自述文件:
In practice, the difference is that with_context
requires a closure, as shown in anyhow's README:
use anyhow::{Context, Result};
fn main() -> Result<()> {
// ...
it.detach().context("Failed to detach the important thing")?;
let content = std::fs::read(path)
.with_context(|| format!("Failed to read instrs from {}", path))?;
// ...
}
但看起来我可以用context
替换with_context
方法,通过删除||
来摆脱闭包,行为程序的内容不会改变.
But it looks like I can replace the with_context
method with context
, get rid of the closure by deleting ||
, and the behaviour of the program wouldn't change.
这两种方法到底有什么区别?
What is the difference between the two methods under the hood?
推荐答案
提供给 with_context
的闭包是惰性求值的,这也是你使用 with_context
而不是 code>context
与您选择懒惰评估任何事情的原因相同:它很少发生并且计算成本很高.一旦满足这些条件,with_context
就比 context
更可取.注释伪示例:
The closure provided to with_context
is evaluated lazily, and the reason you'd use with_context
over context
is the same reason you'd choose to lazily evaluate anything: it rarely happens and it's expensive to compute. Once those conditions are satisfied then with_context
becomes preferable over context
. Commented pseudo-example:
fn calculate_expensive_context() -> Result<()> {
// really expensive
std::thread::sleep(std::time::Duration::from_secs(1));
todo!()
}
// eagerly evaluated expensive context
// this function ALWAYS takes 1+ seconds to execute
// consistently terrible performance
fn failable_operation_eager_context(some_struct: Struct) -> Result<()> {
some_struct
.some_failable_action()
.context(calculate_expensive_context())
}
// lazily evaluated expensive context
// function returns instantly, only takes 1+ seconds on failure
// great performance for average case, only terrible performance on error cases
fn failable_operation_lazy_context(some_struct: Struct) -> Result<()> {
some_struct
.some_failable_action()
.with_context(|| calculate_expensive_context())
}
这篇关于“上下文"和“上下文"有什么区别?和“with_context"无论如何?的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!