Canvas { context, size in
  // Рисуем эллипс
  context.fill(
    Path(ellipseIn: CGRect(origin: .zero, size: size)),
    with: .color(.blue)
  )
  
  // Добавляем текст
  context.draw(Text("Hello Canvas"), at: CGPoint(x: size.width/2, y: size.height/2))
}

@Test("Пользователь нажимает кнопку сохранения без заполненных полей")
func testSaveButtonTapWithEmptyFields() {
}

@Test
func `пользователь нажимает кнопку сохранения без заполненных полей`() {
}

enum VideoFormat {
  case resolution1080p
  case resolution4K
  case frameRate24
  case frameRate60
}

enum VideoFormat {
  case `1080p`
  case `4K`
  case `24fps`
  case `60fps`
}

let format: VideoFormat = .`4K`
let frameRate: VideoFormat = .`60fps`

class CustomAttachmentViewProvider: NSTextAttachmentViewProvider {
  override func loadView() {
    // Ошибка компиляции в Swift 6 и новее
    let hosting = UIHostingController(rootView: MySwiftUIView())
    self.view = hosting.view
  }
}

class CustomAttachmentViewProvider: NSTextAttachmentViewProvider {
  override func loadView() {
    let view = MainActor.assumeIsolated {
      let hosting = UIHostingController(rootView: MySwiftUIView())
      hosting.view.backgroundColor = .clear
      return hosting.view
    }
    self.view = view
  }
}

class CustomAttachmentViewProvider: NSTextAttachmentViewProvider {
  override func loadView() {
    view = createViewSafely()
  }
  
  private func createViewSafely() -> UIView {
    if Thread.isMainThread {
      return Self.createHostingView()
    } else {
      return DispatchQueue.main.sync {
        Self.createHostingView()
      }
    }
  }
  
  private static func createHostingView() -> UIView {
    MainActor.assumeIsolated {
      let hosting = UIHostingController(rootView: MySwiftUIView())
      return hosting.view
    }
  }
}

let configuration = UIMainMenuSystem.Configuration()
UIMainMenuSystem.shared.setBuildConfiguration(configuration) { menuBuilder in
  // Ваша логика кастомизации
  menuBuilder.remove(menu: .file)
}

let configuration = UIMainMenuSystem.Configuration()
configuration.newScenePreference = .removed
configuration.findingConfiguration.style = .search

let persistentStoreCoordinator = NSPersistentStoreCoordinator(
  managedObjectModel: dataModel
)

let migrationOptions: [AnyHashable: Any] = [
  NSMigratePersistentStoresAutomaticallyOption: true,
  NSInferMappingModelAutomaticallyOption: true
]

do {
  try persistentStoreCoordinator.addPersistentStore(
    ofType: NSSQLiteStoreType,
    configurationName: nil,
    at: databaseURL,
    options: migrationOptions
  )
} catch {
  // Обработка неудачной миграции
}

let canMigrateAutomatically = try? NSMappingModel.inferredMappingModel(
  forSourceModel: previousModelVersion,
  destinationModel: updatedModelVersion
) != nil

if canMigrateAutomatically {
  // Легкая миграция возможна
} else {
  // Требуется ручная (тяжелая) миграция
}

// Старый код (до async/await)
func fetchUserData(userId: Int, completion: @escaping (Result<User, Error>) -> Void) {
  // Некоторая асинхронная операция
  NetworkService.shared.request(.user(id: userId)) { result in
    completion(result)
  }
}

// Как мы хотим использовать это в новом коде:
let user = try await fetchUserData(userId: 123)

// Новый async-интерфейс поверх старого API
func fetchUserData(userId: Int) async throws -> User {
  return try await withCheckedThrowingContinuation { continuation in
    // Вызываем старый метод с completion handler
    fetchUserData(userId: userId) { result in
      switch result {
      case .success(let user):
        // Пробуждаем async функцию с результатом
        continuation.resume(returning: user)
      case .failure(let error):
        // Пробуждаем с ошибкой
        continuation.resume(throwing: error)
      }
    }
  }
}

// Опасный код (может вызвать краш)
func dangerousWrap() async -> String {
  await withCheckedContinuation { continuation in
    unreliableAPI { value in
      continuation.resume(returning: value)
      // Если API вызовет completion дважды — будет ошибка
    }
  }
}

// Безопасная обертка
func safeWrap() async -> String {
  await withCheckedContinuation { continuation in
    var hasResumed = false
    unreliableAPI { value in
      guard !hasResumed else { return }
      hasResumed = true
      continuation.resume(returning: value)
    }
  }
}

protocol Coffee {
  func brew()
}

protocol Tea {
  func steep()
}

// Для итальянской кофейни
struct Espresso: Coffee {
  func brew() {
    print("Варим эспрессо")
  }
}

struct ItalianTea: Tea {
  func steep() {
    print("Завариваем итальянский травяной чай")
  }
}

// Для английской кофейни
struct Cappuccino: Coffee {
  func brew() {
    print("Готовим капучино")
  }
}

struct EnglishTea: Tea {
  func steep() {
    print("Завариваем английский черный чай")
  }
}

protocol CafeFactory {
  func makeCoffee() -> Coffee
  func makeTea() -> Tea
}

struct ItalianCafeFactory: CafeFactory {
  func makeCoffee() -> Coffee {
    Espresso()
  }

  func makeTea() -> Tea {
    ItalianTea()
  }
}

struct EnglishCafeFactory: CafeFactory {
  func makeCoffee() -> Coffee {
    Cappuccino()
  }

  func makeTea() -> Tea {
    EnglishTea()
  }
}

final class CafeOrder {
  private let factory: CafeFactory
  
  init(factory: CafeFactory) {
    self.factory = factory
  }
  
  func prepareCoffeeOrder() {
    let coffee = factory.makeCoffee()
    coffee.brew()
  }
  
  func prepareTeaOrder() {
    let tea = factory.makeTea()
    tea.steep()
  }
}

let italianOrder = CafeOrder(factory: ItalianCafeFactory())
italianOrder.prepareCoffeeOrder()
italianOrder.prepareTeaOrder()

let englishOrder = CafeOrder(factory: EnglishCafeFactory())
englishOrder.prepareCoffeeOrder()
englishOrder.prepareTeaOrder()

struct ProfileView: View {
  @State private var user: User?
  
  var body: some View {
    VStack {
      // Задача автоматически отменится при исчезновении View
      .task {
        user = await loadUserData()
      }
    }
  }
}

class DataLoader {
  private var loadingTask: Task<User, Error>?
  
  func loadUser() {
    loadingTask = Task {
      try await fetchUser()
    }
  }
  
  func cancelLoading() {
    loadingTask?.cancel()
  }
}

class NotificationService {
  private var listenerTask: Task<Void, Never>?
  
  func startListening() {
    listenerTask = Task {
      for await notification in await notificationStream() {
        process(notification)
      }
    }
  }
  
  func stopListening() {
    listenerTask?.cancel()
  }
}

func processLargeDataset() async throws {
  for item in dataset {
    try Task.checkCancellation() // Вызывает CancellationError
    // или
    if Task.isCancelled { return }
    
    await process(item)
  }
}

import EmbeddedHal

// Настройка пинов как в embedded-проектах
let ledPin = DigitalOutputPin(pin: 13)
let sensorPin = AnalogInputPin(pin: 0)

@main
struct DeviceController {
  static func main() async {
    while true {
      // Чтение данных с датчика
      let sensorValue = sensorPin.read()
      
      // Логика управления на основе показаний
      if sensorValue > threshold {
        ledPin.write(true)
        await Task.sleep(milliseconds: 500)
        ledPin.write(false)
      }
      
      await Task.sleep(seconds: 1)
    }
  }
}

// Прямая работа с разделами памяти
@section(".__DATA, .sensor_data")
@used
var sensorReadings: [Float] = []

// Упрощённая интеграция с C-кодом
@c(readSensorData)
func readSensorData() -> Float {
  // Взаимодействие с аппаратным датчиком
  return readFromHardware()
}

// Старый подход
NotificationCenter.default.addObserver(
  forName: UIApplication.didBecomeActiveNotification,
  object: nil,
  queue: .main,
  using: { [weak self] _ in
    self?.updateUI() // Warning: Call to main actor-isolated method
  }
)

// Новый подход
private var observationToken: NotificationCenter.ObservationToken?

// Подписываемся и сохраняем token
observationToken = NotificationCenter.default.addObserver(
  of: UIApplication.self,
  for: .didBecomeActive
) { [weak self] message in
  self?.updateUI() // Без предупреждений
}

// Отмена подписки
deinit {
  observationToken?.cancel()
}

struct DataSyncMessage: NotificationCenter.AsyncMessage {
  typealias Subject = SyncResult
  let result: Subject
}

// Отправка из любого контекста
let message = DataSyncMessage(result: syncResult)
NotificationCenter.default.post(message)

@Test(arguments: UserRole.allCases)
func testAccess(role: UserRole) {
  #expect(system.hasAccess(role) == true)
}

enum PaymentMethod: CaseIterable {
  case card, applePay, googlePay // Порядок имеет значение!
}

@Test(arguments: PaymentMethod.allCases)
func testPaymentProcessing(method: PaymentMethod) {
  // Тест зависит от порядка элементов в enum
}

@Test(arguments: ProductCategory.allCases)
func testPricing(category: ProductCategory) {
  if category == .premium {
    #expect(calculatePrice(category) >= 1000)
  } else {
    #expect(calculatePrice(category) < 1000)
  }
}