Haven't used Kotlin serialization much, what's the correct way to be able to deserialize some JSON returned by an API when it's something like:

{
    "type": "Foo" | "Bar" | "Baz"
    "payload": FooPayload | BarPayload | BazPayload
}

When working with delegates, how should I handle situations like this?

class MonoNode : BaseNode() {
    protected val input by input()    // getValue should resolve here; it's a delegate to use the property name
    protected val output by output()  // getValue should not resolve as its value may change over time

    override fun process() {
        // We don't want to call getValue too often in real-time code that needs to be fast!
        // output.getValue should only be called once per process() call
        // input.getValue should only be called in constructor/init
        // Is there a good way to do it without having to store to a variable?

        val x = input[0]   // calls input.getValue
        val y = input[1]   // calls input.getValue
        output[0] = x + y  // calls output.getValue
        output[0] = x + y  // calls output.getValue
    }
}

Hi all, I have a list of strings and I need to batch it into list of list where each list doesn’t exceed 10 items AND also each list doesn’t exceed 100 chars. for example

input: [ "this is item number one",
         "this is item number two",
         "this is item number three",
         "this is item number four",
         "this is item number five",
         "this is item number six"
       ]

output: [
         ["this is item number one", "this is item number two", "this is item number three", "this is item number four"],
         ["this is item number five", "this is item number six"]
       ]

I wrote this

private fun List<String>.batch(): List<List<String>> {
    return fold(mutableListOf(mutableListOf<String>())) { accumulator, string ->
        val currentBucket = accumulator.last()
        val currentBucketCharsCount = currentBucket.sumOf { item -> item.length }
        val willBucketExceedMaximumCharCount = currentBucketCharsCount + string.length > 100
        val willBucketExceedMaximumSize = currentBucket.size + 1 > 10
        if (willBucketExceedMaximumCharCount || willBucketExceedMaximumSize) {
            accumulator.add(mutableListOf(string))
        } else {
            currentBucket.add(string)
        }
        accumulator
    }
}

but I have a feeling that it can be done in a more cleaner/simple way. any ideas?

Hi guys! I have string like that:

[5-XR6Bwlq, 2-Hada32U1D, 7-aaGE7Ve84]

I want to get every single number before

-

and create list of Int with that values. How I can achive that?

(I know it's more a Jackson than a Kotlin question, but I hope someone might have an answer anyway). I have a line `val jackson: YAMLMapper = YAMLMapper.builder().addModule(KotlinModule()).build()`in my code to create a Jackson YAML mapper with Kotlin extensions. This tells me "Kotlin: 'constructor KotlinModule(Int = ..., Boolean = ..., Boolean = ..., Boolean = ..., SingletonSupport = ..., Boolean = ...)' is deprecated. Use KotlinModule.Builder instead of named constructor parameters". Does that really mean I should use `val jackson: YAMLMapper = YAMLMapper.builder().addModule(KotlinModule.Builder().build()).build()`instead? That's an awful amount of build...

how can I merge these “duplicates”? its very unreadable for me // Also, why are the fields not in the source order? its not even alphabetical, I dont get it

Hey, is there anything like partial classes in Kotlin? Lets say that I have a Post model with (id, title, content, createdAt, updatedAt) and I want to have only the primary fields (title, content) for the DTO Which way would be the most efficient to handle that in Spring Boot with Kotin

data class Foo(val price: Int?)

val items = List<Foo>(Foo(133), Foo(324), Foo(3))

How I can get

List<Int?>

with all prices? Is it only solution? https://medium.com/@hayi/kotlin-get-list-of-some-property-values-of-object-from-list-of-object-8da9419c2e77

In kotlin : val a = 10 val b = 10 And in java : int x = 10 int y = 10 What’s the difference?

correct me if i am wrong, in example above: in kotlin, both a and b refers to same value in memory while in java, both x and y are different values in memory

Is it possible to do something like this? fun foo(bar: (Int) -> String, block: () -> Unit) { // Some code } fun test() { foo { bar(5) // This is currently not valid but I need it to be } }

Easy ways to get similar in kotlin In java int[] array = new int[6]; int[][] darray = new int[2][2]; And also how to get jagged array in kotlin?

Can I formulate

fun Provider<out Task>.generateChecksums(destination: Directory? = null) {
    get().generateChecksums(destination)
}

fun Task.generateChecksums(destination: Directory? = null) {
}

fun FileSystemLocation.generateChecksums(destination: Directory? = null) {
}

somehow so that the first one can work for both

Task

or

FileSystemLocation

? Just adding another method does not work of course as both would have the same type-erased form unless I call it differently.

Bitshifting for bytes is not supported in Kotlin and I try to figure out how I can translate this method into Kotlin code:

/**
 * Returns an unsigned 16-bit int calculated from the next two bytes of the sequence.
 *
 * @return the 16 bit int value, between 0x0000 and 0xFFFF
 */
public int getUInt16() {
        return (getByte() << 8 & 0xFF00) |
               (getByte()      & 0xFF);
}

If I add

.toInt()

I can use the

shl

function, but the result is wrong. Is there already a standard function for this calculation?

Does anyone know of a static analysis tool that I can use to check that a package and it’s children don’t contain any classes that do not have the

internal

modifier?

"abc".split("")

splits into a list of Strings

[, a, b, c, ]

(5 elements) with an empty string at the beginning and end. Why is it so? And how to split the string into individual letters to the List<String>?

Is there Big O notation documentation on collection functions like https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/partition.html ? I found it pretty nice in the Apple documentation that they mention the complexity of the function https://developer.apple.com/documentation/swift/array/3017524-partition

This message was deleted.

I’m trying to get kapt working on a multiplatform gradle project, so far I have:

configure<org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension> {
    jvm {
        val main by compilations.getting {
            kotlinOptions {
                freeCompilerArgs = listOf("-Xallow-result-return-type", "-Xinline-classes")
                jvmTarget = JavaVersion.VERSION_11.toString()
                javaParameters = true
            }
        }
    }
    sourceSets {
        val main by getting {
            dependencies {
...
                configurations["kapt"].dependencies.add(platform("io.micronaut:micronaut-bom:${properties["micronautVersion"]}"))
                configurations["kapt"].dependencies.add(project.dependencies.create("io.micronaut:micronaut-inject-java"))
            }
        }
    }
}

however when I run the

kaptKotlinJvm

task I’m getting:

java.lang.IllegalArgumentException: The argument does not represent an annotation type: io.micronaut.context.annotation.Replaces

Any idea what I’m missing? What does this error mean, that the dependencies aren’t working or something else?

I have a api which takes varargs. Its basically a wrapper around String.format and there is a few layers to it. From what I see in the bytecode, every function call forces me to use spread operator which creates a copy of the vararg string array. Should I optimize this away and pass around only a Array<String>? feels very wasteful .. I mean we pass by reference on JVM // Not to mention if I call kotlin

format

then there is another damn copy when it proxies to java TLDR; are vararg apis harmful?

Is something like the following possible somehow?

class BaseType {
    val someProp: Int = 10
}

fun handleProperty(prop: KProperty1<BaseType, Int>) {
    // get BaseType instance here somehow
}

fun main() {
    val x = BaseType()
    handleProperty(x::someProp)
}

Hi, is there a known best practice for encoding/decoding kotlin objects to/from Base64 String instead of going object -> json string -> base64 and the opposite?

not sure if there is a better channel but what is the advantage of definitely non nullable types?

we want to check permissions / scopes in our code. The scope names are defined externally, e.g.

spreadsheets:read.all

We would use is e.g. as

requireScope("spreadsheets:read.all")

I like plain text here over using constants like

SPREADSHEETS_READ_ALL

because it stays in the domain language of the scope, rather than using the kotlin constant. But it would be great to have some sort of compile time check here so you cannot have a typo in the scope string. (They are all known ahead). Any ideas?

Hello, I am migrating my Java modules + Gradle modules application to Kotlin. In one of my modules, I am getting all the packages in another module by

ModuleLayer.boot().findModule(moduleName)

. Now when I moved that code over to Kotlin, I noticed that particular module is not included in the ModuleLayer. I understand that Kotlin doesn't have an equivalent of

module-info.java

(I think) so does that mean this way of loading packages not gonna work in Kotlin?

I want to model a multi-dimensional hierarchy of status codes: I have different operations like "generate data" or "upload file", and for each of them I have either "success" or "failure". All "failure" should carry a message, and groups like "generate" or "upload" also share some attributes. The existing code uses an enum for the different status codes and then a bunch of nullable properties for the different properties (nullable because they are sparsely filled/used). A better way seems to be a sealed class hierarchy. But modelling this straight forward would require multi-inheritance. Is there a good way to model this?

sealed interface Status
sealed class Failure(val message: String) : Status
sealed class Upload(val name: String) : Status
sealed class UploadFailure(message: String, name: String) : Failure(message), Upload(name)

I’ve written a custom ktlint rule but when I try to run it with gradle using the ktlint plugin I get the following

Too many element types registered. Out of (short) range. Most of element types (14991) were registered for 'Language: kotlin'

I’m completely stuck on this, it works fine if I run the ktlint binary with the jar file directly, seems like its something to do with the gradle plugin?

When should you use a computed getter and when a field inside an object returning another const/object? Real world use case:

public object GlobalScope : CoroutineScope {
    override val coroutineContext: CoroutineContext
        get() = EmptyCoroutineContext
}

Why is coroutineContext not a field?

override val coroutineContext = EmptyCoroutineContext

Not sure where does this question belong to, but I’m looking for some simple alternatives to

Poet

where I have full control on the generated Kotlin source code including removing redundant qualifiers, etc. My google research did not lead me any further than just construct the source as a String and write it to a file.