小编Her*_*tar的帖子

我想检查请求的结果是否有任何问题。我将其分为两类：i）服务器错误，ii）其他不成功的原因。第三类是，结果实际上是成功的。然而，在第三类中，我什么都不想做。

所以，我想要的代码是：

if res.status().is_server_error() {
        panic!("server error!");
    } else if !(res.status.is_success()){
        panic!("Something else happened. Status: {:?}", res.status());
    } else{
        pass;
    }

我知道实现此结果的其他方法：使用match, ifs 而不是if else if. 但我想了解 对应的关键字是什么pass，就像我们在 Python 中一样。我的目标是：如果结果成功，就继续前进，如果不成功，有两种方法来处理这种恐慌。

我有一个 Rust 项目，它使用一个相当大的框架。编译和宏扩展需要很长时间。如果我对代码进行微小的更改，则在“货物测试”实际执行之前需要一分钟或更长时间。

是否可以在同一个板条箱中创建子项目或子模块并仅测试模块中的代码（假设模块外部的代码不存在依赖关系）？

注释提供了一种有趣的方式来显示结构最终如何在内存中布局。它还表示，对于默认表示，不提供任何保证。虽然我可以使用std::mem::align_ofand检查对齐和大小std::mem::size_of，但有没有办法获得 Rust 布局我的结构/枚举的确切方式，例如带有字段名称和偏移量的表？

我正在尝试创建一个crash!基本上只是包装的自定义宏eprintln!，但它可以是任何其他format!类似的宏。目前看起来是这样的。

macro_rules! crash {
    ($fmt_str:literal, $($args:expr),*) => {{
        eprintln!($fmt_str, $args);
        std::process::exit(1);
    }};
}

我无法$args直接使用，因为它仍在重复，所以我需要某种方法将其分开，但我不知道该怎么做。

我正在尝试在 Rust 中使用以下松散格式解析 JSON 文件serde_json：

{
  "Source_n": {
    "Destination_n": {
      "distance": 2,
      "connections": [
        {
          "color": "Any",
          "locomotives": 0,
          "tunnels": 0
        }
      ]
    }
...

其中Source和Destination可以是任意数量的键（链接到完整文件）。

我创建了以下结构来尝试反序列化 JSON：

#[derive(Debug, Deserialize)]
struct L0 {
    routes: HashMap<String, L1>,
}

#[derive(Debug, Deserialize)]
struct L1 {
    destination_city: HashMap<String, L2>,
}

#[derive(Debug, Deserialize)]
struct L2 {
    distance: u8,
    connections: Vec<L3>,
}

#[derive(Debug, Deserialize, Clone)]
struct L3 {
    color: String,
    locomotives: u8,
    tunnels: u8,
}

当我尝试将 JSON 作为 …

我需要在 Rust 中执行 128 位乘 64 位除法。x86-64 ISA 包含用于此目的的本机 DIV 指令。但是，我编译的测试代码没有使用该指令。

测试代码：

pub fn div(hi: u64, lo: u64, divisor: u64) -> u64 {
   assert!(hi < divisor);

   let dividend = ((hi as u128) << 64) + lo as u128;
   (dividend / divisor as u128) as u64
}

编译器资源管理器输出：

example::div:
    push    rax
    cmp     rdi, rdx
    jae     .LBB0_1
    mov     rax, rdi
    mov     rdi, rsi
    mov     rsi, rax
    xor     ecx, ecx
    call    qword ptr [rip + __udivti3@GOTPCREL]
    pop     rcx
    ret
.LBB0_1:
    ...

相反，通过 __udivti3 …

我想创建一个具有部分透明背景的视图（舞台、窗口）。我有一个包含 alpha 通道的图像

我在 JavaFx 中使用了这种场景，我必须将场景填充设置为 null，将根节点背景颜色设置为透明。我用 TornadoFX 尝试了同样的方法：

class NextRoundView : View("Következ? kör") {

    override val root = vbox {
        style {
            backgroundColor = multi(Color.TRANSPARENT)
            backgroundImage = multi(URI.create("/common/rope-bg-500x300.png"))
            backgroundRepeat = multi(BackgroundRepeat.NO_REPEAT 
                                  to BackgroundRepeat.NO_REPEAT)
        }
        prefWidth = 500.0
        prefHeight = 300.0

        spacing = 20.0
        padding = insets(50, 20)
        text("A text") {
            font = Font.font(40.0)
            alignment = Pos.CENTER
        }

        button("OK")
        {
            font = Font.font(20.0)
            action {
                close()
            }
        }
        sceneProperty().addListener{ _,_,n ->
            n.fill = null
        }
    }

}

我这样调用视图：

NextRoundView().apply { …

我正在尝试遵循本教程。

我正在 Windows 10 系统中运行 WSL2 Ubuntu18.04 机器，并且在运行此行时陷入困境：

$ solana-test-validator

这是我得到的输出：

Ledger location: test-ledger
Log: test-ledger/validator.log
Unable to connect to validator: Client error: test-ledger/admin.rpc does not exist

关于可能出什么问题的任何线索吗？

当我研究 Rust 时，我试图编写一个 Rust 函数来查看任何可迭代的字符串。

我最初的尝试是

fn example_1(iter: impl Iterator<Item=&str>);
fn example_2(iter: impl Iterator<Item=&String>);
// ...

这需要针对不同情况的两个函数。

我也尝试将上面的案例合并为一个，我得到的是：

fn example_3<'a, T: 'a + ?Sized + Deref<str>>(iter: impl Iterator<Item=&'a T>);

可以接受Iterator<Item=&String>和Iterator<Item=&str>，但不能接受Iterator<String>（因为最后一个需要在函数体中再借用一次）。而且，它看起来比应有的要复杂得多。

我当然可以使用 custom 来实现这一点trait，也许涉及AsRef，但我认为我可能会错过一种更好、更清晰的方法。

是否可以构建结构

struct MyFn<A, B> {
    call: fn(A) -> B
}

这样它就能够捕获不可变的变量，如下面的代码片段所示？

let y: &f64 = &3.0
let my_fn: MyFn<f64, f64> {
    call: |x| {
        x + *y
    }
}

我知道在这种情况下需要闭包，但是 的类型应该是什么，call以便它可以捕获任何不可变的引用（例如函数引用）？