Struct Schema 

pub struct Schema {
    pub dtype: DataType,
    pub shape: Option<Vec<Dimension>>,
}

Describes the shape and type of a Value, without holding the actual data.

Used by:

• Filters: declare what they accept (input) and produce (output)
• Compiler: validate type compatibility between connected filters
• VirtualValue: know schema without materializing
• Cache metadata: describe stored entries

Fields

dtype: DataType

The primitive data type.

shape: Option<Vec<Dimension>>

Shape dimensions. Empty for scalars, [n] for vectors, [r,c] for matrices, etc. None means shape is dynamic/unknown.

Implementations

impl Schema

pub fn vector(dtype: DataType, len: usize) -> Self

Create a schema for a 1D tensor (vector) of known length.

pub fn matrix(dtype: DataType, rows: usize, cols: usize) -> Self

Create a schema for a 2D tensor (matrix) with known dimensions.

pub fn batched(dtype: DataType, feature_dims: &[usize]) -> Self

Create a schema for a tensor with a dynamic batch dimension.

pub fn scalar(dtype: DataType) -> Self

Create a schema for a scalar value.

pub fn json() -> Self

Create a schema for JSON data (shape is irrelevant).

pub fn text() -> Self

Create a schema for UTF-8 text (shape is irrelevant).

This is what a prompt or a completion carries. An edge typed text will not accept a tensor, which is how a mis-wired handoff between two agent nodes becomes a compile error rather than a runtime surprise.

pub fn messages() -> Self

Create a schema for a conversation.

pub fn bytes() -> Self

Create a schema for raw bytes.

pub fn dynamic(dtype: DataType) -> Self

Create a schema with fully dynamic (unknown) shape.

pub fn is_incompatible_with(&self, other: &Schema) -> bool

Is connecting these two definitely a mistake?

True when no reading of self could satisfy other — a tensor arriving where a conversation is expected, say. The compiler refuses to build such a graph, rather than warning and letting it fail mid-run once tokens have been spent.

pub fn is_compatible_with(&self, other: &Schema) -> bool

Check if this schema is compatible with another (can be connected in a pipeline).

Compatibility rules:

• Same dtype required (no implicit coercion)
• If both shapes are known, fixed dimensions must match
• Dynamic dimensions are compatible with any size
• Unknown shape (None) is compatible with anything of the same dtype

pub fn rank(&self) -> Option<usize>

Number of known dimensions (rank).

Trait Implementations

impl Clone for Schema

fn clone(&self) -> Schema

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Schema

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Schema

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Schema

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

Formats the value using the given formatter.

impl PartialEq for Schema

fn eq(&self, other: &Schema) -> 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 Serialize for Schema

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Schema

impl StructuralPartialEq for Schema