as in assume you had: fn reset(p: &mut Point) { p.x = 0; p.y = 0; }
Why can't this be called like so:
reset(&some_point);
rather than needing to say
reset(&mut some_point);
To some extent it's nice that the callsite must document the behavior visually, but its more forcing a style guide rather than anything that's required to compile & work.
I've always figured that was the reason. It's immediately obvious at the call site that a borrow is happening, and that it is a mutable borrow. Otherwise, if you wanted to know, you'd need to inspect each of the function's signatures that the variable is passed to.
(Compare, perhaps, to C++ references, where it isn't apparent at the call site at all that your variable might change.)
Perhaps what you're wondering is "why can't the compiler infer when a borrow needs to be mutable instead of having the programmer specify it"? I can't say for certain what the answer to this is, but my guess is that it would be rather expensive. Consider this example (reusing the "add" function from above):
let mut foo = Point { x: 1, y: 2 };
let bar = &foo;
add(&foo, &foo);
...
// Much later
reset(bar);
Considering how seriously Rust takes explicitness in general, I strongly suspect this was done purely for readability.
fn foo(x: &S);
fn foo(y: &T);
fn foo(x: &A);
fn foo(x: &mut A);