Sobrecarga de funciones en

Acerca de Sobrecarga de funciones

En Swift, puedes definir varias funciones con el mismo nombre siempre que sus firmas sean diferentes. Esta práctica se conoce como sobrecarga de funciones.

Fíjate en la siguiente función base:

func add(_ x: Int, and y: Int, doubleResult: Bool) -> Int {
    let sum = x + y
    return doubleResult ? sum * 2 : sum
}

let twentySix = add(6, and: 7, doubleResult: true)
// => 26

En Swift, dos funciones con el mismo nombre se consideran distintas si se cumple cualquiera de las siguientes condiciones:

• Tienen un número diferente de parámetros.
• Tienen etiquetas de argumento externas diferentes.
• Sus tipos de parámetro difieren.
• Sus tipos de retorno difieren (siempre que el contexto de la llamada aclare cuál usar).

Dada la función add original de arriba, cada una de las siguientes sobrecargas es distinta y válida en el mismo programa:

// 1. Different number of parameters
func add(_ x: Int, and y: Int) -> Int {
    x + y
}

let eleven = add(5, and: 6)
// => 11

// 2. Different parameter type (Double instead of Int)
func add(_ x: Double, and y: Int, doubleResult: Bool) -> Double {
    let sum = x + Double(y)
    return doubleResult ? sum * 2 : sum
}

let twentySeven = add(6.5, and: 7, doubleResult: true)
// => 27.0

// 3. Different argument label (doubleThat instead of doubleResult)
func add(_ x: Int, and y: Int, doubleThat: Bool) -> Int {
    let sum = x + y
    return doubleThat ? sum * 2 : sum
}

let thirteen = add(6, and: 7, doubleThat: false)
// => 13

Sobrecarga por tipo de retorno

Las funciones también se pueden sobrecargar solo por su tipo de retorno. Sin embargo, al llamar a una función así, debes proporcionar una anotación de tipo o un contexto para que el compilador sepa cuál sobrecarga querías:

func add(_ x: Int, and y: Int, doubleResult: Bool) -> Double {
    let sum = Double(x + y)
    return doubleResult ? sum * 2 : sum
}

// Ambiguous call (compiler cannot decide whether you want Int or Double):
// let thirty = add(6, and: 9, doubleResult: true)

// Resolved with an explicit type annotation:
let thirty: Double = add(6, and: 9, doubleResult: true)
// => 30.0

Qué no distingue las sobrecargas

Cambiar solo el nombre interno del parámetro sin cambiar la etiqueta de argumento, el tipo de parámetro ni el número de parámetros no crea una función distinta. El compilador lo trata como una declaración duplicada no válida:

func add(_ w: Int, and y: Int, doubleResult: Bool) -> Int {
    let sum = w + y
    return doubleResult ? sum * 2 : sum
}
// Error: Invalid redeclaration of 'add(_:and:doubleResult:)'