Escribir Swift
Respuesta Inicial
Cuando esta habilidad se invoque por primera vez sin una pregunta específica, responde únicamente con:
Estoy listo para ayudarte a escribir Swift moderno, de la forma en que el lenguaje quiere ser escrito.
No proporciones ninguna otra información hasta que el usuario haga una pregunta.
Cómo escribir Swift de la forma en que el lenguaje quiere ser escrito, actualizado hasta Swift 6.4.
Toolchain baseline: Swift 6.3 (versión actual a agosto de 2026). Todo aquí compila en 6.3 a menos que esté marcado con ⚠, lo que indica funcionalidades no lanzadas de Swift 6.4. Las guías de concurrencia asumen el modelo de Swift 6.2 — si el proyecto está en 6.1 o anterior, las reglas de la sección §3 sobre async y @concurrent no aplican.
El hilo conductor: Swift es un lenguaje de divulgación progresiva. Comienza con lo más simple, más estático y monohilo que funcione, y añade dinamismo — concurrencia, semántica de referencia, existenciales, punteros inseguros — solo donde puedas señalar la razón. Cada regla a continuación es una aplicación de esto.
Modela esta jerarquía de valores predeterminados. Baja un nivel solo con una razón que puedas enunciar:
| Necesidad | Usa | Baja solo cuando |
|---|---|---|
| Datos | struct / enum | necesitas identidad, compartición o herencia |
| Abstracción | tipo concreto | tienes código repetido entre tipos |
| Polimorfismo | some P (genérico) | necesitas almacenamiento heterogéneo → any P |
| Ejecución | actor principal, síncrono | la creación de perfiles muestra un bloqueo → async → @concurrent → actor |
| Memoria | Array, String | la creación de perfiles muestra el costo → InlineArray, Span |
| Seguridad | API segura | Interoperabilidad con C o un hot path medido → Unsafe* |
1. Modela datos con tipos valor
Los tipos valor son la opción predeterminada en Swift, no un caso especial.
- Por defecto, usa
structyenum. Usaclasssolo para identidad, estado mutable compartido, herencia o ciclo de vida de recursos. Una ventana, una conexión a base de datos, una entidad almacenada en un motor de renderizado — esos tienen identidad. UnPunto, unaBebida, unMaterialno. letpor defecto;varsolo cuando mutas. Esta es la misma disciplina quesomeantes queanyy valor antes que referencia: comienza estrecho, amplía con causa.- Un struct con una propiedad de tipo referencia mutable no es ni un valor ni una referencia. Las copias comparten el objeto; las mutaciones se filtran entre copias. O mantén el tipo referenciado inmutable, expón solo propiedades computadas que lo reenvíen, o conviértelo en una propiedad
privatealmacenada detrás de copy-on-write. - Copy-on-write es cómo obtienes almacenamiento fuera de línea y semántica de valor. Envuelve una clase final en un struct y verifica
isKnownUniquelyReferenced(&storage)antes de mutar; copia primero si no lo es. Así es exactamente como funcionanArray,StringyDictionary. - Los enums son la herramienta para "un conjunto fijo de cosas" y para estado mutuamente excluyente. Reemplazar un montón de propiedades almacenadas opcionales (
isSharing,selectedRows,shareTarget) con unenum Statehace que las combinaciones inválidas sean irrepresentables y que el cambio de estado sea atómico en lugar de una secuencia de escrituras de propiedades que puedes olvidar completar. - Componer valores produce un valor. Un struct cuyas propiedades almacenadas son todas tipos valor tiene semántica de valor gratis — lo que hace que deshacer, diffing y restauración de estado sean una única ruta de código en lugar de una por propiedad.
struct Material { // semántica de valor preservada
var roughness: Double
private var _texture: Texture // una clase
var color: Color {
get { _texture.color }
set {
if !isKnownUniquelyReferenced(&_texture) { _texture = Texture(copying: _texture) }
_texture.color = newValue
}
}
}
Tipos no copiables (~Copyable) expresan propiedad única: un descriptor de archivo, una transferencia bancaria, un recurso abierto. Suprimir la copia convierte "no debes ejecutar esto dos veces" de una aserción en un error de compilación, y hace que deinit en un struct sea significativo. Marca el método final como consuming para que el compilador demuestre que es el último uso. La propiedad de los parámetros se vuelve explícita: borrowing (solo lectura, el predeterminado), consuming (lo toma), inout/mutating (acceso de escritura temporal).
2. Errores y opcionales — haz visibles las rutas de fallo
El manejo de errores de Swift se basa en tres puntos: las fuentes de error están marcadas para que no puedan sorprenderte; los errores llevan suficiente contexto para actuar; y los errores recuperables son diferentes de los errores de programador.
- Recuperable →
throw. Error de programador →precondition/fatalError. Una llamada de red fallida mantiene el programa en ejecución. Un índice fuera de límites significa que el código está mal y debe detenerse antes de que el error se convierta en un problema de seguridad. - Los enums con valores asociados son los mejores tipos de error.
case duplicateFriend(String)supera acase duplicateFriend— el contexto es la clave. guardpara condiciones de error, porque fuerza la ruta de salida.if letpara el desempaquetado normal.throws(TipoError)es para funciones internas, código genérico que reenvía errores y entornos restringidos donde empaquetarany Errores demasiado costoso. Para API pública,throwssin tipo preserva tu libertad de cambiar el tipo de error más adelante. Nota la unificación:throwsesthrows(any Error), y no lanzar esthrows(Never)— que es lo que permite amapabstraer sobre ambos.- Forzar desempaquetado solo donde puedas enunciar el invariante, y prefiere un
#require/preconditionfallido con un mensaje sobre un!desnudo.
3. Concurrencia: mantente en un solo hilo hasta que la creación de perfiles diga lo contrario
Esta es la sección que los agentes suelen entender mal con más frecuencia, porque el modelo cambió en Swift 6.2.
Comienza cada aplicación completamente en el hilo principal. El código de un solo hilo llega muy lejos, y la mayoría de las aplicaciones nunca necesitan salir de él.
La progresión, en orden. No te saltes pasos.
- Un solo hilo en el actor principal. Sin concurrencia alguna. Adecuado para la mayoría de las aplicaciones.
async/awaitpara ocultar latencia (red, disco). Aún sin concurrencia propia — APIs del SDK comoURLSession.data(from:)descargan en tu nombre.@concurrentpara mover tu trabajo pesado fuera del hilo principal — solo después de que Instruments muestre un bloqueo.actorpara mover el estado fuera del actor principal — solo cuando demasiado estado del actor principal está forzando a las tareas a saltar constantemente de vuelta.
Activa primero la configuración de compilación correcta. Habilita Concurrencia Accesible en cada proyecto. Para módulos de aplicación y módulos orientados a la interfaz de usuario, también establece Aislamiento de Actor Predeterminado a MainActor — es el valor predeterminado para nuevos proyectos de aplicación en Xcode 26, y elimina la mayoría de tus anotaciones @MainActor. En un paquete: swiftSettings: [.defaultIsolation(MainActor.self)]. No establezcas main-actor-por-defecto para una biblioteca de propósito general — las bibliotecas deben enviar APIs nonisolated y dejar que los clientes decidan dónde se ejecuta el trabajo.
La regla que cambió
En Swift 6.2, marcar una función como async no la mueve fuera del actor actual. Se ejecuta donde fue llamada. Esto es lo que hace que "el código más natural de escribir" esté libre de condiciones de carrera por defecto.
@concurrent— siempre cambia al grupo de hilos concurrentes. Úsalo en tu trabajo pesado de CPU.nonisolated— se ejecuta donde sea llamado. Este es el valor predeterminado correcto para APIs de bibliotecas, porque el llamante decide.nonisolateden un tipo hace que todos sus miembros sean nonisolated (Swift 6.1+).- Ninguno de los dos — permanece en el actor del llamante.
nonisolated struct PhotoProcessor { // desacoplado del actor principal
@concurrent // garantizado para ejecutarse en segundo plano
func process(_ data: Data) async -> ProcessedPhoto {
async let sticker = extractSticker(data) // dos trabajos independientes, en paralelo
async let colors = extractColors(data)
return await ProcessedPhoto(sticker: sticker, colors: colors)
}
}
- Crea un perfil antes de descargar trabajo. Usa Instruments (Time Profiler, Hangs). Si el código se puede hacer más rápido sin concurrencia, hazlo siempre primero. La concurrencia tiene un costo real: asignación de tareas, planificación y razonamiento.
- No generes una tarea para trabajo trivial. Una tarea hija para leer un valor de
UserDefaultscuesta más de lo que ahorra. - Una tarea por operación de principio a fin. El trabajo que debe ocurrir en orden va en una tarea; las operaciones independientes obtienen tareas separadas para que el runtime pueda intercalarlas.
awaites un punto de suspensión, y rompe la atomicidad. El estado puede cambiar mientras estás suspendido, y puedes reanudarte en un hilo diferente. Vuelve a verificar las suposiciones después de cadaawait. Nunca mantengas un bloqueo a través de uno. Nunca confíes en el almacenamiento local de hilo a través de uno.
Reentrancia de actores
Los actores garantizan exclusión mutua, no transacciones. Entre dos awaits en el mismo actor, se ejecuta otro trabajo.
- Muta el estado del actor en métodos síncronos. El código síncrono en un actor se ejecuta hasta completarse sin interrupciones — ese es tu límite de transacción.
- Mantén los métodos async de los actores delgados, compuestos de operaciones transaccionales síncronas, y deja el actor en un estado consistente en cada
await. - El error clásico: verificar caché →
awaitdescarga → escribir caché. Dos tareas fallan ambas, ambas descargan, la segunda sobrescribe la primera. Vuelve a verificar después delawait, o desduplica el trabajo en curso. - Los actores no son FIFO. Ejecutan primero el trabajo de mayor prioridad, precisamente para evitar la inversión de prioridad. Si necesitas orden, usa una tarea (que se ejecuta de principio a fin) o un
AsyncStream, no un actor.
4. Sendable y compartir datos
Sendable marca un tipo como seguro para compartir entre dominios de aislamiento. El compilador lo verifica en cada límite de tarea y actor.
- Los tipos valor son
Sendablecuando su almacenamiento lo es — inferido automáticamente para tipos no públicos. Los tipos públicos nunca obtienen capacidad de envío inferida: marcar un tipo público comoSendablees una promesa a tus clientes, por lo que Swift te obliga a escribirlo. - Los actores y las clases
@MainActorson implícitamenteSendable, porque su estado está aislado. - La mayoría de las clases de modelo no deberían ser ni
@MainActorniSendable. Mantenlas noSendablea propósito — evita que la mitad del modelo se mute en el hilo principal mientras la otra mitad se muta en segundo plano. Si necesitan salir del actor principal, hazlasnonisolated, noSendable. - Aún puedes enviar un objeto no
Sendableentre dominios siempre que el emisor deje de usarlo. Realiza todas tus mutaciones antes de entregarlo; tocarlo después es el error. - Los cierres también capturan estado. Marca un tipo de función como
@Sendablesolo si realmente cruza dominios. @unchecked Sendablees una promesa que el compilador no puede verificar. Resérvalo para tipos con sincronización interna real (unMutex, un bloqueo). Lo mismo paranonisolated(unsafe)en un global — último recurso, no un silenciador de advertencias.
Cuando encuentres un error de condición de carrera, recorre esta lista:
- No lo compartas. Mueve el objeto compartido a un local para que cada trabajo concurrente tenga su propia instancia. (Esta es la solución para la gran mayoría de errores reales.)
- Conviértelo en un tipo valor
Sendable, de modo que "compartir" sea realmente copiar. - Aísla en un actor — el actor principal, o uno propio.
- Solo entonces recurre a
Mutex/Atomicdel móduloSynchronization(almacénalos en propiedadeslet), o@unchecked Sendable.
Las variables globales y estáticas son la fuente más común de errores. En orden de preferencia: conviértela en let; ponla en @MainActor; envuélvela en un Mutex; nonisolated(unsafe). Nota: los globales en Swift se inicializan perezosamente y atómicamente — a diferencia de C.
Adaptando APIs de callback antiguas: anota los protocolos delegados con @MainActor si los posees. Si no, marca el método como nonisolated y usa MainActor.assumeIsolated { } — afirma en lugar de saltar, por lo que atrapa ruidosamente en lugar de competir silenciosamente. @preconcurrency en la conformidad es la abreviatura para lo mismo. Usa @preconcurrency import para silenciar temporalmente las advertencias de sendability de un módulo que no ha migrado; las advertencias vuelven — correctamente — una vez que lo hace.
5. Concurrencia estructurada
Prefiere siempre las tareas estructuradas.
Las tareas estructuradas (async let, grupos de tareas) tienen un ámbito como las variables locales: no pueden sobrevivir al bloque, se esperan automáticamente, y heredan cancelación, prioridad y valores locales de tarea a través del árbol de tareas. Las tareas no estructuradas (Task { }, Task.detached) no te dan nada de eso automáticamente.
async letpara un número fijo, estáticamente conocido, de hijos concurrentes.withTaskGroupcuando el número es dinámico. Los grupos de tareas se ajustan aAsyncSequence— itera los resultados a medida que llegan. UsawithDiscardingTaskGroupcuando los hijos no devuelvan nada: libera los recursos de cada hijo inmediatamente y cancela los hermanos en el primer error.Task { }solo cuando la vida útil del trabajo no encaje en un ámbito — reaccionando a un callback delegado, un toque de botón, la aparición de una vista. Hereda el aislamiento del actor y la prioridad; debes gestionar la cancelación tú mismo.Task.detachedcasi nunca. No hereda nada — ni aislamiento, ni prioridad, ni locales de tarea. Si necesitas una raíz separada, pon un grupo de tareas dentro de ella en lugar de separar repetidamente.
La cancelación es cooperativa. Cancelar establece una bandera; no detiene nada. Verifica Task.isCancelled o try Task.checkCancellation() antes de comenzar trabajo costoso, y también en ayudantes síncronos. Para el trabajo que está suspendido en lugar de ejecutándose (el next() de un AsyncSequence), usa withTaskCancellationHandler — y recuerda que el manejador se ejecuta inmediatamente y concurrentemente con el cuerpo, por lo que el estado que toca necesita sincronización real (un atómico o un bloqueo, no un actor — no puedes garantizar el orden en un actor).
Limita tu concurrencia. No distribuyas un hijo por elemento sobre una lista sin límites. Inicia N hijos, luego agrega un
…
[truncado para traducción]