Class-constrained protocol extension

[DeFrenZ (Davide De Franceschi)]

There are a few previous threads on the topic:

[Bug?] Reference types and mutating methods

I don't believe this has been addressed, please correct me if I'm wrong. --My Situation-- I've recently been working on an observable collection type. Because each stores ‘subscriptions’ to changes that occur, it made sense to me that this should be a reference type, so subscriptions can't be copied with the values themselves. I have made this class conform to RangeReplaceableCollectionType, providing it with all the standard collection functions. I do the following: let array: ObservedArray<…

Is the 'existential' a value or ref type?

In the given example the compiler complains and want that the method is marked as mutating and the property itself is a var: protocol P { var array: [Int] { get set } } class A: P { var array: [Int] = [] } struct S { let value: AnyObject & P func append() { value.array.append(42) } } My question is now if the "existential" box that the compiler generates for us (also known as any AnyObject & P from this thread) is itself a value or a ref type in Swift?

Proposal: Intermediate mutation qualifier for protocol functions on reference-types

Currently, when a reference-type adopts a protocol with a function declared as `mutating`, the reference-type's implementation cannot call that function internally. This is because the compiler enforces an immutable `self` pointer value, and the `mutating` qualifier implies that the function implementation may mutate that `self` pointer value. However, there seems to be a number of fairly reasonable situations where a reference-type implementation of these `mutating` functions may only wan…

Why can we not mutate mutable members on a reference type?

I stumbled against this wall a few times, previously I simply ignored it, but now it seems like a pointless language limitation. Every object type (right now we only have classes) in Swift is implicitly a subtype of AnyObject, which in fact is like a type alias to the class keyword. That makes any instance that is known to be of type AnyObject a reference type. However when used in a protocol extension the compiler does not allow one mutate mutable members even if Self is guaranteed to be a Any…

(and possibly more...)