Sobrecarga de funções em

Sobre Sobrecarga de funções

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

Considere 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 qualquer uma das seguintes condições for atendida:

• Têm um número diferente de parâmetros.
• Têm rótulos de argumentos externos diferentes.
• Seus tipos de parâmetros são diferentes.
• Seus tipos de retorno são diferentes (desde que o contexto da chamada deixe claro qual usar).

Considerando 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

Funções também podem ser sobrecarregadas apenas pelo tipo de retorno. No entanto, ao chamar uma função assim, você precisa fornecer uma anotação de tipo ou contexto para que o compilador saiba qual sobrecarga você pretendia:

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

Mudar apenas o nome interno do parâmetro, sem alterar o rótulo do argumento, o tipo do parâmetro ou a quantidade de parâmetros, não cria uma função distinta. O compilador trata isso 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:)'