Sobrecarga de operadores e grupos de precedência

Por que personalizar operadores?

Sobrecarregar um operador integrado

struct Vector2D: CustomStringConvertible, Equatable {
    var x: Double
    var y: Double
    var description: String { "(\(x), \(y))" }
}
func + (lhs: Vector2D, rhs: Vector2D) -> Vector2D {
    Vector2D(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
}
func == (lhs: Vector2D, rhs: Vector2D) -> Bool {
    lhs.x == rhs.x && lhs.y == rhs.y
}
let a = Vector2D(x: 1, y: 2)
let b = Vector2D(x: 3, y: 4)
let c = a + b
print(c)     // (4.0, 6.0)

Operador personalizado e precedência

// Define power operator ** with right-associative precedence
precedencegroup PowerPrecedence {
    higherThan: MultiplicationPrecedence
    associativity: right
}
infix operator ** : PowerPrecedence

// Simple integer exponent (education-only; no overflow checks)
func ** (base: Int, exp: Int) -> Int {
    guard exp >= 0 else { return 0 }   // keep it simple for demo
    if exp == 0 { return 1 }
    var result = 1
    for _ in 0..<exp { result *= base }
    return result
}
print(2 ** 3)          // 8
print(2 ** 3 ** 2)     // 2 ** (3 ** 2) = 2 ** 9 = 512 (right-assoc)

Operadores de prefixo e pós-fixo

prefix operator √
prefix func √ (x: Double) -> Double { x.squareRoot() }

postfix operator !
postfix func ! (x: Bool) -> Bool { !x }  // purely demo; avoid confusing overrides

print(√9)     // 3.0
print(true!)  // false (demo only — don't ship this)

Precedência na prática

// Demonstrate how precedence affects parsing
// Our PowerPrecedence is higher than Multiplication.
// So this parses as: 2 * (3 ** 2) = 18
let r1 = 2 * 3 ** 2
print(r1)

// Compare if we had lower precedence (hypothetical):
// Then it would parse as (2 * 3) ** 2 = 36

Boas práticas

Declarando operadores corretamente

Recapitulação