generics - 在 Rust 中有使用整型泛型的简单方法吗？

Question

我有一系列几乎相同的函数，不同之处仅在于类型和常量。例如:

fn update16(table: &[u16], init: u16, xs: &[u8]) -> u16 {
    xs.iter().fold(init, |acc, x| { (acc << 8) ^ table[(((acc >> 8) as u8) ^ x) as usize] })
}

fn update32(table: &[u32], init: u32, xs: &[u8]) -> u32 {
    xs.iter().fold(init, |acc, x| { (acc << 8) ^ table[(((acc >> 24) as u8) ^ x) as usize] })
}

所以我考虑让这个函数在类型上通用:

trait Update<T> {
    fn update(table: &[T], init: T, xs: &[u8]) -> T;
}

我最终能够实现这个:

use std::ops::Shl;
use std::ops::Shr;
use std::ops::BitXor;
use std::mem::size_of;

extern crate num;
use num::ToPrimitive;

struct Normal;

impl<
    T: Copy + Shl<u8, Output = T> + Shr<usize, Output = T> + BitXor<Output = T> + ToPrimitive,
> CrcUpdate<T> for Normal {
    fn update(table: &[T], init: T, xs: &[u8]) -> T {
        xs.iter().fold(init, |acc, x| {
            (acc << 8) ^
                table[(ToPrimitive::to_u8(&(acc >> ((8 * size_of::<T>()) - 8))).unwrap() ^ x) as
                          usize]
        })
    }
}

这比我预期的要复杂得多。我不得不使用一堆特征，定义一个空结构，包括一个外部 crate ，并在一定程度上掩盖了基本计算。它肯定比原来多了很多行。

在 Rust 中，这是对整数使用泛型的正确方法吗？还是我错过了一种更简单的方法来解决这个问题？

Answer 1

是也不是。

统一处理整数类型并不顺利。

正如您刚刚在这里发现的那样，标准库不提供任何以统一方式处理数字的“统一”特性。目前还不清楚什么是最好的设计，因此像 num 这样的 crate 已经尝试探索设计空间。

所以，是的，如果您希望以通用方式处理多个积分，您将不得不拉入外部 crate (例如 num)或遭受一些痛苦。

但是，您可以使用更简单的代码。

首先，定义一个 struct 和 trait 是完全没有必要的。 Rust 具有泛型函数:

fn update<T>(table: &[T], init: T, xs: &[u8]) -> T
where
    T: Copy + Shl<u8, Output = T> + Shr<usize, Output = T> + BitXor<Output = T> + ToPrimitive,
{
    xs.iter().fold(init, |acc, x| {
        (acc << 8)
            ^ table[(ToPrimitive::to_u8(&(n >> ((8 * size_of::<T>()) - 8))).unwrap() ^ x) as usize]
    })
}

其次，以可读性的名义，我建议您不要直接使用 ToPrimitive::to_u8，因为它确实会混淆此处的代码。

如果它是一次性的，那么您可以定义一个变量或将其使用包装到一个函数中。

fn upper8<T>(n: T) -> u8 {
    ToPrimitive::to_u8(&(n>> ((8 * size_of::<T>()) - 8))).unwrap()
}

否则，您可以定义自己的“字节选择”特征。现在需要多几行代码，但会使用适合您的域的更清晰的界面来弥补。

trait SelectByte: Sized {
    fn bytes(&self) -> usize { mem::size_of::<Self>() }
    fn lower(&self, n: usize) -> u8;
    fn upper(&self, n: usize) -> u8 { self.lower(self.bytes() - n - 1) }
}

impl SelectByte for u16 {
    fn lower(&self, n: usize) -> u8 {
        assert!(n <= 1);
        ((*self >> (n * 8)) & 255u16) as u8
    }
}

impl SelectByte for u32 {
    fn lower(&self, n: usize) -> u8 {
        assert!(n <= 3);
        ((*self >> (n * 8)) & 255u32) as u8
    }
}

注意:如有必要，您将为 u8、u64 和 u128 实现它。

这给出了一个看起来更简单的结果:

fn update<T>(table: &[T], init: T, xs: &[u8]) -> T
where
    T: Copy + Shl<u8, Output = T> + BitXor<Output = T> + SelectByte,
{
    xs.iter().fold(init, |acc, x| {
        (acc << 8) ^ table[(acc.upper(0) ^ x) as usize]
    })
}

最后，如果您发现自己一遍又一遍地枚举同一组约束，请随意为其定义一个新特征:

trait Numeric: Copy + Shl<u8, Output = Self> + BitXor<Output = Self> + SelectByte {}

impl<T> Numeric for T
    where T: Copy + Shl<u8, Output = T> + BitXor<Output = T> + SelectByte
{}

然后使用您的快捷方式:

fn update<T: Numeric>(table: &[T], init: T, xs: &[u8]) -> T {
    xs.iter().fold(init, |acc, x| { (acc << 8) ^ table[(acc.upper(0) ^ x) as usize] })
}

顺便说一句，如果我没记错的话，这就是 num 箱子的全部想法。

您无法抽象掉的一个痛点是 Rust 不允许文字“无痛地”转换为抽象的 T。您可以为此使用 num::FromPrimitive，但是......是的，它并不是很好。