Struct DocumentConstructor 

pub struct DocumentConstructor { /* private fields */ }

Implementations

impl DocumentConstructor

pub fn new() -> Self

pub fn current_node_id(&self) -> NodeId

pub fn current_node(&self) -> &Node

pub fn current_node_mut(&mut self) -> &mut Node

pub fn current_path(&self) -> &[PathSegment]

pub fn document(&self) -> &EureDocument

pub fn document_mut(&mut self) -> &mut EureDocument

pub fn finish(self) -> EureDocument

impl DocumentConstructor

pub fn begin_scope(&mut self) -> Scope

Begin a new scope. Returns a scope handle that must be passed to end_scope. Scopes must be ended in LIFO order (most recent first).

pub fn end_scope(&mut self, scope: Scope) -> Result<(), ScopeError>

End a scope, restoring the constructor to the state when the scope was created. Returns an error if the scope is not the most recent outstanding scope.

pub fn navigate(&mut self, segment: PathSegment) -> Result<NodeId, InsertError>

Navigate to a child node by path segment. Creates the node if it doesn’t exist.

pub fn navigate_partial_map_entry( &mut self, key: PartialObjectKey, ) -> Result<NodeId, InsertError>

Navigate into a PartialMap entry.

Find-or-create semantics:

• labeled holes and resolved keys reuse an existing entry
• anonymous holes (Hole(None)) always create a fresh entry

pub fn require_hole(&self) -> Result<(), InsertError>

Validate that the current node is a Hole (unbound). Use this before binding a value to ensure the node hasn’t already been assigned.

pub fn bind_hole( &mut self, label: Option<Identifier>, ) -> Result<(), InsertError>

Bind a hole (optionally labeled) to the current node.

pub fn bind_primitive( &mut self, value: PrimitiveValue, ) -> Result<(), InsertError>

Bind a primitive value to the current node. Error if already bound.

pub fn bind_from( &mut self, value: impl Into<PrimitiveValue>, ) -> Result<(), InsertError>

Bind a value to the current node using Into<PrimitiveValue>.

This is a convenience method for use with the eure! macro. It accepts any type that implements Into<PrimitiveValue>.

pub fn bind_empty_map(&mut self) -> Result<(), InsertError>

Bind an empty map to the current node. Error if already bound.

pub fn bind_empty_partial_map(&mut self) -> Result<(), InsertError>

Bind an empty PartialMap to the current node. Error if already bound.

pub fn bind_empty_array(&mut self) -> Result<(), InsertError>

Bind an empty array to the current node. Error if already bound.

pub fn bind_empty_tuple(&mut self) -> Result<(), InsertError>

Bind an empty tuple to the current node. Error if already bound.

pub fn begin_eure_block(&mut self)

Enter a new EureSource block. No-op for DocumentConstructor.

pub fn set_block_value(&mut self) -> Result<(), InsertError>

Set the value binding for current block. No-op for DocumentConstructor.

pub fn end_eure_block(&mut self) -> Result<(), InsertError>

End current EureSource block. No-op for DocumentConstructor.

pub fn begin_binding(&mut self)

Mark the start of a binding statement. No-op for DocumentConstructor.

pub fn end_binding_value(&mut self) -> Result<(), InsertError>

End binding #1: path = value. No-op for DocumentConstructor.

pub fn end_binding_block(&mut self) -> Result<(), InsertError>

End binding #2/#3: path { eure }. No-op for DocumentConstructor.

pub fn begin_section(&mut self)

Start a section header. No-op for DocumentConstructor.

pub fn begin_section_items(&mut self)

Begin section #4: items follow. No-op for DocumentConstructor.

pub fn end_section_items(&mut self) -> Result<(), InsertError>

End section #4: finalize section with items. No-op for DocumentConstructor.

pub fn end_section_block(&mut self) -> Result<(), InsertError>

End section #5/#6: block. No-op for DocumentConstructor.

impl DocumentConstructor

pub fn record<F, T, E>(&mut self, f: F) -> Result<T, E>

where F: FnOnce(&mut RecordWriter<'_>) -> Result<T, E>, E: From<WriteError>,

Write a record (map with string keys) using a closure.

Example

c.record(|rec| {
    rec.field("name", "Alice")?;
    rec.field("age", 30)?;
    Ok(())
})?;

pub fn tuple<F, T, E>(&mut self, f: F) -> Result<T, E>

where F: FnOnce(&mut TupleWriter<'_>) -> Result<T, E>, E: From<WriteError>,

Write a tuple using a closure.

Example

c.tuple(|t| {
    t.next("first")?;
    t.next(42)?;
    t.next(true)?;
    Ok(())
})?;

pub fn set_extension<T: IntoEure>( &mut self, name: &str, value: T, ) -> Result<(), T::Error>

Set an extension value on the current node.

Example

c.set_extension("optional", true)?;

pub fn set_extension_optional<T: IntoEure>( &mut self, name: &str, value: Option<T>, ) -> Result<(), T::Error>

Set an optional extension value on the current node. Does nothing if the value is None.

Example

c.set_extension_optional("default", self.default)?;

pub fn set_variant(&mut self, variant: &str) -> Result<(), WriteError>

Set the $variant extension for union types.

If called multiple times on the same node (nested unions), the variant path is appended using . (e.g., outer.inner.leaf).

Example

match self {
    MyEnum::Foo(inner) => {
        c.set_variant("foo")?;
        c.write(inner)?;
    }
}

pub fn write_subtree( &mut self, src: &EureDocument, node_id: NodeId, ) -> Result<(), WriteError>

Copy a subtree from another EureDocument into the current position.

This recursively copies the node at node_id from src, including all children and extensions, into the current node of this constructor.

pub fn write<T: IntoEure>(&mut self, value: T) -> Result<(), T::Error>

Write a value implementing IntoEure to the current node.

Example

c.write(my_value)?;

pub fn write_via<M, T>(&mut self, value: T) -> Result<(), M::Error>

where M: IntoEure<T>,

Write a remote type using a marker type.

This enables writing types from external crates that can’t implement IntoEure directly due to Rust’s orphan rule.

Example

// DurationDef implements IntoEure<std::time::Duration>
c.write_via::<DurationDef, _>(duration)?;

Trait Implementations

impl Default for DocumentConstructor

fn default() -> Self

Returns the “default value” for a type.

impl InterpreterSink for DocumentConstructor

type Error = InsertError

The error type for operations.

type Scope = Scope

The scope handle type returned by begin_scope.

fn begin_scope(&mut self) -> Self::Scope

Begin a new scope. Returns a handle that must be passed to end_scope. Scopes must be ended in LIFO order (most recent first).

fn end_scope(&mut self, scope: Self::Scope) -> Result<(), Self::Error>

End a scope, restoring the sink to the state when begin_scope was called.

fn navigate(&mut self, segment: PathSegment) -> Result<NodeId, Self::Error>

Navigate to a child node by path segment. Creates the node if it doesn’t exist.

fn require_hole(&self) -> Result<(), Self::Error>

Assert that the current node is unbound (a hole). Use this before binding a value to ensure the node hasn’t already been assigned.

fn bind_primitive(&mut self, value: PrimitiveValue) -> Result<(), Self::Error>

Bind a primitive value to the current node.

fn bind_hole(&mut self, label: Option<Identifier>) -> Result<(), Self::Error>

Bind a hole (with optional label) to the current node.

fn bind_empty_map(&mut self) -> Result<(), Self::Error>

Bind an empty map to the current node.

fn bind_empty_array(&mut self) -> Result<(), Self::Error>

Bind an empty array to the current node.

fn bind_empty_tuple(&mut self) -> Result<(), Self::Error>

Bind an empty tuple to the current node.

fn current_node_id(&self) -> NodeId

Get the current node ID.

fn current_path(&self) -> &[PathSegment]

Get the current path from root.

fn document(&self) -> &EureDocument

Get a reference to the document being built.

fn document_mut(&mut self) -> &mut EureDocument

Get a mutable reference to the document being built.

fn bind_from( &mut self, value: impl Into<PrimitiveValue>, ) -> Result<(), Self::Error>

Bind a value using Into<PrimitiveValue>. Convenience method for use with the eure! macro.

fn begin_eure_block(&mut self)

Enter a new EureSource block (for { eure } patterns). Pushes a new EureSource onto the builder stack. Default: no-op.

fn set_block_value(&mut self) -> Result<(), Self::Error>

Set the value binding for current EureSource (for { = value ... } patterns). Called after bind_* to record the value node. Returns error if called without a preceding bind operation. Default: no-op (returns Ok).

fn end_eure_block(&mut self) -> Result<(), Self::Error>

End current EureSource block. Pops from the builder stack. Returns error if the builder stack is in an invalid state. Default: no-op (returns Ok).

fn begin_binding(&mut self)

Start a binding statement (path ...). Default: no-op.

fn end_binding_value(&mut self) -> Result<(), Self::Error>

End binding #1: path = value. Adds BindingSource with BindSource::Value to current EureSource. Returns error if called without a preceding bind operation. Default: no-op (returns Ok).

fn end_binding_block(&mut self) -> Result<(), Self::Error>

End binding #2/#3: path { eure }. Adds BindingSource with BindSource::Block to current EureSource. The block’s EureSource was built between begin_eure_block/end_eure_block. Returns error if called without a preceding end_eure_block. Default: no-op (returns Ok).

fn begin_section(&mut self)

Start a section header (@ path ...). Default: no-op.

fn begin_section_items(&mut self)

Begin section #4: @ section (items follow). Begins collecting items into SectionBody::Items. Default: no-op.

fn end_section_items(&mut self) -> Result<(), Self::Error>

End section #4: finalize section with items body. Adds SectionSource with SectionBody::Items to current EureSource. Returns error if the builder stack is in an invalid state. Default: no-op (returns Ok).

fn end_section_block(&mut self) -> Result<(), Self::Error>

End section #5/#6: @ section { eure }. Adds SectionSource with SectionBody::Block to current EureSource. The block’s EureSource was built between begin_eure_block/end_eure_block. Returns error if called without a preceding end_eure_block. Default: no-op (returns Ok).

fn comment(&mut self, _comment: Comment)

Add a comment to the layout. Default: no-op.

fn blank_line(&mut self)

Add a blank line to the layout. Default: no-op.