Danielrami703/Swift-Concurrency-Agent-Skill

O que Swift-Concurrency-Agent-Skill faz?

🚀 Aprimore ferramentas de codificação de IA com padrões de concorrência seguros para Swift 6+, focado em desempenho e suporte a migração no formato Agent Skills.

Visão Geral

Esta skill fornece padrões de concorrência seguros para Swift 6+, ajudando desenvolvedores a migrar código legado e escrever código concorrente eficiente. Ela é projetada para ser usada com assistentes de IA como Claude Code, Cursor e Codex, oferecendo orientações sobre async/await, actors, MainActor e Sendable.

Recursos Principais

• async/await: Escreva código assíncrono legível e livre de callbacks.
• Actors: Proteja estado mutável com isolamento de actor.
• MainActor: Execute tarefas na thread principal de forma segura.
• Sendable: Garanta que tipos possam ser passados entre domínios de concorrência.
• Migração: Ferramentas e padrões para migrar de GCD e bloqueios para Swift Concurrency.

Como Usar

Para utilizar esta skill, basta invocar o assistente de IA com um prompt relacionado a concorrência em Swift. Exemplos:

• "Crie uma função assíncrona que busca dados de uma API usando async/await."
• "Migre este código GCD para usar actors e tarefas estruturadas."
• "Explique como usar MainActor para atualizar a UI de forma segura."

Exemplos de Código

Usando async/await

func fetchUserData() async throws -> User {
    let url = URL(string: "https://api.example.com/user")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(User.self, from: data)
}

Usando Actor

actor Counter {
    private var value = 0

    func increment() {
        value += 1
    }

    func getValue() -> Int {
        return value
    }
}

Usando MainActor

@MainActor
class ViewModel: ObservableObject {
    @Published var text: String = ""

    func updateText() {
        Task {
            let result = await fetchData()
            text = result
        }
    }
}

Migração de Código Legado

De GCD para async/await

Antes (GCD):

DispatchQueue.global().async {
    let data = self.loadData()
    DispatchQueue.main.async {
        self.updateUI(data)
    }
}

Depois (Swift Concurrency):

Task {
    let data = await loadData()
    await MainActor.run {
        updateUI(data)
    }
}

Boas Práticas

• Use Sendable para tipos que serão passados entre tarefas.
• Evite bloqueios; use Task.sleep em vez de Thread.sleep.
• Prefira tarefas estruturadas (async let) para paralelismo controlado.
• Marque classes que manipulam UI com @MainActor.

Plataformas Suportadas

Esta skill é compatível com:

• Claude Code
• Cursor
• Codex
• Outros assistentes de IA que suportam o formato Agent Skills

Contribuição

Contribuições são bem-vindas! Envie pull requests ou abra issues no repositório do GitHub.

Licença

MIT License