type write_error = private [>
The type for write errors.
val pp_write_error : write_error Fmt.t
pp_write_error is the pretty-printer for write errors.
create flow allocates send and receive buffers and associates them with the given unbuffered
val read_char : t -> (char Mirage_flow.or_eof, error) result Lwt.t
Reads a single character from the channel, blocking if there is no immediately available input data.
read_some ?len t reads up to
len characters from the input channel and at most a full
len is not specified, it reads all available data and returns that buffer.
read_exactly len t reads
len bytes from the channel
t or fails with
read_line t reads a line of input, which is terminated either by a CRLF sequence, or the end of the channel (which counts as a line).
?len is provided then the maximum length of the line returned will be
len bytes. If the line is longer than
len then an error will be returned. With
len = 0,
read_line always returns an error.
If the input data is untrusted then care should be taken to ensure
len is set to an application-specific small value to bound the amount of memory allocated by
val write_char : t -> char -> unit
write_char t ch writes a single character to the output channel.
val write_string : t -> string -> int -> int -> unit
write_string t buf off len writes
len bytes from a string
buf, starting from from offset
write_buffer t buf copies the buffer to the channel's output buffer. The buffer should not be modified after being written, and it will be recycled into the buffer allocation pool at some future point.
val write_line : t -> string -> unit
write_line t buf writes the string
buf to the output channel and append a newline character afterwards.
val flush : t -> (unit, write_error) result Lwt.t
flush t flushes the output buffer and block if necessary until it is all written out to the flow.
val close : t -> (unit, write_error) result Lwt.t
close t calls
flush and then close the underlying flow.