Swift Academy · Aula

Composição de Protocolos

Combine vários requisitos de protocolos com &.

Composição de Protocolos é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Combinando protocolos

Às vezes, um valor precisa satisfazer vários protocolos ao mesmo tempo. O Swift permite compor protocolos com o operador &: SomeProtocol & AnotherProtocol.

protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }

Um parâmetro composto

Um parâmetro tipado como Named & Aged aceita qualquer valor que esteja em conformidade com os dois protocolos.

protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }

struct Person: Named, Aged {
    let name: String
    let age: Int
}

func intro(_ x: Named & Aged) {
    print(x.name + " is " + String(x.age))
}
intro(Person(name: "Sam", age: 28))

Por que não usar herança

A composição permite exigir os dois protocolos no local da chamada sem criar um novo protocolo combinado. Isso mantém os protocolos pequenos e reutilizáveis.

protocol Drawable { func draw() -> String }
protocol Resizable { func resize(_ f: Double) -> String }

struct Icon: Drawable, Resizable {
    func draw() -> String { "drawing" }
    func resize(_ f: Double) -> String { "x" + String(f) }
}

func render(_ v: Drawable & Resizable) {
    print(v.draw(), v.resize(2))
}
render(Icon())

Três ou mais

É possível encadear quantos protocolos forem necessários usando operadores & adicionais.

protocol A { func a() -> String }
protocol B { func b() -> String }
protocol C { func c() -> String }

struct X: A, B, C {
    func a() -> String { "a" }
    func b() -> String { "b" }
    func c() -> String { "c" }
}

func use(_ v: A & B & C) { print(v.a(), v.b(), v.c()) }
use(X())

Composição com uma classe

É possível combinar um tipo de classe com protocolos: SomeClass & SomeProtocol exige que o valor seja dessa classe ou de uma subclasse AND esteja em conformidade com o protocolo.

class Vehicle { var speed = 0 }
protocol Electric { var battery: Int { get } }

class Tesla: Vehicle, Electric { var battery = 100 }

func check(_ v: Vehicle & Electric) {
    print(v.speed, v.battery)
}
check(Tesla())

Retornando uma composição

Uma função pode retornar um tipo composto, prometendo ao chamador que o resultado está em conformidade com todos os protocolos listados.

protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct Person: Named, Aged { let name: String; let age: Int }

func makePerson() -> Named & Aged {
    Person(name: "Eve", age: 22)
}
let p = makePerson()
print(p.name, p.age)

typealias para composição

Dê um nome legível a uma composição com typealias para reutilizá-la sem repetir a cadeia de &.

protocol Codable2 { func encode() -> String }
protocol Loggable { func log() -> String }

typealias Persistable = Codable2 & Loggable

struct Record: Persistable {
    func encode() -> String { "data" }
    func log() -> String { "logged" }
}
func save(_ r: Persistable) { print(r.encode(), r.log()) }
save(Record())

Composição em coleções

É possível armazenar valores de tipo composto em matrizes e acessar os membros de todos os protocolos em cada elemento.

protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct P: Named, Aged { let name: String; let age: Int }

let group: [Named & Aged] = [P(name: "A", age: 1), P(name: "B", age: 2)]
for g in group { print(g.name, g.age) }

Composição com protocolos padrão

A composição é especialmente útil com protocolos de biblioteca. Por exemplo, é possível exigir tanto CustomStringConvertible quanto Equatable.

func report<T>(_ items: [T]) where T: CustomStringConvertible & Equatable {
    for i in items { print(i.description) }
}
report([1, 2, 3])

Protocolos vazios como marcadores

A composição pode combinar um protocolo marcador (sem requisitos) com um protocolo funcional para expressar uma intenção no sistema de tipos.

protocol Secure {}
protocol Sendable2 { func send() -> String }

struct Packet: Secure, Sendable2 {
    func send() -> String { "sent securely" }
}
func transmit(_ p: Secure & Sendable2) { print(p.send()) }
transmit(Packet())

Composição versus genéricos

A composição (A & B) apaga o tipo concreto; os genéricos (<T: A & B>) preservam-no. Utilize genéricos quando precisar relacionar tipos de parâmetro e de retorno.

protocol A { func a() -> String }
protocol B { func b() -> String }
struct S: A, B { func a() -> String { "a" }; func b() -> String { "b" } }

func generic<T: A & B>(_ x: T) -> T { print(x.a(), x.b()); return x }
_ = generic(S())

Verificação rápida

Teste sua compreensão da composição de protocolos.

Recapitulação

A composição de protocolos com & permite exigir conformidade com vários protocolos (e, opcionalmente, uma classe) de uma só vez, sem definir um novo protocolo combinado. Você pode nomear composições com typealias, usá-las em parâmetros, retornos e coleções, e viu como a composição difere dos genéricos na preservação dos tipos concretos.

Perguntas Frequentes

A aula “Composição de Protocolos” é grátis?

Sim — o texto completo de “Composição de Protocolos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Composição de Protocolos”?

Combine vários requisitos de protocolos com &. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Composição de Protocolos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy