kotlin-patterns

name kotlin-patterns description Idiomatic Kotlin patterns, best practices, and conventions for building robust, efficient, and maintainable Kotlin applications with coroutines, null safety, and DSL builders. Use when writing or reviewing Kotlin code and idiomatic structure or null safety is in question. metadata {"origin":"ECC"} Kotlin Development Patterns Idiomatic Kotlin patterns and best practices for building robust, efficient, and maintainable applications. When to Use Writing new Kotlin code Reviewing Kotlin code Refactoring existing Kotlin code Designing Kotlin modules or libraries Configuring Gradle Kotlin DSL builds How It Works This skill enforces idiomatic Kotlin conventions across seven key areas: null safety using the type system and safe-call operators, immutability via val and copy() on data classes, sealed classes and interfaces for exhaustive type hierarchies, structured concurrency with coroutines and Flow , extension functions for adding behaviour without inheritance, type-safe DSL builders using @DslMarker and lambda receivers, and Gradle Kotlin DSL for build configuration. Examples Null safety with Elvis operator: fun getUserEmail (userId: String ) : String { val user = userRepository.findById(userId) return user?.email ?: "unknown@example.com" } Sealed class for exhaustive results: sealed class Result < out T > { data class Success < T >( val data : T) : Result<T>() data class Failure ( val error: AppError) : Result< Nothing >() data object Loading : Result< Nothing >() } Structured concurrency with async/await: suspend fun fetchUserWithPosts (userId: String ) : UserProfile = coroutineScope { val user = async { userService.getUser(userId) } val posts = async { postService.getUserPosts(userId) } UserProfile(user = user.await(), posts = posts.await()) } Core Principles 1. Null Safety Kotlin's type system distinguishes nullable and non-nullable types. Leverage it fully. // Good: Use non-nullable types by default fun getUser (id: String ) : User { return userRepository.findById(id) ?: throw UserNotFoundException( "User $id not found" ) } // Good: Safe calls and Elvis operator fun getUserEmail (userId: String ) : String { val user = userRepository.findById(userId) return user?.email ?: "unknown@example.com" } // Bad: Force-unwrapping nullable types fun getUserEmail (userId: String ) : String { val user = userRepository.findById(userId) return user!!.email // Throws NPE if null } 2. Immutability by Default Prefer val over var , immutable collections over mutable ones. // Good: Immutable data data class User ( val id: String, val name: String, val email: String, ) // Good: Transform with copy() fun updateEmail (user: User , newEmail: String ) : User = user.copy(email = newEmail) // Good: Immutable collections val users: List<User> = listOf(user1, user2) val filtered = users.filter { it.email.isNotBlank() } // Bad: Mutable state var currentUser: User? = null // Avoid mutable global state val mutableUsers = mutableListOf<User>() // Avoid unless truly needed 3. Expression Bodies and Single-Expression Functions Use expression bodies for concise, readable functions. // Good: Expression body fun isAdult (age: Int ) : Boolean = age >= 18 fun formatFullName (first: String , last: String ) : String = " $first $last " .trim() fun User. displayName () : String = name.ifBlank { email.substringBefore( '@' ) } // Good: When as expression fun statusMessage (code: Int ) : String = when (code) { 200 -> "OK" 404 -> "Not Found" 500 -> "Internal Server Error" else -> "Unknown status: $code " } // Bad: Unnecessary block body fun isAdult (age: Int ) : Boolean { return age >= 18 } 4. Data Classes for Value Objects Use data classes for types that primarily hold data. // Good: Data class with copy, equals, hashCode, toString data class CreateUserRequest ( val name: String, val email: String, val role: Role = Role.USER, ) // Good: Value class for type safety (zero overhead at runtime) @JvmInline value class UserId ( val value: String) { init { require(value.isNotBlank()) { "UserId cannot be blank" } } } @JvmInline value class Email ( val value: String) { init { require( '@' in value) { "Invalid email: $value " } } } fun getUser (id: UserId ) : User = userRepository.findById(id) Sealed Classes and Interfaces Modeling Restricted Hierarchies // Good: Sealed class for exhaustive when sealed class Result < out T > { data class Success < T >( val data : T) : Result<T>() data class Failure ( val error: AppError) : Result< Nothing >() data object Loading : Result< Nothing >() } fun <T> Result <T> . getOrNull () : T? = when ( this ) { is Result.Success -> data is Result.Failure -> null is Result.Loading -> null } fun <T> Result <T> . getOrThrow () : T = when ( this ) { is Result.Success -> data is Result.Failure -> throw error.toException() is Result.Loading -> throw IllegalStateException( "Still loading" ) } Sealed Interfaces for API Responses sealed interface ApiError { val message: String data class NotFound ( override val message: String) : ApiError data class Unauthorized ( override val message: String) : ApiError data class Validation ( override val message: String, val field: String, ) : ApiError data class Internal ( override val message: String, val cause: Throwable? = null , ) : ApiError } fun ApiError. toStatusCode () : Int = when ( this ) { is ApiError.NotFound -> 404 is ApiError.Unauthorized -> 401 is ApiError.Validation -> 422 is ApiError.Internal -> 500 } Scope Functions When to Use Each // let: Transform nullable or scoped result val length: Int ? = name?.let { it.trim().length } // apply: Configure an object (returns the object) val user = User().apply { name = "Alice" email = "alice@example.com" } // also: Side effects (returns the object) val user = createUser(request).also { logger.info( "Created user: ${it.id} " ) } // run: Execute a block with receiver (returns result) val result = connection.run { prepareStatement(sql) executeQuery() } // with: Non-extension form of run val csv = with(StringBuilder()) { appendLine( "name,email" ) users.forEach { appendLine( " ${it.name} , ${it.email} " ) } toString() } Anti-Patterns // Bad: Nesting scope functions user?.let { u -> u.address?.let { addr -> addr.city?.let { city -> println(city) // Hard to read } } } // Good: Chain safe calls instead val city = user?.address?.city city?.let { println(it) } Extension Functions Adding Functionality Without Inheritance // Good: Domain-specific extensions fun String. toSlug () : String = lowercase() .replace(Regex( "[^a-z0-9\\s-]" ), "" ) .replace(Regex( "\\s+" ), "-" ) .trim( '-' ) fun Instant. toLocalDate (zone: ZoneId = ZoneId.systemDefault() ): LocalDate = atZone(zone).toLocalDate() // Good: Collection extensions fun <T> List <T> . second () : T = this [ 1 ] fun <T> List <T> . secondOrNull () : T? = getOrNull( 1 ) // Good: Scoped extensions (not polluting global namespace) class UserService { private fun User. isActive () : Boolean = status == Status.ACTIVE && lastLogin.isAfter(Instant.now().minus( 30 , ChronoUnit.DAYS)) fun getActiveUsers () : List<User> = userRepository.findAll().filter { it.isActive() } } Coroutines Structured Concurrency // Good: Structured concurrency with coroutineScope suspend fun fetchUserWithPosts (userId: String ) : UserProfile = coroutineScope { val userDeferred = async { userService.getUser(userId) } val postsDeferred = async { postService.getUserPosts(userId) } UserProfile( user = userDeferred.await(), posts = postsDeferred.await(), ) } // Good: supervisorScope when children can fail independently suspend fun fetchDashboard (userId: String ) : Dashboard = supervisorScope { val user = async { userService.getUser(userId) } val notifications = async { notificationService.getRecent(userId) } val recommendations = async { recommendationService.getFor(userId) } Dashboard( user = user.await(), notifications = try { notifications.await() } catch (e: CancellationException) { throw e } catch (e: Exception) { emptyList() }, recommendations = try { recommendations.await() } catch (e: CancellationException) { throw e } catch (e: Exception) { emptyList() }, ) } Flow for Reactive Streams // Good: Cold flow with proper error handling fun observeUsers () : Flow<List<User>> = flow { while (currentCoroutineContext().isActive) { val users = userRepository.findAll() emit(users) delay( 5. seconds) } }. catch { e -> logger.error( "Error observing users" , e) emit(emptyList()) } // Good: Flow operators fun searchUsers (query: Flow < String >) : Flow<List<User>> = query .debounce( 300. milliseconds) .distinctUntilChanged() .filter { it.length >= 2 } .mapLatest { q -> userRepository.search(q) } . catch { emit(emptyList()) } Cancellation and Cleanup // Good: Respect cancellation suspend fun processItems (items: List < Item >) { items.forEach { item -> ensureActive() // Check cancellation before expensive work processItem(item) } } // Good: Cleanup with try/finally suspend fun acquireAndProcess () { val resource = acquireResource() try { resource.process() } finally { withContext(NonCancellable) { resource.release() // Always release, even on cancellation } } } Delegation Property Delegation // Lazy initialization val expensiveData: List<User> by lazy { userRepository.findAll() } // Observable property var name: String by Delegates.observable( "initial" ) { _, old, new -> logger.info( "Name changed from ' $old ' to ' $new '" ) } // Map-backed properties class Config ( private val map: Map<String, Any?>) { val host: String by map val port: Int by map val debug: Boolean by map } val config = Config(mapOf( "host" to "localhost" , "port" to 8080 , "debug" to true )) Interface Delegation // Good: Delegate interface implementation class LoggingUserRepository ( private val delegate: UserRepository, private val logger: Logger, ) : UserRepository by delegate { // Only override what you need to add logging to override suspend fun findById (id: String ) : User? { logger.info( "Finding user by id: $id " ) return delegate.findById(id).also { logger.info( "Found user: ${it?.name ?: "null" } " ) } } } DSL Builders Type-Safe Builders // Good: DSL with @DslMarker @DslMarker annotation class HtmlDsl @HtmlDsl class HTML { private val children = mutableListOf<Element>() fun head ( init : Head .() -> Unit ) { children += Head().apply( init ) } fun body ( init : Body .() -> Unit ) { children += Body().apply( init ) } override fun toString () : String = children.joinToString( "\n" ) } fun html ( init : HTML .() -> Unit ) : HTML = HTML().apply( init ) // Usage val page = html { head { title( "My Page" ) } body { h1( "Welcome" ) p( "Hello, World!" ) } } Configuration DSL data class ServerConfig ( val host: String = "0.0.0.0" , val port: Int = 8080 , val ssl: SslConfig? = null , val database: DatabaseConfig? = null , ) data class SslConfig ( val certPath: String, val keyPath: String) data class DatabaseConfig ( val url: String, val maxPoolSize: Int = 10 ) class ServerConfigBuilder { var host: String = "0.0.0.0" var port: Int = 8080 private var ssl: SslConfig? = null private var database: DatabaseConfig? = null fun ssl (certPath: String , keyPath: String ) { ssl = SslConfig(certPath, keyPath) } fun database (url: String , maxPoolSize: Int = 10 ) { database = DatabaseConfig(url, maxPoolSize) }