2

Here's the code:

protocol A {
  var a: Int { get set }
}

extension A {
  var convenientAccessor: Int {
    get { return a }
    set { a = newValue }
  }
}

class B: A {
  var a: Int = 0
}

func acceptsB (instance: B) {
  instance.a = 1                     // This compiles
  instance.convenientAccessor = 2    // This does not
}

I sort of understand the problem here, but I really would love both an answer from someone who understands it more deeply, and more importantly a workaround for my problem which is that I want to pass around known class types and be able to use convenient accessors without being inhibited by the non-possibility that I'm using a value type. In my case, the protocols which define these convenient accessors should not be class-bound (they are perfectly valid and useful for value types), so while that is technically a workaround, it is not satisfactory to me.

Jonathan Hall
  • 75,165
  • 16
  • 143
  • 189
jeremyabannister
  • 3,796
  • 3
  • 16
  • 25
  • A (perhaps not satisfying) workaround would be to add `var instance = instance` at the start of the function. – Martin R Sep 20 '18 at 07:06
  • 1
    This is a tricky case because unlike class members, `mutating` protocol extension members (which by default includes the setter for `convenientAccessor`) are able to assign a completely new value to `self` – compare https://stackoverflow.com/q/51678708/2976878. – Hamish Sep 20 '18 at 11:53

1 Answers1

0

Let's start with a summary: convenientAccessor is a writable property, thus any assignment on it will result in a mutation. And this mutation happens inside your function.

The thing is that when the convenientAccessor property is used the compiler treats instance as protocol A, and because arguments to a function are let's, it doesn't allow mutations on them, as at this point the protocol can be implemented by a value type also.

Two solutions that come into my mind are:

  1. restrict protocol A to only classes:

    protocol A: class

    This informs the compiler that only classes can conform to the protocol, which allows the mutation on any kind of variables (let or var)

  2. make the function parameter inout:

    func acceptsB (instance: inout B)

    This creates a "write hole" as now instance is writable, so any changes to it are propagated back upstream, even if B is a value type.

Personally, I'd go with #1 if you plan in using only classes, as you mentioned in the question.

Cristik
  • 30,989
  • 25
  • 91
  • 127