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.

Considera 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 alguna de las siguientes condiciones:

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

Dada la función add original anterior, 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 el tipo devuelto

Las funciones también se pueden sobrecargar únicamente por su tipo devuelto. Sin embargo, cuando llamas a una función así, debes proporcionar una anotación de tipo o un contexto para que el compilador sepa cuál de las sobrecargas pretendí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 entre sobrecargas

Cambiar solo el nombre interno del parámetro sin cambiar la etiqueta de argumento, el tipo de parámetro o 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:)'