怎样在 Rust 中写一个 panic 安全的机制，类似 Java 的 try { ... } finally { ... }，同时允许 try 和 finally 块分别可变借用同一个值？
我需要的是，无论正常离开还是因 panic 栈展开而离开 try 块，它的借用都立刻结束，而 finally 块的借用只有在控制流到达那里时才开始。
用 scopeguard::defer! 时，必须先声明闭包，再写对应的 try 块，可变借用会在创建闭包时立刻开始，因此对应 try 块的代码就无法再可变借用那个已经被闭包借用的值。
What would be a way for me to write a panic-safe mecanism in Rust that behaves similarly to Java's try { ... } finally { ... }, where the try and finally blocks each mutably borrow the same value?
What I need is for a try block's borrows to finish as soon as control leaves it, whether by normal execution or panic unwinding, with the finally block borrowing only once control reaches it.
With scopeguard::defer!, the closure has to be declared before the equivalent try block, which starts the mutable borrow immediately upon creating that closure, which means the code corresponding to the try block cannot then take its own mutable borrow of the same thing already borrowed by that closure.
用 scopeguard::defer! 时，必须先声明闭包，再写对应的 try 块，可变借用会在创建闭包时立刻开始，
这里不适合用 defer!()，可以改用 guard 函数，把值放进 scopeguard::ScopeGuard。
因为 ScopeGuard 提供了 Deref 和 DerefMut，访问这个 guard 就和访问它包含的值一样。
struct Resource {}
// ownership of the resource goes into this destructor
// a closure normally serves this purpose
fn release_resource(resource: Resource) {
println!("dropping resource");
}
fn main() {
// obtain the resource, then give it a guard
let resource: Resource = acquire_resource();
let mut resource = guard(resource, release_resource);
// borrowing the resource mutably is another option
// let mut resource = guard(&mut resource, release_resource_by_mut);
// access the enclosed resource through its guard
resource.refresh();
inspect_resource(&resource);
change_resource(&mut resource);
// leaving this scope runs the destructor
// or disable the guard to recover the resource
// without invoking its destructor
// let resource = ScopeGuard::into_inner(resource);
}With scopeguard::defer!, the closure has to be declared before the equivalent try block, which starts the mutable borrow immediately upon creating that closure,
defer!() isn't suitable here, but the guard function can place your value inside a scopeguard::ScopeGuard insted.
since ScopeGuard supplies Deref and DerefMut, accessing the guard works like accessing the value it holds.
struct Resource {}
// ownership of the resource goes into this destructor
// a closure normally serves this purpose
fn release_resource(resource: Resource) {
println!("dropping resource");
}
fn main() {
// obtain the resource, then give it a guard
let resource: Resource = acquire_resource();
let mut resource = guard(resource, release_resource);
// borrowing the resource mutably is another option
// let mut resource = guard(&mut resource, release_resource_by_mut);
// access the enclosed resource through its guard
resource.refresh();
inspect_resource(&resource);
change_resource(&mut resource);
// leaving this scope runs the destructor
// or disable the guard to recover the resource
// without invoking its destructor
// let resource = ScopeGuard::into_inner(resource);
}谢谢！这个办法看起来能满足需求。我希望 scopeguard 文档先展示“带值”的情况，再展示使用单元值的例子。
Thanks! That looks like it does the job. In the scopeguard documentation, I'd prefer seeing the case "with value" before the example that uses a unit value.
Nim 2 是按调用点决定拷贝还是移动的，不是按 proc。 同一个参数，同一个 proc。第一次调用会拷贝，因为后面还要用 a。第二次就移动了。调用点上没有任何东西告诉你是哪种。nim c --expandArc:main 会打印改写后的函数体，两…
每次尝试从键盘往一些 char 数组里输入内容，程序最后都会崩溃。 有什么简单方便的方法，可以从键盘读取 char 数组并保存下来？
我想写一个函数，处理并过滤用户输入，然后把得到的字符串返回给调用它的函数。 能不能不声明下面例子中的这种全局变量，也实现这个功能？
