小编Luk*_*odt的帖子

我尝试实现Dump类似于serdes的proc_macro Serialize。

为了这个目的，我有一个箱子foo包含我的“原始”结构（P1和P2在这种情况下），这应该只是dumpable。

接下来，我确实有一个foo_derive包含程序宏本身的板条箱。

因为我想支持多种格式，所以我有第三个板条箱foo_dump，其中包含trait定义Dump（例如，可以转储此结构）和Dumper（这是后端应实现的）。非常直截了当的到这一点。

现在，我想编译它时，出现以下错误：

$ cargo build
error: cyclic package dependency: package `foo v0.1.0 (/tmp/tmp.u34pI5J6qd/example/foo)` depends on itself. Cycle:
package `foo v0.1.0 (/tmp/tmp.u34pI5J6qd/example/foo)`
    ... which is depended on by `foo_dump v0.1.0 (/tmp/tmp.u34pI5J6qd/example/foo_dump)`
    ... which is depended on by `foo_derive v0.1.0 (/tmp/tmp.u34pI5J6qd/example/foo_derive)`

我不知道正确的方法是什么，如何在此板条箱中使用依赖项。我当前的是：

这当然是不可能的。

我想念什么？我该怎么做才能打破依赖圈？

（mcve @ github）

/Cargo.toml

[workspace]
members = [ 
    "foo",
    "foo_derive",
    "foo_dump",
]

/foo/Cargo.toml

[package]
name …

我有一个通用函数foo具有一些复杂的特征边界：

use std::ops::Index;\n\n// This trait is just as an example\ntrait Float {\n    const PI: Self;\n    fn from_f32(v: f32) -> Self;\n}\n// impl Float for f32, f64 ...\n\nfn foo<C>(container: &C)\nwhere\n    C: Index<u32>,\n    <C as Index<u32>>::Output: Float,\n{\n    // ...\n}\n

我现在需要<C as Index<u32>>::Output在函数内部使用一堆类型（例如通过::PI或说获取 \xcf\x80 ::from_f32(3.0)）。但这种类型手动输入很长，并且使整个代码非常冗长且难以阅读。（笔记：在我的真实代码中，实际类型甚至更长、更难看。）

为了解决这个问题，我尝试创建一个函数本地类型别名：

// Inside of `foo`:\ntype Floaty = <C as Index<u32>>::Output;\n

但这会导致以下错误：

use std::ops::Index;\n\n// This trait is just as an example\ntrait Float {\n    const PI: …

我希望实现 type 的功能OpResource。

type OpResource = Object<OC, Status>;

impl OpResource {
    pub fn get_parameter_values(&self) -> Vec<ParameterValue> {
        self.spec
            .parameter_values
            .clone()
            .or_else(|| Some(vec![]))
            .unwrap()
    }
}

然后我得到一个错误

type OpResource = Object<OC, Status>;

impl OpResource {
    pub fn get_parameter_values(&self) -> Vec<ParameterValue> {
        self.spec
            .parameter_values
            .clone()
            .or_else(|| Some(vec![]))
            .unwrap()
    }
}

我不明白我错在哪里，我只是实现了类型下面的函数，为什么它说我已经超出了箱子？

我已阅读如何使用索引位置迭代 Vec<T>？答案是enumerate在for-loop 中使用。

但是，如果我不使用这样的for-loop：

fn main() {
    let v = vec![1; 10]
        .iter()
        .map(|&x| x + 1  /* + index */ ) // <--
        .collect::<Vec<_>>();

    print!("v{:?}", v);
}

我怎样才能在上面的闭包中获得索引？

在我的网络应用程序中，我获得了MediaStream一个 viagetUserMedia或getDisplayMedia. 在某些情况下，该流的视频轨道可以改变其大小。例如，如果getDisplayMedia跟踪特定窗口，该窗口可以改变大小。或者在移动设备上，当从横向模式切换到纵向模式时，相机图像将旋转 90°（即宽度和高度交换）。

我知道如何获取MediaStream(如此处所述)的尺寸。我现在想在尺寸发生变化时收到通知。某种回调/事件。

我已经尝试过MediaStream.onaddtrack（猜测可能轨道被删除并以不同的大小读取）并且我也尝试MutationObserver在<video>我显示流的元素上使用 a 。这些都不起作用。我还检查了 MDN 中可能对我有帮助的其他事件，但我没有找到任何有希望的事件。

有没有办法订阅视频轨道尺寸的变化？每次尺寸改变时都应该调用我的一个函数。如果不可能，我需要忙于轮询：有没有一种聪明的方法可以让轮询不那么忙？

我在内存中有大量 64 位值。不幸的是，它们可能不会与 64 位地址对齐。我的目标是改变所有这些值的字节序，即交换/反转它们的字节。

我知道bswap交换 32 位或 64 位寄存器字节的指令。但是因为它需要一个寄存器参数，所以我不能将它传递给我的内存地址。当然我可以先将内存加载到寄存器中，然后交换，然后写回：

mov rax, qword [rsi]
bswap rax
mov qword [rsi], rax

但这是否正确，因为地址可能未对齐？

另一种可能性是手动进行交换：

mov al, byte [rsi + 0]
mov bl, byte [rsi + 7]
mov byte [rsi + 0], bl
mov byte [rsi + 7], al

mov al, byte [rsi + 1]
mov bl, byte [rsi + 6]
mov byte [rsi + 1], bl
mov byte [rsi + 6], al

mov al, byte [rsi + 2]
mov bl, …

我有一个简单的.rs文件，想使用进行编译rustc。我总是听说在发布模式下进行编译有多么重要，因为否则我的Rust程序会很慢。

但是，如果我使用经常引用的--release标志，则它不起作用。如果旗帜甚至不存在，每个人都在谈论什么？

$ rustc --release foo.rs
error: Unrecognized option: 'release'.

我正在尝试使用 WebAssembly 运行一个用 Rust 编写的 hello world 程序，但是当我尝试加载该程序时收到一条错误消息。

按照我发现的一些教程，我能够让它运行，问题是他们使用 Emscripten 创建 JavaScript 和 HTML 来加载代码，但是这个 JavaScript 和 HTML 包含大量的样板文件和其他东西。我有点迷路了，而是想尝试获得一个非常简单的例子，我正在加载自己。

我运行以下命令来编译 hello.wasm

echo 'fn main() { println!("Hello, Emscripten!"); }' > hello.rs
rustc --target=wasm32-unknown-emscripten hello.rs

为了加载 hello.wasm，我从 Mozilla WebAssembly 文档中获取示例并尝试运行它。

var importObject = {
  imports: {
    imported_func: function(arg) {
      console.log(arg);
    }
  }
};

fetch('hello.wasm').then(response =>
  response.arrayBuffer()
).then(bytes =>
  WebAssembly.instantiate(bytes, importObject)
).then(results => {
  // Do something with the compiled results!
});

WebAssembly.instantiate 崩溃：

var importObject = {
  imports: {
    imported_func: function(arg) { …

我目前正在玩LLVM,我正在尝试编写一些优化器来熟悉opt和clang.我写了一个test.c文件,如下所示:

int foo(int aa, int bb, int cc){
    int sum = aa + bb;
    return sum/cc;
}

我编译了源代码并生成了2个.ll文件,一个未经优化,一个用mem2reg优化器传递:

clang -emit-llvm -O0 -c test.c -o test.bc
llvm-dis test.bc
opt -mem2reg -S test.ll -o test-mem2reg.ll

两个.ll文件都给了我以下输出:

ModuleID = 'test.bc'
source_filename = "test.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

; Function Attrs: noinline nounwind optnone uwtable
define i32 @foo(i32 %aa, i32 %bb, i32 %cc) #0 {
entry:
  %aa.addr = alloca i32, align 4
  %bb.addr = alloca i32, align 4
  %cc.addr = …

我有一个Buffer对象，我想检查它是否全部都是有效的 UTF-8。理想情况下，我也想得到一个string带有上述解码的 UTF-8 文本。

我尝试了Buffer.toString它采用encoding默认为 的参数utf8。不幸的是，文档是这样说的：

如果encoding是'utf8'并且输入中的字节序列不是有效的 UTF-8，则每个无效字节将替换为替换字符U+FFFD。

这不是我想要的：我宁愿想要一个异常或一个布尔标志。只需检查结果字符串是否包含U+FFFD与输入文本可能已包含的内容不同U+FFFD（就像有效的 Unicode 代码点一样）。当然，可以尝试U+FFFD在缓冲区和字符串中计数，然后进行比较，但这似乎毫无用处，复杂且低效。

有没有更好的办法？