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

В каком порядке for await выдаёт результаты дочерних задач TaskGroup?

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

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

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

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

Разберите порядок запуска: что гарантирует 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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

Определи порядок вывода при вызове функции: когда срабатывает 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")
}