Array builders

[rikkimax]

Builders are a data structure used for constructing an array of something.
They are not merely an append-only abstraction like an appender.

Supporting other methods such as removal and insertion is useful for the purposes of pretty printing of types.

An overview of the API of a string builder:

struct StringBuilder {
    private {
        Block* head, tail;
        size_t amount;
        
        struct Block {
            Block* previous, next;
            char[] data;
            size_t used;
        }
    }
    
    @disable this(this);

    size_t length();
    void clear() => this.removeAt(0, size_t.max);
    
    string asUTF8();
    wstring asUTF16();
    dstring asUTF32();

    alias append = opOpAssign!"~";
    alias put = opOpAssign!"~";
    void opOpAssign(string op : "~")(const(char)[] input) => this.insertAt(ptrdiff_t.max, input);
    
    size_t insertAt(ptrdiff_t index, const(char)[] input);
    size_t insertAt(ptrdiff_t index, const(wchar)[] input);
    size_t insertAt(ptrdiff_t index, const(dchar)[] input);
    
    void removeAt(ptrdiff_t index, size_t amount);
    
    size_t startsAt(ptrdiff_t index, const(char)[] against);
    size_t startsAt(ptrdiff_t index, const(wchar)[] against);
    size_t startsAt(ptrdiff_t index, const(dchar)[] against);
    
    size_t endsAt(ptrdiff_t index, const(char)[] against);
    size_t endsAt(ptrdiff_t index, const(wchar)[] against);
    size_t endsAt(ptrdiff_t index, const(dchar)[] against);
    
    bool startsWith(const(char)[] against) => this.startsAt(0, against) > 0;
    bool startsWith(const(wchar)[] against => this.startsAt(0, against)) > 0;
    bool startsWith(const(dchar)[] against) => this.startsAt(0, against) > 0;
    
    bool endsWith(const(char)[] against) => this.endsWith(ptrdiff_t.max, against) > 0;
    bool endsWith(const(wchar)[] against) => this.endsWith(ptrdiff_t.max, against) > 0;
    bool endsWith(const(dchar)[] against) => this.endsWith(ptrdiff_t.max, against) > 0;
}

It can be genericarised to other basic types, and with that non-basic types.

These are typically implemented using an unrolled linked list, such as C#'s StringBuilder.

A key idea for this is that we would drop output ranges entirely for printing of types behavior, and instead use methods such as:

interface IPrint {
    void toPrint(ref StringBuilder output); // do not have any control chars i.e. new line emitted, escape them
    void toPrint(ref StringBuilder output, ref PrettyPrinter pp); // emit prefix before new line, unless its data. Start all functions with prefix call.
}

Unifying on a GC approach that gives good clean readable output. It should not be hacked together by each user.