Escreva Swift
Resposta Inicial
Quando esta skill for invocada pela primeira vez sem uma pergunta específica, responda apenas com:
Estou pronto para ajudar você a escrever Swift moderno, do jeito que a linguagem quer ser escrita.
Não forneça nenhuma outra informação até que o usuário faça uma pergunta.
Como escrever Swift do jeito que a linguagem quer ser escrita, atualizado até Swift 6.4.
Linha de base da toolchain: Swift 6.3 (versão atual em agosto de 2026). Tudo aqui compila no 6.3, a menos que marcado com ⚠, que sinaliza funcionalidades não lançadas do Swift 6.4. As orientações de concorrência assumem o modelo do Swift 6.2 — se o projeto estiver no 6.1 ou anterior, as regras da seção §3 sobre async e @concurrent não se aplicam.
A linha condutora: Swift é uma linguagem de divulgação progressiva. Comece com a coisa mais simples, mais estática e mais single-threaded que funciona, e compre dinamismo — concorrência, semântica de referência, existenciais, ponteiros inseguros — apenas onde você puder apontar o motivo. Cada regra abaixo é uma aplicação disso.
Modele esta hierarquia de padrões. Desça um nível apenas com um motivo que você possa declarar:
| Necessidade | Use | Desça apenas quando |
|---|---|---|
| Dados | struct/enum | precisar de identidade, compartilhamento ou herança |
| Abstração | tipo concreto | tiver código repetido entre tipos |
| Polimorfismo | some P (genérico) | precisar de armazenamento heterogêneo → any P |
| Execução | actor principal, síncrono | o perfil mostrar um travamento → async → @concurrent → actor |
| Memória | Array, String | o perfil mostrar o custo → InlineArray, Span |
| Segurança | API segura | interoperabilidade com C ou um caminho crítico medido → Unsafe* |
1. Modele dados com tipos de valor
Tipos de valor são o padrão em Swift, não um caso especial.
- Use
structeenumcomo padrão. Useclassapenas para identidade, estado mutável compartilhado, herança ou ciclo de vida de recurso. Uma janela, uma conexão de banco de dados, uma entidade armazenada em um motor de renderização — esses têm identidade. UmPonto, umaBebida, umMaterialnão têm. letpor padrão;varapenas quando você altera. É a mesma disciplina desomeantes deanye valor antes de referência: comece estreito, amplie com motivo.- Um struct com uma propriedade mutável de tipo referência não é nem valor nem referência. Cópias compartilham o objeto; mutações vazam entre cópias. Mantenha o tipo referenciado imutável, exponha apenas propriedades computadas que o delegam ou torne-o uma propriedade armazenada
privatepor trás de copy-on-write. - Copy-on-write é como você obtém armazenamento fora da linha e semântica de valor. Encapsule uma classe final em um struct e verifique
isKnownUniquelyReferenced(&storage)antes de alterar; copie primeiro se não for. É exatamente assim queArray,StringeDictionaryfuncionam. - Enums são a ferramenta para "um conjunto fixo de coisas" e para estado mutuamente exclusivo. Substituir uma pilha de propriedades armazenadas opcionais (
isSharing,selectedRows,shareTarget) por umaenum Statetorna combinações inválidas irrepresentáveis e torna a mudança de estado atômica em vez de uma sequência de escritas de propriedade que você pode esquecer de concluir. - Compor valores produz um valor. Um struct cujas propriedades armazenadas são todas tipos de valor tem semântica de valor gratuitamente — o que torna desfazer, diff e restauração de estado um único caminho de código em vez de um por propriedade.
struct Material { // semântica de valor preservada
var roughness: Double
private var _texture: Texture // uma classe
var color: Color {
get { _texture.color }
set {
if !isKnownUniquelyReferenced(&_texture) { _texture = Texture(copying: _texture) }
_texture.color = newValue
}
}
}
Tipos não copiáveis (~Copyable) expressam propriedade exclusiva: um descritor de arquivo, uma transferência bancária, um recurso aberto. Suprimir a cópia transforma "você não deve executar isso duas vezes" de uma asserção em um erro de compilação e torna deinit em um struct significativo. Marque o método finalizador como consuming para que o compilador prove que é o último uso. A propriedade de parâmetro se torna explícita: borrowing (somente leitura, o padrão), consuming (toma posse), inout/mutating (acesso de escrita temporário).
2. Erros e optionals — torne os caminhos de falha visíveis
O tratamento de erros do Swift se apoia em três pontos: fontes de erro são marcadas para que não possam surpreender; erros carregam contexto suficiente para agir; e erros recuperáveis são diferentes de erros de programador.
- Recuperável →
throw. Erro de programador →precondition/fatalError. Uma chamada de rede falha mantém o programa em execução. Um índice fora dos limites significa que o código está errado e deve parar antes que o bug se torne um problema de segurança. - Enums com valores associados são os melhores tipos de erro.
case duplicateFriend(String)é melhor quecase duplicateFriend— o contexto é o ponto principal. guardpara condições de erro, porque força o caminho de saída.if letpara o desembrulho comum.throws(MyError)com tipo explícito é para funções internas, código genérico que encaminha erros e ambientes restritos onde encapsularany Erroré muito custoso. Para API pública,throwssem tipo preserva sua liberdade de mudar o tipo de erro depois. Observe a unificação:throwséthrows(any Error), e sem lançamento éthrows(Never)— o que permite quemapabstraia sobre ambos.- Force-unwrap apenas onde você puder declarar a invariante, e prefira um
#require/preconditioncom falha e uma mensagem em vez de um!simples.
3. Concorrência: fique single-threaded até que o perfil diga o contrário
Esta é a seção que os agentes mais erram, porque o modelo mudou no Swift 6.2.
Inicie cada aplicativo inteiramente na thread principal. Código single-threaded vai longe, e a maioria dos aplicativos nunca precisa sair dela.
A progressão, em ordem. Não pule etapas.
- Single-threaded no actor principal. Nenhuma concorrência. Bom para a maioria dos aplicativos.
async/awaitpara ocultar latência (rede, disco). Ainda sem concorrência própria — APIs do SDK comoURLSession.data(from:)descarregam em seu nome.@concurrentpara mover seu trabalho pesado para fora da thread principal — apenas depois que o Instruments mostrar um travamento.actorpara mover estado para fora do actor principal — apenas quando muito estado do actor principal está forçando tarefas a voltar constantemente.
Ative as configurações de compilação corretas primeiro. Ative Concorrência Acessível em todos os projetos. Para módulos de aplicativo e módulos voltados para UI, defina também Isolamento de Actor Padrão como MainActor — é o padrão para novos projetos de aplicativo no Xcode 26, e elimina a maioria das suas anotações @MainActor. Em um pacote: swiftSettings: [.defaultIsolation(MainActor.self)]. Não defina MainActor como padrão para uma biblioteca de uso geral — bibliotecas devem fornecer APIs nonisolated e deixar os clientes decidirem onde o trabalho é executado.
A regra que mudou
No Swift 6.2, marcar uma função como async não a move para fora do actor atual. Ela é executada onde foi chamada. Isso é o que torna "o código mais natural de escrever" livre de data races por padrão.
@concurrent— sempre alterna para o pool de threads concorrentes. Use em seu trabalho pesado de CPU.nonisolated— executa onde é chamada. Este é o padrão correto para APIs de biblioteca, porque o chamador decide.nonisolatedem um tipo torna todos os seus membros nonisolated (Swift 6.1+).- Nem um nem outro — permanece no actor do chamador.
nonisolated struct PhotoProcessor { // desacoplado do actor principal
@concurrent // garantido para executar em segundo plano
func process(_ data: Data) async -> ProcessedPhoto {
async let sticker = extractSticker(data) // dois trabalhos independentes, em paralelo
async let colors = extractColors(data)
return await ProcessedPhoto(sticker: sticker, colors: colors)
}
}
- Crie perfil antes de descarregar. Use Instruments (Time Profiler, travamentos). Se o código puder ser acelerado sem concorrência, faça isso primeiro. Concorrência tem custo real — alocação de tarefas, escalonamento e raciocínio.
- Não crie uma tarefa para trabalho trivial. Uma tarefa filha para ler um valor de
UserDefaultscusta mais do que economiza. - Uma tarefa por operação de ponta a ponta. Trabalho que deve acontecer em ordem vai em uma tarefa; operações independentes recebem tarefas separadas para que o runtime possa intercalá-las.
awaité um ponto de suspensão e quebra a atomicidade. O estado pode mudar enquanto você está suspenso, e você pode retomar em uma thread diferente. Reavalie as suposições após cadaawait. Nunca segure um lock através de um. Nunca confie em armazenamento local de thread através de um.
Reentrância de Actor
Actors garantem exclusão mútua, não transações. Entre dois awaits no mesmo actor, outro trabalho é executado.
- Altere o estado do actor em métodos síncronos. Código síncrono em um actor é executado até o fim sem interrupção — essa é sua fronteira de transação.
- Mantenha métodos async do actor enxutos, compostos de operações transacionais síncronas, e deixe o actor em um estado consistente em cada
await. - O bug clássico: verificar cache →
awaitdownload → escrever cache. Duas tarefas erram, ambas baixam, a segunda sobrescreve a primeira. Reavalie após oawaitou desduplique o trabalho em andamento. - Actors não são FIFO. Eles executam o trabalho de maior prioridade primeiro, precisamente para evitar inversão de prioridade. Se você precisar de ordenação, use uma tarefa (que executa do início ao fim) ou um
AsyncStream, não um actor.
4. Sendable e compartilhamento de dados
Sendable marca um tipo como seguro para compartilhar entre domínios de isolamento. O compilador verifica em cada fronteira de tarefa e actor.
- Tipos de valor são
Sendablequando seu armazenamento é — inferido automaticamente para tipos não públicos. Tipos públicos nunca têm sendability inferida: marcar um tipo público comoSendableé uma promessa para seus clientes, então Swift obriga você a escrevê-lo. - Actors e classes
@MainActorsão implicitamenteSendable, porque seu estado é isolado. - A maioria das classes de modelo não deve ser nem
@MainActornemSendable. Mantenha-as intencionalmente nãoSendable— isso impede que metade do modelo seja alterada na thread principal enquanto a outra metade é alterada em segundo plano. Se precisarem sair do actor principal, torne-asnonisolated, nãoSendable. - Você ainda pode enviar um objeto não
Sendableentre domínios desde que o remetente pare de usá-lo. Faça todas as suas alterações antes de entregá-lo; tocar nele depois é o erro. - Closures também capturam estado. Marque um tipo de função como
@Sendableapenas se ele genuinamente cruzar domínios. @unchecked Sendableé uma promessa que o compilador não pode verificar. Reserve para tipos com sincronização interna real (umMutex, um lock). O mesmo vale paranonisolated(unsafe)em um global — último recurso, não um silenciador de avisos.
Quando você encontrar um erro de data race, percorra esta lista:
- Não compartilhe. Mova o objeto compartilhado para um local para que cada trabalho concorrente tenha sua própria instância. (Esta é a correção para a grande maioria dos erros reais.)
- Transforme-o em um tipo de valor
Sendable, para que "compartilhar" seja realmente copiar. - Isole-o em um actor — o actor principal ou o seu próprio.
- Só então recorra a
Mutex/Atomicdo móduloSynchronization(armazene-os em propriedadeslet) ou@unchecked Sendable.
Variáveis globais e estáticas são a fonte mais comum de erros. Em ordem de preferência: transforme em let; coloque em @MainActor; encapsule em um Mutex; nonisolated(unsafe). Observe que globais em Swift são inicializados lentamente e atomicamente — diferente de C.
Ligando APIs de callback antigas: anote protocolos delegados com @MainActor se você os possui. Se não possui, marque o método como nonisolated e use MainActor.assumeIsolated { } — ele afirma em vez de saltar, então trava alto em vez de correr silenciosamente. @preconcurrency na conformidade é a abreviação para a mesma coisa. Use @preconcurrency import para silenciar temporariamente avisos de sendability de um módulo que não migrou; os avisos voltam — corretamente — quando ele migra.
5. Concorrência estruturada
Sempre prefira tarefas estruturadas.
Tarefas estruturadas (async let, grupos de tarefas) têm escopo como variáveis locais: não podem sobreviver ao bloco, são aguardadas automaticamente e herdam cancelamento, prioridade e valores locais de tarefa através da árvore de tarefas. Tarefas não estruturadas (Task { }, Task.detached) não oferecem nada disso automaticamente.
async letpara um número fixo e estaticamente conhecido de filhos concorrentes.withTaskGroupquando o número é dinâmico. Grupos de tarefas conformam aAsyncSequence— itere os resultados conforme chegam. UsewithDiscardingTaskGroupquando os filhos não retornam nada: libera os recursos de cada filho imediatamente e cancela irmãos no primeiro erro.Task { }apenas quando o tempo de vida do trabalho não se encaixa em um escopo — reagir a um callback de delegate, um toque de botão, uma view aparecendo. Ele herda isolamento de actor e prioridade; você deve gerenciar o cancelamento manualmente.Task.detachedquase nunca. Não herda nada — nem isolamento, nem prioridade, nem valores locais de tarefa. Se você precisar de uma raiz destacada, coloque um grupo de tarefas dentro dela em vez de destacar repetidamente.
Cancelamento é cooperativo. Cancelar define uma flag; não para nada. Verifique Task.isCancelled ou try Task.checkCancellation() antes de iniciar trabalho caro, e também em auxiliares síncronos. Para trabalho que está suspenso em vez de em execução (o next() de uma AsyncSequence), use withTaskCancellationHandler — e lembre-se de que o handler executa imediatamente e concorrentemente com o corpo, então o estado que ele toca precisa de sincronização real (um atômico ou um lock, não um actor — você não pode garantir ordenação em um actor).
Limite sua concorrência. Não distribua um filho por item em uma lista sem limites. Inicie N filhos e depois adicione um novo apenas quando um filho terminar.
[Nota: O conteúdo original foi truncado; a tradução continua até onde o texto original foi fornecido.]