相关疑难解决方法(0)

我正在阅读以下文档File:

//..
let mut file = File::create("foo.txt")?;
//..

什么是?在这条线？我不记得以前在Rust Book中看过它了.

由于分号在Rust中显然是可选的,为什么,如果我这样做:

fn fn1() -> i32 {    
    let a = 1
    let b = 2
    3
}

我收到错误:

error: expected one of `.`, `;`, `?`, or an operator, found `let`
 --> src/main.rs:3:9
  |
2 |         let a = 1
  |                  - expected one of `.`, `;`, `?`, or an operator here
3 |         let b = 2
  |         ^^^ unexpected token

？

我正在阅读Rust文档,并遇到了以下示例和声明

使用return作为函数的最后一行有效,但被认为是糟糕的样式:

fn foo(x: i32) -> i32 {
    if x < 5 { return x; }

    return x + 1;
}

我知道我可以写上面的内容

fn foo(x: i32) -> i32 {
    if x < 5 { return x; }

    x + 1
}

但我更倾向于写前者,因为这更直观.我确实理解函数返回值应该用作表达式,以便后面有效但是为什么不鼓励前者呢？

我正在panic::catch_unwind惊慌失措:

use std::panic;

fn main() {
    let result = panic::catch_unwind(|| {
        panic!("test panic");
    });

    match result {
        Ok(res) => res,
        Err(_) => println!("caught panic!"),
    }
}

(游乐场)

这似乎工作得很好,但我仍然得到了恐慌的输出到stdout.我想这只打印出来:

caught panic!

代替

thread '<main>' panicked at 'test panic', <anon>:6
note: Run with `RUST_BACKTRACE=1` for a backtrace.
caught panic!

在像C#这样的语言中,给出这个代码(我没有await故意使用关键字):

async Task Foo()
{
    var task = LongRunningOperationAsync();

    // Some other non-related operation
    AnotherOperation();

    result = task.Result;
}

在第一行中,long操作在另一个线程中运行,并Task返回a(即未来).然后,您可以执行另一个与第一个并行运行的操作,最后,您可以等待操作完成.我认为,这也是行为async/ await在Python,JavaScript等

另一方面,在Rust中,我在RFC中读到:

Rust的期货与其他语言的期货之间的根本区别在于,除非进行调查,否则Rust的期货不会做任何事情.整个系统是围绕这个建立的:例如,取消正在降低未来正是出于这个原因.相比之下,在其他语言中,调用异步fn会旋转一个立即开始执行的未来.

在这种情况下,是什么目的async/ await鲁斯特？看到其他语言,这种表示法是一种运行并行操作的便捷方式,但是如果调用async函数没有运行任何东西,我无法看到它在Rust中是如何工作的.

我有一个函数调用另一个返回a的函数Result。我需要检查Resultis是Ok或Err，如果它是an Err，则需要return从我的函数开始。这就是我现在正在做的：

match callable(&mut param) {
    Ok(_v) => (),
    Err(_e) => return,
};

有没有更惯用的Rust方法来做到这一点？

我正在编写一个函数，该函数在成功（和失败）时返回 serde_json::Value。以前在 Rust 中，我一直省略分号以从函数返回数据，如下面的代码示例所示：

use serde_json::{Result, Value};
use core::result::Result as ResultCore;

fn returning_function() -> ResultCore<Value, Value> {
    let data = r#"
    {
        "status": "ok",
        "response": {
            "data": "secret message!"
         }
    }
    "#;

    match str_to_json(data) {
        Ok(json_data) => match json_data["status"].as_str() {
            Some(status_str) => {
                if status_str == "ok" {
                    Ok(json_data["response"].clone())
                }
            }
            None => eprintln!("\"status\" was not a string")
        }
        Err(error) => eprintln!("something went wrong! here's what: {}", error)
    }

    Err(serde_json::Value::Null)
}

fn str_to_json(json_data: &str) -> Result<Value> {
    Ok(serde_json::from_str(json_data)?)
}

这是我不明白的部分：这不能编译。Rust …

考虑一下:

loop {
    let data = match something() {
        Err(err) => {
            warn!("An error: {}; skipped.", err);
            continue;
        },
        Ok(x) => x
    };

    let data2 = match somethingElse() {
        Err(err) => {
            warn!("An error: {}; skipped.", err);
            continue;
        },
        Ok(x) => x
    };

    // and so on
}

如果我不需要分配ok值data,我会使用if let Err(err) = something(),但是上面的代码是否有快捷方式,以避免复制粘贴Err/Ok分支,我认为,典型情况？像这样的东西if let也会返回ok值.