Swift Academy · Aula

Restrições de Parâmetros de Tipo

Exija conformidade nos parâmetros genéricos.

Restrições de Parâmetros de Tipo é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 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 genéricos

Uma função genérica usa um parâmetro de tipo como <T> para funcionar com muitos tipos. Porém, um T sem restrições só pode ser passado adiante, não inspecionado. As restrições liberam capacidades.

func identity<T>(_ x: T) -> T { x }
print(identity(5))
print(identity("hi"))

A restrição Comparable

Escrever <T: Comparable> garante que os valores de T aceitem <, > e operadores semelhantes, permitindo compará-los.

func largest<T: Comparable>(_ a: T, _ b: T) -> T {
    a > b ? a : b
}
print(largest(3, 9))
print(largest("apple", "pear"))

Por que as restrições são necessárias

Sem Comparable, o compilador rejeita a > b, porque nem todo tipo aceita essa operação. A restrição é a promessa que torna a operação válida.

func minOf<T: Comparable>(_ list: [T]) -> T? {
    list.min()
}
print(minOf([4, 2, 8])!)

A restrição Equatable

Equatable habilita == e !=. Utilize-a para contar ou encontrar elementos correspondentes.

func count<T: Equatable>(_ x: T, in list: [T]) -> Int {
    list.filter { $0 == x }.count
}
print(count(2, in: [2, 3, 2, 2]))

A restrição Hashable

Hashable permite usar valores como membros de Set ou como chaves de dicionários.

func unique<T: Hashable>(_ list: [T]) -> [T] {
    Array(Set(list))
}
print(unique([1, 1, 2, 3, 3]).sorted())

Restrições de protocolo

Qualquer protocolo pode servir como restrição. Aqui, um protocolo personalizado habilita seu método no parâmetro genérico.

protocol Speaker { func speak() -> String }
struct Dog: Speaker { func speak() -> String { "Woof" } }

func announce<T: Speaker>(_ x: T) {
    print(x.speak())
}
announce(Dog())

Restrições de classe

Você pode exigir que T herde de uma classe específica, obtendo acesso aos membros dessa classe.

class Animal { func name() -> String { "animal" } }
class Cat: Animal { override func name() -> String { "cat" } }

func describe<T: Animal>(_ x: T) { print(x.name()) }
describe(Cat())

Várias restrições

Combine restrições com & para exigir vários protocolos de uma só vez.

func show<T: CustomStringConvertible & Equatable>(_ a: T, _ b: T) {
    print(a.description, a == b)
}
show(5, 5)

Vários parâmetros de tipo

Uma função pode ter vários parâmetros com restrições, cada um com seus próprios requisitos.

func zipMap<K: Hashable, V>(_ keys: [K], _ vals: [V]) -> [K: V] {
    var d: [K: V] = [:]
    for (k, v) in zip(keys, vals) { d[k] = v }
    return d
}
print(zipMap(["a", "b"], [1, 2]))

Restrições em tipos

Tipos genéricos, e não apenas funções, também aceitam restrições. Uma estrutura genérica pode exigir que seu parâmetro esteja em conformidade com um protocolo.

struct SortedBox<T: Comparable> {
    var items: [T]
    var smallest: T? { items.min() }
}
print(SortedBox(items: [5, 1, 9]).smallest!)

Restrições numéricas

Protocolos padrão como Numeric permitem que o código genérico faça cálculos aritméticos com Int, Double e outros tipos.

func sum<T: Numeric>(_ list: [T]) -> T {
    list.reduce(0, +)
}
print(sum([1, 2, 3]))
print(sum([1.5, 2.5]))

Verificação rápida

Teste sua compreensão das restrições de parâmetros de tipo.

Recapitulação

As restrições de parâmetros de tipo (<T: Protocol> ou <T: SomeClass>) informam ao compilador o que um tipo genérico pode fazer. Você viu Comparable, Equatable, Hashable, Numeric, protocolos personalizados, restrições de classe, várias restrições com & e restrições em tipos genéricos.

Perguntas Frequentes

A aula “Restrições de Parâmetros de Tipo” é grátis?

Sim — o texto completo de “Restrições de Parâmetros de Tipo” é 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 Parâmetros de Tipo”?

Exija conformidade nos parâmetros 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 1 de 4.

Quanto tempo leva a aula “Restrições de Parâmetros de Tipo”?

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