suspend fun createFoo(foo: Foo) {
    // Create record in DB and then perform additional tasks within scoped functions
    dbService.saveFoo(foo)
        .also {
            // Cache invalidation
            cacheService.invalidateCacheForFoo(foo.id)
        }
        .also {
            // Update search engine
            searchEngineService.addFooToSearch(foo)
        }
}

interface Foo {
    val xyz: String
}

class Bar : Foo {
    
    override val xyz: String
    
    init {
        xyz = compXyz("XYZ")
    }
    
    fun compXyz(key: String) = key.reversed()
}

fun main() {
    val s = Bar()
    println(s.xyz)
}

Property must be initialized, be final, or be abstract. This warning will become an error in future releases.

kson

val TOTAL_TRIES = 3
            val triedPorts = ArrayList<Int>(TOTAL_TRIES)
            while (true) {
                val realPort = port ?: findFreePort()
                triedPorts.add(realPort)
                val undertow: Undertow = buildUndertow(rootHandlers, defaultHandler, realPort, host)
                try {
                    undertow.start()
                } catch (e: RuntimeException) {
                    // it seems that undertow sometimes wraps the bind exception in a runtime exception
                    if (e.cause is BindException) {
                        if (port != null)
                            throw RestaurantException("could not start server on port $port")
                        if (triedPorts.size == TOTAL_TRIES)
                            throw RestaurantException("could not start restaurant after trying $TOTAL_TRIES times." +
                                    " ports tried: $triedPorts")
                        continue
                    }
                } catch (e: BindException) {
                    // if no port was specified, we retry
                    if (port != null)
                        throw RestaurantException("could not start server on port $port")
                    if (triedPorts.size == TOTAL_TRIES)
                        throw RestaurantException("could not start restaurant after trying $TOTAL_TRIES times." +
                                " ports tried: $triedPorts")
                    continue
                }

List<T:Any?>

T:Any?

inline fun <reified T : Any> Statement.helperList(param: Collection<T>?, stmt: (Param<*>) -> Statement) = TODO("thing that has to know T")
inline fun <reified T : Any> Statement.helper(param: T?, stmt: (Params<*>) -> Statement) = TODO("Same thing but handled a differnt way since its not a collection"

helper

Any

// version 1
println(comment.body)
println()

// version 2
println("${comment.body}\n")

// version 3
println(comment.body + "\n")

isLoading

@Test
    fun `loadMovies updates uiState.isLoading`() = runTest {
        coEvery { repository.getMovies(MovieCategory.DEFAULT) } coAnswers {
            delay(600)
            Resource.Success(emptyList())
        }

        assertFalse(viewModel.uiState.value.isLoading)

        viewModel.loadMovies(MovieCategory.DEFAULT)

        advanceTimeBy(200)

        assertTrue(viewModel.uiState.value.isLoading)

        advanceUntilIdle()
        assertFalse(viewModel.uiState.value.isLoading)

        coVerify { repository.getMovies(MovieCategory.DEFAULT) }
    }

class MyCustomException(val trace: List<StackTraceElement>): Exception(){
    init {
        stackTrace = trace.toTypedArray()
    }

    override fun fillInStackTrace() = this //interrupt call to dump back-trace into stack-trace
}

sleepsort

import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll

suspend fun main() {
    println(sleepsort(listOf(63, 32, 62, 14, 5)))
}

suspend fun sleepsort(list: List<Int>): List<Int> = coroutineScope {
    buildList {
        list.map { number ->
            async {
                delay(number.toLong())
                add(number)
            }
        }.awaitAll()
    }
}

import com.stochastictinkr.json.*

fun main() {
    val obj = jsonObject {
        "name"("John Doe")
        "age"(25)
        "address" {
            "number"(123)
            "street"("Main Street")
            "city"("Anytown")
            "state"("AS")
            "zip"(12345)
        }
        "phoneNumbers"[{
            add("555-1234")
            add("555-5678")
        }]
        "favoriteColor"(null)
        "averageScore"(85.5)
    }
    println(JsonWriter.Pretty.writeToString(obj))
}

{
  "name": "John Doe",
  "age": 25,
  "address": {
    "number": 123,
    "street": "Main Street",
    "city": "Anytown",
    "state": "AS",
    "zip": 12345
  },
  "phoneNumbers": [
    "555-1234",
    "555-5678"
  ],
  "favoriteColor": null,
  "averageScore": 85.5
}

.let

null

?.let

interface Alphabet {
    fun a(): String
    fun b(): String
    // and many more
    fun z(): String
}

class A : Alphabet by TODO("NOPE") {
    override fun a() = "a"
}

TODO()

// Hoping for
A().a() == "a" // true
A().b() // NotImplementedError

// but got 
A() // NotImplementedError

StateFlow

StateFlow

CoroutineScope

private class MappedStateFlow<T, R>(
    private val original: StateFlow<T>,
    private val transform: (T) -> R
) : StateFlow<R> {
    override val replayCache: List<R>
        get() = original.replayCache.map(transform)

    override val value: R
        get() = transform(original.value)

    override suspend fun collect(collector: FlowCollector<R>): Nothing {
        original.collect { collector.emit(transform(it)) }
    }
}

fun <T, R> StateFlow<T>.mapState(transform: (T) -> R): StateFlow<R> {
    return MappedStateFlow(this, transform)
}

customKeyListener?.onCustomKeyPressed()

customKeyListener::onCustomKeyPressed

enum class ToggleValue {
    YES,
    NO,
    UNKNOWN
}

val ToggleValue.asBoolean: Boolean? // this one
    get() = when (this) {
        ToggleValue.YES -> true
        ToggleValue.NO -> false
        ToggleValue.UNKNOWN -> null
    }

val Boolean?.asToggleValue: ToggleValue
    get() = when (this) {
        true -> ToggleValue.YES
        false -> ToggleValue.NO
        null -> ToggleValue.UNKNOWN
    }

Density

fun TextUnit.scale(scale: Float, density: Density): TextUnit {
    if (this.isUnspecified) return this
    return with(density) {
        (scale * this@scale.toPx()).toSp()
    }
}

val artifactName: Property<String> = project.objects.property(String::class.java)

artifactName

// Add a plugin to detect duplicate artifact names
plugins.withId("maven-publish") {
    // Create a simple task that will run on every project to check for duplicate artifact names
    val checkDuplicateArtifactNames =
        tasks.register("checkDuplicateArtifactNames") {
            group = "verification"
            description = "Checks for duplicate artifact names across all projects"

            doLast {
                // Map to store artifact names and their corresponding projects
                val artifactMap = mutableMapOf<String, MutableList<String>>()

                // Collect all artifact names from all projects
                rootProject.allprojects.forEach { proj ->
                    val projExtension = proj.extensions.findByType(GDConventionsExtension::class.java)
                    if (projExtension != null && projExtension.artifactName.isPresent) {
                        val artifactName = projExtension.artifactName.get()
                        if (!artifactMap.containsKey(artifactName)) {
                            artifactMap[artifactName] = mutableListOf()
                        }
                        artifactMap[artifactName]?.add(proj.path)
                    }
                }

                // Find duplicates (artifact names used by more than one project)
                val duplicates = artifactMap.filter { it.value.size > 1 }

                // If duplicates are found, throw an error with details
                if (duplicates.isNotEmpty()) {
                    val errorMessage = StringBuilder("\nDuplicate artifact names detected:\n")

                    duplicates.forEach { (artifactName, projects) ->
                        errorMessage.append("\n  Artifact name '$artifactName' is used by multiple projects:\n")
                        projects.forEach { projectPath ->
                            errorMessage.append("    - $projectPath\n")
                        }
                    }

                    errorMessage.append("\nPlease ensure each module has a unique artifactName in its fooConventions block.\n")
                    errorMessage.append("For example:\n")
                    errorMessage.append("gdConventions {\n")
                    errorMessage.append("    artifactName.set(\"unique-name\")\n")
                    errorMessage.append("}\n")

                    throw GradleException(errorMessage.toString())
                }
            }
        }

    // Make sure the check runs as part of the build
    tasks.named("build").configure {
        dependsOn(checkDuplicateArtifactNames)
    }
}

private fun String.asDomainSpecificObject(): DomainSpecificObject = ...

Language

@Language("SQL")
val sql = "SELECT weight, name FROM boxes"

`fun doSomething(@Language("JSON") payload: String) { ...

Jetpack Compose

ContactViewModel

StateFlow

ContactsApi

runCatching

Throwable

Exception

Error

OutOfMemoryError

StackOverflowError

runCatching

Exception