Программирование Swift

Как в Swift спроектировать тип ошибки, чтобы вызывающий код надёжно различал причины сбоя без разбора текста сообщения?

Определи порядок вывода при вызове функции: когда срабатывает defer относительно обработки ошибки?

import Foundation

enum Failure: Error { case invalid }

func run() throws -> Int {
    defer { print("defer") }
    print("start")
    throw Failure.invalid
}

do {
    _ = try run()
    print("success")
} catch {
    print("catch")
}

В конструкции с несколькими async let дочерняя задача завершилась ошибкой до await: когда родительская задача узнает об этой ошибке?

За счёт какого механизма экземпляр типа, изолированного глобальным актором, можно передавать между конкурентными задачами без собственной блокировки?

Если удалить последнюю ссылку на дескриптор Task, отменится ли выполняемая задача?

Можно ли безопасно вызывать continuation AsyncStream из нескольких конкурентных задач без собственной блокировки?

После отмены родительской задачи автоматически отменяется созданная внутри неё Task.detached?

Почему добавление одного ссылочного свойства может лишить структуру автоматической проверки как Sendable в Swift?

Оцените безопасность передачи дескриптора Task между конкурентными задачами без дополнительной блокировки.

Старый Swift-модуль импортирован с @preconcurrency: что изменится при проверке передачи его типов между конкурентными задачами?

Если отдельно запущенная задача Swift завершилась ошибкой, но никто не запросил её результат, как эта ошибка распространяется?

Допустимо ли считать вызов nonisolated-метода actor сериализованным самим actor?

В чём принципиальное преимущество TaskGroup перед async let при динамическом числе дочерних операций?

Когда объект Swift, запустивший долгоживущую обычную Task с сильным захватом self, сможет деинициализироваться?

Можно ли безопасно передать ссылку на actor между задачами Swift, несмотря на его ссылочную семантику?

Разберите порядок запуска: что гарантирует async let до первого await и какой порядок вывода допустим?

func work(_ name: String) async -> String {
    print("start \(name)")
    await Task.yield()
    print("finish \(name)")
    return name
}

func demo() async {
    async let first = work("A")
    print("between")
    async let second = work("B")
    print("before await")
    _ = await (first, second)
}

Разберите последствия: что гарантирует withTaskCancellationHandler, если задача уже отменена до регистрации обработчика?

Почему захват несамопередаваемого значения обычно допустим в Task, но запрещается в Task.detached?

Почему чтение неизменяемого let-свойства actor может не требовать await?

Всегда ли await означает фактическую приостановку задачи?