Overload the pattern matching operator for custom matching behavior

Swift's pattern matching is an exceptionally flexible technique predominantly used in switch statements to accommodate a wide range of patterns. In this context, an expression pattern within a switch case represents the value of an expression. The core of this functionality hinges on the pattern matching operator (~=), which Swift utilizes behind the scenes to assess whether a pattern corresponds with the value. Typically, ~= performs comparisons between two values of the same type using ==. However, the pattern matching operator can be overloaded to enable custom matching behaviors, offering enhanced control and adaptability in how data is evaluated and handled.

Let's consider a custom type Circle and demonstrate how to implement custom pattern matching for it. We'll define a simple Circle struct and overload the ~= operator to match a Circle with a specific radius. This overload will allow us to use a Double in a switch statement case to match against a Circle.

struct Circle {
    var radius: Double
}

func ~= (pattern: Double, value: Circle) -> Bool {
    return value.radius == pattern
}


let myCircle = Circle(radius: 5)

switch myCircle {
case 5:
    print("Circle with a radius of 5")
case 10:
    print("Circle with a radius of 10")
default:
    print("Circle with a different radius")
}

We can add as many overloads as we need. For example, we can define custom logic to check whether the Circle's radius falls within a specified range. The switch statement will now be able to match myCircle against Double values and ranges, thanks to our custom implementations of the ~= operator.

func ~= (pattern: ClosedRange<Double>, value: Circle) -> Bool {
    return pattern.contains(value.radius)
}

switch myCircle {
case 0:
    print("Radius is 0, it's a point!")
case 1...10:
    print("Small circle with a radius between 1 and 10")
default:
    print("Circle with a different radius")
}

Custom pattern matching in Swift opens up a lot of possibilities for handling complex types more elegantly. By overloading the ~= operator, we can tailor the pattern matching process to suit our custom types. As with any powerful tool, we should use it wisely to enhance our code without compromising on readability.