Struct Constructor 

pub struct Constructor {

    pub cs: Token,
    pub nargs: Option<usize>,
    pub paramlist: Option<Parameters>,
    pub replacement: Option<ReplacementClosure>,
    pub sizer: Option<SizingClosure>,
    pub before_digest: Vec<BeforeDigestClosure>,
    pub after_digest: Vec<DigestionClosure>,
    pub before_construct: Vec<ConstructionClosure>,
    pub after_construct: Vec<ConstructionClosure>,
    pub properties: PropertiesClosure,
    pub capture_body: bool,
    pub after_digest_body: Vec<DigestionClosure>,
    pub reversion: Option<Reversion>,
    pub alias: Option<String>,
}

Fields

cs: Token

nargs: Option<usize>

paramlist: Option<Parameters>

replacement: Option<ReplacementClosure>

sizer: Option<SizingClosure>

before_digest: Vec<BeforeDigestClosure>

after_digest: Vec<DigestionClosure>

before_construct: Vec<ConstructionClosure>

after_construct: Vec<ConstructionClosure>

properties: PropertiesClosure

capture_body: bool

after_digest_body: Vec<DigestionClosure>

reversion: Option<Reversion>

alias: Option<String>

Implementations

impl Constructor

pub fn invoke_primitive_shared(me: &Rc<Constructor>) -> Result<Vec<Digested>>

Digest through the Rc<Constructor> the state table already holds, instead of deep-cloning the definition for every invocation.

Every Whatsit keeps a back-reference to the definition that built it (Whatsit::definition), and Definition::invoke_primitive fills that slot with Rc::new(self.clone()) — a fresh deep clone per invocation, carrying the Parameters and all three Vec<Rc<dyn Fn…>> hook lists with it. Those clones are not transient: a Whatsit lives in the digested tree for the whole Build, so a document retains one private copy of the constructor per construct it uses. Measured with dhat (2026-07-29, debug profile, math-dense fixture): the Rc<Constructor> itself was 1,215 blocks / 349,920 B — an exact 1:1 with the 1,215 constructor invocations — plus 3,638 blocks / 314,816 B inside <Constructor as Clone>::clone for the parameters and hook vectors.

The state table’s entry is Stored::Constructor(Rc<Constructor>) (common/store.rs), so the invoker is already holding a shareable handle; passing it through turns that whole per-invocation cost into a refcount bump. Sharing is sound because the definition is immutable once installed — nothing calls Rc::get_mut on it, and PartialEq for Whatsit compares definitions by value (*self.definition == *other.definition), so a shared handle compares exactly as a private clone did.

Trait Implementations

impl Clone for Constructor

fn clone(&self) -> Constructor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Constructor

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

Formats the value using the given formatter.

impl Default for Constructor

fn default() -> Self

Returns the “default value” for a type.

impl Definition for Constructor

fn invoke_primitive(&self) -> Result<Vec<Digested>>

Digest the constructor; This should occur in the Stomach to create a Whatsit. The whatsit which will be further processed to create the document.

Allocates a fresh Rc for the Whatsit’s back-reference. Callers that already hold the state table’s Rc<Constructor> should use Constructor::invoke_primitive_shared instead, which reuses it — see there for why that matters.

fn before_digest(&self) -> Option<&Vec<BeforeDigestClosure>>

fn after_digest(&self) -> Option<&Vec<DigestionClosure>>

fn after_digest_body(&self) -> Option<&Vec<DigestionClosure>>

fn capture_body(&self) -> bool

fn get_sizer(&self) -> Option<SizingClosure>

fn invoke(&self, _once_only: bool) -> Result<Tokens>

fn get_cs(&self) -> Cow<'_, Token>

We can almost always return the CS by reference, except in a Register’s RefCell, where we are forced to clone

fn get_cs_name(&self) -> Cow<'_, str>

fn get_alias(&self) -> Option<&String>

fn get_parameters(&self) -> Option<&Parameters>

fn get_num_args(&self) -> usize

fn do_absorption( &self, document: &mut Document, whatsit: &Whatsit, ) -> Result<Vec<Node>>

fn get_reversion_spec(&self) -> Option<Reversion>

fn get_cs_or_alias(&self) -> Cow<'_, Token>

fn is_protected(&self) -> bool

fn is_register(&self) -> bool

fn is_prefix(&self) -> bool

fn is_readonly(&self) -> bool

fn get_test(&self) -> Option<&ConditionalClosure>

fn get_conditional_type(&self) -> Option<ConditionalType>

fn read_arguments(&self) -> Result<Vec<ArgWrap>>

where Self: Sized,

fn invocation( &mut self, args: Vec<Option<Tokens>>, _gullet: &mut Gullet, ) -> Result<Tokens>

fn execute_before_digest(&self) -> Result<Vec<Digested>>

fn execute_after_digest(&self, whatsit: &mut Whatsit) -> Result<Vec<Digested>>

fn execute_after_digest_body( &self, whatsit: &mut Whatsit, ) -> Result<Vec<Digested>>

fn value_of(&self, _args: Vec<ArgWrap>) -> Option<RegisterValue>

fn set_value( &self, _value: RegisterValue, _scope: Option<Scope>, _args: Vec<ArgWrap>, )

runs the setter to assign the value for a register

fn register_type(&self) -> Option<RegisterType>

fn get_expansion(&self) -> Option<&ExpansionBody>

fn stringify_type(&self, deftype: &str) -> String

impl Display for Constructor

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

Formats the value using the given formatter.

impl From<Constructor> for Stored

fn from(value: Constructor) -> Self

Converts to this type from the input type.

impl Object for Constructor

fn stringify(&self) -> String

fn isa_box(&self) -> bool

fn is_expandable(&self) -> bool

fn is_definition(&self) -> bool

fn is_comment(&self) -> bool

fn be_digested(self) -> Result<Digested>

where Self: Sized + Debug,

fn get_locator(&self) -> Option<Locator>

The object’s stored source locator, if it has one. None is the honest “no recorded source position” (replacing the old Locator::default() file!()/line!() sentinel). For “where the parser is now” (error reporting, box creation), use the free fn gullet::get_locator().

fn revert(&self) -> Result<Tokens>

each concrete object needs to provide its own path back to tokens

impl PartialEq for Constructor

fn eq(&self, other: &Constructor) -> bool

Equality operator ==.

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

Inequality operator !=.