std.io

Reader/Writer, std streams, FixedBuf, NullWriter, printing; no allocation

IoError

pub IoError :: errors {
    write_failed,
    short_write,
    read_failed,
    end_of_stream,
    buffer_full,
}

• write_failed: The underlying write call returned zero bytes
• short_write: A partial write where a full write was required
• read_failed: The underlying read call failed
• end_of_stream: The reader reached the end of available data
• buffer_full: A FixedBuf ran out of space mid-write

Writer

pub Writer :: interface {
    write :: fn(self: *Self, data: []const u8) -> usize ! IoError;
    flush :: fn(self: *Self) -> void ! IoError;
}

byte sink; use *Writer for dynamic dispatch

Reader

pub Reader :: interface {
    read :: fn(self: *Self, buf: []u8) -> usize ! IoError;
}

byte source; read gives <= buf.len, may give fewer; 0 only at end (or for an empty buf)

Stdout

pub Stdout :: struct {
    marker: u8,
}

Stderr

pub Stderr :: struct {
    marker: u8,
}

stdout

pub stdout :: fn() -> Stdout

stderr

pub stderr :: fn() -> Stderr

Stdin

pub Stdin :: struct {
    marker: u8,
}

stdin as a Reader; read gives 0 at end (closed pipe, Ctrl+Z / Ctrl+D)

stdin

pub stdin :: fn() -> Stdin

SliceReader

pub SliceReader :: struct {
    rest: []const u8,
}

• rest: the bytes not read yet

slice_reader

pub slice_reader :: fn(data: []const u8) -> SliceReader

copy

pub copy :: fn(dst: *Writer, src: *Reader, buf: []u8) -> u64 ! IoError

copy all of src to dst via buf; returns bytes copied

FixedBuf

pub FixedBuf :: struct {
    data: [256]u8,
    pos: usize,
}

fixed_buf

pub fixed_buf :: fn() -> FixedBuf

buf_len

pub buf_len :: fn(self: *FixedBuf) -> usize

bytes written

buf_remaining

pub buf_remaining :: fn(self: *FixedBuf) -> usize

bytes left

buf_reset

pub buf_reset :: fn(self: *FixedBuf)

clear for reuse

buf_flush_stdout

pub buf_flush_stdout :: fn(self: *FixedBuf) -> usize ! IoError

flush to stdout in one syscall

buf_flush_stderr

pub buf_flush_stderr :: fn(self: *FixedBuf) -> usize ! IoError

flush to stderr in one syscall

buf_flush

pub buf_flush :: fn(self: *FixedBuf, sink: *Writer) -> usize ! IoError

flush to any *Writer in one call

NullWriter

pub NullWriter :: struct {
    count: usize,
}

null_writer

pub null_writer :: fn() -> NullWriter

null_reset

pub null_reset :: fn(self: *NullWriter)

zero the byte count

write_all

pub write_all :: fn(self: *Writer, data: []const u8) -> usize ! IoError

all of data or fail; a short write is short_write

write_line

pub write_line :: fn(self: *Writer, data: []const u8) -> usize ! IoError

data then “\n”

write_char

pub write_char :: fn(self: *Writer, ch: u8) -> usize ! IoError

write_repeat

pub write_repeat :: fn(self: *Writer, ch: u8, count: usize) -> usize ! IoError

count copies of ch

write_bool

pub write_bool :: fn(self: *Writer, value: bool) -> usize ! IoError

write_u64

pub write_u64 :: fn(self: *Writer, value: u64) -> usize ! IoError

decimal; recursion depth <= 20

write_i64

pub write_i64 :: fn(self: *Writer, value: i64) -> usize ! IoError

decimal; i64 min is safe: abs via -(n+1)+1, no overflow

write_hex_byte

pub write_hex_byte :: fn(self: *Writer, value: u8) -> usize ! IoError

two lowercase hex digits

write_hex_u64

pub write_hex_u64 :: fn(self: *Writer, value: u64) -> usize ! IoError

lowercase hex, no leading zeros, no prefix; recursion depth <= 16

write_hex_u64_full

pub write_hex_u64_full :: fn(self: *Writer, value: u64) -> usize ! IoError

exactly 16 lowercase hex digits, no prefix

print

pub print :: fn(f: Format) -> usize ! IoError

println

pub println :: fn(f: Format) -> usize ! IoError

eprint

pub eprint :: fn(f: Format) -> usize ! IoError

eprintln

pub eprintln :: fn(f: Format) -> usize ! IoError

print_u64

pub print_u64 :: fn(value: u64) -> usize ! IoError

print_i64

pub print_i64 :: fn(value: i64) -> usize ! IoError

print_hex_u64

pub print_hex_u64 :: fn(value: u64) -> usize ! IoError

print_bool

pub print_bool :: fn(value: bool) -> usize ! IoError

eprint_u64

pub eprint_u64 :: fn(value: u64) -> usize ! IoError

eprint_i64

pub eprint_i64 :: fn(value: i64) -> usize ! IoError

write_fmt

pub write_fmt :: fn(self: *Writer, f: Format) -> usize ! IoError

write f through a 512-byte buffer, so a line is one write

write_fmt_line

pub write_fmt_line :: fn(self: *Writer, f: Format) -> usize ! IoError

write_fmt + newline

show_value

pub show_value :: fn(f: *Formatter, d: *const u8, id: usize, ti: TypeInfo, spec: []const u8)

Formatter.show for std.io: the value at d (type ti, type id id) per spec