> Swift also classifies methods between regular (accessible on both var and let binding) and `mutating` (only accessible on let bindings), though I think that a

> Swift also classifies methods between regular (accessible on both var and let binding) and `mutating` (only accessible on let bindings), though I think that also works for value types (structs). Just to clarify the terminology, the `mutating` keyword in Swift is only used with value types (`struct` and `enum`) and is only accessible on `var` bindings (`let` bindings are readonly). IMO allowing interior mutability by default on `let`-bound reference (`class`) types was a mistake in the language design and the same syntax should've been required there, but I assume Apple wanted to make things clearer for programmers who don't have a C/C++/similar background and so don't yet understand the distinction between [stack-allocated, pass-by-copy] values and references [to heap-allocated, reference-counted objects]. In C++ terms: struct O {int f;}; template<class T> struct SwiftRef : shared_ptr<T> { template<class U> SwiftRef(U u) : shared_ptr<T>(new T{u}) {} operator T() const noexcept {return **this;} }; O struct_var_binding{4}; const O struct_let_binding{4}; SwiftRef<O> class_var_binding{4}; const SwiftRef<O> class_let_binding{4}; // What it should be, IMO: const SwiftRef<const O> class_let_binding{4};