在为多层嵌套数组实现 From 时，如何避免指定常量泛型值？

Question

我正在尝试创建一个具有一些友好的 From 特征实现的结构。该结构是数组数组的数组的包装器，用于表示 3D 矩阵。

pub struct Table<T, const X: usize, const Y: usize, const Z: usize> {
    pub content: [[[T; X]; Y]; Z],
}

impl<T, const X: usize> From<[T; X]> for Table<T, X, 1, 1> {
    fn from(row: [T; X]) -> Self {
        Table { content: [[row]] }
    }
}

impl<T, const X: usize, const Y: usize> From<[[T; X]; Y]> for Table<T, X, Y, 1> {
    fn from(layer: [[T; X]; Y]) -> Self {
        Table { content: [layer] }
    }
}

impl<T, const X: usize, const Y: usize, const Z: usize> From<[[[T; X]; Y]; Z]>
    for Table<T, X, Y, Z>
{
    fn from(matrix: [[[T; X]; Y]; Z]) -> Self {
        Table { content: matrix }
    }
}

fn main() {
    let i1 = [1];
    let i2 = [[1]];
    let i3 = [[[1]]];

    // Table<i32>
    // notice how you can avoid specifying the constant values
    let tbl1 = Table::from(i1);

    // type annotations needed
    // cannot infer type for struct `Table<_, {_: usize}, {_: usize}, {_: usize}>`
    // let tbl2 = Table::from(i2);
}

我尝试了一些替代解决方案，包括：

1. to_table 特征解决方案（这反过来会导致相同的问题）
2. Macro_rules （无法确定提供的类型是否嵌套在数组中。我的宏经验很少）
3. 特定类型 impl(s) （这可行，但这是一个糟糕的选择，因为它限制了我可以用来填充表的开箱即用支持类型的数量）

我很想了解如何区分泛型类型实现和内的泛型类型实现数组。我觉得我的根本问题是 T 和 [T; _] 是同一件事 - 或者更确切地说，它们使编译器感到困惑。

替代问题：有没有办法在 Rust 中指定元素的非常量泛型类型？如果使用有效，我会很高兴

// possible to skip X, Y, Z?
let tbl: Table<i32> = Table::from([[1]]);

，但是如果您手动输入通用属性，则必须指定所有常量的长度。对第二点的澄清也将不胜感激。