Swift Advanced Custom Pattern Matching

When you use pattern matching in Swift, the compiler uses the ~= operator behind the scenes to match the value against each case pattern.

By default, the ~= operator compares two values of the same type using the == operator. It can also match a value with a range of values, by checking whether the value is contained within the range.

The Swift Standard Library provides default implementations of the ~= operator for several built-in types, such as Int, String, and Optional, but developers can also define their own implementations of the operator for custom types or custom pattern matching logic.

To overload the ~= operator in Swift, you need to define a function that takes two parameters: a value to match and a pattern to match against.

Here are some examples to demonstrate how this works:

Matching against an array pattern

func ~=<T>(pattern: [T], value: T) -> Bool {
    return pattern.contains(value)

let fruits = ["apple", "banana", "orange"]
let fruit = "banana"

if case fruit = fruits {
    print("The fruit is in the list")
} else {
    print("The fruit is not in the list")

In this example, we’ve defined an overload for the ~= operator that matches a value against an array pattern. The function takes an array pattern and a value, and returns true if the value is contained in the pattern. We then use this operator overload in a case statement to match a string fruit against an array of fruits, and print a message indicating whether the fruit is in the list or not.

Matching against a range pattern

func ~=<T: Comparable>(pattern: ClosedRange<T>, value: T) -> Bool {
    return pattern.contains(value)

let number = 5
if case 1...10 = number {
    print("The number is in the range")
} else {
    print("The number is outside the range")

In this example, The overload function takes a ClosedRange pattern and a value, and returns true if the value is contained within the pattern.

Matching against a regular expression pattern

import Foundation

func ~= (pattern: NSRegularExpression, value: String) -> Bool {
    return pattern.firstMatch(in: value, range: NSRange(value.startIndex..., in: value)) != nil

let email = "johndoe@example.com"

if let regex = try? NSRegularExpression(pattern: "[a-z]+@[a-z]+\\.[a-z]+") {
    if case regex = email {
        print("The email is valid")
    } else {
        print("The email is invalid")

// Prints: The email is valid

In this example, the overload function takes an NSRegularExpression pattern and a String value, and returns true if the value matches the regular expression.

Matching against custom pattern

protocol MyPattern {
    associatedtype Input
    func matches(_ value: Input) -> Bool

func ~=<P: MyPattern>(pattern: P, value: P.Input) -> Bool {
    return pattern.matches(value)

struct MyIntPattern: MyPattern {
    typealias Input = Int
    let patternValue: Int

    func matches(_ value: Int) -> Bool {
        return value % patternValue == 0

    init(_ patternValue: Int) {
        self.patternValue = patternValue

let number = 10

if case MyIntPattern(5) = number {
    print("\(number) is a multiple of 5")
} else {
    print("\(number) is not a multiple of 5")

// Prints: 10 is a multiple of 5

In this example, we define a protocol MyPattern. Then we overload the ~= operator to work with any type that conforms to the MyPattern protocol. Finally, we define a concrete implementation of the MyPattern protocol with MyIntPattern. It takes an Int pattern value and checks whether a given value is a multiple of the pattern.