Compare protocol in Swift class hierarchies

Question

I have a hierarchy of 2 Swift classes and need them to implement Comparable:

class Thing : Comparable {
    var name = "Thing"
    init(name : String){
        self.name = name
    }
}

class Thingy: Thing {
    override init(name: String){
        super.init(name: "Thingy")

    }  
}
func ==(lhs: Thing, rhs:Thing)->Bool{
    return lhs.name == rhs.name
}

To comply with Comparable, I need to implement this function:

func <(lhs: Thing, rhs: Thing) -> Bool{
    return lhs.name < rhs.name
}

So far so good, but what happens if I need a specific < function for different subtypes, such as:

func <(lhs: SubThing, rhs: Thing) -> Bool{
        return lhs.name < rhs.name
    }

How am I supposed to do this? The compiler seems to ignore this last declaration.

Will it also work if the types are inverted?

lhs: SubThing, rhs: Thing

instead of

lhs: Thing, rhs: SubThing

R Menke · Accepted Answer · 2016-01-11 06:56:24Z

2

Generics to the rescue. Make your Equatable, Comparable functions generic. Constrain T to be a subclass of Thing.

func ==<T:Thing>(lhs: T, rhs:T) -> Bool {
    return lhs.name == rhs.name
}


let a = Thing(name: "alpha")
let b = Thingy(name: "beta")

a == b // false

answered Jan 11, 2016 at 6:56

R Menke

8,4294 gold badges40 silver badges64 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Cristik · Accepted Answer · 2016-01-11 07:39:32Z

1

Overriding the < operator should take the most specific match, so in your case

func <(lhs: Thing, rhs: Thing) -> Bool {
    print("Base");
    return lhs.name < rhs.name
}

func <(lhs: Subthing, rhs: Thing) -> Bool {
    print("Child");
    return lhs.name < rhs.name
}

Subthing(name: "a") < Thing(name: "b")

should print Child, however this doesn't happen.

Overloading using generics seem to work though:

func < <T1:Thing, T2: Thing>(lhs: T1, rhs: T2) -> Bool {
    print("Base");
    return lhs.name < rhs.name
}

func < <T1: Subthing, T2: Thing>(lhs: T1, rhs: T2) -> Bool {
    print("Child");
    return lhs.name < rhs.name
}

Subthing(name: "a") < Thing(name: "b")

correctly prints Child.

It seems that generic overloading has better type matching than the basic overload.

edited Jan 11, 2016 at 7:39

answered Jan 11, 2016 at 7:11

Cristik

33.2k26 gold badges106 silver badges143 bronze badges

Collectives™ on Stack Overflow

Compare protocol in Swift class hierarchies

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related