用户定义类型

用户定义类型有两种：Composite 和 Variant。

两者在其定义中都使用了 Path 和 Field 类型。

字段

表示用户定义类型的根本构建块是 Field 结构体，它定义了字段的 Type 以及其可选的名称。用户定义类型的构建器强制执行一个不变量：要么所有字段都有名称（例如结构体），要么所有字段都是无名的（例如元组）。

路径

类型的路径是一系列唯一的标识符序列。Rust 类型通常从命名空间和标识符构建路径，例如 foo::bar::Baz 转换为路径 ["foo", "bar", "Baz"]。

复合类型

复合数据类型由一组 Fields 组成。

结构体 通过一组 命名 字段表示，在构建过程中强制执行

struct Foo<T> {
    bar: T,
    data: u64,
}

impl<T> TypeInfo for Foo<T>
where
    T: TypeInfo + 'static,
{
    type Identity = Self;

    fn type_info() -> Type {
        Type::builder()
            .path(Path::new("Foo", module_path!()))
            .type_params(vec![MetaType::new::<T>()])
            .composite(Fields::named()
                .field(|f| f.ty::<T>().name("bar").type_name("T"))
                .field(|f| f.ty::<u64>().name("data").type_name("u64"))
            )
    }
}

元组 通过一组 无名称 字段表示，在构建过程中强制执行

struct Foo(u32, bool);

impl TypeInfo for Foo {
    type Identity = Self;

    fn type_info() -> Type {
        Type::builder()
            .path(Path::new("Foo", module_path!()))
            .composite(Fields::unnamed()
                .field(|f| f.ty::<u32>().type_name("u32"))
                .field(|f| f.ty::<bool>().type_name("bool"))
            )
    }
}

变体

变体类型，也称为枚举或标记联合，由一组变体组成。变体可以具有无名称字段、命名字段或没有字段。

enum Foo<T>{
    A(T),
    B { f: u32 },
    C,
}

impl<T> TypeInfo for Foo<T>
where
    T: TypeInfo + 'static,
{
    type Identity = Self;

    fn type_info() -> Type {
        Type::builder()
            .path(Path::new("Foo", module_path!()))
            .type_params(vec![MetaType::new::<T>()])
            .variant(
                Variants::new()
                   .variant("A", |v| v.fields(Fields::unnamed().field(|f| f.ty::<T>())))
                   .variant("B", |v| v.fields(Fields::named().field(|f| f.ty::<u32>().name("f").type_name("u32"))))
                   .variant_unit("C")
            )
    }
}

如果没有变体包含字段，则可以显式设置区分符，由构建器在构建过程中强制执行

enum Foo {
    A,
    B,
    C = 33,
}

impl TypeInfo for Foo {
    type Identity = Self;

    fn type_info() -> Type {
        Type::builder()
            .path(Path::new("Foo", module_path!()))
            .variant(
                Variants::new()
                    .variant("A", |v| v.index(1))
                    .variant("B", |v| v.index(2))
                    .variant("C", |v| v.index(33))
            )
    }
}

注册表

类型信息在所谓的类型注册表（Registry）中提供。类型定义在此注册，并关联唯一的 ID，外部可以引用这些 ID，提供一种轻量级的方法来减少开销，而不是使用类型标识符。

所有具体的 TypeInfo 结构体有两种形式

• 一种元形式（MetaType），它充当与其他形式之间的桥梁
• 一种适合序列化的可移植形式。

还必须实现 IntoPortable 特性，以便使用类型注册表的实例准备类型定义进行序列化。

转换后，所有类型定义都存储在类型注册表中。请注意，类型注册表应作为元数据结构的一部分进行序列化，其中注册的类型被用于允许消费者解析类型。

编码

类型注册表可以编码为

• JSON（启用“serde”功能）。
• SCALE自身（使用parity-scale-codec）。

特性

以下可选的cargo特性可用

• serde包括对类型注册表进行JSON序列化/反序列化的支持。请参阅示例这里。
• derive导出scale-info-derivecrate。

已知问题

当为具有泛型紧凑字段的类型推导TypeInfo时，例如。

#[derive(Encode, TypeInfo)]
struct Foo<S> { #[codec(compact)] a: S }

当使用此泛型类型且没有正确的界限时，您可能会遇到以下错误

error[E0275]: overflow evaluating the requirement `_::_parity_scale_codec::Compact<_>: Decode`

有关更多信息，请参阅https://github.com/paritytech/scale-info/issues/65。

资源

• 请参阅描述ink!智能合约元数据的类型使用示例这里。
• 原始设计草案（已过时）