final class ContentViewModel: ObservableObject {
    @Published var text = "Hello @StateObject"
    
    init() {
        print("ViewModel init")
    }
    
    deinit {
        print("ViewModel deinit")
    }
}

struct ContentView: View {
    @StateObject private var viewModel: ContentViewModel
    
    init(viewModel: ContentViewModel) {
        _viewModel = StateObject(wrappedValue: viewModel)
        
        print("ContentView init")
    }
    
    var body: some View {
        Text(viewModel.text)
    }
}

struct RootView: View {
    @State private var isOn = false
    
    var body: some View {
        VStack(spacing: 20) {
            ContentView(viewModel: ContentViewModel())
            
            if isOn { Text("is on") }
            
            Button("Trigger") { isOn.toggle() }
        }
    }
}

Text("Привет, мир!")
  .task {              // ✅ запускается при появлении и отменяется при уходе
    await loadData()
  }

.searchable(text: $query)
.task(id: query) {    // каждый раз новый `query` – новая задача
  results = await fetch(query)
}

.task(priority: .background) {
  await cleanupCache()
}

Структурированная конкурентность требует:
1. Scoped lifetime: дочерние задачи не могут пережить родительскую задачу.
2. Автоматическое ожидание: родитель должен дождаться всех дочерних задач перед завершением.
3. Fail-fast behavior: ошибки в дочерних задачах распространяются на родительскую.
4. Строгая иерархия parent-child: четкие отношения для распространения отмены и приоритета.

func demonstrateUnstructuredTaskCancellation() async {
    print("🔵 Демонстрация Task {} - unstructured")
    
    let parentTask = Task {
        print("👨 Parent task начала работу")
        
        let childTask = Task {
            print("👶 Child task начала работу")
            
            // Проверяем отмену каждую секунду
            for i in 1...5 {
                if Task.isCancelled {
                    print("👶 Child обнаружила отмену на итерации \(i)")
                    return "Child завершилась по отмене"
                }
                
                print("👶 Child работает... итерация \(i)")
                try? await Task.sleep(nanoseconds: 1_000_000_000)
            }
            
            print("👶 Child завершила всю работу")
            return "Child успешно завершилась"
        }
        
        // Ждем немного и отменяем parent
        try? await Task.sleep(nanoseconds: 2_500_000_000)
        print("👨 Parent отменяется!")
        
        // Получаем результат child
        let result = await childTask.value
        print("👨 Parent получил результат: \(result)")
        
        return "Parent завершен"
    }
    
    // Отменяем parent task через 2.5 секунды
    parentTask.cancel()
    
    let finalResult = await parentTask.value
    print("🔵 Финальный результат: \(finalResult)")
    print("🔵 Обратите внимание: child task продолжила работу после отмены parent!\n")
}

// Запуск примера
await demonstrateUnstructuredTaskCancellation()

func demonstrateStructuredTaskCancellation() async {
    print("🟢 Демонстрация TaskGroup - structured")

    do {
        try await withThrowingTaskGroup(of: String.self) { group in
            print("👨 TaskGroup начала работу")

            // Запускаем три дочерние задачи
            for i in 1...3 {
                group.addTask {
                    print("👶 задача \(i) начала работу")
                    
                    for j in 1...5 {
                        try Task.checkCancellation()             // бросит CancellationError, если отменена
                        print("👶 задача \(i) итерация \(j)")
                        try await Task.sleep(nanoseconds: 1_000_000_000)
                    }
                    print("👶 задача \(i) завершилась")
                    return "задача \(i) успех"
                }
            }

            // Ждём 2.5 секунды в этой же области и отменяем группу
            try await Task.sleep(nanoseconds: 2_500_000_000)
            print("👨 TaskGroup отменяет все задачи!")
            group.cancelAll()

            // Сбор завершённых результатов
            var results: [String] = []
            for try await result in group {
                results.append(result)
                print("👨 Получен результат: \(result)")
            }
            print("👨 TaskGroup завершена. Всего результатов: \(results.count)")
        }
    } catch {
        print("🟢 TaskGroup завершилась с ошибкой: \(error)")
    }
    
    print("\n🟢 Все дочерние задачи в группе гарантированно либо отработали, либо были отменены.")
}

// Запуск примера
await demonstrateStructuredTaskCancellation()

  @inlinable
  @_semantics("array.mutate_unknown")
  internal mutating func _reserveCapacityAssumingUniqueBuffer(oldCount: Int) {
    // Due to make_mutable hoisting the situation can arise where we hoist
    // _makeMutableAndUnique out of loop and use it to replace
    // _makeUniqueAndReserveCapacityIfNotUnique that precedes this call. If the
    // array was empty _makeMutableAndUnique does not replace the empty array
    // buffer by a unique buffer (it just replaces it by the empty array
    // singleton).
    // This specific case is okay because we will make the buffer unique in this
    // function because we request a capacity > 0 and therefore _copyToNewBuffer
    // will be called creating a new buffer.
    let capacity = _buffer.mutableCapacity
    _internalInvariant(capacity == 0 || _buffer.isMutableAndUniquelyReferenced())

    if _slowPath(oldCount &+ 1 > capacity) {
      _createNewBuffer(bufferIsUnique: capacity > 0,
                       minimumCapacity: oldCount &+ 1,
                       growForAppend: true)
    }
  }