Updated version of my Json building DSL. Feedback requested. README.md

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))
}

Resulting JSON:

{
  "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
}

Do you think if pipeline programming is good to put everywhere like this? I'm just so obsessed with it. It makes the code so clear, simple and straightforward. IMO. Like this: do steps one, two, three. And that's it. But one can say that the 3 usages of

.let

are redundant here (because there is no

null

to handle using

?.let

). Still this disadvantage does not outweight. IMO

For some reason the flow doesn't work as expected for my use case. More in 🧵

Given a rather large 3rd party interface, I need to implement only a small handful methods. (for testing, i control the calling code)

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

I thought I had a really bright idea, since the following is valid syntax:

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

I was hoping the delegation would act as with actual objects, routing calls to the override if they were present, and throwing NotImplementedError otherwise. Unfortunately, the

TODO()

is evaluated on instantiation of A() and not during method call 😞

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

// but got 
A() // NotImplementedError

Does anyone have an elegant way to partially implement an interface and default to NotImplementedError for the rest, without explicitly doing so for every single method?

For producing a

StateFlow

from another

StateFlow

without requiring a

CoroutineScope

(so no new coroutine):

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)
}

Is there way to have method reference for optional receiver?

customKeyListener?.onCustomKeyPressed()

something like

customKeyListener::onCustomKeyPressed

What do you think of that file - having the Extension function right below the enum?

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
    }

Hi, I recently started a small Kotlin project for the "Build Your Own Interpreter" challenge. It's purely for practice and has no open-source value. If you have time, I’d appreciate any feedback on Kotlin idioms, readability, and best practices. Tests aren’t fully implemented yet — I'll add them once the overall structure is settled. Thanks!

I know it’s more standard to put

Density

as the receiver, but isn’t the API usage cleaner when doing this?

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

I’ve got a conventions plugin, that has an extension containing a field:

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

that is consumed by maven-publish to set the name of the artifact (jar) to be published. a couple of times, due to copy paste errors, folks have complained about failure to publish to artifactory when in fact they’ve just used the same

artifactName

in multiple modules of a project. Does this approach make sense for identifying this case and proactively failing the build and alerting the user? Am i missing something much simpler?

// 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)
    }
}

What are opinions on extensive use of extension functions/properties in codebases? I've recently started working on a new codebase and it feels like every file I look at has things like:

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

I would prefer a function to handle such things that explicitly took a string. I thought the overwhelming view/opinion was that extension functions and properties were right when they extended the abstraction of the class that was being given an extension. Beyond initial confusion and my own opinion, is there any reason to avoid such use of extension functions/properties, or should I embrace it?

Hey, I have a Profile UI where, when the user lands on the screen, I want to show a loading indicator while fetching the API response. If the request is successful, I display the user data; if not, I show an error message using a Flow. In the successful response, the user has three available actions: Delete Account, Change Password, and Logout. For Delete Account and Change Password, I need to navigate to another Compose screen, and I’m still using event flow for these actions. For Logout, I need to call an API. While the API call is in progress, I show a loading indicator, and stop it once the process is complete. On success, I clear the token and other relevant user data. In my ViewModel, I’m calling domain layer interfaces for login and profile operations. The data layer handles API requests, and both repositories return a Result. I combine these results using StateFlow.

How can you define a ByteArray value class with a structural equals operator? Kotlin complains that Member with the name 'equals' is reserved for future releases.

Generally I'd use

Language

annotation on a String literal for syntax highlighting and such, for example

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

But I'm reviewing code where parameters are annotated with it:

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

why would we want to do that? what does it buy us?

Hi everyone, I've written an app which is intended to allow players of Tekken 8 to save combos they make in game or found online to allow them to practice while playing the game. I've used RoomDB & Datastore APIs for data persistence. I know there's definitely places I can improve but I would love it if someone was able to have a look at my code and give it a review. https://github.com/Dooques/FightingFlow Thanks in advance

Hi I'm working on a

Jetpack Compose

screen that fetches contact data using a

ContactViewModel

. The ViewModel uses

StateFlow

, performs API calls through a

ContactsApi

, and includes email validation logic using a UseCase. It all works, but I want to refactor this to align more with Kotlin best practices, Jetpack architecture guidelines, and better separation of concerns.

am I being a dummy? the other local variables shouldn't be considered JSON just because I annotated a single local variable right?

Is there a reason commonly used

runCatching

catches a

Throwable

not an

Exception

? Even official documentation states that • The

Error

subclass represents serious fundamental problems that an application might not be able to recover from by itself. These are problems that you generally would not attempt to handle, such as

OutOfMemoryError

or

StackOverflowError

. https://kotlinlang.org/docs/exceptions.html#exception-hierarchy Personally we use a slightly modified version of

runCatching

that only catches an

Exception

. What am I missing?

Hello everyone. I don't have a java/kotlin background but I'd like to get your opinion on theses factory classes (used with the faker library). They are used for creating fake data when testing. I don't know if it makes sens for a kotlin dev. Or is there something better ? But here is the UserFactory: https://github.com/danygiguere/spring-boot-3-reactive-with-kotlin-coroutines/blob/main/src/main/kotlin/factory/UserFactory.kt and how I use it in a test: https://github.com/danygiguere/spring-boot-3-reactive-with-kotlin-coroutines/blob/[…]/kotlin/com/example/demo/factory/integration/UserFactoryTest.kt. Does it make sens or do you think Fixtures are better ?

I've created a checkPostOwnershipWebFilter (checkPostOwnership) to check if the Post to be updated or deleted is owned by the logged in user. How does it look to you ? Could I do better ? : https://github.com/danygiguere/spring-boot-3-reactive-with-kotlin-coroutines/commit/ad39b35d255afc55e6279dcae974490fd0838584#diff-c6813[…]94512d8R36

What’s the most idiomatic way to attach a reified function to an interface? currently I’m adding an extension function next to the interface in the same file, but it’s not very discoverable: The user has to know about this and import it explicitly before use:

interface IExample {
  fun <T> something(cls: KClass<T>)
}

inline fun <reified T> ITest.something() = something(T::class)

val t: IExample = Example()
// caller has to manually know about, and import extension function before they can do
t.something<String>()

Im trying to design a DSL style API for ffmpeg filters and I just wanna get some feedback. The main idea is filters have inputs and outputs and can be connected to one another

val graph = FilterGraph {
    // split input into 2 (default) outputs
    filter("split") {
        // get first output and assign to variable
        val tmp = output {
            filter("crop") {
                option("out_w", "iw")
                option("out_h", "ih/2")
                option("x", 0)
                option("y", 0)
            }
            // flip vertically 
            filter("vflip")
        }
        
        // get the second output
        output {
            // overlay tmp on top of this output
            filter("overlay", tmp)
        }
    }
}

apologies for the meta question (no code to show) but is everyone using

turbine

for their coroutine testing?

I have a list containing 4 million ordered elements, but I'd like to extract the first from each group within that list. The list is kind of like a linear tree, the first element is the parent and all following elements (up to a point) are its children. I'm using a sequence, but it's kind of slow on KMP/JS Browser(~20 seconds to pull 200 elements). This is in a KMP react app, but this block is where the iteration happens.

useEffect(setTopLevel, props.pluginElementMarkers) {
        val last = props.pluginElementMarkers.lastOrNull()
        if (last == null) {
            return@useEffect
        }
        val sequence = props.pluginElementMarkers.asSequence()
        val topLevelList = mutableListOf<PluginElementMarker>()
        var nextMarker = sequence.take(1).single()
        while (nextMarker != last) {
            val skip = nextMarker.skip
            val size = when (nextMarker) {
                is GroupElementMarker -> nextMarker.elementSize
                is RecordElementMarker -> nextMarker.elementSize
                is SubRecordElementMarker -> nextMarker.elementSize.toUInt()
            }.toLong()

            topLevelList += nextMarker
            nextMarker = sequence
                .dropWhile { marker -> marker.skip < skip + size }
                .take(1)
                .singleOrNull() ?: last
        }
        console.log("actually done")
        setTopLevel(topLevelList)
    }

Hi friends! I have a test that checks whether a

.properties

file correctly loads entries as UTF-8 — once the

reader

is using the correct charset,

Properties

works as expected. Consider this excerpt:

val expected = mapOf(
    "italian" to "anatra",
    "russian" to "утка",
    "chinese" to "鸭子",
    "japanese" to "アヒル",
    "korean" to "오리",
    "arabic" to "بطه",
    "hindi" to "बत्तख",
    ...
)

I was wondering if I should hardcode these strings into the Kotlin file, specially that I have RTL ones in there. Is this okay or there is a better way? Any suggestions are welcome! Thanks!

import kotlinx.serialization.StringFormat
import kotlinx.serialization.json.Json


private val format: StringFormat = Json { encodeDefaults = true }
object MyFormat : StringFormat by format

When I try to inline

format

the expression insists on referring to the class

Json

instead of the factory function

Json

Any tips to avoid the intermediate

format

variable?

For the time being we are forced to use

java.time.Instant

over kotlinx.datetime. We are leveraging the typealias trick to make

Instant

@Serializable. This has been working just fine up until now, but today i was writing a specific test and came over something surprising: When using the aliased type inside a

@Serializable

data class, it works as expected. But when trying to serialize a naked

MyInstant

i get an exception 🤯

typealias MyInstant = @Serializable(InstantSerializer::class) java.time.Instant


@Serializable
data class Test(val i: MyInstant)

fun main() {
    val epoch = MyInstant.EPOCH
    println(Json.encodeToString(Test(epoch)))  // {"i":"1970-01-01T00:00:00Z"}
    println(Json.encodeToString(epoch))        // kotlinx.serialization.SerializationException: Serializer for class 'Instant' is not found.
}

Does anyone have a clue why this happens?

Hi! I've been thinking about whether or not this code is thread-safe in practice (in a sense that the output of get is always random).

import kotlin.concurrent.Volatile

object RandomPool {
  private val writeLock = ReentrantLock()
  private val random = kotlin.random.Random.Default

  @Volatile private var array = FloatArray(0)
  private var _array = array

  operator fun get(index: Int): Float {
    // Available in the thread-local cached array
    val local = _array
    if (index < local.size) {
      return local[index]
    }

    // Available in general
    val latest = array
    if (index < latest.size) {
      _array = latest
      return latest[index]
    }

    // Not available, need to grow
    ensureCapacity(index + 1)
    return array[index]
  }

  fun ensureCapacity(capacity: Int) =
    writeLock.withLock {
      // Double-Checked Locking: After acquiring the lock, check the condition again.
      // Another thread might have already grown the array while this thread was waiting.
      val currentArray = array
      if (capacity <= currentArray.size) return@withLock

      // This thread has the lock and has confirmed the array is still too small.
      // Proceed with the resizing operation.
      val oldSize = currentArray.size
      // Grow the array with some extra capacity to reduce the frequency of re-allocations.
      val newSize = maxOf(capacity, (1.5 * oldSize).toInt())

      // Copy-on-Write: Create and populate the new array completely before publishing it.
      val newArray = currentArray.copyOf(newSize)
      for (i in oldSize until newSize) {
        newArray[i] = random.nextFloat()
      }

      array = newArray
      _array = newArray
    }
}

I believe in this case, the

_array

should be an acceptable optimization and shouldn't cause any wrong output being returned, but asking AI, it keeps on insisting otherwise, and points out that there actually is a way that

_array

can return `0.0`(not randomly, but as an uninitialized value). The

array

is only ever set to completely filled arrays, and the

_array

is only updated afterwards, plus the values themselves never change. So, I don't seem to see any problem. Do you know if it's actually wrong, or the AI is hallucinating?

I have developed a multi-platform HugeInt arbitrary-precision integer arithmetic package. The API utilizes Kotlin features and is explicitly not a drop-in replacement for java.math.BigInteger. So I'm particularly interested in having folks review the user-facing API, give honest feedback, and tell me whether it feels Kotlin-friendly before the initial release. https://github.com/migueldecimal128/HugeInt