About reassigning self in classes

[Jens]

Thanks for providing those links! I've read them through and they are mostly about the problem as formulated in the forked thread, and while they provide answers to the problem from that perspective, they don't quite answer the specific questions of this thread, namely:

Given the program in the OP (which demonstrates that it is possible to reassign self in classes, and that the way it is done is such that it might happen accidentally):

@Jens

• Why is it important to prevent reassigning self in classes? (rhetorical question)
• Why is it then not prevented to (even accidentally) do so via a protocol's default implementation?

---

I've quoted the parts of the linked discussions that comes closest to answering these questions here:

@jrose

Until we have the "this protocol is only for value types" part, we can't do the "treat mutating as if it is not there in reference types" part. It's also not obviously a good idea since an immutable class type is pretty much indistinguishable from a value type except for ObjectIdentifier (and === ).

(A long time ago @dabrahams and I talked about disallowing classes from conforming to protocols with mutating requirements, which is similar. But at this point it'd be massively source-breaking to do so.)

@Dante-Broggi

One thing I have wondered about related to this issue is why Swift does not allow writing:

class Foo {
  mutating func bar() {
    self = Foo()
  }
}

@jrose

We could allow it, sure. But it would only change this reference, not any other references pointing to the same object, and not having mutating doesn't prevent you from changing stored properties (see Avoiding unbreakable reference cycle with value types and closures?). So it's left out of the language to avoid introducing a point of confusion.

Have you come across a situation where you would have wanted this?

@Dante-Broggi

No, I just noted it would be a generally consistent and unambiguous extension of the current meaning.

---

So what I'm saying is that after reading and understanding the above (and the other parts of the linked discussions) I've yet to see the rationale for the seemingly inconsistent behavior demonstrated by the program in the OP. That is:
Why does Swift allow a default implementation of a protocol to reassign self of a class from under our feet (while actively preventing us from doing it explicitly within the class)?