How to Build a Custom Operator in Swift

Swift allows developers to create custom operators to make their code more expressive and readable. Custom operators can simplify complex operations and improve code clarity. In this article, we'll explore how to define and use custom operators in Swift with simple examples.

Understanding Operators in Swift

Operators in Swift are symbols (like +, -, *, /) used to perform operations on variables and values. Swift supports various types of operators:

• Unary operators: Operate on a single value (e.g., !value).
• Binary operators: Operate on two values (e.g., a + b).
• Ternary operator: Operates on three values (e.g., condition ? trueValue : falseValue).

Defining a Custom Operator

To create a custom operator in Swift, follow these steps:

1. Declare the Operator

You need to declare the operator outside of any class or function. Use prefix, postfix, or infix to define its position.

2. Implement the Operator Function

Create a function that implements the operator’s behavior.

3. Use the Operator in Code

Once defined, the operator can be used just like built-in operators.

Example: Creating a Custom Power Operator (**)

Get Commit Studio’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Let's create an ** operator to calculate the power of a number.

infix operator ** : MultiplicationPrecedence

func ** (base: Int, exponent: Int) -> Int {
    return Int(pow(Double(base), Double(exponent)))
}

let result = 2 ** 3  // 2 raised to the power of 3
print(result)  // Output: 8

Explanation

• infix operator ** : MultiplicationPrecedence func ** (base: Int, exponent: Int) -> Int { return Int(pow(Double(base), Double(exponent))) } let result = 2 ** 3 // 2 raised to the power of 3 print(result) // Output: 8Explanation
• infix operator ** : MultiplicationPrecedence declares ** as an infix operator.
• The function ** takes two integers and returns the result of base raised to exponent.
• The pow() function (from the Foundation framework) is used to compute the power.

Custom Unary Operator Example

A unary operator works on a single operand. Let’s create a custom √ (square root) operator.

prefix operator √

prefix func √ (value: Double) -> Double {
    return sqrt(value)
}

let result = √9  // Square root of 9
print(result)  // Output: 3.0

Custom Postfix Operator Example

A postfix operator appears after the operand. Let's create a ! operator that doubles a number.

postfix operator !

postfix func ! (value: Int) -> Int {
    return value * 2
}

let result = 5!
print(result)  // Output: 10

Setting Operator Precedence and Associativity

Operator precedence determines the execution order of operators. Associativity defines how operators of the same precedence group are evaluated (left-to-right or right-to-left).

Example:

precedencegroup PowerPrecedence {
    associativity: right
    higherThan: MultiplicationPrecedence
}

infix operator ** : PowerPrecedence

This ensures that ** follows right associativity and has higher precedence than multiplication.

Conclusion

Custom operators in Swift enhance code readability and usability. They allow developers to create meaningful and expressive code while maintaining clarity. Just remember to use them wisely to avoid confusion.

Now that you know how to build a custom operator in Swift, try experimenting with your own! Happy coding!