Why does Jacoco think there are six branches?

Is there a better (or "more Kotlin") way to get an enum value when I don't have a concrete type? It feels weird having to resort to

java.lang.Enum

...

sealed class EnumBinding<E : Enum<E>>(
	private val enumType: Class<E>
) : Binding<Any?, E?> {

	override fun converter(): Converter<Any?, E?> = object : Converter<Any?, E?> {
		override fun from(databaseObject: Any?): E? =
			databaseObject?.let { java.lang.Enum.valueOf(enumType, it.toString()) }
        …
    }
    …
}

(it's a custom jOOQ binding, so I can't change

Binding

or

Converter

)

What is the best way to write the below code?

viewLifecycleOwner.lifecycleScope.launch {
            viewLifecycleOwner.lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
                launch {
                    collectABCState()
                }

                launch {
                    collectABCInfo()
                }

                launch {
                    collectXYZFailedEvents()
                }

                launch {
                    collectABCTime()
                }

                launch {
                    collectABCSummary()
                }
            }

How can I allow this to accept a String in the

find

extension in addition to an Int? Is there anything else I can do to optimize as well?

infix fun <T> T?.ifNull(block: () -> T?) = this ?: block()

inline fun <reified T> EnumCompanion<T>.find(value: Int): T? where T : Enum<T>, T : EnumValue<T> =
    enumValues<T>().run {
        firstOrNull { (it.value as Int) == value }
            .ifNull { firstOrNull { it.name == "Unknown" } }
            .ifNull { throw Exception("Enum value does not exist") }
    }

interface EnumCompanion<T : Enum<T>>

interface EnumValue<T> {
    val value: T
}

enum class MyEnum(override val value: Int) : EnumValue<Int> {
    Unknown(0),
    First(1),
    Second(2),
    Third(3);

    companion object : EnumCompanion<MyEnum>
}

MyEnum.find(1)

Kotlin has 1️⃣

check(…)

and 2️⃣

require(…)

. Which would be better to signal an invalid configuration (i.e. on startup)? Or should I make up 3️⃣ my own exception class? I'm really torn between "a bad config is an illegal argument" and "the app is in an illegal state and can't start" 😕

I’m at a loss here, what is wrong with this code? what’s wrong with the Stack I’ve implemented ? https://paste.ofcode.org/MmxwVcvXvdBY5EZfZpTPWS the moment I use Java’s own Stack, the function works fine and returns true for 1st test and false for 2nd

How to write this method in better way?

/** Returns the signed in users ID as a `String` or `null` if no ID in shared preferences found (or `0`). */

fun SharedPreferencesManager.userId(): String? {
    val userIdLong: Long = this.loadCurrentAdminPsid()
    return if (userIdLong == 0L) null else userIdLong.toString()
}

I have a property called captureMode which observes on a camera

StateFlow

and change it’s value when the camera changes. Additionally, I want to be able to set captureMode manually. But since captureMode is a stateFlow, I can’t set it. Is there a better way?

Hi all, I’ve created a small DSL, but my challenge is that I need a reference to some of the items in the tree I’m building, and I was wondering if you have any suggestions on how to do this. This is my current DSL:

lateinit var childFolder1 : FolderNode
         lateinit var childFolder2 : FolderNode

         val rootFolder = buildFolders(am,"System") {
            childFolder1 = folder("A") {
                +entry(Attribute("x"), Sample("1"))
            }
            childFolder2 = folder("A") {
                +entry(Attribute("x"), Sample("2"))
                +entry(Attribute("x"), Sample("2"))
            }

            +childFolder1
            +childFolder2
        }

        println(childFolder1) // simplified here

As you can see, I need a reference to childFolder1 in my code, but my current solution seems a bit non-idiomatic, so I was wondering if you have any suggestions on how to improve this? (I’m also not sure if this is the right channel, the new setup confuses me a bit, so if I need to post this somewhere else, please let me know)

I wrote these so I can chain casts so I can avoid the parenthesis involved in using

as?

. Is there a better way to chain casts, or something similar in the stdlib that I missed?

Any ideas to make this more compact or idiomatic?

I have a function that maps a sealed exception type

ServiceException

to an implementation of some sealed payload interface

T

e.g.:

inline fun <reified T> ServiceException.toError(): T {
  return when(this) {
    is InvalidInputException -> InvalidInputError(...)
    is PermissionDeniedException -> PermissionDeniedError(...)
  } as T
}

The payload type

T

is some interface. I can cast the result of the

when

to T as shown, but then forgetting to implement

T

in each of these error types will result in a run-time exception. What would be the best way to create a re-usable function here that is compile-time type-validated, just as if that function were literally inlined?

Is there a better way to check a string contains both number and alphabet?

val text = "aas211w"
if (text.any { it.isDigit() } && text.any { it.isLetter() }) {
}

Hi , Is there any way to intercept method from interface and cache result “WITHOUT” spring’s method cache ? Take a simple calculator for example :

interface ICalculate {

  fun multiply(a: Int, b: Int): Int
}

It just multiplies

a

and

b

, and return the result . Suppose it is a heavy computation work . And there are two implementations :

class CalculatorDumb : ICalculate {
  override fun multiply(a: Int, b: Int): Int {
    var sum = 0
    (1..a).forEach {
      (1..b).forEach {
        sum++
      }
    }
    return sum
  }
}

The dumb implementation just add one by one .

class CalculatorSmart : ICalculate {

  override fun multiply(a: Int, b: Int): Int {
    return a * b
  }
}

And this smart implementation just returns

a * b

. OK , here is the point . I hope client can initialize no matter dumb or smart implementation , and can get result if the parameter is identical. There is a

Memoize

pattern , described here : https://jorgecastillo.dev/kotlin-purity-and-function-memoization :

class Memoize<in T, out R>(val f: (T) -> R) : (T) -> R {
  private val values = mutableMapOf<T, R>()
  override fun invoke(x: T): R {
    return values.getOrPut(x) { f(x) }
  }
}

fun <T, R> ((T) -> R).memoize(): (T) -> R = Memoize(this)

I can use it in the implementation class , like this :

class CalculatorSmart : ICalculate {

  data class CacheKey(val a: Int, val b: Int)

  private val innerCalculate: (CacheKey) -> Int = { key: CacheKey ->
    println("cache miss")
    key.a * key.b
  }.memoize()

  override fun multiply(a: Int, b: Int): Int {
    return innerCalculate(CacheKey(a, b))
  }
}

But it seems it’s hard to apply it in the interface layer. I wonder if there are any patterns to achieve : 1. Each implementation class ( dumb or smart in this example) doesn’t need to implement its cache . 2. There are no two versions of method (

multiply()

and

cachedMultiply()

for example ) 3. Client only knows one method of the interface , No matter the client initialize smart or dumb class , the result of the same parameter will be cached and returned. For example : such scenario is OK

val calSmart: ICalculate = CalculatorSmart()
println(calSmart.multiply(3, 7)) // cache miss
println(calSmart.multiply(3, 7)) // cache hit

val calDumb: ICalculate = CalculatorDumb()
println(calDumb.multiply(3, 7)) // cache miss
println(calDumb.multiply(3, 7)) // cache hit

It will work like Spring’s method cache . but I hope there will be a kotlin-idiomatic style , maybe more functional , just like the memoization pattern above . Is there any idea ? Thanks.

Anyone know a faster and more efficient way to check if a given word is a shuffled version of another given word? Here's my current code:

fun String.checkIfShuffledVersionOfAns(ans: String): Boolean {
    val listOfChars = this.toCharArray()
    val shuffledListOfStrings = mutableListOf<String>()

    var iterations = 0

    while (iterations < 100000) {
        listOfChars.shuffle()
        if (!shuffledListOfStrings.distinct().contains(listOfChars.concatToString())) {
            shuffledListOfStrings.add(listOfChars.concatToString())
        }
        iterations++
    }

    for (string in shuffledListOfStrings.distinct()) {
        if (string == this) return true
    }

    return false
}

Hello, I'm modeling the different types of audio focus as a Kotlin type hierarchy, and I'm unsure about picking

sealed interface

or

sealed class

. What would you pick? Any reason beyond personal preference? 1️⃣ Here's with `interface`:

sealed interface AudioFocus {
    object Gain : AudioFocus
    sealed interface Loss : AudioFocus {
        companion object : Loss
        sealed interface Transient : Loss {
            companion object : Transient
            object CanDuck : Transient
        }
    }
}

2️⃣ Here's with `class`:

sealed class AudioFocus {
    object Gain : AudioFocus()
    sealed class Loss : AudioFocus() {
        companion object : Loss()
        sealed class Transient : Loss() {
            companion object : Transient()
            object CanDuck : Transient()
        }
    }
}

Hello, Im looking for a way to clean this code. I dont like this part of init empty String, is there other way write this?

fun getStreetNameByStreetId(id: String): String {
        val query = Query()
        query.fields().include("name")
        query.addCriteria(Criteria.where("_id").`is`(id))
        var streetName = ""
        mongoTemplate.executeQuery(
            query, STREET_COLLECTION
        ) { document: Document ->
            streetName = document.getValue("name").toString()
        }
        return streetName
    }

Is there any way to get lazy int ranges in Kotlin? I’m currently writing code like

(1..n).asSequence()

and it’s really annoying that you always have to clutter the code with the

asSequence()

call to make it lazy (read: perform well). EDIT: Yes, that came across the wrong way … lazy evaluation isn’t always better. 🙂

i’ve got a class like:

class MyFoo(
    val title:  String,
    val client: Foo = (some default)
) {...}

I want to provide a default value of Foo when if it’s not provided, but it’s nontrivial to create a valid instance, and requires storing an instance variable e.g.

val x = Bar()
client = Foo.builder().bar(x).baz(Baz.builder().bar(x).build()).build()

i’m struggling to figure out if this is possible with initializer / secondary constructors, without having to make

client

a nullable

var

.

works good! Softref holds the String pinning the weakref 😛

val bolCache: MutableMap<String, SoftReference<Pai2<RowVec, String>>> = WeakHashMap(0)

Hoping to do away with an unchecked cast - any thoughts?

@Suppress("UNCHECKED_CAST")
fun <IdType> createWidgetFactory(cls: KClass<out IdType>): WidgetFactory<IdType> =
    when (cls) {
        IdA::class -> WidgetFactoryA() as WidgetFactory<IdType>
        IdB::class -> WidgetFactoryB() as WidgetFactory<IdType>
        else -> throw UnsupportedOperationException("Unknown WidgetFactory type!")
    }

[RFC] I consider adding the following item to the Effective Kotlin. What do you think? (I hope it is a right place for RFC) https://kt.academy/article/ek-operators

is there any better way of improving this code. For example, using some std extension function idk:

fun addChatHeaders(itemList: List<ChatMessage>): List<HelpCenterChatItem> {
    return buildList {
        itemList.forEachIndexed { index, item ->
            val current: ChatMessage = item
            val previous: ChatMessage? = itemList.getOrNull(index - 1)

            if (previous == null || (previous.date.dayOfYear != current.date.dayOfYear)) {
                add(
                    HelpCenterChatItem.HeaderDate(
                        dateFormatter.format(
                            current.date,
                            DatePattern.ISO_DAY_MONTH_YEAR_SLASHED
                        )
                    )
                )
            }
            add(current)
        }
    }
}

Hello! I have a number of classes that might or might not be resolved to some external data source. So that just means wrapping in a container. A combination of optional / decorator pattern.

sealed class Resolvable<T>
class Resolved<T>(val value: T, val pk: Long) : Resolvable<T>()
class Unresolved<T>(val value: T) : Resolvable<T>() {
    fun resolved(pk: Long) = Resolved(value, pk)
}

Now I want to take a

Collection<Resolvable<ItemIdentifier>>

and filter only unresolved ones, into a

Collection<Unresolved<ItemIdentifier>>

. This works:

val x : Collection<Unresolved<ItemIdentifier>> = itemIdentifiers.mapNotNull { when(it) {is Unresolved -> it else -> null }}

But I wonder if there's a more idiomatic way to do it? (type annotation on

x

just for clarity).

Any suggestions on how to improve my custom navigation animations? I've wrapped them inside a composable function.

Which one? 1.

class SnackbarUtils {
    companion object {
        fun makeSnackbar() {

        }
    }
}

2.

class SnackbarUtils {
    fun makeSnackbar() {

    }
    companion object {
        val instance get() = SnackbarUtils()
    }
}

3.

class SnackbarUtils {
    fun makeSnackbar() {

    }
    companion object {
        val instance = SnackbarUtils()
    }
}

Hi guys .... hope you doing will what is the diff and what should i choose

private val empID 
             get() = (userModelId ?: session.getUserModelId().toSafetyString()).toSafetyString()

	private val empID2 by lazy { (userModelId ?: session.getUserModelId().toSafetyString()).toSafetyString()  }

Hi this is horrible do you know a more elegant way to refactor that ? ( sorry cor the format i am on mobile the three format ``` are not picked up) if (count() > 5) take(5).forEach { firstFiveSubsectionItems -> buildAlwaysVisibleLogic(alwaysVisibleView, firstFiveSubsectionItems) } else { forEach { itemsSubsection -> buildAlwaysVisibleLogic(alwaysVisibleView, itemsSubsection) } }

debugging challenge:

fun main() {
    val root = Thing(null, 0).apply {
        addChild(1) {
            addChild(2)
            addChild(3) {
                addChild(4)
            }
        }
        addChild(5)
    }
    root.printTree()
}

abstract class Nestable(
    val parent: Nestable?
) {
    val children = mutableListOf<Nestable>()
}

class Thing(
    parent: Thing?,
    val number: Int
) : Nestable(parent) {
    init {
        parent?.children?.add(this)
    }

    fun addChild(
        number: Int,
        block: Nestable.() -> Unit = {}
    ) = Thing(this, number).run(block)

    fun printTree(indentation: Int = 0) {
        println(" ".repeat(indentation) + number)
        children.forEach {
            (it as? Thing)?.printTree(indentation + 1)
        }
    }
}

expected output:

0
 1
  2
  3
   4
 5

actual output:

0
 1
 2
 3
 4
 5

find the bug >:)