小编mca*_*ton的帖子

我正在生成一个线程来做一些工作。有时我希望这个线程在工作完成后死亡，其他时候我希望它等待更多的工作去做。为此，我传入了一个Option<Receiver<T>>. 如果Option<Receiver<T>>是None线程应该死，否则就应该等待接收更多的工作。

fn foo(rx: Option<Receiver<usize>>) {
    thread::spawn(move || {
        loop {
            do_some_work();
            if let Some(r) = rx {
                match r.recv() {
                    Ok(x)  => {}
                    Err(_) => panic!("Oh no!"),
                }
            } else {
                break; //Die
            }
        }
    });
}

（链接到操场）

编译器说：

fn foo(rx: Option<Receiver<usize>>) {
    thread::spawn(move || {
        loop {
            do_some_work();
            if let Some(r) = rx {
                match r.recv() {
                    Ok(x)  => {}
                    Err(_) => panic!("Oh no!"),
                }
            } else {
                break; //Die …

Rust文档说默认的整数类型是i32，这意味着变量默认可以保存的最大数字是2147483647ie 2e31 - 1。事实证明，这是千真万确的：如果我试图挽救数量大于2e31 - 1在x变，我得到的错误literal out of range。

码

fn main() {
    let x = 2147483647;
    println!("Maximum signed integer: {}", x);
    let x = 2e100;
    println!("x evalues to: {}", x);
}

但是，如果我2e100在x变量中保存值，为什么我不会出错？它的计算结果肯定大于2e31 - 1。

输出量

fn main() {
    let x = 2147483647;
    println!("Maximum signed integer: {}", x);
    let x = 2e100;
    println!("x evalues to: {}", x);
}

码

fn main() {
    let …

（希望如此）来自一个完整的 Rust 初学者的一个简单问题。我的循环有什么问题？

num评估为 '69' 相当快，但一旦num设置为 '69' ，循环永远不会退出。我错过了一些明显的东西，我敢肯定......

extern crate rand;

use rand::Rng;

fn main() {
    let funny_number: u16 = 69;
    let mut num: u16 = 0;
    let mut rng = rand::thread_rng();

    while num != funny_number {
        let mut num: u16 = rng.gen_range(0, 100);
        println!("{}", num);
    }
}

我有一个哈希映射的引用（data在下面的代码中），我想将其克隆到一个新的、拥有的哈希映射中。克隆参考给了我一个新的参考，这不是我需要的。

我还尝试对data引用进行迭代 + 映射，并单独克隆键和值对，然后进行收集，但这也不起作用。这是一个最小的工作示例：

use core::cell::Cell;
use std::collections::HashMap;
use std::collections::HashSet;
use std::rc::Rc;

struct Dummy<K, V> {
    dirty: Rc<Cell<bool>>,
    data: Cell<Option<HashMap<K, HashSet<V>>>>,
}

impl<K, V> Dummy<K, V> {
    fn persist(&self, prefix: &str, data: &HashMap<K, HashSet<V>>) {
        self.dirty.set(true);
        self.data.set(Some(data.clone()));
    }
}

这给出了以下错误：

error[E0308]: mismatched types
  --> src/lib.rs:14:28
   |
14 |         self.data.set(Some(data.clone()));
   |                            ^^^^^^^^^^^^ expected struct `std::collections::HashMap`, found reference
   |
   = note: expected type `std::collections::HashMap<K, std::collections::HashSet<V>>`
              found type `&std::collections::HashMap<K, std::collections::HashSet<V>>`

（固定链接到操场）

这段代码的目的是通过Dummystruct观察hashmap的内容，用于单元测试。

我猜这个问题是因为给定泛型类型没有办法确定如何深度克隆键和值对象？

有没有办法在给定对现有哈希图的引用的情况下创建新的哈希图？

There is a method contains that can be used to check if a particular element exists in a Vec. How to check if all elements from a Vec are contained in another Vec? Is there something more concise than iterating manually and checking all elements explicitly?

我正在阅读https://www.abubalay.com/blog/2018/04/08/recursive-ascent，它做了我无法理解的事情

let Elements(array) = elements;

这种表达是什么意思？它在创建array变量吗？那Elements(...)!!

问候

拉斯特大部分图案由性状（捕获Iterator，From，Borrow，等）。

为什么像len/这样普遍的模式is_empty在标准库中没有相关特征？这会导致我无法预见的问题吗？被认为是无用的吗？或者只是没有人想到它（这似乎不太可能）？

我试图重载运算符+和+ = std :: vector,我做的是

namespace std {
    template<class T>
    vector<T> operator+(vector<T> x, vector<T> y) {
        vector<T> result;
        result.reserve(x.size());
        for (size_t i = 0; i < x.size(); i++)
            result[i] = x[i] + y[i];
        return result;
   }
}

但我认为这是不好的做法,因为clang-tidy警告我"修改std命名空间会导致未定义的行为".在为STL类重载运算符时还有其他更好的做法吗？

在这里，我有一个简单的映射并通过迭代器求和：

fn main() {
    let s = "
aoeu
aoeu
aoeu
aoeu
";

    let ls = s.lines();
    let i: usize = ls.map(|l| l.len()).sum();
    dbg!(i);
}

这样可以编译并正常运行。当我查看源代码时lines，该next方法返回Option<Result<String>>。

但是上面的地图.len()直接调用每个项目。我知道该值是从内部提取的Option（一个None值表示迭代器的结尾）。是.len()被调用的Result对象？为什么我们不需要调用map()*来从中提取值Result呢？

谢谢！

*我原以为Result::map与含义不同Iterator::map，但也许让我感到困惑...

我的编码函数是这样的：

fn encode_login(packet: &str) {
    let bytes = packet.as_bytes();
    for (i, &element) in bytes.iter().enumerate() {
        println!("Index: {}, Byte: {}", i, &element);
        let decoded = (element ^ 0xC3) + 0xF;
        println!("Decoded Byte: {}", decoded);
    }
}

fn main() {
    // let packet = "0123456789"; // Doesn't work
    let packet = "abcdefghijklmnopqrstuvwxyz"; // Work

    encode_login(packet);
}

当我使用字母时，程序会很好地对其进行加密，但是当我输入数字时，它会出现恐慌。我不知道为什么，我是 Rust 的新手，所以也许我做错了什么。

我正在努力改进我的match表达方式。

我有一个类似下面的代码，其中foo是一个字符串：

if foo.chars().nth(0).unwrap() != '2' && 
    foo.chars().nth(0).unwrap() != '3' &&
    &foo[0..3] != "xyz"
    {
        return message;
    }

是否可以使用匹配来创建相同的行为？像这样的想法：

match foo {
   &[0] == (2 | 3) => do_nothing
   &[0..3] == "xyz" => do_nothing
   _ => return message;
}