小编Mic*_*yin的帖子

我正在尝试自己实现大整数（仅用于教育）。该实现按数据类型通用：

struct LongNum<T>
where T: Integer + MulAssign + CheckedMul + CheckedAdd + Copy + From<u8>
{
    values: Vec<T>,
    powers: Vec<u8>,
    radix: u8,
}

问题在于，我需要在所有impls中对T重复此冗长的约束。太麻烦了

我可以结合这些约束来做出自己的特征，如下所示：

trait LongNumValue: Integer + MulAssign + CheckedMul + CheckedAdd + Copy + From<u8> {}

struct LongNum<T: LongNumValue>
{
    values: Vec<T>,
    powers: Vec<u8>,
    radix: u8,
}

但是在这种情况下，我必须为此LongNumValue特性添加impls到可以在LongNum中使用的所有类型：

impl LongNumValue for u8 {}
impl LongNumValue for u16 {}
impl LongNumValue for u32 {}
...

这意味着，如果我不向此impls列表中添加某种类型，则即使该类型传递了所有约束，我的板条箱用户也将无法将其用于LongNum。

有什么方法可以避免编写长时间的重复成本损失，而又不会给用户增加不必要的限制？

哪个Linux版本最适合haskell开发？我想安装ghc并在其中编译Leksah.我现在正在使用CentOS,但它的存储库并不够丰富和新鲜.

我想在我的函数中重用标准库ParseIntError。但是，我自己实现了输入字符串的解析，因此不需要返回标准库返回的错误值。

我没有找到构建价值的方法ParseIntError。我找到的唯一解决方案如下所示：

use std::num::ParseIntError;

fn from_str_radix(s: &str, radix: u32) -> Result<(), ParseIntError> {
    let error_empty = "".parse::<i32>().expect_err("get empty input error");
    let error_invalid_digit = "Z".parse::<i32>().expect_err("get invalid digit error");

    if s.is_empty() {
        return Err(error_empty);
    }

    for c in s.chars().rev() {
        match c.to_digit(radix) {
            None => return Err(error_invalid_digit),
            _ => unimplemented!(),
        }
    }

    Ok(())
}

ParseIntError有没有更优雅的方式从我自己的代码返回？

我有一个类型的值T中value: Box<dyn Any>，并希望将其解压。我找到的唯一方法是：

let pv = value.downcast_mut::<T>();
let v = std::mem::replace(pv, T::default());

有v没有不需要T实现的方法Default？

我想使用默认类型创建通用结构。但是Rust编译器在创建结构时仍然需要我指定显式类型。

struct A {}

struct C<T = A> {
    t: Option<T>
}

fn main() {
    let c = C { t: None };
}

Rust编译器显示此错误：

struct A {}

struct C<T = A> {
    t: Option<T>
}

fn main() {
    let c = C { t: None };
}

如何允许我的代码用户忽略通用参数？

我需要找到树中具有最大值的节点，假设子节点的值总是大于所属节点的值，然后修改它：

#[derive(Debug)]
struct Node {
    val: usize,
    nodes: Vec<Node>,
}

fn find_max(node: &mut Node, val: usize) -> Option<&mut Node> {
    if node.val < val {
        return None;
    }
    let mut max_val = node.val;
    let mut max: Option<&mut Node> = Some(node);
    for n in &mut node.nodes {
        if let Some(m) = find_max(n, max_val) {
            max_val = m.val;
            max = Some(m);
        }
    }
    max
}

fn main() {
    let mut root = Node {
        val: 1,
        nodes: vec![
            Node {
                val: 2, …