Simple library for concatenating immutable strings efficiently

`type t`````
`val empty : t`

Primitive, constant-time operations

`val nl : t`
`val plus : t ‑> t ‑> t`
`val length : t ‑> int`
`val concat : ?⁠sep:t ‑> t list ‑> t`

Linear in the number of elements.

`val concat_string : ?⁠sep:string ‑> string list ‑> t`

Linear in the number of elements in the list.

`include Core.Stringable.S with type t := t`
`type t`````
`val of_string : string ‑> t`
`val to_string : t ‑> string`
`val of_bigstring : Core.Bigstring.t ‑> t`
`val to_bigstring : t ‑> Core.Bigstring.t`
`val of_char : char ‑> t`
`val output_unix : t ‑> Async.Writer.t ‑> unit`
`val output_bigbuffer : t ‑> Core.Bigbuffer.t ‑> unit`
`val output_channel : t ‑> Core.Out_channel.t ‑> unit`
`module Underlying : sig ... end`
`val fold : t ‑> init:'accum ‑> f:('accum ‑> Underlying.t ‑> 'accum) ‑> 'accum`
`val iter : t ‑> f:(Underlying.t ‑> unit) ‑> unit`
`val is_suffix : t ‑> suffix:string ‑> bool`