coding kotlin
- Repo stars 39
- Author repo awesome-omni-skill
- Domain
- Other
- Author-declared agents
- No explicit declaration found; this is not inferred or tested compatibility
- Static check
- 94 / 100 · heuristic scan, not runtime safety proof
- Runtime evidence
- Not run; no isolated runtime test evidence is currently recorded
- Author / version / license
- @diegosouzapw · no license declared
- Token usage
- Lean
- Setup complexity
- Guided setup
- External API key
- Required · Vendor-specific
- Operating systems
- Unspecified (assume cross-platform)
- Runtime requirements
- No explicit requirements detected
- Detected file/system behavior
-
- Read-only
- Write / modify
- Shell exec
- Env read
- Network behavior
- External requests
- Install commands
- None (reference only)
# Concrete Usage Examples
1. **Example: Asynchronous network call with coroutines**
2. **Example: Modeling API response with sealed classes and data classes**
# 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).
Sections and files
Listed in source order.
sections -> Purpose → When to Use → Key Capabilities → Usage Patterns → Common Commands/API → Integration Notes
terms -> Example: Asynchronous network call with coroutines · Example: Modeling API response with sealed classes and data classes
files/cmd -> kotlinx.coroutines · data class User(val name: String, val id: Int) · sealed class Result { data class Success(val data: String) : Result() } · fun String.reverse() = this.reversed() · import kotlinx.coroutines.* · runBlocking { } · launch · async
body sha256 -> a453a54eaf16
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.coroutinesfor non-blocking I/O. Data classes: Automatically generate equals, hashCode, and toString; define withdata 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() }.Usage Patterns
To accomplish tasks, always import necessary packages first (e.g.,
import kotlinx.coroutines.*). For async operations, wrap code in a coroutine scope likerunBlocking { }and uselaunchfor fire-and-forget orasyncfor 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--infofor 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 --stacktraceto compile and debug; usegradle assembleDebugfor Android builds; in KMM, add dependencies in build.gradle.kts likeimplementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4"). Coroutines API: Uselaunch { delay(1000L); println("Task completed") }for delayed execution; orval deferred = async { someFunction() }; deferred.await()for concurrent tasks.