CODEWITHSUNDEEP
swift
Ken Zhang
Ken Zhang

Reputation: 1474

Protocol doesn't support the "===" operator?

It seems that protocol doesn't support the === operator, while class does.

protocol P {
}

class A : P {
}

var a1 = A()
var a2 = A()
var p1:P = a1
var p2:P = a2

a1 === a2    // true
p1 === p2    // error: Type 'P' does not conform to protocol 'AnyObject'

I think it could probably caused by the fact that the concrete type that conforms to the protocol could also be a value type (like struct) which doesn't support the === operator. I'm just wondering that if I'm sure the real type is a class, how can I compare the references of them, like the p1 and p2 here?

Upvotes: 26

Views: 5142

Answers (3)

Dan
Dan

Reputation: 830

Conform the protocol to either class or AnyObject This means that only classes will be able to conform to that protocol, not struct.

For example, from:

protocol P {
}

to (Swift 4 version)

protocol P : AnyObject {
}

or (Swift 3 version)

protocol P : class {
}

Upvotes: 0

Sentry.co
Sentry.co

Reputation: 5569

Equality between protocols

Drop this in playground and your on your way. 

protocol IPositional:class{}
class A:IPositional{}
class B:IPositional{}
let a:IPositional = A()
let b:IPositional = B()
let c:IPositional = a
a === b //false
a === c //true

Upvotes: 1

Nate Cook
Nate Cook

Reputation: 93276

First let's look at the definition of the === operator. It isn't just a test of equality between the value of two instances, but it checks to see if two variables point to the exact same instance of an object (see "Identity Operators" here).

So your example code isn't quite right:

var a1 = A()
var a2 = A()
var a3 = a2
a1 === a2     // actually false, a1 and a2 were instantiated separately
a2 === a3     // true, because they are the same instance

Only classes can be compared in this way, because everything that isn't a class in Swift is value-typed*, and two value-typed variables can't possibly be pointing to the same instance.

Therefore, if you try to compare a regular protocol with ===, Swift doesn't have enough information to use the operator. The instances you're comparing (p1 and p2) could be class instances or they could be struct instances, and at compile-time Swift can't tell if it's okay.

If you want to be able to use a protocol as a type in this way and compare with ===, you'll need to declare a class-only protocol by using class as the first item in your protocol's inheritance list, like this:

protocol P : class {
}

class A : P {
}

Now you can do what you were attempting, without the compiler error:

var p1:P = a1
var p2:P = a2
var p3:P = a3
p1 === p2    // false
p2 === p3    // true

*Semantically, anyway. Swift does a lot of behind-the-scenes reference-typing, but enforces this value-typed behavior, so for the purposes of this discussion just go with struct and enum being truly value-typed.

Upvotes: 40

Related Questions