Swift allows us to redefine specific operators to work in a different way, based on the classes to which we apply them. For example, we can make comparison operators, such as less than (<) and greater than (>), and return the results of comparing the age value when they are applied to instances of Dog.

An operator that works in one way when applied to an instance of a class might work differently on instances of another class. We can also redefine the overloaded operators to work on specific subclasses. For example, we can make the comparison operators work in a different way in a superclass and its subclass.

We want to be able to compare the age of the different Animal instances using the following binary operators in Swift:

We can overload operators in Swift to achieve our goals by declaring operator functions with function names that match the operators to be overloaded and receive Animal instances as arguments. In this case, the four operators are binary operators; therefore, all the operator functions receive two input parameters of the Animal type and return a Bool value. Swift invokes these functions under the hood whenever we use the operators to compare instances of Animal. We have to declare operator functions with the following names and specify two Animal arguments:

All the operator functions have the same declaration. Swift passes the instance specified on the left-hand side of the operator as the first argument, usually named left, and the instance on the right-hand side of the operator as the second argument, which is usually named right. Thus, we have left and right as the arguments for the operator functions, and we must return a Bool value with the result of the application of the operator, in our case, with the result of the comparison operator applied to the age property of each instance.

Let's consider that we have two instances of Animal, or any of its subclasses, named animal1 and animal2. If we enter print(animal1 < animal2) in the Playground, Swift will invoke the < operator function with left equal to animal1 and right equal to animal2. Thus, we must return a Bool value indicating whether left.age < right.age is equivalent to animal1.age < animal2.age.

We must add the following lines to make it possible to compare the age of any animal using the previously specified comparison operators. The code file for the sample is included in the swift_3_oop_chapter_04_11 folder:

    public func < (left: Animal, right: Animal) -> Bool { 
      return left.age < right.age 
    } 
 
    public func <= (left: Animal, right: Animal) -> Bool { 
      return left.age <= right.age 
    } 
 
    public func > (left: Animal, right: Animal) -> Bool { 
      return left.age > right.age 
    } 
 
    public func >= (left: Animal, right: Animal) -> Bool { 
      return left.age >= right.age 
    } 

The following lines use the four operators that will work with the Animal class and its subclasses: greater than (>), less than (<), greater than or equal to (>=), and less than or equal to (<=). Remember that we created operator functions that Swift invokes under the hood whenever we use the operators. In this case, we will apply the operators on instances of TerrierDog and Cat. The operators return the results of comparing the age value of the different instances. The code file for the sample is included in the swift_3_oop_chapter_04_11 folder:

    print(pluto > marie) 
    print(pluto < marie) 
    print(pluto >= marie) 
    print(pluto <= marie) 

The following screenshot shows the four operator functions and the results of their execution in the Playground when we use the operators in instances of TerrierDog and Cat: