Extensões de Protocolos

Parte da seção Programação Orientada a Objetos do Journey de Swift da Coddy. Lição 29 de 57.

Uma extensão de protocolo fornece uma implementação padrão para os métodos de um protocolo. Todo tipo em conformidade a recebe gratuitamente, e um tipo ainda pode fornecer sua própria versão:

protocol Greeter {
    var name: String { get }
    func greet() -> String
}

extension Greeter {
    func greet() -> String { "Hello, \(name)!" }
}

struct English: Greeter { let name: String }
struct Pirate: Greeter {
    let name: String
    func greet() -> String { "Ahoy, \(name)!" }
}

print(English(name: "Ada").greet())
print(Pirate(name: "Ada").greet())

Saída:

Hello, Ada!
Ahoy, Ada!

Uma extensão também pode adicionar novos métodos construídos apenas a partir dos requisitos. Um tipo em conformidade escreve a pequena parte necessária e recebe o restante:

protocol Scored {
    var points: [Int] { get }
}

extension Scored {
    var total: Int { points.reduce(0, +) }
    var best: Int { points.max() ?? 0 }
    func summary() -> String { "total \(total), best \(best)" }
}

struct Player: Scored {
    let points: [Int]
}

print(Player(points: [3, 9, 4]).summary())

Saída:

total 16, best 9

Isso compartilha comportamento entre structs, classes e enums sem herança. A biblioteca padrão funciona da mesma forma: toda Collection obtém isEmpty, first e map por meio de extensões de protocolos.

extension Collection {
    // isEmpty, first, map, filter, ... são todos definidos uma vez aqui
    // e todo array, set, dictionary e string os recebe
}

Uma extensão com restrição adiciona métodos apenas para alguns tipos conformes, escrita com where:

protocol Container {
    associatedtype Item
    var items: [Item] { get }
}

extension Container where Item == Int {
    var sum: Int { items.reduce(0, +) }
}

struct Box: Container {
    var items: [Int]
}

print(Box(items: [2, 5]).sum)

Saída:

Desafio

Fácil

Declare um protocolo Priced que exija var price: Int { get } (em centavos) e var formatted: String { get }. Em uma extensão do protocolo, forneça um valor padrão para formatted que retorne $4.50 e adicione um método isAffordable(budget:) que retorne se o preço cabe no orçamento. Faça com que as structs Coffee (preço 450) e Sandwich (um price armazenado) estejam em conformidade. Coffee deve substituir o formatted padrão por coffee $4.50.

O código fornecido lê um orçamento e, em seguida, linhas coffee ou sandwich,650. Ele imprime formatted e yes ou no para cada item.

Seu código deve estar em Priced.swift, Coffee.swift e Sandwich.swift. main.swift contém o código fornecido de entrada/saída e não pode ser editado.

Experimente você mesmo

// Código de entrada/saída fornecido: mantenha-o como está
var input: [String] = []
while let line = readLine() { input.append(line) }
let budget = Int(input[0])!
for line in input.dropFirst() {
    let item: any Priced = line == "coffee" ? Coffee() : Sandwich(price: Int(line.split(separator: ",")[1])!)
    print("\(item.formatted) \(item.isAffordable(budget: budget) ? "yes" : "no")")
}