coding-kotlin

Purpose

This skill equips the AI to generate, debug, and optimize Kotlin code, focusing on coroutines for async operations, data classes for immutable data handling, sealed classes for type-safe hierarchies, extension functions for reusable code, Gradle for project builds, and KMM for multiplatform development.

When to Use

Use this skill for Android app development requiring async tasks (e.g., network calls), data modeling in APIs, or cross-platform projects with shared logic. Apply it when performance matters, like using coroutines to avoid blocking threads, or when setting up Gradle for dependency management in KMM setups.

Key Capabilities

• Coroutines: Handle asynchronous code with structured concurrency; use kotlinx.coroutines for non-blocking I/O.
• Data classes: Automatically generate equals, hashCode, and toString; define with data class User(val name: String, val id: Int).
• Sealed classes: Restrict class inheritance for exhaustive when expressions; e.g., sealed class Result { data class Success(val data: String) : Result() }.
• Extension functions: Add methods to existing classes without inheritance; e.g., fun String.reverse() = this.reversed().
• Gradle: Manage builds with scripts like build.gradle.kts for dependencies and tasks.
• KMM: Share code between Android/iOS; configure with shared modules in Gradle.

Usage Patterns

To accomplish tasks, always import necessary packages first (e.g., import kotlinx.coroutines.*). For async operations, wrap code in a coroutine scope like runBlocking { } and use launch for fire-and-forget or async for awaited results. When modeling data, use data classes for POJOs and sealed classes for state machines. For Gradle tasks, run commands from the project root and pass flags like --info for debugging. In KMM projects, structure code into shared and platform-specific modules, then link via Gradle configurations. Always check for nullability with ? to prevent crashes.

Common Commands/API

• Gradle commands: Run gradle build --stacktrace to compile and debug; use gradle assembleDebug for Android builds; in KMM, add dependencies in build.gradle.kts like implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4").
• Coroutines API: Use launch { delay(1000L); println("Task completed") } for delayed execution; or val deferred = async { someFunction() }; deferred.await() for concurrent tasks.
• Data classes: Define and use as data class Person(val name: String); val p = Person("John"); println(p.copy(name = "Jane")) to create copies with modifications.
• Sealed classes: Handle with when (result) { is Result.Success -> process(data); is Result.Error -> handleError() } for exhaustive checking.
• Extension functions: Implement as fun Int.isEven() = this % 2 == 0; val num = 4; println(num.isEven()) to extend built-ins.
• KMM setup: In build.gradle.kts, add kotlin { android { compilations.all { kotlinOptions.jvmTarget = "1.8" } } ios { binaries { framework() } } } for multiplatform configuration.
• API endpoints: For external services in Kotlin, use libraries like Ktor; e.g., HttpClient().get("https://api.example.com/data") with auth via env var like $KOTLIN_API_KEY in headers.

Integration Notes

Integrate this skill by ensuring the environment has Kotlin SDK installed (e.g., via SDKMAN: sdk install kotlin). For Android, add Kotlin plugins in build.gradle: plugins { id("org.jetbrains.kotlin.android") } and set minSdk to 21 for coroutines. In KMM projects, link shared modules with expect fun platformFunction() in common code and actual fun platformFunction() = ... in platform-specific files. Use environment variables for secrets, like setting $GRADLE_API_KEY for repository access in gradle.properties: apiKey=$GRADLE_API_KEY. Test integrations with ./gradlew test and handle platform differences by checking OS via System.getProperty("os.name").

Error Handling

Always use structured error handling in coroutines: wrap code in try { launch { riskyOperation() } } catch (e: CancellationException) { log("Coroutine cancelled") } finally { cleanup() }. For data classes, validate inputs at construction: e.g., data class User(val name: String) { init { require(name.isNotBlank()) { "Name cannot be blank" } } }. In sealed classes, ensure all subclasses are handled in when expressions to avoid UnreachableCode errors. For Gradle, parse output with --stacktrace and check for common issues like dependency conflicts by running gradle dependencies. In KMM, handle platform-specific errors with expect class PlatformException() { actual constructor() } and catch in common code.

Concrete Usage Examples

1. Example: Asynchronous network call with coroutines
   Import coroutines and launch a scope: import kotlinx.coroutines.*; suspend fun fetchData() = "Data"; fun main() = runBlocking { val result = async { fetchData() }.await(); println(result) }. This fetches data without blocking the main thread.

2. Example: Modeling API response with sealed classes and data classes
   Define structures: sealed class ApiResult { data class Success(val data: String) : ApiResult(); data class Error(val message: String) : ApiResult() }; fun process(result: ApiResult) = when (result) { is Success -> println(result.data); is Error -> println(result.message) }. Use this to handle responses safely in KMM shared code.

Graph Relationships

• Related to: coding-android (shares tags like "android" and focuses on Kotlin integration).
• Connected via: coding cluster (links to other coding skills like coding-java for JVM interoperability).
• Overlaps with: tools-kmm (via KMM multiplatform features) and build-gradle (for shared Gradle usage).