如何让Rust函数对u8或u32切片实现泛型？

我正在移植一个TypeScript库，其中包含以下类型别名和函数：

type GlkTypedArray = Uint8Array | Uint32Array
get_buffer(buf: GlkTypedArray): number

该函数接受Uint8Array或Uint32Array类型的参数。我尝试在Rust中通过只为u8和u32实现的 trait 来实现相同功能：

trait GlkInt: Sized {}
impl GlkInt for u8 {}
impl GlkInt for u32 {}

fn get_buffer(buf: &mut [dyn GlkInt]) -> u32;

但代码编译失败，错误信息如下：

error[E0277]: the size for values of type `dyn misc::GlkInt` cannot be known at compilation time
  --> remglk/src/glkapi/streams.rs:18:29
   |
18 |     fn get_buffer(buf: &mut [dyn GlkInt]) -> u32;
   |                             ^^^^^^^^^^^^ doesn't have a size known at compile-time
   |
   = help: the trait `Sized` is not implemented for `dyn misc::GlkInt`
   = note: slice and array elements must have `Sized` type

error[E0038]: the trait `misc::GlkInt` cannot be made into an object
  --> remglk/src/glkapi/streams.rs:18:30
   |
18 |     fn get_buffer(buf: &mut [dyn GlkInt]) -> u32;
   |                              ^^^^^^^^^^ `misc::GlkInt` cannot be made into an object
   |
note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
  --> remglk/src/common/misc.rs:13:19
   |
13 | pub trait GlkInt: Sized {}
   |           ------  ^^^^^ ...because it requires `Self: Sized`
   |           |
   |           this trait cannot be made into an object...

请问我是否需要调整实现方式？这个思路可行吗？还有其他方案吗？

你的思路需要调整，核心问题有两点：

1. 给GlkInt trait 添加的Sized约束，直接导致该 trait 无法被对象化（object-safe），而&mut [dyn GlkInt]这种动态分发的切片要求 trait 必须满足对象安全条件。
2. Rust 的切片元素必须是Sized类型，dyn GlkInt属于动态大小类型（DST），不符合切片的类型要求。

下面提供几种可行的实现方案：

方案一：泛型函数（推荐） #

这是最符合 Rust 风格的静态分发方案，通过泛型约束实现类似 TS 联合类型的效果：

trait GlkInt {}
impl GlkInt for u8 {}
impl GlkInt for u32 {}

fn get_buffer<T: GlkInt>(buf: &mut [T]) -> u32 {
    // 编写业务逻辑，可通过std::mem::size_of::<T>()区分u8/u32类型
    buf.len() as u32 // 示例返回值，按需替换
}

调用时 Rust 会自动推导类型：

let mut u8_buf = vec![0u8; 10];
let mut u32_buf = vec![0u32; 5];
get_buffer(&mut u8_buf);
get_buffer(&mut u32_buf);

方案二：枚举封装动态类型 #

如果需要在运行时动态切换传入的切片类型，可以用枚举封装两种可能的切片：

enum GlkBuffer<'a> {
    U8(&'a mut [u8]),
    U32(&'a mut [u32]),
}

fn get_buffer(buf: GlkBuffer) -> u32 {
    match buf {
        GlkBuffer::U8(slice) => {
            // 处理u8切片逻辑
            slice.len() as u32
        }
        GlkBuffer::U32(slice) => {
            // 处理u32切片逻辑
            slice.len() as u32 * 4 // 示例按字节数返回
        }
    }
}

调用方式：

let mut u8_buf = vec![0u8; 10];
let mut u32_buf = vec![0u32; 5];
get_buffer(GlkBuffer::U8(&mut u8_buf));
get_buffer(GlkBuffer::U32(&mut u32_buf));

方案三：调整 trait 为对象安全（不推荐） #

如果一定要用动态分发的 trait 对象，需要去掉Sized约束，但因为你的GlkInt trait 是空的，这种方式对实现原逻辑帮助不大，反而会失去连续内存数组的特性，示例参考：

trait GlkInt {}
impl GlkInt for u8 {}
impl GlkInt for u32 {}

// 无法直接使用&mut [dyn GlkInt]，只能用Vec<Box<dyn GlkInt>>这类结构，与原TS逻辑不符

总结：方案一的泛型实现最适配你的场景，既保留了 Rust 的静态类型安全与性能，又能满足仅接受u8/u32数组的需求；方案二更适合需要运行时动态切换类型的场景。

内容的提问来源于stack exchange，提问作者curiousdannii