This message was deleted.

Is there a name for classes that aren't enum classes or data classes, or are they just plain old classes?

Are there any api docs for kotlin/compose that are easily searchable and not spread around 40 or so different web pages?

if i have a singleton declared with object syntax

object Foo { ... }

why is it still possible to read an instance of this "class" using jackson objectMapper with

objectMapper.readValue(input, Foo::class.java)

and then I can access fields from that.. Does this not violate the singleton?

I'm having trouble passing a method reference into a Kotlin function. What's weird is it works if I declare and pass it from Kotlin, but if I declare/pass from Java I get a compile error. The type resolves correctly in the first line, but it complains in the second line, even though the type I'm passing looks like it should meet all variance requirements. I verified that all imports are correct, and, again, it works in an equivalent Kotlin file. Any ideas? (Note that the type

Pair<List<String>, String>

is just for testing purposes and is not final.)

i have list of TodoItem

data class TodoItem(
    val taskName :String,
    val isCompleted : Boolean  = false,
)

 private val taskList = mutableListOf<TodoItem>()

how can i change an element 'isCompleted' to true. so if user said 4th element is completed how can i change it to complete

taskList[index] = TodoItem(taskName = taskList[index].taskName, isCompleted = true)

like this???

Hi all, this topic is more advanced but I can’t find a better channel to place it. I need to execute some code on startup without knowing of its existence, think of an expendable registry where classes can register themselves (somehow like observer). The challenge is that - as I can’t instantiate these classes (actively) - the code is currently within a

companion object

. So I decided to provide an interface (or an annotation) and find the functions to call on startup as follows using (using classgraph as for scanning - I’m not bound to that framework):

interface OnStartup {
  fun onStartup()
}

// a class that wil instantiated a lot of times during runtime
data class SomeClass(val name: String) {
  companion object : OnStartup {
    override fun onStartup() {
      // notify someone at startup about our existence
    }
  }
}

fun main() {
  ClassGraph().enableAllInfo().acceptPackages("com.test").scan()
    .getClassesImplementing(OnStartup::class.java)
    .filter { it.isStatic }
    .flatMap { findStartupMethods(it) }
    .forEach {
      it.call()
    }
}

private fun findStartupMethods(classInfo: ClassInfo): List<KFunction<*>> {
  return classInfo.methodInfo.filter { function ->
    function.name == "onStartup"
  }.mapNotNull { method ->
    method.loadClassAndGetMethod().kotlinFunction
  }
}

This will not work as

call()

expects a parameter:

Callable expects 1 arguments, but 0 were provided.

which should be the instance of the class (from my understanding), so I guess it should be the

companionObjectReference

. The code works well if I define the

onStartup

function on top level (but that has negative impacts for my idea). Is there any way to retrieve the

companionObjectReference

? Or to achieve this behaviour? Maybe there is another annotation scanner that fits better for Kotlin? Any help is appreciated.

Maybe I'm just blind, but given that there is a

.single()

, I would expect there to be function that does this: • If there are no elements: null • If there is one element: it • If there are more elements: exception However, the implementation

.singleOrNull()

returns null on multiple elements too. There have been several occassions where we now check size first and manually do a 0,1,else check to do this correctly, but am I just missing something or should I just do a language proposal?

Hi everyone, is this the right place to ask questions regarding ktor and kotlinx? I am looking for info on how to add ids (like you would in html) to elements created with kotlinx.html, for example adding an id to a list item, so I find the list item in a javascript function.

I'm looking for some idiomatic Kotlin to replace an element in a

List<T>

at some index, i.e. I'd create a new list. Currently I do:

val list: List<T> = /*..*/
val elementToReplace: T = /*...*/
val newElement: T = /*..*/
val newList = list.toMutableList().apply {
    this[indexOf(elementToReplace)] = newElement
}

E.g. as an extension:

fun <T> List<T>.replaceWith(old: T, new: T): List<T> = toMutableList().apply {
    this[indexOf(old)] = new
}

Can this be done with some stdlib function, or in a shorter more idiomatic way?

hi here, I am having a companion object, that declares a method annotated with

JvmStatic

I want to write a junit/mockito test where I want to mock the method. Is there a way to do it? What if I remove

JvmStatic

? What are my options? I think it’s a part of the broader topic - how does the companion object relate to beans/singleton concepts of

Spring

, for example. Ideally, I would want no static methods at all. But instead having a singleton-y classes that I could mock or do whatever I can with the normal classes.

abstract class A {
    abstract inner class B : A() {
        init {
            // How can I access the outer class?
        }
    }
}

In that example,

this

refers to the class

B

,

this@A

refers to the parent class. How can I access the outer class?

Just noticed something today:

fun smartCast(
    condition1: String?,
    condition2: String?
): String? {
    if (condition1 == null || condition2 == null) return null
    return dummy(condition1) // OK, smart cast succeed
}

fun smartCastFailed(
    condition1: String?,
    condition2: String?
): String? {
    val checkCondition = condition1 == null || condition2 == null
    if (checkCondition) return null
    return dummy(condition1) // KO, smart cast fails
}

fun dummy(condition: String): String = TODO("do something with condition")

That might seem like a stupid example but I had a bunch of conditions that would not fit in one line and I also wanted to explicit a bit the check with the variable. I assume this type of optimization is a bit hard for the compiler? Any way around that? I guess using

!!

is fine since I’m sure the condition is not null.

Hi here, what is the use case for the companion objects? Coming from the java world, the normal way (to me ) would be to instantiate a singleton (using a container) and then provide it as a dependency to the caller code. Companion objects seem to work as a hardcoded dependencies, essentially not different from the static method calls.

Hi here, I was reading this answer: https://discuss.kotlinlang.org/t/best-practices-for-top-level-declarations/2198/3 on kotlin forum. The author references “recommended practice” what practices is he talking about and where can I find them?

The API is android, but the question itself isn't, feels more like a basic Kotlin question. I have this API to implement: https://developer.android.com/reference/androidx/activity/result/contract/ActivityResultContract by inheritance. The

parseResult

demands a non-null return value - however,

null

is a possible result I may get in there. How do I wrap the

null

into a non-null value, so the compiler is happy with me?

Can anyone show me place in Kotlin docs (or maybe even in Kotlin spec) where full description of deferred assignment usage rules is placed? All I found about deferred assignment is short mention in "Basic syntax" page. But obviously the rules are not trivial...

here i tried to reproduce my problem .. for set of custom data filter and then remove is not working but remove if is working fine.. and if any inner value not change then its works ..

import org.junit.Test

class TestMutableSetDelete {
    @Test
    fun testRemoveMutableSet(){
        val data = TestSetList(mutableSetOf(), mutableSetOf())
        add(data)
        change(data)
        //deletes not work in any inner value ever change 
        delete(data)
        // removeIf always works . but i my code need to work below api 24 too.
//        data.span.removeIf { it.start==it.end }
        // FIXME: without change this works . but if change happend its not
        data.range.forEach { println("start > ${it.start} > ${it.end}") }
        assert(data.range.size==2)
    }
}
data class TestSetList(
    val range: MutableSet<Range> = mutableSetOf(),
    val para: MutableSet<Para> = mutableSetOf()
)
data class Para(
    val start:Int,
    val end:Int
)
data class ChangedData(
    var name:String="",
    var age:Long
)
data class Range(
    val start:Int,
    val end:Int,
    val changedData: ChangedData
)
fun add(data:TestSetList){
    val cd =ChangedData("naser",26)
    data.range.add(Range(0,0,cd))
    data.range.add(Range(1,2,cd))
    data.range.add(Range(1,5,cd))
    data.range.add(Range(2,2,cd))
    data.range.add(Range(3,3,cd))
}
fun change(data: TestSetList){
    //simulate some change in the process .
    data.range.forEach { it.changedData.name = it.start.toString() }
}
fun delete(data:TestSetList){
    data.range.filter { it.start == it.end }.forEach { data.range.remove(it) }
}

So, after upgrading to kotlin 1.7.10, the exhaustive when clause has kicked in. This has caused us to have to add a lot of this type of block to our code in cases where we’re only interested in one or two cases of an enum:

SOME_VALUE_WE_DONT_CARE_ABOUT -> { }

The issue is that sonarqube is treating this as a code smell, and our quality gate is blocking merges when this happens. So we have to either change our quality gate, or use admin privs to merge. Does anyone know if there’s a way to tell sonar to ignore these?

hi here, what are good books on writing idiomatic kotlin? Or maybe ones that teach general programming using kotlin.

hey. where can i read how does this works: ?

kotlin
InputDecoration(color=if(isValid) blue else red) {
    Input(value, onChange)
  }

Looking for a way to make this code more kotlin-like. Just trying to get more comfortable with the more nuanced syntactical aspects of the language. My code is like this:

val foo: Map<String, String> = if (str.contains(bar1)) {
    map1
} else if (str.contains(bar2)) {
    map2
} else if (str.contains(bar3)) {
    map3
} else {
    defaultMap
}

The maps are properties defined in the class that this function is in. There is potential for more maps to be added in the future. This is basically a way for me to select which map to use.

str

is a value passed into this function and is expected to meet 1 of the 3 criteria. Is there a more clever way to do this?

Python has a

random.choices()

method which lets you provide a list of options and a list of weights for them. Is there some equivalent way to do that in kotlin?

Apologies if this question has been asked before. How do you verify that Google's advertising id is legitimate i.e. they recognise that they id exists in their system.

is it possible to do something like this in kotlin

interface ClientEvents {
  ready: () => void;
}

export declare interface Client {

  on<Event extends keyof ClientEvents>(
    event: Event,
    listener: ClientEvents[Event],
  ): this;
  off<Event extends keyof ClientEvents>(
    event: Event,
    listener: ClientEvents[Event]
  ): this;
  emit<Event extends keyof ClientEvents>(
    event: Event,
    ...args: Parameters<ClientEvents[Event]>
  ): boolean;
}

I'm reading the Kotlin

String

API and have a few questions... https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/

How could I use markov chains to generate a string? I couldn't find any kotlin examples

null

is a valid value for

out Any?

, right?

It seems like it should be allowed, yet this fails to compile:

interface Param

data class A<P : Param?>(val v: (P) -> Unit)

fun <P> create(v: (P) -> Unit) = A(v)

fun main() {
    val a = create { _: Nothing? -> }

    println(a.v(null)) // Null can not be a value of a non-null type Nothing
}

According to IDEA,

a

has type

A<out Any?>

, so why is

null

not allowed? (playground link)