Enum SubstitutionSpec 

pub enum SubstitutionSpec {
    Explicit(Vec<Substitution>),
    Modifiers(Vec<SubstitutionOp>),
}

Specification for substitutions to apply to a block.

This type represents how substitutions are specified in a subs attribute:

• Explicit: A direct list of substitutions (e.g., subs=specialchars,quotes)
• Modifiers: Operations to apply to the block-type default substitutions (e.g., subs=+quotes,-callouts)

The parser cannot know the block type when parsing attributes (metadata comes before the block delimiter), so modifier operations are stored and the converter applies them with the appropriate baseline (VERBATIM for listing/literal, NORMAL for paragraphs).

Serialization

Serializes to a flat array of strings matching document syntax:

• Explicit: ["special_chars", "quotes"]
• Modifiers: ["+quotes", "-callouts", "macros+"]

Variants

Explicit(Vec<Substitution>)

Explicit list of substitutions to apply (replaces all defaults)

Modifiers(Vec<SubstitutionOp>)

Modifier operations to apply to block-type defaults

Implementations

impl SubstitutionSpec

pub fn apply_modifiers( ops: &[SubstitutionOp], default: &[Substitution], ) -> Vec<Substitution>

Apply modifier operations to a default substitution list.

This is used by converters to resolve modifiers with the appropriate baseline.

pub fn resolve(&self, default: &[Substitution]) -> Vec<Substitution>

Resolve the substitution spec to a concrete list of substitutions.

• For Explicit, returns the list directly
• For Modifiers, applies the operations to the provided default

Trait Implementations

impl Clone for SubstitutionSpec

fn clone(&self) -> SubstitutionSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SubstitutionSpec

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

Formats the value using the given formatter.

impl Hash for SubstitutionSpec

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 SubstitutionSpec

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

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 SubstitutionSpec

impl StructuralPartialEq for SubstitutionSpec