Operadores propios

En Swift un operador no es una construcción privilegiada del compilador: es una función cuyo nombre está hecho de símbolos. + es una función estática declarada en la biblioteca estándar, y nada impide que declares las tuyas ni que inventes símbolos nuevos. Ese poder viene con una factura, porque un operador es la forma más densa y a la vez más opaca de nombrar una operación: cuando el símbolo evoca lo correcto multiplica la claridad, y cuando no, produce código que solo su autor sabe leer.

Los operadores son funciones

Sobrecargar un operador es declarar una función estática cuyo nombre es el símbolo. Lo idiomático es ponerla dentro del tipo al que sirve:

struct Vector2D {
    var x: Double
    var y: Double

    static func + (izq: Vector2D, der: Vector2D) -> Vector2D {
        Vector2D(x: izq.x + der.x, y: izq.y + der.y)
    }

    static prefix func - (v: Vector2D) -> Vector2D {
        Vector2D(x: -v.x, y: -v.y)
    }

    static func * (v: Vector2D, escalar: Double) -> Vector2D {
        Vector2D(x: v.x * escalar, y: v.y * escalar)
    }

    static func += (izq: inout Vector2D, der: Vector2D) {
        izq = izq + der
    }
}

let suma = Vector2D(x: 1, y: 2) + Vector2D(x: 3, y: 4)   // 4, 6

Los operadores ya existentes no necesitan declaración previa: el compilador conoce +, -, * y su precedencia, y basta con darles una implementación para tu tipo. El operador de asignación compuesta toma su primer parámetro como inout porque modifica el valor en su sitio.

Antes de escribir nada, conviene recordar que muchos operadores llegan gratis al conformar un protocolo. Declarar Equatable sintetiza == y != comparando todos los campos almacenados; Comparable da <, > y sus variantes con solo implementar el menor estricto; y AdditiveArithmetic aporta el += y el -= a partir de la suma y la resta. Escribir a mano lo que la biblioteca estándar deduce es trabajo perdido y una fuente de incoherencias.

struct Dinero: Comparable, AdditiveArithmetic {
    var centimos: Int
    static let zero = Dinero(centimos: 0)

    static func < (a: Dinero, b: Dinero) -> Bool { a.centimos < b.centimos }
    static func + (a: Dinero, b: Dinero) -> Dinero { Dinero(centimos: a.centimos + b.centimos) }
    static func - (a: Dinero, b: Dinero) -> Dinero { Dinero(centimos: a.centimos - b.centimos) }
}
// == , != , > , <= , >= , += y -= vienen incluidos

Declarar un operador nuevo

Para un símbolo que no existe hacen falta dos pasos: declararlo a nivel de archivo indicando su posición, y después implementarlo. La declaración de un operador infijo puede indicar además a qué grupo de precedencia pertenece.

infix operator **: PotenciaPrecedence          // potencia
prefix operator √                              // raiz cuadrada
postfix operator %%                            // porcentaje

func ** (base: Double, exponente: Double) -> Double {
    pow(base, exponente)
}

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

postfix func %% (valor: Double) -> Double {
    valor / 100
}

let area = √16 + 2 ** 3 + 50%%       // 4 + 8 + 0.5

Los símbolos permitidos son un conjunto acotado de caracteres matemáticos y de puntuación de Unicode; no se pueden usar letras ni dígitos. Un operador prefix no admite espacio entre el símbolo y su operando, y un postfix tampoco: esa es la señal con la que el compilador decide, ante un mismo carácter, si está viendo la versión prefija, infija o posfija.

Precedencia y asociatividad

Un operador infijo sin grupo declarado cae en DefaultPrecedence, que no es asociativo y tiene precedencia mayor que la asignación: sirve para poco más que expresiones de un solo operador. Los grupos se definen indicando su posición relativa respecto a otros y cómo agrupan los operadores consecutivos.

precedencegroup PotenciaPrecedence {
    higherThan: MultiplicationPrecedence
    associativity: right
}

infix operator **: PotenciaPrecedence

La precedencia decide quién se evalúa antes cuando conviven operadores distintos: al declarar el grupo por encima de MultiplicationPrecedence, la expresión 2 * 3 ** 2 se agrupa como dos por el resultado de tres elevado a dos. La asociatividad decide cómo se agrupan varios operadores iguales seguidos: con right, la expresión 2 ** 3 ** 2 se lee como dos elevado al resultado de tres elevado a dos, que es la convención matemática. Con left se leería al revés, y con none ni siquiera compilaría sin paréntesis.

flowchart TD
A[Quiero un simbolo nuevo] --> B{Es infijo}
B -->|No, prefijo o posfijo| C[Solo declaro la posicion]
B -->|Si| D{Existe un grupo que encaje}
D -->|Si| E[Reutilizo AdditionPrecedence o similar]
D -->|No| F[Defino precedencegroup con higherThan y lowerThan]
F --> G{Como agrupa consigo mismo}
G -->|Como la potencia| H[associativity right]
G -->|Como la resta| I[associativity left]
G -->|Encadenar no tiene sentido| J[associativity none]

Cuándo sí y cuándo no

El criterio no es técnico sino de comunicación, y se puede reducir a una pregunta: ¿existe ya una notación que tu lector conoce antes de abrir tu código?

Cuando la respuesta es sí, el operador gana. Álgebra vectorial y matricial, aritmética de tipos numéricos propios como dinero o unidades, composición de funciones en bibliotecas funcionales, combinación de conjuntos: en todos esos dominios el símbolo procede de fuera del programa y su significado no hay que aprenderlo. Sobrecargar + para sumar dos vectores no añade vocabulario, reutiliza el que ya había.

Cuando la respuesta es no, el operador pierde casi siempre. Un símbolo inventado obliga a cada lector a buscar su declaración, no aparece en el autocompletado escribiendo un punto tras el valor, es difícil de mencionar en una conversación o de buscar en el repositorio, y su precedencia frente al resto es invisible en el punto de uso. Un método con nombre claro no tiene ninguno de esos problemas: presupuesto.aplicando(descuento) se entiende sin contexto, y una versión con un símbolo raro no.