Method declarations

[tmssngr]

struct StringCharSource {
	text: string,
	index: int
}
impl StringCharSource {
	fn next(mut self) -> int {
		...
		self.index += 1
		...
	}
}

doesn't compile with receiver is immutable which looks weird to me as I have put the mut before self. Instead, Lis wants me to declare self as ref: fn next(mut self: Ref<StringCharSource>) -> int {. To me mut self and mut self: Ref<StringCharSource> are far apart. Why in one case I don't need to (or even must not?) specify the type, but in the other case I must provide it? IMHO this needs some polishing. Maybe mut Ref<self> would be more compact (if you want to stick with the Ref for the moment)?

[ivov]

#1287 fixes this. Merged last week, but not yet released.

Starting with v0.12, mut will mark a type, so that:

• self operates on a copy of the struct
• self: Ref<T> points at the struct, read-only
• self: mut Ref<T> points at the struct, writable

As for syntax, self is shorthand for self: T, the common case.

Earlier in #1202 and #892 we discussed signaling mutability in the context of e.g. Ref<T>. The new guarantee in #1287 is a step in that direction. Curious what you'll think of it.

[tmssngr]

That are great news!

Could self: Ref<T> be simplified to self: Ref (ditto for the mut variant) for method declarations?

[ivov]

This has come up from other users as well. Worth exploring, tracking at #1344.

[tmssngr]

I gave Lis 0.12 a try and it is a great step into the right direction.

Maybe it also would make sense to require a Rust-like mut for any parameter passed to a mut Ref argument, even if the local variable is already of type mut Ref:

let mut chain = create_chain()
append_all_cool_items(items, mut chain)

...
fn append_all_cool_items(..., chain: mut Ref<Chain>) {
   ...
}

Benefit: we would see immediately in the calling code which passed variables can be modified by a function invocation (without needing to look at the function declaration). As this usually only happens for a lower number of arguments, the mut would stand out good enough.

For the self-reference of methods, though, I'm not sure and I'd keep it as-is (at least for now):

let mut chain = create_chain()
chain.append("hello")

...
impl Chain {
...
   fn append(self: mut Ref<Chain>, text: string) {
   ...
   }
...
}