Module fmt/index

The default spec: no width, no precision, no radix.

Parse a spec. TOTAL: anything unrecognised is ignored rather than rejected, so a malformed spec degrades to plain to_string() output instead of failing at runtime.

Apply width/fill/alignment (and text truncation) to an already-rendered body. dflt is the alignment used when the spec did not give one — Left for text, Right for numbers, as in Rust.

Number-aware padding: with 0 set and no explicit alignment, the zero fill goes BETWEEN the sign/prefix and the digits, so -0042 and 0x0000002a are reachable. Otherwise this is ordinary right-aligned padding over the whole rendering.

Create a new, empty StringBuilder.

Create a StringBuilder pre-allocated for capacity bytes.

Returns the current number of bytes in the buffer.

Returns true if the buffer is empty.

Append a str (raw byte slice) to the buffer.

Append a String to the buffer.

Append a single byte to the buffer.

Append a single Unicode code point, encoded as UTF-8.

Example

sb := StringBuilder.new();
sb.write_rune(rune(0x1F600));  // 😀
sb.write_rune(rune(0x41));     // 'A'

Append a String followed by a newline byte (\n).

Detach the accumulated bytes as a String, leaving the builder EMPTY and still usable.

It does not copy and it does not consume the builder: the receiver is a reference, and it starts over with a fresh buffer, so building an N-byte string costs O(N) once. The returned String is therefore independent — a later write_* on the same builder cannot mutate a string already handed to a caller.

Append an unsigned 64-bit integer in lowercase hexadecimal.

Append n with exactly precision decimal places.

Append s padded to width RUNES with pad, aligned per align. A s already at or over the width is written unpadded.

Width is a RUNE count, matching FormatSpec's {:width$} and Rust's. It used to be a BYTE count here, so write_padded("héllo", 8, ' ', .Left) emitted two spaces instead of three and the column did not line up — the two width bases in one module disagreed (issues/fixed/write-padded-counted-bytes-where-formatspec-counts-runes.md).

Empty the builder.

This RELEASES the buffer rather than retaining its capacity — unlike Rust's String::clear and unlike ArrayList.clear, both of which keep the allocation for reuse. A builder cleared in a loop therefore reallocates from zero on every pass; when that matters, keep a fresh builder per iteration instead (it costs the same) or hand the bytes off with to_string(), which detaches for the same price. (issues/stddoc-str-string-builder-clear-drops-capacity.md)

The default value of the type.