Kotlin-Swift Interopedia

The Kotlin/Swift Interop Playground demonstrates how both simple types (Strings, primitives like Int, Boolean, Char) and custom types (such as data class) can be passed as arguments and returned from function calls across the language boundary.

When calling Kotlin functions from Swift, Kotlin top-level functions are typically accessed via a generated class named after the Kotlin file with a Kt suffix (e.g., TypesKt).

// Kotlin side
fun printInt(intType: Int): Int {
    println("Int type: $intType")
    return intType
}

fun printString(stringType: String): String {
    println("String type: $stringType")
    return stringType
}

data class CustomType(val name: String, val surname: String)

fun printCustomType(customType: CustomType): CustomType {
    println("Custom type: $customType")
    return customType
}

// Swift side
let intType = TypesKt.printInt(intType: 123)
let stringType = TypesKt.printString(stringType: "abc")
let customType = TypesKt.printCustomType(customType: CustomType(name: "Author name", surname: "Author surname"))

By default, Kotlin/Native does not generate a native Swift enum for Kotlin enum class definitions. Instead, it generates a Swift class containing static elements that represent the enum entries.

Because the generated type is a class and not a Swift enum, switch expressions in Swift are not exhaustive. You must always provide a default case when switching over a Kotlin enum instance to handle potential cases that the Swift compiler cannot verify.

Key capabilities available in Swift:

• Access enum elements via static properties (e.g., EnumClass.entryOne).
• Access properties defined in the Kotlin enum constructor.
• Access functions defined within the Kotlin companion object via the .companion property.
• Call the values() function to retrieve all entries.

// Kotlin definition
enum class EnumClass(val type: String) {
    ENTRY_ONE("entry_one"),
    ENTRY_TWO("entry_two");

    companion object {
        fun findByType(type: String) = values().find { it.type == type }
    }
}

// Swift usage
func useEnumClass() {
    let e1 = EnumClass.entryOne
    
    // Accessing properties
    let type = e1.type
    
    // Accessing companion object
    let found = EnumClass.companion.findByType(type: "entry_two")
    
    // Switching requires a default case
    switch e1 {
    case .entryOne: print("one")
    case .entryTwo: print("two")
    default: print("default")
    }
}

When using Kotlin sealed interfaces in a Swift environment via the Interopedia bridge, the sealed hierarchy is not preserved as a single unified type in Swift. Instead, the bridge generates separate, unrelated protocols for each implementation of the interface.

Key Behaviors:

• Kotlin Side: The sealed interface works as expected. In when expressions, the compiler provides autocompletion for all possible subtypes, ensuring exhaustive checks.
• Swift Side: The subtypes are generated as independent protocols that inherit from a base protocol but do not inherit from each other. Because they are seen as separate protocols, Swift's switch statements do not provide exhaustive pattern matching or autocompletion for all branches. You must use a default case in Swift switch expressions.
• Workaround: To achieve Swift-like exhaustive pattern matching, you should use Swift enums. You can write custom bridge code to convert the Kotlin sealed interface into a Swift enum.

// Kotlin: Exhaustive when expression
sealed interface SealedInterfaces {
    interface First : SealedInterfaces {
        fun firstFunctionExample(): String
    }
    interface Second : SealedInterfaces {
        fun secondFunctionExample(): String
    }
}

fun sealedInterfaceExample(sie: SealedInterfaces) {
    when (sie) {
        is SealedInterfaces.First -> sie.firstFunctionExample()
        is SealedInterfaces.Second -> sie.secondFunctionExample()
    }
}

// Swift: Non-exhaustive switch expression (requires default)
func switchOnSealedInterfaces(sealedInterfaces: SealedInterfaces) {
    switch(sealedInterfaces) {
    case is SealedInterfacesFirst: 
        print((sealedInterfaces as! any SealedInterfacesFirst as SealedInterfacesFirst).firstFunctionExample())
    case is SealedInterfacesSecond: 
        print((sealedInterfaces as! any SealedInterfacesSecond as SealedInterfacesSecond).secondFunctionExample())
    default: 
        print("default")
    }
}

When calling Kotlin suspend functions from Swift, the behavior depends on the interop method used:

1. Default Completion Handlers: By default, a Kotlin suspend function is translated into a Swift function that accepts a completion handler.
2. Experimental Async/Await: With Swift 5.5+, there is an experimental way to map suspend functions directly to Swift's async/await syntax.

Important Limitation: Neither the default completion handler nor the experimental async/await mapping provides native cancellation support. If a Swift Task is cancelled, the underlying Kotlin suspend function will continue to execute until it completes normally.

// Default Completion Handler pattern
ThingRepository().getThing(succeed: true, completionHandler: { thing, error in
    // do something
})

// Experimental Async/Await pattern
Task {
    do {
        let thing = try await ThingRepository().getThingSimple(succeed: true)
        print("Thing is \(thing).")
    } catch {
        print("Found error: \(error)")
    }
}

In Kotlin, you can define functions that accept a lambda with a receiver (e.g., UsualClassExample.() -> Unit). This allows the lambda body to access the receiver's members directly using this or implicit access.

When calling these functions from Swift via interop, the Kotlin extension function is transformed into a standard Swift closure where the first parameter is the receiver object. You must explicitly name this parameter (e.g., usualClassExample in) and use it to access the object's properties.

// Kotlin: Lambda with receiver allows implicit 'this'
fun funcWithExtension(extension: UsualClassExample.() -> Unit) {
    val someObject = UsualClassExample(/*...*/) 
    someObject.extension()
}

// Usage in Kotlin
funcWithExtension {
    this.param1 = "changed"
    println(param1)
}

// Swift: The receiver is passed as the first argument to the closure
FunctionWithExtensionKt.funcWithExtension(extension: { usualClassExample in
    usualClassExample.param1 = "changed"
    print("\(usualClassExample.param1)")
})