Swift Academy · Aula

Restrições de Tipos Associados

Limite tipos associados em contextos genéricos.

Restrições de Tipos Associados é 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.

Recapitulação dos tipos associados

Um protocolo pode declarar um tipo associado com associatedtype, um espaço reservado que o tipo em conformidade define. Element em um protocolo de contêiner é o exemplo clássico.

protocol Container {
    associatedtype Item
    var count: Int { get }
    func item(at i: Int) -> Item
}

Conformidade com um tipo concreto

Um tipo em conformidade fixa o tipo associado, geralmente inferido a partir da forma como ele é usado.

protocol Container {
    associatedtype Item
    func item(at i: Int) -> Item
}
struct IntBox: Container {
    let values: [Int]
    func item(at i: Int) -> Int { values[i] }
}
print(IntBox(values: [10, 20]).item(at: 1))

Restringindo o tipo associado

Adicione uma restrição diretamente na declaração: associatedtype Item: Comparable obriga o tipo de item de cada tipo em conformidade a aceitar comparações.

protocol Sorted {
    associatedtype Item: Comparable
    var items: [Item] { get }
}
struct Nums: Sorted { let items: [Int] }
print(Nums(items: [3, 1, 2]).items.sorted())

Usando a restrição

Como o tipo associado é restringido, as extensões de protocolo podem contar com essa capacidade.

protocol Sorted {
    associatedtype Item: Comparable
    var items: [Item] { get }
}
extension Sorted {
    var smallest: Item? { items.min() }
}
struct Nums: Sorted { let items: [Int] }
print(Nums(items: [5, 2, 8]).smallest!)

where em associatedtype

O Swift também permite uma cláusula where em um tipo associado para relacioná-lo a outro tipo associado ou a um tipo aninhado.

protocol Sequence2 {
    associatedtype Element
    associatedtype Iterator: IteratorProtocol where Iterator.Element == Element
}

Restringindo a outro protocolo

Um tipo associado pode ser obrigado a estar em conformidade com um protocolo definido por você, sobrepondo comportamentos.

protocol HasName { var name: String { get } }
protocol Registry {
    associatedtype Entry: HasName
    var entries: [Entry] { get }
}
struct User: HasName { let name: String }
struct Users: Registry { let entries: [User] }
print(Users(entries: [User(name: "Ada")]).entries[0].name)

Vários tipos associados

Um protocolo pode declarar vários tipos associados, cada um com suas próprias restrições.

protocol Mapping {
    associatedtype Key: Hashable
    associatedtype Value
    func value(for k: Key) -> Value?
}
struct Phonebook: Mapping {
    let data: [String: Int]
    func value(for k: String) -> Int? { data[k] }
}
print(Phonebook(data: ["x": 1]).value(for: "x")!)

Tipo associado padrão

Você pode fornecer um valor padrão para um tipo associado com =, usado quando um tipo em conformidade não o especifica de outra forma.

protocol Producer {
    associatedtype Output = String
    func make() -> Output
}
struct Hello: Producer {
    func make() -> String { "hi" }
}
print(Hello().make())

Restrições habilitam algoritmos genéricos

Com um tipo associado restringido, uma extensão de protocolo pode implementar algoritmos reais compartilhados por todos os tipos em conformidade.

protocol Scored {
    associatedtype Score: Comparable
    var scores: [Score] { get }
}
extension Scored {
    var best: Score? { scores.max() }
}
struct Game: Scored { let scores: [Int] }
print(Game(scores: [10, 40, 25]).best!)

Restrições de mesmo tipo em extensões

Fora do protocolo, você pode restringir ainda mais o tipo associado ao estender o protocolo.

protocol Box2 {
    associatedtype Content
    var content: Content { get }
}
extension Box2 where Content == Int {
    var doubled: Int { content * 2 }
}
struct IB: Box2 { let content: Int }
print(IB(content: 7).doubled)

Por que restringir

Restringir tipos associados é a forma de manter os protocolos genéricos e, ao mesmo tempo, poderosos: a restrição é uma promessa da qual a extensão e os chamadores podem depender.

protocol Listy {
    associatedtype E: Equatable
    var elements: [E] { get }
}
extension Listy {
    func has(_ x: E) -> Bool { elements.contains(x) }
}
struct L: Listy { let elements: [String] }
print(L(elements: ["a", "b"]).has("b"))

Verificação rápida

Teste sua compreensão sobre a restrição de tipos associados.

Recapitulação

Você pode restringir tipos associados diretamente (associatedtype Item: Comparable), relacioná-los com cláusulas where, exigir conformidade com protocolos, fornecer valores padrão com =, declarar vários tipos associados e refiná-los em extensões. As restrições permitem que extensões de protocolo implementem algoritmos compartilhados e seguros quanto aos tipos.

Perguntas Frequentes

A aula “Restrições de Tipos Associados” é grátis?

Sim — o texto completo de “Restrições de Tipos Associados” é 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 “Restrições de Tipos Associados”?

Limite tipos associados em contextos genéricos. 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 “Restrições de Tipos Associados”?

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