Struct TypeNode 

pub struct TypeNode {
    pub id: &'static str,
    pub parent: Option<&'static str>,
    pub kind: TypeKind,
    pub ffi_name: &'static str,
    pub wire_hash: u64,
    pub denotation: &'static str,
}

Static type-identity carrier. Identity is pointer equality; subtype queries route through Lattice.

Fields

id: &'static str

Dotted-namespace identifier ("any", "tensor.f32"). Must be unique across submissions.

parent: Option<&'static str>

Parent’s id, or None for the root.

kind: TypeKind

Dispatchable leaf vs. abstract bound.

ffi_name: &'static str

C-FFI struct name (cbindgen). Empty for abstract nodes.

wire_hash: u64

Wire-envelope discriminator. Concrete leaves non-zero; abstract nodes 0.

denotation: &'static str

ONNX denotation stamped on ValueInfoProto.type.denotation. Empty when no canonical denotation exists.

Implementations

impl TypeNode

pub fn is_subtype_of(&'static self, other: &'static TypeNode) -> bool

true if self is other or a descendant. Cached on the global Lattice.

pub fn is_concrete(&self) -> bool

true iff this node is a concrete (dispatchable) leaf.

pub fn is_abstract(&self) -> bool

true iff this node is an abstract interior bound.

Trait Implementations

impl Clone for TypeNode

fn clone(&self) -> TypeNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for TypeNode

impl Debug for TypeNode

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

Formats the value using the given formatter.

impl Eq for TypeNode

impl Hash for TypeNode

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 PartialEq for TypeNode

fn eq(&self, other: &Self) -> 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.