Что нового в Swift 6?

Swift 6 — это важное обновление языка программирования Swift, разработанного Apple. Данная версия включает множество нововведений и улучшений, особенно в области параллелизма. В этом документе мы рассмотрим основные изменения и их влияние на разработчиков, опираясь на официальную документацию Apple.

Пожалуйста, обратите внимание, что все упомянутые изменения являются актуальными на момент выхода Swift 6, и в будущем могут появиться новые обновления и дополнения. Рассмотрим основные нововведения Swift 6, начиная с изменений в доменах изоляции и параллелизма.

Полный параллелизм включен по умолчанию

Swift 6 включает в себя множество обновлений, касающихся параллелизма, и команда разработчиков может гордиться своими достижениями. Самое значительное изменение заключается в том, что полная проверка параллельности теперь включена по умолчанию. Это изменение может потребовать некоторых корректировок в вашем коде, что неудивительно, так как в предыдущих версиях эта функция была опциональной, чтобы дать разработчикам время адаптироваться к изменениям.

Swift 6 улучшает проверку параллелизма, устраняя множество ложных предупреждений о гонках данных, которые присутствовали в версии 5.10. Внесены также ряд целевых изменений, которые делают параллелизм легче для освоения.

Одним из крупнейших нововведений является SE-0414, который вводит домены изоляции, позволяющие компилятору убедительно доказать, что различные части вашего кода могут выполняться параллельно.

В основе этого изменения лежит существующая концепция отправляемости (sendability). Тип Sendable — это такой тип, который можно безопасно передавать в параллельной среде. Это могут быть типы значений, такие как структуры, финальные классы с константными свойствами, акторы, которые автоматически защищают свое изменяемое состояние, и многое другое.

Ранее компилятор Swift был очень строг: если у вас было значение, не поддающееся отправке (non-sendable), и вы пытались передать его другому актору, вы получали предупреждение о проверке параллельности. Например, хотя тела представлений SwiftUI выполняются на основном акторе, сами представления SwiftUI этого не делают, что может легко вызвать ложные предупреждения компилятора.

Рассмотрим следующий код:

class User {     var name = "Anonymous" }      struct ContentView: View {     var body: some View {         Text("Hello, world!")             .task {                 let user = User()                 await loadData(for: user)             }     }          func loadData(for user: User) async {         print("Loading data for \(user.name)…")     } } 

До Swift 6 вызов функции loadData() вызвал бы предупреждение: «передача аргумента типа ‘User’ за пределы изолированного контекста основного актора может вызвать гонки данных.»

В Swift 6 это предупреждение исчезает: Swift теперь определяет, что код не представляет проблемы, так как user не используется одновременно из нескольких мест, и не выдаст предупреждение. Компилятор анализирует поток программы и определяет, что это безопасно.

Это изменение означает, что объекты, пригодные для отправки, теперь либо соответствуют протоколу Sendable, либо не нуждаются в этом, потому что компилятор может доказать, что они используются безопасно — это значительное улучшение параллелизма для разработчиков, возможно благодаря передовым разработкам компилятора.

Также внесены множество других, более мелких улучшений, включая:

• SE-430 добавляет новое ключевое слово sending, когда нужно отправить значения между доменами изоляции.

• SE-0423 улучшает поддержку параллельности при работе с фреймворками Objective-C.

• SE-0420 позволяет создавать асинхронные функции, изолированные тем же актором, что и их вызывающий код.

Устаревшие функции

Некоторые изменения были доступны в предыдущих версиях Swift, но скрыты за флажками функций. Например, SE-0401 удаляет функцию, введенную в Swift 5.5: вывод акторов для оберток свойств.

Ранее любой структурный или классовый тип, использующий обертку свойства с @MainActor для его обернутого значения, автоматически становился @MainActor. Это позволило @StateObject и @ObservedObject передавать «main-actor-ness» на представления SwiftUI, которые их используют.

@MainActor class ViewModel: ObservableObject {     func authenticate() {         print("Authenticating…")     } }  @MainActor struct LogInView: View {     @StateObject private var model = ViewModel()          var body: some View {         Button("Hello, world", action: startAuthentication)     }          func startAuthentication() {         model.authenticate()     } } 

Ранее @MainActor присваивался бы всему представлению из-за его свойства @StateObject.

Строгий параллелизм для глобальных переменных

Еще одно старое изменение, теперь включенное в Swift 6, — SE-0412, требующее, чтобы глобальные переменные были безопасны в параллельных средах. Это касается как глобальных переменных в проекте, так и статических переменных в типах.

Примеры:

var gigawatts = 1.21  struct House {     static var motto = "Winter is coming" } 

Эти данные могут быть доступны в любое время, что делает их небезопасными. Чтобы решить эту проблему, нужно либо преобразовать переменную в sendable-константу, либо ограничить ее глобальным актором, например, @MainActor, либо, если нет других вариантов, пометить её как nonisolated.

struct XWing {     @MainActor     static var sFoilsAttackPosition = true }      struct WarpDrive {     static let maximumSpeed = 9.975 }      @MainActor var idNumber = 24601  // Не рекомендуется, если вы не уверены, что это безопасно nonisolated(unsafe) var britishCandy = ["Kit Kat", "Mars Bar", "Skittles", "Starburst", "Twix"] 

Изменения в значениях по умолчанию для функций

Другое изменение, которое теперь включено, — SE-0411, которое изменяет значения по умолчанию для функций так, чтобы они имели ту же изоляцию, что и сама функция.

@MainActor class Logger {}  @MainActor  class DataController {     init(logger: Logger = Logger()) {} } 

Поскольку и DataController, и Logger ограничены основным актором, Swift теперь считает создание Logger() также ограниченным основным актором, что имеет смысл.

Новый метод count(where:)

SE-0220 ввел новый метод count(where:), который выполняет эквивалент filter() и count в одном проходе. Это экономит создание нового массива, который сразу же отбрасывается, и предоставляет ясное и лаконичное решение распространенной проблемы.

Пример:

let scores = [100, 80, 85] let passCount = scores.count { $0 >= 85 }

Этот метод доступен для всех типов, которые соответствуют Sequence, так что вы можете использовать его для множеств и словарей.

Типизированные выбросы ошибок (Typed Throws)

SE-0413 ввел возможность указать, какие именно типы ошибок может выбросить функция, известную как «typed throws». Это решает неудобство с ошибками в Swift: раньше требовалось общее выражение catch, даже если вы специально обрабатывали все возможные ошибки.

Пример:

enum CopierError: Error {     case outOfPaper }  struct Photocopier {     var pagesRemaining: Int          mutating func copy(count: Int) throws(CopierError) {         guard count <= pagesRemaining else {             throw CopierError.outOfPaper         }              pagesRemaining -= count     } }  do {     var copier = Photocopier(pagesRemaining: 100)     try copier.copy(count: 10) } catch CopierError.outOfPaper {     print("Please refill the paper") } 

Итерация пакета (Pack Iteration)

SE-0408 вводит итерацию по пакетам, что добавляет возможность обхода параметров пакета, введенных в Swift 5.9. Это позволяет, например, сравнивать кортежи любой арности всего в нескольких строках кода:

func == <each Element: Equatable>(lhs: (repeat each Element), rhs: (repeat each Element)) -> Bool {     for (left, right) in repeat (each lhs, each rhs) {         guard left == right else { return false }     }     return true } 

Операции с элементами коллекций

SE-0270 вводит различные новые методы для работы с коллекциями, такие как перемещение или удаление нескольких элементов, которые не являются смежными. Это изменение поддерживается новым типом RangeSet.

Пример:

struct ExamResult {     var student: String     var score: Int }      let results = [     ExamResult(student: "Eric Effiong", score: 95),     ExamResult(student: "Maeve Wiley", score: 70),     ExamResult(student: "Otis Milburn", score: 100) ]  let topResults = results.indices { student in     student.score >= 85 }  for result in results[topResults] {     print("\(result.student) scored \(result.score)%") } 

Модификаторы уровня доступа для объявлений импорта

SE-0409 добавляет возможность отмечать объявления импорта модификаторами уровня доступа, такими как private import SomeLibrary. Это помогает разработчикам библиотек избегать случайного утечки собственных зависимостей.

Пример:

// Внутренняя библиотека public struct BankTransaction {     // код здесь }  // Основная библиотека public func sendMoney(from: Int, to: Int) -> BankTransaction {     // обработка перевода денег     return BankTransaction() }  // Основное приложение import BankingLibrary sendMoney(from: 123, to: 456) 

С Swift 6 можно использовать internal import Transactions в основной библиотеке, чтобы ограничить видимость.

Улучшения для noncopyable типов

Несколько улучшений для noncopyable типов, введенных в Swift 5.9. Noncopyable типы позволяют создавать типы с уникальным владением, которые можно передавать, используя заимствование или потребление.

Пример:

struct Message: ~Copyable {     var agent: String     private var message: String          init(agent: String, message: String) {         self.agent = agent         self.message = message     }          consuming func read() {         print("\(agent): \(message)")     } }      func createMessage() {     let message = Message(agent: "Ethan Hunt", message: "You need to abseil down a skyscraper for some reason.")     message.read() }      createMessage() 

В Swift 6, все структуры, классы, перечисления, параметры обобщений и протоколы автоматически соответствуют новому протоколу Copyable, если явно не отказаться от него, используя ~Copyable.

Типы 128-битных целых чисел

SE-0425 вводит Int128 и UInt128. Эти типы работают так же, как и другие целочисленные типы в Swift.

Пример:

let enoughForAnybody: Int128 = 170_141_183_460_469_231_731_687_303_715_884_105_727

Протокол BitwiseCopyable

SE-0426 вводит новый протокол BitwiseCopyable, который позволяет компилятору создавать более оптимизированный код для соответствующих типов.

Пример:

@frozen public enum CommandLine: ~BitwiseCopyable { } 

Эти улучшения помогают делать noncopyable типы более естественными в использовании и повышают производительность кода.

Swift 6 приносит значительные улучшения, особенно в доменах параллелизма, делая ее более доступной и понятной для разработчиков. Новые возможности, такие как полная проверка параллелизма по умолчанию, домены изоляции и усовершенствованное понятие sendability, упрощают написание безопасного и эффективного кода. Большая часть изменений направлена на адаптацию разработчиков к новым требованиям и использованию мощных функций языка Swift для создания высокопроизводительных приложений. 

Полагаю что это только начало, начало огромного будущего нами всеми любимого языка.