SKIE

https://skie.touchlab.co/
Admin
SKIE is a Swift-friendly API generator for Kotlin Multiplatform that bridges modern Kotlin language...
Tokens:42,683
Snippets:378
Trust Score:9.4
Update:6 hours ago
Show doc for...
Tokens:
Raw
### Declare Flow-returning function helloWorld

Source: https://skie.touchlab.co/features/combine

Example function returning a Flow<String> that emits three values with delays. Used to demonstrate converting a Flow to Combine.Publisher.

```kotlin
fun helloWorld(): Flow<String> {
    return flow {
        emit("Hello")
        delay(1.seconds)
        emit("World")
        delay(1.seconds)
        emit("!")
    }
}
```

--------------------------------

### Configure plugin repositories in settings.gradle.kts

Source: https://skie.touchlab.co/Installation

Example configuration for settings.gradle.kts to ensure SKIE plugin resolution. Adds google(), mavenCentral(), and gradlePluginPortal() to pluginManagement, and google() and mavenCentral() to dependencyResolutionManagement.

```kotlin
pluginManagement {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
    }
}
```

--------------------------------

### Declare suspending function helloWorld

Source: https://skie.touchlab.co/features/combine

Example suspending function that returns a String. Used to demonstrate converting a suspend function to Combine.Future.

```kotlin
suspend fun helloWorld(): String {
    return "Hello World!"
}
```

--------------------------------

### Use toPublisher() in Swift

Source: https://skie.touchlab.co/features/combine

Swift code showing how to use the toPublisher() function on a Flow. Note that the example doesn't store the cancellable, so it would immediately cancel and receiveValue wouldn't be called.

```swift
let publisher = helloWorld().toPublisher()
publisher.sink { value in
    // Value is a `String` type
    // Receives with a 1-second delay between them:
    // - "Hello"
    // - "World"
    // - "!"
}
```

--------------------------------

### Kotlin data class User with name and age

Source: https://skie.touchlab.co/features/default-arguments

Defines a simple data class with two properties. Used as the basis for the default arguments example.

```Kotlin
data class User(
    val name: String,
    val age: Int,
)
```

--------------------------------

### Observing SwiftUI view with initial values

Source: https://skie.touchlab.co/features/flows-in-swiftui

Use the `Observing` view to observe multiple flows, providing initial values for flows that need them. Here, `counter` gets an initial value via `withInitialValue(0)`, and `toggle` is a StateFlow. The content closure receives the latest values.

```swift
struct ExampleView: View {
    let viewModel = SharedViewModel()

    var body: some View {
        // Observing multiple flows with attached initial values, only requiring a single view closure for content.
        Observing(viewModel.counter.withInitialValue(0), viewModel.toggle) { counter, toggle in
            Text("Counter: \(counter), Toggle: \(toggle)")
        }
    }
}
```

--------------------------------

### Use Future initializer in Swift

Source: https://skie.touchlab.co/features/combine

Swift code showing how to use the new Future initializer with the suspending function. Note that the example doesn't store the cancellable, so it would immediately cancel and receiveValue wouldn't be called. Futures are hot and invoke the async immediately, and don't support cancellation.

```swift
let future = Future(async: helloWorld)
future.sink { error in
    // Handle an error throw by the function.
    // Note that this could also be `CancellationError`.
} receiveValue: { value in
    // Value is a `String` "Hello World!"
    print(value)
}
```

--------------------------------

### Kotlin suspend function in ChatRoom

Source: https://skie.touchlab.co/features

Defines a suspend function `send` in a Kotlin class. This is the Kotlin side of the interop example.

```kotlin
class ChatRoom {
    suspend fun send(message: String) {
        // Send a message
    }
}
```

--------------------------------

### Kotlin generic class with suspend function

Source: https://skie.touchlab.co/features/suspend

Defines a generic class `A<T>` with a suspend function `foo`. This is the example for the generic class limitation.

```kotlin
class A<T> {
    
    suspend fun foo(): Int = 0
}
```

--------------------------------

### Replace import with Foundation import

Source: https://skie.touchlab.co/known-issues/missing-foundation

Replace all occurrences of `import YourKotlinModuleName` with the two-line import block to explicitly import Foundation.

```text
import YourKotlinModuleName
import Foundation
```

--------------------------------

### Enable SwiftUI Observing Preview in build.gradle.kts

Source: https://skie.touchlab.co/features/flows-in-swiftui

Add this configuration to your `build.gradle.kts` to enable SKIE's preview support for observing Flows in SwiftUI. This enables both the `Observing` view and the `collect` view modifier.

```kotlin
skie {
    features {
        enableSwiftUIObservingPreview = true
    }
}
```

--------------------------------

### Kotlin open class with open suspend function

Source: https://skie.touchlab.co/features/suspend

Defines an open class `A` with an open suspend function `foo`. This is the example for the overriding limitation.

```kotlin
open class A {
    
    open suspend fun foo(): Int = 0
}
```

--------------------------------

### Generic class with suspend method

Source: https://skie.touchlab.co/changelog/0.5.0

Example of a generic Kotlin class with a suspend method, used to illustrate the new `skie` function syntax.

```kotlin
class A<T> {

    suspend fun foo(bar: Int): Int = bar 
}
```

--------------------------------

### Swift call with SKIE for function extension

Source: https://skie.touchlab.co/features/interface-extensions

Shows the SKIE-generated Swift syntax for calling the extension function foo directly on an instance of C.

```swift
C().foo(i: 1)
```

--------------------------------

### Enable Combine.Publisher support in build.gradle.kts

Source: https://skie.touchlab.co/features/combine

Add this configuration to your build.gradle.kts to enable the Combine.Publisher conversion. When enabled, each Flow bridged to Swift will contain a toPublisher() method.

```kotlin
skie {
    features {
        enableFlowCombineConvertorPreview = true
    }
}
```

--------------------------------

### Kotlin enum with suspend function

Source: https://skie.touchlab.co/changelog/0.5.0

Example of a Kotlin enum with a suspend function, used to illustrate the new suspend wrapper generation for original enums.

```kotlin
enum class E {
    E1;

    suspend fun foo(): Int = 0
}
```

--------------------------------

### Enable distributable framework with produceDistributableFramework()

Source: https://skie.touchlab.co/configuration/swift-compiler

Use this Gradle configuration to make the Kotlin framework distributable to other computers. It enables `enableSwiftLibraryEvolution`, `noClangModuleBreadcrumbsInStaticFrameworks`, and `enableRelativeSourcePathsInDebugSymbols`.

```kotlin
skie {
    build {
        produceDistributableFramework()
    }
}
```

--------------------------------

### Enable Swift library evolution in Gradle configuration

Source: https://skie.touchlab.co/changelog/0.7.0

Use this Gradle configuration to explicitly enable Swift library evolution for SKIE builds. This is necessary for projects that require it, as it is now disabled by default except for XCFrameworks.

```kotlin
skie {
    build {
        enableSwiftLibraryEvolution.set(true)
    }
}
```

--------------------------------

### EnumInterop.Enabled Gradle configuration

Source: https://skie.touchlab.co/configuration/enums

Configure the Enabled option in build.gradle.kts using EnumInterop.Enabled(true) or false.

```kotlin
import co.touchlab.skie.configuration.EnumInterop

skie {
    features {
        group {
            EnumInterop.Enabled(true) // or false
        }
    }
}
```

--------------------------------

### Kotlin interface extension property

Source: https://skie.touchlab.co/features/interface-extensions

Defines an extension property bar on interface I with a getter and setter. This is the base example for demonstrating SKIE's property extension support.

```kotlin
var I.bar: Int
    get() = 1
    set(value) {}
```

--------------------------------

### EnumInterop.LegacyCaseName Gradle configuration

Source: https://skie.touchlab.co/configuration/enums

Configure the LegacyCaseName option in build.gradle.kts using EnumInterop.LegacyCaseName(true) or false.

```kotlin
import co.touchlab.skie.configuration.EnumInterop

skie {
    features {
        group {
            EnumInterop.LegacyCaseName(true) // or false
        }
    }
}
```

--------------------------------

### Swift switch with SKIE

Source: https://skie.touchlab.co/features/sealed

Shows the simplified switch using onEnum(of:) with exhaustive cases and no default.

```swift
func updateStatus(status: Status) {
    switch onEnum(of: status) {
    case .loading:
        showLoading()
    case .error(let error):
        showError(message: error.message)
    case .success(let success):
        showResult(data: success.result)
    }
}
```

--------------------------------

### Kotlin SharedViewModel with Flow and MutableStateFlow

Source: https://skie.touchlab.co/features/flows-in-swiftui

A Kotlin view model with a `counter` Flow that emits an incrementing integer every second and a `toggle` MutableStateFlow. This is the model used in the SwiftUI examples on this page.

```kotlin
class SharedViewModel {
    
    val counter = flow<Int> {
        var counter = 0
        while (true) {
            emit(counter++)
            delay(1.seconds)
        }
    }

    val toggle = MutableStateFlow<Boolean>(false)
}
```

--------------------------------

### SwiftUI task modifier calling activate()

Source: https://skie.touchlab.co/features/flows

Starts the async loop in activate() with a .task modifier. The task is automatically canceled when the user leaves the screen, integrating with Swift's concurrency lifecycle.

```swift
VStack {
    // SwiftUI views ..
}
.task {
    await viewModel.activate()
}
```

--------------------------------

### Kotlin interface and extension function definition (File.kt)

Source: https://skie.touchlab.co/changelog/0.6.0

Defines an interface, a class implementing it, and an extension function on the interface. SKIE enables calling the extension directly on instances.

```kotlin
interface I

class C : I

fun I.interfaceExtension(i: Int): Int = i
```

--------------------------------

### Observing SwiftUI view with initial content closure

Source: https://skie.touchlab.co/features/flows-in-swiftui

Use the `Observing` view with an initial content closure to handle flows that may not have an initial value. Until `counter` produces a value, a `ProgressView` is shown, then replaced with the content closure.

```swift
struct ExampleView: View {
    let viewModel = SharedViewModel()

    var body: some View {
        // Observing multiple flows with a "initial content" view closure.
        Observing(viewModel.counter, viewModel.toggle) {
            ProgressView("Waiting for counters to flows to produce a first value")
        } content: { counter, toggle in
            Text("Counter: \(counter), Toggle: \(toggle)")
        }
    }
}
```

--------------------------------

### Disable FlowInterop for a specific package in build.gradle.kts

Source: https://skie.touchlab.co/configuration

Disables Flow interop only for declarations whose fully qualified name starts with `co.touchlab.skie.types`. The `group` argument matches a prefix of the fully qualified name.

```kotlin
import co.touchlab.skie.configuration.FlowInterop

skie {
    features {
        group("co.touchlab.skie.types") {
            FlowInterop.Enabled(false)
        }
    }
}
```

--------------------------------

### Kotlin example: lambda type as type argument in generic class

Source: https://skie.touchlab.co/known-issues/lambda-types-in-type-argument

This Kotlin code defines a generic class `A<T>` and an enum `E` with a function `foo()` that returns `A<() -> Unit>`. This triggers the SKIE generation issue.

```kotlin
class A<T>

enum class E {
    Q;

    fun foo(): A<() -> Unit> = A()
}
```

--------------------------------

### Swift property access with SKIE

Source: https://skie.touchlab.co/features/interface-extensions

Shows the SKIE-generated Swift syntax for accessing the extension property bar directly on an instance of C.

```swift
let c = C()

let getValue = c.bar

c.bar = 1
```

--------------------------------

### Swift signatures after SKIE renaming for value class overload

Source: https://skie.touchlab.co/features/overloaded-functions

Shows the resulting Swift signatures when SKIE renames the conflicting function. The first function keeps its name, the second gets an underscore suffix.

```swift
func foo(v: Int32)

func foo_(v: Int32)
```

--------------------------------

### Swift call to Kotlin global function without SKIE

Source: https://skie.touchlab.co/changelog/0.6.0

Shows the original Swift syntax for calling a Kotlin global function, requiring the file-class prefix 'FileKt'.

```swift
FileKt.globalFunction(i: 1)
```

--------------------------------

### collect view modifier with Binding and async closure

Source: https://skie.touchlab.co/features/flows-in-swiftui

Use the `collect` view modifier to collect a Flow into a `@State` property via a SwiftUI `Binding`, or through an async closure for extra processing. The example shows both approaches on the same view.

```swift
struct ExampleView: View {
    let viewModel = SharedViewModel()
    
    @State
    var boundCounter: KotlinInt = 0
    
    @State
    var manuallyUpdatedCounter: Int = 0

    var body: some View {
        // Collecting a flow into a SwiftUI @State property using a Binding, which requires the property to be of the same type.
        Text("Bound counter using Binding: \(boundCounter)")
            .collect(flow: viewModel.counter, into: $boundCounter)
        
        Text("Manually updated counter: \(manuallyUpdatedCounter)")
            .collect(flow: viewModel.counter) { latestValue in
                manuallyUpdatedCounter = latestValue.intValue
            }
    }
}
```

--------------------------------

### Kotlin copy method with default arguments

Source: https://skie.touchlab.co/features/default-arguments

Shows the equivalent of the generated copy method for the User data class, using default arguments for name and age. SKIE generates overloads so Swift can call doCopy() without providing all parameters.

```Kotlin
fun User.copy(name: String = this.name, age: Int = this.age) = User(name, age)
```

--------------------------------

### Kotlin StateFlow with List<String>

Source: https://skie.touchlab.co/features/flows

Defines a ChatRoom class exposing a StateFlow<List<String>>. This is the Kotlin side that SKIE converts to an AsyncSequence in Swift.

```kotlin
class ChatRoom {
    private val _messages = MutableStateFlow(emptyList<String>())
    val messages: StateFlow<List<String>> = _messages
    // etc
}
```

--------------------------------

### Override annotations with Gradle configuration using overridesAnnotations

Source: https://skie.touchlab.co/configuration

Sets `overridesAnnotations = true` for a group so that Gradle configuration takes precedence over annotations. In this example, Flow interop is disabled for the entire `co.touchlab.skie.types` package, even if declarations have the `@FlowInterop.Enabled` annotation.

```kotlin
import co.touchlab.skie.configuration.FlowInterop

skie {
    features {
        group("co.touchlab.skie.types", overridesAnnotations = true) {
            FlowInterop.Enabled(false)
        }
    }
}
```

--------------------------------

### Swift call to Kotlin interface extension with SKIE

Source: https://skie.touchlab.co/changelog/0.6.0

Shows the improved Swift syntax with SKIE, calling the interface extension directly on an instance.

```swift
C().interfaceExtension(i: 1)
```

--------------------------------

### Using @FlowInterop annotations to enable/disable Flow interop

Source: https://skie.touchlab.co/configuration

Use @FlowInterop.Enabled and @FlowInterop.Disabled to selectively override SKIE's default Flow interop behavior for individual functions. This example shows both annotations applied to functions returning Flow<Int>.

```kotlin
import co.touchlab.skie.configuration.annotations.FlowInterop

@FlowInterop.Enabled
fun enabledFlow(): Flow<Int> = flowOf(1)

@FlowInterop.Disabled
fun disabledFlow(): Flow<Int> = flowOf(1)
```

--------------------------------

### Swift call without SKIE for function extension

Source: https://skie.touchlab.co/features/interface-extensions

Shows the Objective-C style call to the extension function foo, using the global function FileKt.foo with the receiver as the first parameter.

```swift
FileKt.foo(C(), i: 1)
```

--------------------------------

### Kotlin global function definition (File.kt)

Source: https://skie.touchlab.co/changelog/0.6.0

Defines a global function in Kotlin. SKIE generates wrappers so it can be called from Swift without the file-class prefix.

```kotlin
fun globalFunction(i: Int): Int = i
```

--------------------------------

### Swift call to Kotlin global function with SKIE

Source: https://skie.touchlab.co/changelog/0.6.0

Shows the improved Swift syntax with SKIE, calling the global function directly without the file-class prefix.

```swift
globalFunction(i: 1)
```

--------------------------------

### build.gradle.kts configuration for CInterop framework name

Source: https://skie.touchlab.co/known-issues/cinterop

Kotlin DSL configuration in build.gradle.kts that sets the framework name for the group 'co.touchlab.crashkios.bugsnag' to 'Bugsnag'. This is required to use the generated declarations with custom cinterop types.

```kotlin
import co.touchlab.skie.configuration.ClassInterop

skie {
    features {
        group("co.touchlab.crashkios.bugsnag") {
            ClassInterop.CInteropFrameworkName("Bugsnag")
        }
    }
}
```

--------------------------------

### Swift call to Kotlin interface extension without SKIE

Source: https://skie.touchlab.co/changelog/0.6.0

Shows the original Swift syntax for calling a Kotlin interface extension, requiring the file-class prefix and explicit receiver.

```swift
FileKt.interfaceExtension(C(), i: 1)
```

--------------------------------

### Adding the SKIE configuration-annotations dependency to build.gradle.kts

Source: https://skie.touchlab.co/configuration

Add the configuration-annotations dependency to all modules where you want to use SKIE annotations. Typically added to the commonMain source set, but adjust based on your use case.

```kotlin
val commonMain by sourceSets.getting {
    dependencies {
        implementation("co.touchlab.skie:configuration-annotations:0.10.15")
    }
}
```

--------------------------------

### Swift property access without SKIE

Source: https://skie.touchlab.co/features/interface-extensions

Shows the Objective-C style access to the extension property bar using global getter and setter functions FileKt.bar and FileKt.setBar.

```swift
let c = C()

let getValue = FileKt.bar(c)

FileKt.setBar(c, value: 1)
```

--------------------------------

### Enable/Disable Default Arguments via Gradle

Source: https://skie.touchlab.co/configuration/default-arguments

Configure the default arguments feature globally using DefaultArgumentInterop.Enabled(true) or false in the build.gradle.kts file.

```kotlin
import co.touchlab.skie.configuration.DefaultArgumentInterop

skie {
    features {
        group {
            DefaultArgumentInterop.Enabled(true) // or false
        }
    }
}

```

--------------------------------

### FileScopeConversion Enabled/Disabled Annotation Configuration

Source: https://skie.touchlab.co/configuration/functions

Annotation configuration for FileScopeConversion. Use @FunctionInterop.FileScopeConversion.Enabled to enable and @FunctionInterop.FileScopeConversion.Disabled to disable. Default is true.

```kotlin
import co.touchlab.skie.configuration.annotations.FunctionInterop

@FunctionInterop.FileScopeConversion.Enabled
fun enabled() {
}

@FunctionInterop.FileScopeConversion.Disabled
fun disabled() {
}
```

--------------------------------

### Enable Combine.Future support in build.gradle.kts

Source: https://skie.touchlab.co/features/combine

Add this configuration to your build.gradle.kts to enable the Combine.Future extension. When enabled, SKIE extends Combine.Future with an initializer accepting any async lambda.

```kotlin
skie {
    features {
        enableFutureCombineExtensionPreview = true
    }
}
```

--------------------------------

### LegacyName Gradle Configuration

Source: https://skie.touchlab.co/configuration/functions

Gradle configuration for LegacyName. Use FunctionInterop.LegacyName(true) to enable or false to disable. Default is false.

```kotlin
import co.touchlab.skie.configuration.FunctionInterop

skie {
    features {
        group {
            FunctionInterop.LegacyName(true) // or false
        }
    }
}
```

--------------------------------

### FileScopeConversion Gradle Configuration

Source: https://skie.touchlab.co/configuration/functions

Gradle configuration for FileScopeConversion. Use FunctionInterop.FileScopeConversion.Enabled(true) to enable or false to disable. Default is true.

```kotlin
import co.touchlab.skie.configuration.FunctionInterop

skie {
    features {
        group {
            FunctionInterop.FileScopeConversion.Enabled(true) // or false
        }
    }
}
```

--------------------------------

### Swift switch without SKIE

Source: https://skie.touchlab.co/features/sealed

Shows the verbose switch syntax required without SKIE, including a default case with fatalError.

```swift
func updateStatus(status: Status) {
    switch status {
    case _ as Status.Loading:
        showLoading()
    case let error as Status.Error:
        showError(message: error.message)
    case let success as Status.Success:
        showResult(data: success.result)
    default:
        fatalError("Unknown status")
    }
}
```

--------------------------------

### Add SKIE Gradle plugin to build.gradle.kts

Source: https://skie.touchlab.co/Installation

Add the SKIE plugin with version 0.10.15 to the module that builds the Xcode Framework. The plugin is deployed to Maven Central; if not found, add mavenCentral() to plugin repositories.

```kotlin
plugins {
    id("co.touchlab.skie") version "0.10.15"
}
```

--------------------------------

### Swift generated by SKIE without framework name configuration

Source: https://skie.touchlab.co/known-issues/cinterop

Generated Swift function that is unavailable and uses a placeholder type when the framework name is not provided. The function cannot be called, but the original Kotlin declaration can still be used.

```swift
@available(*, unavailable, message: "Unknown Swift framework for type 'co.touchlab.crashkios.bugsnag.BugsnagConfiguration'. ...")
public func configureBugsnag(config: __SkieUnknownCInteropFrameworkErrorType) {
    fatalError("...")
}
```

--------------------------------

### Swift call with SKIE for default argument

Source: https://skie.touchlab.co/features

Swift call to 'sayHello()' with SKIE, which calls the Kotlin function with the default argument 'Hello'.

```swift
// calls sayHello(message: "Hello")

sayHello() 
```
Tokens:
Raw