What is the right method to add a String?

[davidanthoff]

I'm thoroughly confused between append! (current choice), print, write or some other option?

[jw3126]

I prefer append! here. The difference between using StringBuilder or plain IOBuffer seems mostly psychological. The mental model of StringBuilder is for me that you assemble your string from pieces. While the mental model of using plain IOBuffer is that you print all the pieces to a stream and extract the whole content in the end.

So append! fits StringBuilder, while print and write are for IOBuffer. I also like the ! in append! as this is a mutating operation.

[StefanKarpinski]

It seems rather like StringBuilder is just a mutable string type...

[davidanthoff]

It seems rather like StringBuilder is just a mutable string type...

It might be, who knows ;) This is really just playing around. I think this all comes down to what use-case one tries to optimize for. I think StringBuilder to me suggests that this is meant to build up strings from pieces, and not necessarily a general purpose mutable string. That is what it is right now. Could easily morph into something else, though.

[StefanKarpinski]

Makes sense. I guess a generally mutable string has a far more complex API than just a string that can be mutated by appending.

[innerlee]

overload an operator? sb *= "thing"

[jlapeyre]

@innerlee No, this syntax would confuse StringBuilder with the problem it is meant to solve. The updating operators, like *=, rebind the left hand side, and Strings are immutable, so we have to have.

julia> s = "hi"
"hi"

julia> s1 = s
"hi"

julia> Base.unsafe_convert(Cstring,s)
Cstring(0x00007f39edf48718)

julia> Base.unsafe_convert(Cstring,s1)  # same memory location
Cstring(0x00007f39edf48718)

julia> s *= "there"
"hithere"

julia> Base.unsafe_convert(Cstring,s)   # both "hi" and "there" are copied to a new location
Cstring(0x00007f39eebf2378)

julia> Base.unsafe_convert(Cstring,s1) # s1 cannot be mutated and does not move
Cstring(0x00007f39edf48718)

On the other hand append! mutates an object, ie does not necessarily copy the first part to a new location. So using append! signals the essential behavior of StringBuilder, while *= obscures it.

[chakravala]

Is this faster than constructing strings with String immutables? Some of my programs heavily rely on string processing, and I'd like to speed it up.

[jlapeyre]

If you are building strings like this:

a = "string 1"
a *= "string 2"

etc., then yes, it can be much faster. As usual, it depends on how much of this you do, and the rest of the program, etc.
If you build a very long string from a lot of short pieces this way, then the entire is string is copied every time. This sounds like .... O(n^2) in the number of small pieces or something like that.

[chakravala]

The problem is that sometimes the string is built non-linearly, and needs to be analyzed, reconstructed, and taken apart along the way. But the buffer method could help in intermediate steps.

[jlapeyre]

Yes, you might find IOBuffer and seek useful. There are other string packages around. There used to be RopeString, but I don't know where to find it.