Make objects returned from the functions mutable to enable chain methods

[avitkauskas]

Now this would not work:

pub fn (s mut []string) sort() []string {
	s.sort_with_compare(compare_strings)
	return s
}

fn main() {
	m := {
		'b': 1
		'a': 2
	}
	for k in m.keys().sort() {
		println(m[k])
	}
}

because sort() requires mutable receiver.

You have to do:

fn main() {
	m := {
		'b': 1
		'a': 2
	}
	mut k := m.keys()
	for i in k.sort() {
		println(m[i])
	}
}

I think it would be good if objects (structs, arrays, primitives) returned from the funtions would be treated as mutable by compiler until they are assigned to some immutable variable.

This way it would enable method chaining independently of the mutability of the receiver of the method.

Could it be that method returns an immutable object (like the same immutable receiver it works on), and then this proposed change would allow to change the immutable object (that should never happen)?

Is there some better way to enable that?
Indicating if the returned object can be mutated of not?

fn (m map) keys() mut []string {...}

[thecodrr]

fn (m map) keys() mut []string {...}

This would be cool to have and readable too => method keys returns mutable string array