Enum SchemaType

Source

pub enum SchemaType {
Show 38 variants    Ref {
        id: TypeId,
        metadata: MetadataEnvelope,
    },
    Bool {
        metadata: MetadataEnvelope,
    },
    S8 {
        restrictions: Option<NumericRestrictions>,
        metadata: MetadataEnvelope,
    },
    S16 {
        restrictions: Option<NumericRestrictions>,
        metadata: MetadataEnvelope,
    },
    S32 {
        restrictions: Option<NumericRestrictions>,
        metadata: MetadataEnvelope,
    },
    S64 {
        restrictions: Option<NumericRestrictions>,
        metadata: MetadataEnvelope,
    },
    U8 {
        restrictions: Option<NumericRestrictions>,
        metadata: MetadataEnvelope,
    },
    U16 {
        restrictions: Option<NumericRestrictions>,
        metadata: MetadataEnvelope,
    },
    U32 {
        restrictions: Option<NumericRestrictions>,
        metadata: MetadataEnvelope,
    },
    U64 {
        restrictions: Option<NumericRestrictions>,
        metadata: MetadataEnvelope,
    },
    F32 {
        restrictions: Option<NumericRestrictions>,
        metadata: MetadataEnvelope,
    },
    F64 {
        restrictions: Option<NumericRestrictions>,
        metadata: MetadataEnvelope,
    },
    Char {
        metadata: MetadataEnvelope,
    },
    String {
        metadata: MetadataEnvelope,
    },
    Record {
        fields: Vec<NamedFieldType>,
        metadata: MetadataEnvelope,
    },
    Variant {
        cases: Vec<VariantCaseType>,
        metadata: MetadataEnvelope,
    },
    Enum {
        cases: Vec<String>,
        metadata: MetadataEnvelope,
    },
    Flags {
        flags: Vec<String>,
        metadata: MetadataEnvelope,
    },
    Tuple {
        elements: Vec<SchemaType>,
        metadata: MetadataEnvelope,
    },
    List {
        element: Box<SchemaType>,
        metadata: MetadataEnvelope,
    },
    FixedList {
        element: Box<SchemaType>,
        length: u32,
        metadata: MetadataEnvelope,
    },
    Map {
        key: Box<SchemaType>,
        value: Box<SchemaType>,
        metadata: MetadataEnvelope,
    },
    Option {
        inner: Box<SchemaType>,
        metadata: MetadataEnvelope,
    },
    Result {
        spec: ResultSpec,
        metadata: MetadataEnvelope,
    },
    Text {
        restrictions: TextRestrictions,
        metadata: MetadataEnvelope,
    },
    Binary {
        restrictions: BinaryRestrictions,
        metadata: MetadataEnvelope,
    },
    Path {
        spec: PathSpec,
        metadata: MetadataEnvelope,
    },
    Url {
        restrictions: UrlRestrictions,
        metadata: MetadataEnvelope,
    },
    Uuid {
        metadata: MetadataEnvelope,
    },
    Datetime {
        metadata: MetadataEnvelope,
    },
    Duration {
        metadata: MetadataEnvelope,
    },
    Quantity {
        spec: QuantitySpec,
        metadata: MetadataEnvelope,
    },
    Union {
        spec: UnionSpec,
        metadata: MetadataEnvelope,
    },
    Secret {
        spec: SecretSpec,
        metadata: MetadataEnvelope,
    },
    QuotaToken {
        spec: QuotaTokenSpec,
        metadata: MetadataEnvelope,
    },
    PermissionCard {
        spec: PermissionCardSpec,
        metadata: MetadataEnvelope,
    },
    Future {
        inner: Option<Box<SchemaType>>,
        metadata: MetadataEnvelope,
    },
    Stream {
        inner: Option<Box<SchemaType>>,
        metadata: MetadataEnvelope,
    },
}

Expand description

One schema type in the recursive in-memory representation.

Every variant carries a MetadataEnvelope so docs / aliases / examples / deprecation / role can attach to any node, not only to registered defs or named positions. Use SchemaType::metadata / SchemaType::metadata_mut for ergonomic access regardless of variant.

Recursive positions hold owned, boxed children (rather than indices) so consumers can walk and pattern-match the schema directly without chasing indices into a flat node list. The WIT-shaped flat form is reconstructed on demand by [super::wit].

Closed sum types come in two shapes that differ by how the decoder learns which branch a value belongs to:

SchemaType::Variant is a carried-tag sum: the value explicitly carries its case (via super::VariantValuePayload::case). Zero- inference decoding. Natural mapping for language-level algebraic data types.
SchemaType::Union is an inferred-tag sum: the value does not carry its tag. Each branch declares a DiscriminatorRule and the decoder picks the branch whose rule matches the raw value.

Variants§

§

Ref

Reference to a named definition in the enclosing super::SchemaGraph.

Fields

§id: TypeId

§metadata: MetadataEnvelope

§

Bool

Fields

§metadata: MetadataEnvelope

§