Confused about String mutability

[rcliftonharvey]

Forgive me if it's a silly question, or if it's been discussed before, I did look.

But... why are mutable immutable Strings immutable and not mutable?

Yeah, OK. Let me explain...

At first, the V documentation states that Strings are immutable.

In V, a string is a read-only array of bytes. [...] String values are immutable.

After stating this absolute rule, just a few lines further down in the documentation, an example discounts this absolute rule by just assigning a new value to an existing String, without any further comment or explanation to the example or what's happening.

mut s := 'hello '
s += 'world' // `+=` is used to append to a string
println(s) // "hello world"`

So clearly, by applying the "mut" keyword to the declaration, Strings CAN very much be made mutable, and clearly the absolute rule of String immutability is wrong. (They're just immutable upon declaration without "mut", like any other variable.)

Now if Strings are mutable, then why can the content of a mutable String not be changed with the [] access operator?

error: cannot assign to s[i] since V strings are immutable
(note, that variables may be mutable but string values are always immutable, like in Go and Java)
    5 |     mut str := "Hell "
    6 |     str[4] = "o"

Why does this give me an error? This behaviour is totally counter-intuitive and confusing.

If the String had been declared without the "mut" keyword, i.e. as a regular immutable String, then I would have no objections. But to tell me that a clearly mutable String can not be altered because it's immutable... that just doesn't make any sense whatsoever.

I mean, I can (probably) understand the programming/implementation side of it. I guess the [] access operator returns a const reference, which explains why the String can't be written to - but not, why this would be the case.

And if a String marked as mutable can not be altered with the [] access operator... then why can it be altered via += concatenation, which is (from the outside) no different than assigning a different value, i.e. str1 += str2 == str1 = str1+str2?

For comparison, in a C++ std::string, the [] access operator of a non-const std::string instance, as well as the .at() access method, always give write access to the underlying String data. Only if the String is marked as const, will assignment through these operators/methods fail.

std::string str1 = "Hell ";
str1[4] = 'o';    // str1 --> "Hello"
str1.at(4) = '0'; // str1 --> "Hell0"

const std::string str2 = "Worl ";
str2[4] = 'd';    // Error --> assignment of read-only location
str2.at(4) = 'D'; // Error --> assignment of read-only location

This C++ way is a totally logical concept. A non-const string can be altered, a const string can not be altered.

I can understand that variables in V are automatically const/immutable on declaration, unless the "mut" keyword is specified. I can wrap my head around that and code accordingly.

But my OCD can not accept that a variable that's clearly marked as mutable can NOT be altered. This is illogical and inconsistent behaviour, and I think this should be improved for consistency and logic.

Or am I just missing something too obvious?

Cheers

[JalonSolov]

The thing you're missing is that adding 2 strings together, as in your first example, creates a third string and assigns it to s. By declaring s as mutable, you have told V that s itself can be changed, even though the string data it points to cannot.

If you attempt to modify the contents of the string using [], you are correctly told that the string cannot be changed.

I agree it can be a bit confusing at first.

[medvednikov]

Immutable strings are used as keys a lot, for example in maps. And having immutable keys helps with concurrent code.

[medvednikov]

More reasons: https://www.digitalocean.com/community/tutorials/string-immutable-final-java

[rcliftonharvey]

I understand that IMmutable Strings are IMmutable i.e. "const" and not changeable in size.
That's totally fine. Immutable Strings are amazing.

But my grief is that MUTABLE Strings (i.e. Strings that are clearly marked as content-changeable) are made IMmutable in some cases - but then not in other cases. This makes no sense. Either ALL Strings should be forced to ALWAYS be immutable, and never allow modification of any kind (incl. concatenation) at any time. Or data write access should be available for Strings that are intentionally marked as mutable (again: NOT immutable!).

Letting a user define a String explicitly as mutable i.e. content-changeable, but then denying the user to actually change the content of the String, is counter-intuitive and inconsistent. THAT'S what I'm having trouble with.

NOT that Strings are immutable by default, or that immutable Strings exist in general. But that MUTABLE Strings are denied the promised and declared mutability.

[medvednikov]

The string is not marked mutable, the variable is, like @JalonSolov explained. You're confusing the two concepts.

[Wajinn]

This might have a positive side, as a way to adjust the wording in the documentation or to emphasis particular points. Giving it a shot at explaining, though others already have. But maybe different explanations, will be good for future such questions.

string is a type, like int or bool. Which is different from what is a variable (which might need to be more strongly emphasized as a teaching point). A variable is used to store information. When we refer to what kind of information is being stored by a variable, we may use the term "type". The variable may store values of the string, int, or bool type (primitive types).

A variable in V can be designated as mutable or immutable. A string in V is a read-only array of bytes, where its elements can't be mutated. Thus the individual string elements can't be changed. This is for good reasons, among them are: security, multithreading, concurrency, and hash map keys. A link was provided about this.

With a mutable variable, we can add to or remove a string (array of bytes) that are being stored. The string 'Hello' and 'world!' can be concatenated together, to form 'Hello world!'. However, we can't change the individual elements which compose the string. The string 'Hello' is immutable, and we can't change the 'H' to 'h'.

If we have, mut var := 'Hello'. Then var[0] = 'h' is not possible, as the string is immutable, even though the variable is mutable. We can, however, change the contents of var. We can do, var += ' world!', to get 'Hello world!', because var is mutable.

mut var := 'Hello'
// var[0] = 'h' // not allowed and will give error message
var += ' world!'
println(var) // Hello world!
var =''
println(var)
var = 'Greetings earthlings!'
println(var)