Struct TextSchema 

pub struct TextSchema {
    pub language: Option<String>,
    pub min_length: Option<u32>,
    pub max_length: Option<u32>,
    pub pattern: Option<Regex>,
    pub unknown_fields: IndexMap<String, NodeId>,
}

Text type constraints

The language field determines what kind of text is expected:

• None - accepts any text (no language constraint)
• Some("plaintext") - expects plaintext (from "..." syntax or Language::Plaintext)
• Some("rust") - expects Rust code (from rust`...` syntax or Language::Other("rust"))

Schema Syntax

• .text - any text (language=None)
• .text.X - text with language X (e.g., .text.rust, .text.email)

Validation Rules

When validating a Text value against a TextSchema:

• Language::Plaintext matches schema with language=None or language=Some("plaintext")
• Language::Implicit matches any schema (the schema’s language is applied)
• Language::Other(lang) matches schema with language=None or language=Some(lang)

@variants.text
language = .text (optional)  # e.g., "rust", "email", "markdown"
min-length = .integer (optional)
max-length = .integer (optional)
pattern = .text (optional)

Fields

language: Option<String>

Language identifier (e.g., “rust”, “javascript”, “email”, “plaintext”)

• None - accepts any text regardless of language
• Some(lang) - expects text with the specific language tag

Note: When a value has Language::Implicit (from `...` syntax), it can be coerced to match the schema’s expected language.

min_length: Option<u32>

Minimum length constraint (in UTF-8 code points)

max_length: Option<u32>

Maximum length constraint (in UTF-8 code points)

pattern: Option<Regex>

Regex pattern constraint (applied to the text content). Pre-compiled at schema parse time for efficiency.

unknown_fields: IndexMap<String, NodeId>

Unknown fields (for future extensions like “flatten”)

Trait Implementations

impl Clone for TextSchema

fn clone(&self) -> TextSchema

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TextSchema

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

Formats the value using the given formatter.

impl Default for TextSchema

fn default() -> TextSchema

Returns the “default value” for a type.

impl<'doc> FromEure<'doc> for TextSchema

type Error = ParseError

The error type returned by parsing.

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

Parse a value of type T from the given parse context.

impl PartialEq for TextSchema

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.