3 ms·
Rust seems to handle that reasonably well, interior mutability[0] aside mutating an object requires having an &mut to it, which you can only get through a mut b
by masklinn 9y ago
Rust seems to handle that reasonably well, interior mutability[0] aside mutating an object requires having an &mut to it, which you can only get through a mut binding (or a pre-existing &mut).
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).
[0] https://doc.rust-lang.org/book/mutability.html#interior-vs-exterior-mutability https://doc.rust-lang.org/book/mutability.html#interior-vs-e...
- smitherfield 9y ago> 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};
- masklinn 9y ago> 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]. They also likely didn't want to make the work of bridging/using Obj-C types (which I believe are all reference types) even harder.
- masklinn 9y ago> only accessible on let bindings Should read "var bindings" (mutable bindings), sadly the edition window is now closed.