小编Her*_*tar的帖子

是否可以创建技术上可变大小但在编译时已知的数组？更准确地说，我想做这样的事情：

fn main() {
    for n in 1..5 {
        let array: [i32; n] = [0; n];
        // Do stuff with array
    }
}

for这段代码无法编译，但我觉得应该可以做到，因为编译器唯一可以解开循环，如下所示：

fn main() {
    let array: [i32; 1] = [0; 1];
    let array: [i32; 2] = [0; 2];
    let array: [i32; 3] = [0; 3];
    let array: [i32; 4] = [0; 4];
    let array: [i32; 5] = [0; 5];
}

它编译并执行我想要的操作，但非常重复

我可以使用向量或其他数据结构，但是我会在堆中包含变量，并且我认为我不应该仅仅因为我在循环中使用数组而使用for堆

我想对某些结构提供一些业务规则保证。例如，anEmailAddress是有效的电子邮件，或者 aDateRange的 from 位于 from 之前，等等。因此，当传递这样的值时，可以保证遵守该结构的所有业务规则。

struct InvalidEmailAddress;
struct EmailAddress {
  value: String
}

impl EmailAddress {
  fn new(value: String) -> Result<Self, InvalidEmailAddress> {
    if value.contains("@") { // I know, this isn't any sort of validation. It's an example.
        Ok(Self { value })
    } else {
        Err(InvalidEmailAddress)
    }
  }
}

忽略 now 的new()行为是意外的（使用方法可能会更好build()），这会带来一个问题：当有人EmailAddress通过构造函数构建 an 时，它保证是“有效的”。但是当有人将其构造为普通结构时，它可能不是。：

let guaranteed_valid = EmailAddress::new(String::from("hi@example.com")).unwrap();
let will_crash = EmailAddress::new(String::from("localhost")).unwrap()
let unknown_valid = EmailAddress { …

我正在尝试找到最快的方法来翻转 Rust 中布尔值的值？IE

false => true
true => false

对于我的应用程序，我不关心布尔值的当前值，只关心它被翻转。对于我的应用程序（阿特金筛法 - 埃拉托斯特尼筛法的改进版本），这需要执行大量次，因此最好让它尽可能快地运行。目前我的代码是：

item[i] = !item[i]

因为，（如上所述） item[i] 的当前值是无关紧要的，我确信有一种更快的（可能是按位的）方法来做到这一点。但是，我有点生锈，一直找不到它，有人可以建议我更好的方法吗？

谢谢，

我有一个带有泛型类型参数的特征。我想将实现此特征的不同对象放入一个集合中。对象有不同的类型参数。

当我这样做时，编译器告诉我需要指定泛型类型参数。实际上，我的情况不需要这种通用类型信息，因此某种通配符适合我。让我展示代码，因为它更好地表明了我的意图：

trait Test<T> {
    fn test(&self) -> T;
}
struct Foo;
struct Bar;
impl Test<i64> for Foo {
    fn test(&self) -> i64 {
        println!("foo");
        42
    }
}
impl Test<String> for Bar {
    fn test(&self) -> String {
        println!("bar");
        "".to_string()
    }
}

fn main() {
    // I'm not going to invoke test method which uses generic type parameter.
    // So some kind of wildcard would work for me.
    // But underscore is not wildcard and this does not compile.
    let …

我想重载此结构的索引运算符：

struct Ram<'a> {
    ram: &'a mut [u8]
}

impl<'a> Ram<'a> {
  pub fn new( bytes: &mut[u8]) -> Ram {
    Ram {
        ram: bytes
    }
  }
}

...基本上是字节数组上的“控制器”。我这样做是因为我想将它重用于不同大小的字节数组。我知道生命周期在这里是为了确保“ram”引用在整个执行过程中都是有效的。这是我当前的索引代码：

use std::ops::{Index};
impl<'a> Index<usize> for Ram<'a> {
    type Output = u8;
    fn index(&self, i: usize) -> &'a u8 {
        &self.ram[i]
    }
}

这不编译。Rust 说有一个匿名生命周期定义与 'a 在 index(...) 定义中冲突：“错误[E0495]：由于需求冲突，无法推断函数调用中生命周期参数的适当生命周期”。

我应该如何实现这一点？还是我对一生的假设完全错误？谢谢。

我正在尝试将目录压缩到tar.gz文件中，并在使用 Rust 后将其解压缩。我正在使用板条箱tar = "0.4.35"和flate2 = "1.0.20". 我在 Windows 上。

我的代码与此处的示例几乎相同。

let tar = File::create("a.tar.gz").unwrap();
let enc = GzEncoder::new(tar, Compression::default());
let mut a = tar::Builder::new(enc);
a.append_dir_all("", "in").unwrap();

let tar = File::open("a.tar.gz").unwrap();
let dec = GzDecoder::new(tar);
let mut a = Archive::new(dec);
a.unpack("out").unwrap();

解压时总是报错： thread 'main' panicked at 'called Result::unwrap() on an Errvalue: Custom { kind: InvalidInput, error: TarError { desc: "failed to iterate over archive", io: Custom { kind: InvalidInput, error: "invalid gzip …

我的程序使用csvcrate into读取 CSV 文件Vec<Vec<String>>，其中外部向量表示行，内部向量将行分成列。

use std::{time, thread::{sleep, park}};
use csv;

fn main() {
    different_scope();

    println!("Parked");
    park();
}

fn different_scope() {
    println!("Reading csv");
    let _data = read_csv("data.csv");

    println!("Sleeping");
    sleep(time::Duration::from_secs(4));

    println!("Going out of scope");
}

fn read_csv(path: &str) -> Vec<Vec<String>> {
    let mut rdr = csv::Reader::from_path(path).unwrap();

    return rdr
        .records()
        .map(|row| {
            row
                .unwrap()
                .iter()
                .map(|column| column.to_string())
                .collect()
        })
        .collect();
}

我正在查看 RAM 使用情况，htop这使用 2.5GB 内存来读取 250MB CSV 文件。

以下是内容 cat /proc/<my pid>/status

Name:   (name)
Umask:  0002 …

我需要在 C 和 Rust 应用程序之间共享内存。Rust - 生产者，C - 消费者。

在 CI 中会创建一个共享内存区域并将其传递给 Rust 进行写入。

在C端我使用这样的东西：

fd = shm_open(STORAGE_ID, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
res = ftruncate(fd, STORAGE_SIZE);
addr = mmap(NULL, STORAGE_SIZE, PROT_WRITE, MAP_SHARED, fd, 0);
// read from that memory after it is written by Rust app
char data[STORAGE_SIZE];
memcpy(data, addr, STORAGE_SIZE);

我在 Rust 方面该怎么做才能使用 STORAGE_ID 打开内存并写入它？我想它是沿着使用这个的路线，但找不到可靠的例子：

https://docs.rs/libc/0.2.77/libc/fn.shm_open.html

https://docs.rs/memmap/0.6.1/memmap/struct.Mmap.html

https://doc.rust-lang.org/nightly/std/primitive.slice.html#method.clone_from_slice

基本上，我需要做这样的事情，但是用 Rust 编写的 set.c： POSIX 共享内存 IPC 示例（shm_open、mmap），在 Linux 和 macOS 上工作

fn pair_finder(pairs_length: u64) {
    let mut path: HashMap<u64, u64> = HashMap::new();

        for i in 0..pairs_length {
            if (metadata.token0 == pair_metadata.token0)
                || (metadata.token0 == pair_metadata.token1)
                || (i == *path.get(&current_depth).unwrap())
            {
                continue;
            }
    }
}

我有一个包含上述块的函数。Path 是HashMap其中第一个u64 是路径的 ID，第二个u64 是对 ID。current_depth used 是循环的一部分，在添加新的路径后它会增加。

然而它惊慌失措。这是因为我i == *path.get(&current_depth).unwrap()在 if 块中使用了。并且HashMap是空的current_depth并且它有一个None 值。有什么方法可以防止恐慌None并将 if 块视为false？

thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/main.rs:69:52

如何在 Rust 中将向量写入 JSON 文件？

代码：

use std::fs::File;
use std::io::prelude::*;

let vec1 = vec![1.0,2.0,2.1,0.6];

let mut file = File::create("results.json").unwrap();
let data = serde_json::to_string(&vec1).unwrap();

file.write(&data);

错误：

mismatched types
expected reference `&[u8]`
   found reference `&std::string::String`rustc(E0308)