Взаимодействие со Swift с помощью Swift export

Классы

Swift export поддерживает только final-классы, напрямую наследующие Any, например class Foo(). Они преобразуются в классы Swift, наследующие специальный класс KotlinBase:

// Kotlin
class MyClass {
    val property: Int = 0

    fun method() {}
}

// Swift
public class MyClass : KotlinRuntime.KotlinBase {
    public var property: Swift.Int32 {
        get {
            // ...
        }
    }
    public override init() {
        // ...
    }
    public func method() -> Swift.Void {
        // ...
    }
}

Объекты

Объекты преобразуются в классы Swift с приватным init и статическим аксессором shared:

// Kotlin
object O

// Swift
public class O : KotlinRuntime.KotlinBase {
    public static var shared: O {
        get {
            // ...
        }
    }
    private override init() {
        // ...
    }
}

Псевдонимы типов

Псевдонимы типов Kotlin экспортируются без изменений:

// Kotlin
typealias MyInt = Int

// Swift
public typealias MyInt = Swift.Int32

Перечисления

Объявления enum class в Kotlin экспортируются как обычные нативные типы enum в Swift:

// Kotlin
enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF)
}

val color = Color.RED

// Swift
public enum Color: Swift.CaseIterable, Swift.LosslessStringConvertible, Swift.RawRepresentable {
    case RED, GREEN, BLUE

    public var rgb: Swift.Int32 { get }
}

Запечатанные классы и интерфейсы

Иерархии, объявленные в Kotlin как запечатанные, сопоставляются с перечислениями Swift, что позволяет использовать исчерпывающие инструкции switch.

Swift export создает метод .sealedType() для каждого запечатанного типа. Этот метод возвращает перечисление Swift, варианты которого соответствуют непосредственным подклассам запечатанной иерархии. Чтобы сопоставить более глубокие уровни иерархии, можно вкладывать эти вызовы друг в друга.

Например, объявите в Kotlin запечатанный интерфейс с иерархией классов:

// Kotlin
sealed interface Shape

class Circle : Shape {
    override fun toString(): String = "Circle"
}

class Rectangle : Shape {
    override fun toString(): String = "Rectangle"
}

fun createCircle(): Shape = Circle()

На стороне Swift можно использовать исчерпывающую инструкцию switch без варианта default:

// Swift
let shape = createCircle()

let name = switch shape.sealedType() {
    case let .circle(type): "It's a \(type.value)"
    case let .rectangle(type): "It's a \(type.value)"
}
// name == "It's a Circle"

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

Функции

Swift export поддерживает простые функции верхнего уровня и методы:

// Kotlin
fun foo(a: Short, b: Bar) {}

fun baz(): Long = 0

// Swift
public func foo(a: Swift.Int16, b: Bar) -> Swift.Void {
    // ...
}

public func baz() -> Swift.Int64 {
    // ...
}

Для функций-расширений Kotlin параметр-получатель становится обычным параметром Swift, расположенным первым:

// Kotlin
fun Int.foo(): Unit = TODO()

// Swift
func foo(_ receiver: Int32) {}

Функции Kotlin с vararg сопоставляются с функциями Swift, принимающими переменное число аргументов:

// Kotlin
fun log(vararg messages: String)

// Swift
public func log(messages: Swift.String...)

Свойства

Свойства Kotlin преобразуются в свойства Swift:

// Kotlin
val a: Int = 0

var b: Short = 15

const val c: Int = 0

// Swift
public var a: Swift.Int32 {
    get {
        // ...
    }
}
public var b: Swift.Int16 {
    get {
        // ...
    }
    set {
        // ...
    }
}
public var c: Swift.Int32 {
    get {
        // ...
    }
}

Конструкторы

Конструкторы преобразуются в инициализаторы Swift:

// Kotlin
class Foo(val prop: Int)

// Swift
public class Foo : KotlinRuntime.KotlinBase {
    public init(
        prop: Swift.Int32
    ) {
        // ...
    }
}

kotlin.Nothing

Тип Nothing в Kotlin преобразуется в тип Never:

// Kotlin
fun foo(): Nothing = TODO()

fun baz(input: Nothing) {}

// Swift
public func foo() -> Swift.Never {
    // ...
}

public func baz(input: Swift.Never) -> Void {
    // ...
}

Типы-классификаторы

В настоящее время Swift export поддерживает только final-классы, напрямую наследующие Any.

Приостанавливающиеся функции

Вы можете вызывать код Kotlin с приостанавливающимися функциями из Swift. Приостанавливающиеся функции Kotlin и функциональные типы с приостанавливающимися функциями экспортируются как соответствующие типы async в Swift:

// Kotlin
suspend fun hello(): String {
    delay(1000)
    return "Hello Swift! This is Kotlin."
}

// Swift
let msg = try await hello()

Потоки

Также можно экспортировать потоки kotlinx.coroutines как тип AsyncSequence в Swift:

// Kotlin
// Preserves the String type when exporting Flow
fun flowOfStrings(): Flow<String> = flowOf("hello", "any", "world")

// Swift
var actual: [String] = []

// Infers the String type from Kotlin
for try await element in flowOfStrings().asAsyncSequence() {
    actual.append(element)
}

Диспетчеры корутин

По умолчанию при вызове приостанавливающейся функции Kotlin из Swift или использовании функции asAsyncSequence Kotlin создает контекст корутины с диспетчером Dispatchers.Default и выполняет экспортированный код в этом контексте.

Чтобы выполнять экспортированный код с помощью другого диспетчера, используйте функцию withContext(), чтобы переключить контекст корутины в Kotlin. Например:

suspend fun runOnMain(): Int = withContext(Dispatchers.Main) {
    delay(10L)
    42
}