Module Prelude.Buffer

Additional Buffer functions.

include module type of struct include Stdlib.Buffer end
type t = Stdlib__Buffer.t
val create : int -> t
val contents : t -> string
val to_bytes : t -> bytes
val sub : t -> int -> int -> string
val blit : t -> int -> bytes -> int -> int -> unit
val nth : t -> int -> char
val length : t -> int
val clear : t -> unit
val reset : t -> unit
val output_buffer : Stdlib.out_channel -> t -> unit
val truncate : t -> int -> unit
val add_char : t -> char -> unit
val add_utf_8_uchar : t -> Stdlib.Uchar.t -> unit
val add_utf_16le_uchar : t -> Stdlib.Uchar.t -> unit
val add_utf_16be_uchar : t -> Stdlib.Uchar.t -> unit
val add_string : t -> string -> unit
val add_bytes : t -> bytes -> unit
val add_substring : t -> string -> int -> int -> unit
val add_subbytes : t -> bytes -> int -> int -> unit
val add_substitute : t -> (string -> string) -> string -> unit
val add_buffer : t -> t -> unit
val add_channel : t -> Stdlib.in_channel -> int -> unit
val to_seq : t -> char Stdlib.Seq.t
val to_seqi : t -> (int * char) Stdlib.Seq.t
val add_seq : t -> char Stdlib.Seq.t -> unit
val of_seq : char Stdlib.Seq.t -> t
val add_uint8 : t -> int -> unit
val add_int8 : t -> int -> unit
val add_uint16_ne : t -> int -> unit
val add_uint16_be : t -> int -> unit
val add_uint16_le : t -> int -> unit
val add_int16_ne : t -> int -> unit
val add_int16_be : t -> int -> unit
val add_int16_le : t -> int -> unit
val add_int32_ne : t -> int32 -> unit
val add_int32_be : t -> int32 -> unit
val add_int32_le : t -> int32 -> unit
val add_int64_ne : t -> int64 -> unit
val add_int64_be : t -> int64 -> unit
val add_int64_le : t -> int64 -> unit
val scons : string -> t -> t

(scons s b) adds the string s to buffer b, returning b.

Useful for folding into a buffer accumulator.

val snocs : t -> string -> t

snocs is (flip scons).

Example: (fun xs -> withbuf 100 (flip (foldl snocs) xs)) is (String.concat "").

val ccons : char -> t -> t

(ccons c b) adds the char c to buffer b, returning b.

val withbuf2 : int -> (Stdlib.Buffer.t -> 'a) -> string * 'a

(withbuf2 n f) is ((let r = f buf in Buffer.contents buf, r)) where buf is a fresh Buffer.t of size n.

val withbuf : int -> (Stdlib.Buffer.t -> 'a) -> string

(withbuf size f) is (withbuf2 size f |> fst).

It discards the value of (f buf), which is frequently ().

This abstracts the common pattern:

let f x =
  let buf = Buffer.create n in
  let f' () =
    something (); Buffer.add_THING buf thing; something ()
  in
  f' () |> ignore; Buffer.contents buf

into:

let f' buf = ... Buffer.add_... buf ... in withbuf n f'

For example:

let implode cs = withbuf (len cs) (fun b -> iter (Buffer.add_char b) cs)