Использование const, определенного в общих типах с привязкой к признакам в Rust

В общем, требование о том, чтобы разные типы не имели одного и того же свойства, может быть соблюдено на уровне типа путем проецирования этого свойства обратно на тип. В вашем случае можно определить новый признак, скажем ResourceKindOf, который имеет связанный тип Kind, а затем потребовать, чтобы Kind соответствовал ожидаемому типу:

pub trait ResourceKindOf {
    type Kind: ResourceKind;
}

pub trait ResourceKind {
    type Id: ResourceKindOf<Kind = Self>;
    type Prefix: ResourceKindOf<Kind = Self>;
}

Конечно, для этого требуется, чтобы рассматриваемые свойства были типами, а не константами, что немного усложняет нам задачу, особенно при отсутствии функции adt_const_params, которая позволила бы нам легко создавать типы, обертывающие константу по нашему выбору.

Тип, который следует использовать для Id, довольно очевиден: [u8; Z], где Z — предыдущая константа SIZE. Мы можем обеспечить разрешение только типов, соответствующих такому шаблону, добавив ограничение PermissableId, где PermissableId — запечатанный признак, который мы реализуем только для [u8; Z]:

mod sealed {
    pub trait PermissableId {}
}
use sealed::PermissableId;

impl<const Z: usize> PermissableId for [u8; Z] {}

pub trait ResourceKind {
    type Id: PermissableId + ResourceKind<Kind = Self>;
    // etc
}

С префиксом немного сложнее, поскольку не существует такой очевидной версии произвольной строки на уровне типа. Лучшее, что я могу придумать, это использовать список минусов символов:

struct Nil;
struct Cons<T, const C: char>(PhantomData<T>);

Тогда, например, мы можем иметь уровень типа "foo" как Cons<Cons<Cons<Nil, 'o'>, 'o'>, 'f'>. Однако писать это довольно ужасно, поэтому давайте (немного) упростим задачу с помощью макроса:

macro_rules! cons {
    () => {Nil};
    ($c:literal $($rest:tt)*) => {$crate::Cons<cons!($($rest)*), $c>};
}

Теперь мы можем вместо этого написать cons!('f''o''o'), чтобы получить строку уровня типа, представляющую "foo". Раздражает то, что нам нужно цитировать каждый символ индивидуально, но я не могу придумать лучшего способа (во всяком случае, без макроса proc).

Затем мы можем добавить такое же ограничение, как и раньше, чтобы гарантировать, что Prefix всегда является строкой уровня типа. Однако в данном случае мы также хотим иметь возможность конвертировать cons-список обратно в отображаемую строку во время выполнения, поэтому давайте добавим метод fmt к нашему запечатанному признаку:

mod sealed {
    use std::fmt;

    pub trait PermissablePrefix {
        fn fmt(f: &mut fmt::Formatter<'_>) -> fmt::Result;
    }
}
use sealed::PermissablePrefix;

impl PermissablePrefix for Nil {
    fn fmt(_: &mut fmt::Formatter<'_>) -> fmt::Result {
        Ok(())
    }
}

impl<T: PermissablePrefix, const C: char> PermissablePrefix for Cons<T, C> {
    fn fmt(f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_char(C)?;
        T::fmt(f)
    }
}

pub trait ResourceKind {
    type Prefix: PermissablePrefix + ResourceKind<Kind = Self>;
    // etc
}

Наконец, давайте упростим использование всего этого, создав макрос для определения типов ресурсов и связанных с ними реализаций признаков:

macro_rules! resource_kinds {
    ($($kind:ident{$size:literal, $($prefix:tt)*})+) => {$(
        pub struct $kind;
        impl $crate::ResourceKind for $kind {
            type Id = [u8; $size];
            type Prefix = $crate::cons!($($prefix)*);
        }
        impl $crate::ResourceKindOf for [u8; $size] {
            type Kind = $kind;
        }
        impl $crate::ResourceKindOf for $crate::cons!($($prefix)*) {
            type Kind = $kind;
        }
    )+}
}

Посмотрите все это вместе на детской площадке.