Swift Academy · Aula

Conformidade Condicional

Conforme genericamente somente quando as restrições forem atendidas.

Conformidade Condicional é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 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.

O que é conformidade condicional

A conformidade condicional faz um tipo genérico estar em conformidade com um protocolo somente quando seus parâmetros de tipo atendem a determinadas restrições. O exemplo clássico é: um Array só é Equatable quando seu Element é Equatable.

extension Array where Element: Equatable {
    func allEqual(to x: Element) -> Bool {
        allSatisfy { $0 == x }
    }
}

Exemplo integrado

A biblioteca padrão já utiliza isso: [Int] é Equatable porque Int também é. Duas matrizes são comparadas como iguais elemento a elemento.

let a = [1, 2, 3]
let b = [1, 2, 3]
print(a == b)

Declarando conformidade condicional

Escreva uma extensão que adicione conformidade com um protocolo usando uma cláusula where. Aqui, um invólucro está em conformidade com Equatable somente quando seu tipo de valor também está.

struct Pair<T> {
    let first: T
    let second: T
}

extension Pair: Equatable where T: Equatable {
    static func == (l: Pair, r: Pair) -> Bool {
        l.first == r.first && l.second == r.second
    }
}

print(Pair(first: 1, second: 2) == Pair(first: 1, second: 2))

Por que a restrição é importante

Sem a restrição, o compilador não poderia sintetizar ==, porque comparar o valor envolvido exige que o próprio valor possa ser comparado. A cláusula where fornece exatamente essa garantia.

struct Box<T> { let value: T }
extension Box: Equatable where T: Equatable {}

print(Box(value: "hi") == Box(value: "hi"))
print(Box(value: 5) == Box(value: 9))

Codable condicional

Você pode estabelecer conformidade condicional com Codable. Um contêiner é codificável somente quando seu elemento também é.

struct Wrapper<T> { let payload: T }
extension Wrapper: Codable where T: Codable {}

let w = Wrapper(payload: 42)
let data = try! JSONEncoder().encode(w)
print(String(data: data, encoding: .utf8)!)

Várias restrições

Uma cláusula where pode listar vários requisitos separados por vírgulas.

struct Stack<T> { var items: [T] = [] }

extension Stack where T: Comparable {
    func maxItem() -> T? { items.max() }
}

var s = Stack<Int>()
s.items = [3, 9, 1]
print(s.maxItem()!)

CustomStringConvertible condicional

Faça com que um tipo possa ser impresso somente quando seu conteúdo também puder, compondo descrições a partir dos elementos.

struct Labeled<T> { let label: String; let value: T }

extension Labeled: CustomStringConvertible where T: CustomStringConvertible {
    var description: String { label + ": " + value.description }
}

print(Labeled(label: "Age", value: 30))

Conformidade condicional aninhada

A conformidade condicional é combinável: um vetor de vetores de Int é Equatable porque cada camada encadeia a restrição.

let grid1 = [[1, 2], [3, 4]]
let grid2 = [[1, 2], [3, 4]]
print(grid1 == grid2)

Restringindo a outro protocolo

A cláusula where pode exigir que o elemento esteja em conformidade com um protocolo definido por você, permitindo comportamentos baseados nesse protocolo.

protocol Priced { var price: Double { get } }
struct Item: Priced { let price: Double }

extension Array where Element: Priced {
    var totalPrice: Double { reduce(0) { $0 + $1.price } }
}

print([Item(price: 1.5), Item(price: 2.5)].totalPrice)

Restrições de mesmo tipo

Você pode restringir um tipo associado a um tipo específico usando ==. Aqui, os métodos se aplicam somente a matrizes de String.

extension Array where Element == String {
    func joinedUpper() -> String {
        map { $0.uppercased() }.joined(separator: "-")
    }
}

print(["a", "b", "c"].joinedUpper())

Como o compilador usa isso

A conformidade condicional permite que o compilador conceda os benefícios de um protocolo exatamente quando eles são válidos, mantendo o código genérico seguro e extremamente reutilizável.

struct Optional2<T> { let value: T? }
extension Optional2: Equatable where T: Equatable {
    static func == (l: Optional2, r: Optional2) -> Bool { l.value == r.value }
}
print(Optional2(value: 1) == Optional2(value: 1))

Verificação rápida

Teste sua compreensão da conformidade condicional.

Recapitulação

A conformidade condicional usa extension Type: Protocol where ... para conceder conformidade somente quando os parâmetros de tipo atendem às restrições. Você viu isso com Equatable, Codable e CustomStringConvertible, com restrições de protocolo, restrições de mesmo tipo (==) e aninhamento. Isso mantém os tipos genéricos seguros e reutilizáveis.

Perguntas Frequentes

A aula “Conformidade Condicional” é grátis?

Sim — o texto completo de “Conformidade Condicional” é 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 “Conformidade Condicional”?

Conforme genericamente somente quando as restrições forem atendidas. 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 4 de 4.

Quanto tempo leva a aula “Conformidade Condicional”?

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