请看一下代码：
struct Human {
name: String,
profession: Profession,
}
enum Profession {
Doctor,
Teacher
}
struct Family {
family_doctor: // How to express type that will mean Human (because name matters) of profession Doctor?
}
是否可以通过以Human某种方式进行泛型并将变体作为字段Doctor的类型参数传递来做到这一点？profession如果没有，那么您建议的这种关系最接近的解决方法是什么？
请注意，这个问题可能看起来与旧问题重复。但首先，Rust 不断发展，其次，我要求一种解决方法。
该代码为什么不编译：
fn use_cursor(cursor: &mut io::Cursor<&mut Vec<u8>>) {
// do some work
}
fn take_reference(data: &mut Vec<u8>) {
{
let mut buf = io::Cursor::new(data);
use_cursor(&mut buf);
}
data.len();
}
fn produce_data() {
let mut data = Vec::new();
take_reference(&mut data);
data.len();
}
在这种情况下的错误是：
fn use_cursor(cursor: &mut io::Cursor<&mut Vec<u8>>) {
// do some work
}
fn take_reference(data: &mut Vec<u8>) {
{
let mut buf = io::Cursor::new(data);
use_cursor(&mut buf);
}
data.len();
}
fn produce_data() {
let mut data = Vec::new();
take_reference(&mut data);
data.len();
} …我有一个usize确实达到了非常大的值。我还对它应用了一个增量，我以isize. 在不损失任何精度的情况下应用增量的最佳方法是什么？
fn main() {
let mut big_indexer: usize = 4295032832; // 2^32 + 2^16
let delta: isize = -65792; // 2^16 + 2^8
let big_indexer = (big_indexer as isize) + delta // Can't do this b/c overflow
let big_indexer = big_indexer + (delta as usize) // Can't do this b/c lose negative number
// This is ugly
if delta < 0 {
let big_indexer -= delta.abs() as usize;
} else {
let big_indexer += delta.abs() …我学过：
cargo test -- --nocapture它告诉 Cargo 显示输出而不是隐藏输出；我感兴趣的是看到成功测试的输出，而不仅仅是失败的测试。env_loggercrate 允许使用环境变量来设置日志级别。我正在寻找任何类似的方法，最好是任何官方参考指南，以展示实现这一目标的好方法。
如何获取从另一个函数struct返回的 a的值Result？下面举例。
#[derive(Debug)]
pub struct Keypair(ed25519_dalek::Keypair);
pub fn keypair_from_seed(seed: &[u8]) -> Result<Keypair, Box<dyn error::Error>> {
let dalek_keypair = ed25519_dalek::Keypair { secret, public };
Ok(Keypair(dalek_keypair))
}
fn main(){
//here seed_bytes is mnemonics
let sk = keypair_from_seed(&seed_bytes);
//sk contains the secret key and public key, i want to extract it different secret key & public key
}
我对 Rust 比较陌生，并且遇到了如何用另一种语言编写构造函数的特殊情况。我有一个结构体S3Logger，它在磁盘上创建一个临时文件，当将一定量的数据写入该文件时，该文件将上传到 S3 并旋转到另一个文件。
我希望我的new函数使用类 上的方法gen_new_file，它将在写入位置打开一个具有正确名称的新文件。但是，为了使其成为一种方法，我必须已经有一个S3Logger要传入的参数，而在函数期间我还没有传入该new参数。在下面的示例中，我展示了如何用另一种语言执行此操作，在使用对象方法完成构造之前部分构造对象；但这显然在 Rust 中不起作用。
我可以使用 anOption来表示current_log_file，但这感觉有点恶心。我想强制执行以下不变量：如果我有一个S3Logger，我就知道它有一个打开的文件。
对于此类问题，Rust 的最佳实践是什么？
pub struct S3Logger {
local_folder: PathBuf,
destination_path: String,
max_log_size: usize,
current_log_file: File,
current_logged_data: usize
}
impl S3Logger {
pub fn new<P: AsRef<Path>>(
local_folder: P,
destination_path: &str,
max_log_size: usize
) -> Self {
std::fs::create_dir_all(&local_folder).unwrap();
let mut ret = Self {
local_folder: local_folder.as_ref().to_path_buf(),
destination_path: destination_path.to_string(),
max_log_size: max_log_size,
current_logged_data: 0
};
// fails ^^^^ …有没有限制的大小BigInt或BigUint从num鲁斯特箱子？我看到在Java中,它的长度受整数上限的限制,Integer.MAX_VALUE因为它存储为数组int.
我确实通过了它的文档,但无法真正推断出我的答案
甲BigUint类型的值BigUint {数据:VEC(A,B,C)}表示数(A + B*big_digit :: BASE + C*big_digit :: BASE ^ 2).
big_digit::BASE 被定义为
pub const BASE: DoubleBigDigit = 1 << BITS
BITS 反过来是32
那么BigInt是否在(a + b * 64 + c * 64^2)内部表现？
我正在寻找分配一个小型结构的向量。
这需要 30 毫秒并线性增加：
let v = vec![[0, 0, 0, 0]; 1024 * 1024];
这需要几十微秒：
let v = vec![0; 1024 * 1024];
对于第一种情况是否有更有效的解决方案？我可以接受不安全的代码。
在 Rust 中，如何在for样式循环中执行可变大小的步骤？我可以使用此构造执行固定大小的步骤：
for i in (0..vals.len()).step_by(4)
{
println!("{}: {}", i, vals[i]);
}
或者更合适的：
for (i,val) in vals.iter().enumerate().step_by(4)
{
println!("{}: {}", i, val);
}
但我真正想做的是：
for i in 0..vals.len()
{
println!("{}: {}", i, vals[i]);
if vals[i] == 1 { i += 2; }
else if vals[i] == 2 { i += 4; }
}
但当然，修改i不会影响循环迭代器。
由于主要具有 C 语言背景，现代语言对迭代器的依赖常常让人感觉像是戴着手套进行编程。通常谷歌会来救援，但我还没有找到任何解决方案来解决这个看似相当简单的问题。
我想出的最好的是
let mut i:usize = 0;
while i < vals.len()
{
println!("{}: {}", i, vals[i]);
if vals[i] == …我想了解为什么以下似乎在 Rust 中无法正常工作。
我想对一个向量进行分块，并给每个线程一个块来处理它。我尝试使用 Arc 和 Mutex 组合来相互访问我的 vec。
这是我的第一次（明显的）尝试：声明 vec，将其分块，将块发送到每个线程中。根据我的理解，它应该有效，因为 Chunk 方法保证不重叠的块。
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let data = Arc::new(Mutex::new(vec![0;20]));
let chunk_size = 5;
let mut threads = vec![];
let chunks: Vec<&mut [u8]> = data.lock().unwrap().chunks_mut(chunk_size).collect();
for chunk in chunks.into_iter(){
threads.push(thread::spawn(move || {
inside_thread(chunk)
}));
}
}
fn inside_thread(chunk: &mut [u8]) {
// now do something with chunk
}
该错误表明数据不够活跃。愚蠢的我，通过分块，我创建了指向数组的指针，但没有将 Arc 引用传递到线程中。所以我改变了几行，但这没有意义，因为我的线程中有一个未使用的引用！？
for i in 0..data.lock().unwrap().len() / 5 {
let ref_to_data = data.clone();
threads.push(thread::spawn(move || { …