Enum TypeRef 

#[repr(u8)]
pub enum TypeRef<Id = SchemaHash> {
    Concrete {
        type_id: Id,
        args: Vec<TypeRef<Id>>,
    },
    Var {
        name: TypeParamName,
    },
}

A reference to a type in a schema. Either a concrete type (with optional type arguments for generics) or a type variable bound by the enclosing generic’s type_params.

Generic over the ID type: TypeSchemaId for final schemas, MixedId during extraction.

Variants

Concrete

A concrete type, possibly generic.

Fields

type_id: Id

args: Vec<TypeRef<Id>>

Type arguments for generic types. Empty for non-generic types.

Var

A reference to a type parameter of the enclosing generic type, by name (e.g. TypeParamName("T")).

Fields

name: TypeParamName

Implementations

impl<Id> TypeRef<Id>

pub fn concrete(type_id: Id) -> Self

Shorthand for a non-generic concrete type reference.

pub fn generic(type_id: Id, args: Vec<TypeRef<Id>>) -> Self

Shorthand for a generic concrete type reference with type arguments.

pub fn collect_ids(&self, out: &mut Vec<Id>)

where Id: Copy,

Collect all concrete IDs reachable from this TypeRef (depth-first).

pub fn expect_concrete_id(&self) -> &Id

Return the concrete type ID if this is a non-generic Concrete variant, panicking otherwise.

pub fn map<OtherId, F: Fn(Id) -> OtherId + Copy>(self, f: F) -> TypeRef<OtherId>

Map a TypeRef<Id> to TypeRef<OtherId> by applying f to every concrete ID.

pub fn try_map<OtherId, E, F: Fn(Id) -> Result<OtherId, E> + Copy>( self, f: &F, ) -> Result<TypeRef<OtherId>, E>

Fallible version of map — applies f to every concrete ID, propagating errors.

impl TypeRef

pub fn resolve_kind(&self, registry: &SchemaRegistry) -> Option<SchemaKind>

Look up the schema for this TypeRef in the registry and return the schema’s kind with all type variables substituted.

For non-generic types (Concrete { args: [] }), returns the kind as-is. For generic types, substitutes Var references with the concrete type arguments from this TypeRef.

Returns None if the schema is not in the registry or this is a Var.

Trait Implementations

impl<Id: Clone> Clone for TypeRef<Id>

fn clone(&self) -> TypeRef<Id>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Id: Debug> Debug for TypeRef<Id>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'ʄ, Id> Facet<'ʄ> for TypeRef<Id>

where Id: Facet<'ʄ>,

const SHAPE: &'static Shape

The shape of this type, including: whether it’s a Struct, an Enum, something else?

impl<Id: Hash> Hash for TypeRef<Id>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Id: PartialEq> PartialEq for TypeRef<Id>

fn eq(&self, other: &TypeRef<Id>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Id: Eq> Eq for TypeRef<Id>

impl<Id> StructuralPartialEq for TypeRef<Id>