Struct StyxWriter 

pub struct StyxWriter { /* private fields */ }

Low-level Styx output writer.

This writer handles the formatting logic for Styx output, including:

• Indentation and newlines
• Scalar quoting decisions
• Inline vs multi-line formatting

Implementations

impl StyxWriter

pub fn new() -> Self

Create a new writer with default options.

pub fn with_options(options: FormatOptions) -> Self

Create a new writer with the given options.

pub fn finish(self) -> Vec<u8>

Consume the writer and return the output bytes.

pub fn finish_document(self) -> Vec<u8>

Consume the writer and return the output bytes, ensuring a trailing newline. This matches CST formatter behavior for standalone documents.

pub fn finish_string(self) -> String

Consume the writer and return the output as a String.

Panics

Panics if the output is not valid UTF-8 (should never happen with Styx).

pub fn depth(&self) -> usize

Current nesting depth.

pub fn available_width(&self) -> usize

Calculate available width at current depth.

pub fn should_inline(&self) -> bool

Check if we should use inline formatting at current depth.

pub fn write_indent(&mut self)

Write indentation for the current depth.

pub fn write_newline_indent(&mut self)

Write a newline and indentation.

pub fn write_raw(&mut self, bytes: &[u8])

Write raw bytes to the output.

pub fn write_str(&mut self, s: &str)

Write a raw string to the output.

pub fn write_byte(&mut self, b: u8)

Write a single byte.

pub fn begin_struct(&mut self, is_root: bool)

Begin a struct/object.

If is_root is true, no braces are written (implicit root object).

pub fn begin_struct_with_options( &mut self, is_root: bool, force_multiline: bool, )

Begin a struct/object with explicit multiline control.

If is_root is true, no braces are written (implicit root object). If force_multiline is true, the struct will never be inlined.

pub fn begin_struct_after_tag(&mut self, force_multiline: bool)

Begin a struct directly after a tag (no space before the brace).

pub fn field_key_raw(&mut self, key: &str) -> Result<(), &'static str>

Write a field key without quoting (raw).

Use this for keys that should be written exactly as-is, like @ for unit keys.

pub fn field_key(&mut self, key: &str) -> Result<(), &'static str>

Write a field key.

Returns an error message if called outside of a struct context.

pub fn end_struct(&mut self) -> Result<(), &'static str>

End a struct/object.

Returns an error message if called without a matching begin_struct.

pub fn begin_seq(&mut self)

Begin a sequence.

pub fn end_seq(&mut self) -> Result<(), &'static str>

End a sequence.

Returns an error message if called without a matching begin_seq.

pub fn write_null(&mut self)

Write a null/unit value.

pub fn write_bool(&mut self, v: bool)

Write a boolean value.

pub fn write_i64(&mut self, v: i64)

Write an i64 value.

pub fn write_u64(&mut self, v: u64)

Write a u64 value.

pub fn write_i128(&mut self, v: i128)

Write an i128 value.

pub fn write_u128(&mut self, v: u128)

Write a u128 value.

pub fn write_f64(&mut self, v: f64)

Write an f64 value.

pub fn write_string(&mut self, s: &str)

Write a string value with appropriate quoting.

pub fn write_char(&mut self, c: char)

Write a char value.

pub fn write_bytes(&mut self, bytes: &[u8])

Write bytes as hex-encoded string.

pub fn write_variant_tag(&mut self, name: &str)

Write a variant tag (e.g., @some).

pub fn write_scalar(&mut self, s: &str)

Write a scalar value with appropriate quoting. Alias for write_string, for when you have a pre-existing scalar.

pub fn write_tag(&mut self, name: &str)

Write a tag (e.g., @string). Same as write_variant_tag.

pub fn clear_skip_before_value(&mut self)

Clear the skip_next_before_value flag. Call this when a tag’s payload is skipped (e.g., None for a unit variant).

pub fn begin_seq_after_tag(&mut self)

Begin a sequence directly after a tag (no space before the paren).

pub fn write_doc_comment_and_key(&mut self, doc: &str, key: &str)

Write a doc comment followed by a field key. Multiple lines are supported (each line gets /// prefix).

pub fn write_doc_comment_and_key_raw(&mut self, doc: &str, key: &str)

Write a doc comment followed by a raw field key (no quoting). Use this for keys like @ that should be written literally.

pub fn before_value(&mut self)

Handle separator before a value in a container.

Trait Implementations

impl Default for StyxWriter

fn default() -> Self

Returns the “default value” for a type.