Struct RecordWriter 

pub struct RecordWriter<'a> { /* private fields */ }

Helper for writing record (map with string keys) to Eure documents.

Used within the closure passed to DocumentConstructor::record.

When ext_mode is true, field writes are redirected to extension writes. This is used by flatten_ext to write fields as extensions.

Example

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

Implementations

impl<'a> RecordWriter<'a>

pub fn new_with_ext_mode( constructor: &'a mut DocumentConstructor, ext_mode: bool, ) -> Self

Create a new RecordWriter with the specified ext_mode.

This is primarily used by generated derive code that needs to write flattened extension fields onto an existing node.

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

Write a required field.

In ext_mode, this redirects to an extension write.

Example

rec.field("name", "Alice")?;

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

where M: IntoEure<T>,

Write a required field using a marker type.

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

In ext_mode, this redirects to an extension write via the marker type.

Example

// DurationDef implements IntoEure<std::time::Duration>
rec.field_via::<DurationDef, _>("timeout", duration)?;

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

Write an optional field. Does nothing if the value is None.

Example

rec.field_optional("age", self.age)?;

pub fn field_with<F, T>(&mut self, name: &str, f: F) -> Result<T, WriteError>

where F: FnOnce(&mut DocumentConstructor) -> Result<T, WriteError>,

Write a field using a custom writer closure.

Useful for nested structures that need custom handling.

Example

rec.field_with("address", |c| {
    c.record(|rec| {
        rec.field("city", "Tokyo")?;
        Ok(())
    })
})?;

pub fn field_with_optional<T, F, R>( &mut self, name: &str, value: Option<T>, f: F, ) -> Result<Option<R>, WriteError>

where F: FnOnce(&mut DocumentConstructor, T) -> Result<R, WriteError>,

Write an optional field using a custom writer closure. Does nothing if the value is None.

Example

rec.field_with_optional("metadata", self.metadata.as_ref(), |c, meta| {
    c.write(meta)
})?;

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

where M: IntoEure<T>,

Flatten a value’s fields into this record writer.

The flattened type’s fields are written as if they were direct fields of this record. The current ext_mode is inherited.

Example

rec.flatten(value.address)?;

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

where M: IntoEure<T>,

Flatten a value’s fields as extensions into this record.

Creates a temporary RecordWriter with ext_mode: true, so that all field writes from the flattened type become extension writes.

Example

rec.flatten_ext(value.ext)?;

pub fn constructor(&mut self) -> &mut DocumentConstructor

Get a mutable reference to the underlying DocumentConstructor.

Useful for advanced use cases that need direct access.