Sobrecarga de funções em

Sobre Sobrecarga de funções

Em Swift, podes definir várias funções com o mesmo nome desde que as suas assinaturas sejam diferentes. Esta prática é conhecida como sobrecarga de funções.

Considera a seguinte função 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

Em Swift, duas funções com o mesmo nome são consideradas distintas se alguma das seguintes condições se verificar:

• Têm um número diferente de parâmetros.
• Têm etiquetas de argumento externas diferentes.
• Os seus tipos de parâmetros são diferentes.
• Os seus tipos de retorno são diferentes (desde que o contexto da chamada esclareça qual deles usar).

Dada a função add original acima, cada uma das seguintes sobrecargas é distinta e válida no mesmo 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

As funções também podem ser sobrecarregadas apenas pelo seu tipo de retorno. No entanto, ao chamar uma função dessas, tens de fornecer uma anotação de tipo ou contexto para que o compilador saiba qual sobrecarga pretendias:

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

O que não distingue sobrecargas

Alterar apenas o nome interno do parâmetro sem alterar a etiqueta de argumento, o tipo de parâmetro ou o número de parâmetros não cria uma função distinta. O compilador trata isto como uma declaração duplicada invá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:)'