Hey guys can we improve this piece of code?

val filteredTopics by lazy { MutableStateFlow<List<Topics>>(emptyList()) }

val temp = list.filter { it.topics != null }.filter { it.title == value.title }
filteredTopics.value = temp.firstOrNull()?.topics?.sortedBy { topic -> topic.title } ?: emptyList()

Hey guys, Can we improve this piece of code ?

fun getConsultationCoverageList(): List<ContentWithTitle> {
    val list = mutableListOf<ContentWithTitle>()
    val consultation = getConsultationItem()
    consultation?.consultationCategories?.forEachIndexed { _, consultationCategory ->
        val paragraphs = mutableListOf<Paragraph>()
        consultationCategory.consultationTopics?.forEachIndexed { _, consultationTopics ->
            paragraphs.add(Paragraph(type = LIST_ITEM.type, text = consultationTopics.title))
        }

        list.add(ContentWithTitle(title = consultationCategory.title, content = Paragraphs(paragraphs), description = consultationCategory.description))
    }
    return list
}

Hi guys, Which do u prefer and why? 1️⃣

public interface Payload {
    public val data: Any
    public val error: Error
}

with factory fun:

public fun <T : Any> Payload(data: T): Payload {
    return PayloadImpl(data)
}
public fun errorPayload(error: Error): Payload {
    return PayloadImpl(error = error)
}

2️⃣

data class Payload(val data: Any, val error: Error)

Is there a more elegant way to do this with the Kotlin standard lib?

val values = listOf("name", "ASC", "description", "DESC")
val propNames = values.filterIndexed { index, _ -> index.mod(2) == 0 }
val sortDirections = values.filterIndexed { index, _ -> index.mod(2) != 0 }
propNames zip sortDirections // [(name, ASC), (description, DESC)]

Is there a Kotlinic (idiomatic Kotlin) way for multiple Coroutines to access/manipulate data? Below is some code relating to data access/manipulation:

private val runningFunctions: FuncList = mutableListOf()
typealias FuncList = MutableList<Pair<UInt, String>>

internal fun addRunningFunction(pid: UInt, funcName: String) {
    runningFunctions += pid to funcName
}

internal fun removeRunningFunction(pid: UInt) {
    val list = runningFunctions.filter { it.first == pid }
    if (list.size == 1) runningFunctions -= list.first()
}

internal fun listRunningFunctions() = runningFunctions.toList()
// ...

Would the code above be scalable with multiple Coroutines running at the same time?

Is there a way to use

putAll

on a mutable map, passing it another map and a value transformation function?

putAll

allows you to put all entries of another map into this map, but doesn't let you transform them on the fly.

mapTo

allows you to transform the entries but you can only write them to a Collection, not to a MutableMap. Is there a method that does what the commented-out line does?

fun main() {
    val map1 = mapOf(1 to "one", 2 to "two", 3 to "three")
    val map2 = buildMap {
        put(4, "fourfour")
        put(5, "fivefive")

        // map1.mapTo(this) { (k, v) -> k to v + v } DOESN'T COMPILE

        // instead we have to use:
        putAll(map1.toMutableMap().apply { replaceAll { _, v -> v + v } })
        // or:
        putAll(map1.map { (k, v) -> k to v + v })
    }
    println(map2)
}

is there a way to get this to work?

fun <Result> doit(lambda: () -> Result={Unit}) {

}

when the lambda is not passed i want Result to be of type Unit. I get the error Required: Result, found: Unit.

What is the best way to replace multiple elements in list from another list? For example - some entities from list updates from server and should be replaced in cache by id In general in the case we have two lists of unknown size, let say N And loop gets us that calculation time will be O(n^2) - whether we should loop incoming list and then replace in stored with foreach or conversely Now i solve this like that , but something tell me that speed and performance could be better

fun replaceAlerts(newAlerts: List<ExternalAlert>) {
        val data = stateFlow.value
        val existsAlerts = data.alerts.toMutableList()
        newAlerts.forEach { newAlert ->
            for (i in existsAlerts.indices) {
                if (newAlert.id == existsAlerts[i].id) {
                    existsAlerts[i] = newAlert
                    return@forEach
                }
            }
            existsAlerts.add(newAlert)
        }
        stateFlow.value = data.copy(alerts = existsAlerts)
    }

is there a more idiomatic way to write a map-with-loop like this?

val flowed = allShapes.map {
            var p = it
            for (i in 0 until STRETCH_ITERATIONS) {
                p = flow(p)
            }
            p
        }

Which one would you prefer: 1.

rateLimiter.acquire()
while (System.nanoTime() < endTime) {
    foo()
    bar()
    baz()
    if (System.nanoTime() < endTime)
       rateLimiter.acquire()
}

2.

while (true) {
    rateLimiter.acquire()
    if (System.nanoTime() >= endTime)
        break
    foo()
    bar()
    baz()
}

3.

while (run { rateLimiter.acquire(); System.nanoTime() < endTime }) {
    foo()
    bar()
    baz()
}

Is there a better way to write the following:

override fun compareTo(other: NamedObject): Int {
   // 5 cases
   // we both have null names, compare by oid
   // my name is null, his is not, i'm greater (1)
   // my name is not null, his is, im less (-1)
   // we both have names, compare them
   //    if names are equal, back to oid
   return when {
      name == null && other.name == null -> oid.compareTo(other.oid)
      name == null && other.name != null -> 1
      name != null && other.name == null -> -1
      else -> when (val nameCompare = name!!.compareTo(other.name!!)) {
         0 -> oid.compareTo(other.oid)
         else -> nameCompare
      }
   }
}

In particular, I was hoping to somehow avoid the !!'s in the middle. I was hoping to somehow invoke the smart pointer thing where it turns green and I don't have to check if it's null after I have previously.

I'm excited that I'll be teaching Intro CS with Kotlin this fall. Could someone review my use of KDoc in this code? I know my use of values is unidiomatic.

/**
 * Prompts a user for their name and returns their response.
 */
fun getUserName(): String {
    println("What is your name? ")
    val newName = readln()
    return newName
}

/**
 * Prints a greeting, using the person's [name].
 */
fun greetUser(name: String) {
    println("Hello, $name")
}

/**
 * Carries on a brief conversation with a user.
 */
fun converse() {
    val name = getUserName()
    greetUser(name)
}

Hi guys, I am getting difficult to understand this piece of code. I don't understand how

let

is going inside the lambda block if value is null. Can someone guide me on this. Thanks

I would like to be able to modify the properties in the initializer but nowhere else. Unfortunately, I don't think one can make private setters for properties declared as parameters. (Feel free to correct my terminology.)

class USMoney(var dollars: Int, var cents: Int) {
    init {
        require(dollars >= 0 && cents >= 0)
        if (cents >= NUM_CENTS_PER_DOLLAR) {
            dollars += cents / NUM_CENTS_PER_DOLLAR
            cents %= NUM_CENTS_PER_DOLLAR        
        }
    }
}

I rewrote the code as shown. Is this a good approach and, if so, is there a standard naming convention for the parameters/properties?

class USMoney(_dollars: Int, _cents: Int) {
    val dollars = _dollars + _cents / NUM_CENTS_PER_DOLLAR
    val cents = _cents % NUM_CENTS_PER_DOLLAR
    init {
        require(_dollars >= 0 && _cents >= 0)
    }
}

what is the most performant way to do this:

log("going to work in items ${items.map {it.id}}")

maybe a way to append directly to the string buffer instead of creating an array.

Hello, can somebody explain why this doesn’t compile:

class A {
    fun String.hello() {}
}

fun String.hello2() {
    A().hello() // cannot find hello()
}

I'm trying to find a clean way to build a full name out of nullable components. I'm sure you can do better than I did:

class Person (val personalName: String?, val middleInitial: String?, val familyName: String?) {
    override fun toString(): String {
        val nameParts = mutableListOf<String>()
        if (personalName != null) nameParts.add(personalName)
        if (middleInitial != null) nameParts.add(middleInitial)
        if (familyName != null) nameParts.add(familyName)
        return nameParts.joinToString(separator = " ")
    }
}

Is there a better way of writing this without using scope functions, which I haven't introduced yet?

Hi all, I am trying to create a basic, generic validation implementation. Here is the test class showing 2 alternatives. (I could also create another method checking data types (Int, String, Double, etc) first and then calling validate method but I didn’t prefer to use it.) Could you please share your recommendations? Thanks..

hi gang, is there any nice, easily understandable/identifiable way to turn a list of Byte (

List<Byte>

) into a list of Shorts? (

List<Short>

) such that [ 0x10, 0x01 ] would become [ 0x1001 ]

inline fun <reified C> name() = C::class.simpleName

name<Collection<String>>()

this returns “Collection”. is there a way make it return “Collection<String>“?

A do-while loop seems more appropriate to me:

var x: Int
        var y: Int
        do {
            x = Random.nextInt(0, NUM_COLS)
            y = Random.nextInt(0, NUM_ROWS)
        } while (isOccupied(x, y))
        place(entity, x, y)

I sometimes want to create getters of immutable versions of properties. Is there a better way than having two properties with different names?

Hello! Is

this::field.isInitialized

considered thread-safe? (

field

is a

lateinit var

). Trying to figure out if I need to make sure the field gets created from the same thread that it's later accessed from, or if I can just rely on

isInitialized

being thread-safe 😄

Can any one enhance this code 🌹

private fun getCustomEmployeeShifts(
  employeeShifts: List<Shifts>?,
  approvedOvertimes: List<ApprovedOvertimesModel>?
): List<Shifts> {

  val resultList = mutableListOf<Shifts>()
  var sh: Shifts

  employeeShifts?.forEach { shiftsModel ->
    sh = shiftsModel
    approvedOvertimes?.forEach { appOverModel ->
      if (sh.id == appOverModel.employeeShiftId) {
        sh.approvedOvertimes.add(appOverModel)
      }
    }
    resultList.add(sh)
  }

  return resultList.toList()
}

Hi friends! In this code, I ended up using

var

, but I was wondering if there was a way of getting rid of them (just as a personal challenge). Of course, my life would be easier if

BreakIterator

could implement

Iterable

, but no luck. 😉 Here's the code added for convenience:

fun toGraphemes(str: String) = buildList {
    val boundary = BreakIterator.getCharacterInstance()
    boundary.setText(str)
    var start = boundary.first()
    var end = boundary.next()
    while (end != BreakIterator.DONE) {
        add(str.substring(start, end))
        start = end
        end = boundary.next()
    }
}

Any suggestion is welcome! Thank you! 🦆

Hey guys, style-wise, do you think there is anything “wrong” with a secondary copy-constructor, like:

class Person {

  constructor(id: Int, name: String)  

  constructor(person: Person) : this(person.id, person.name)

}

or would it be “more kotlin-like” to do something like a

fun copy() = Person(id, name)

method?

I've implemented a Minecraft-like game for assignments in a class I am teaching. Classes include

Mob

(abstract),

Zombie

, and

Spider

. I would like to create a class

Spawner<T: Mob>

to create, for example, Spider Spawners (blocks that periodically construct and place new instances of

Spider

). I'm trying to figure out the best way to instantiate a new instance of

T

from within

Spawner<T>

. I tried the following, but it doesn't work because of type erasure:

class Spawner<T: Mob> {
    fun spawn() {
        val constructor = T::class.constructors.find { it.parameters.isEmpty() } // error: Cannot use 'T' as reified type parameter
        val newMob = constructor?.call()
    }
}

I'd rather not require the students to create factory classes. (This is an introductory programming class.) Instead I was thinking of faking a factory with a

copy()

method:

class Spawner<T: Mob>(val mob: T) {
    fun spawn() {
        val newMob = mob.copy()
        // Place newMob on game board.
    }
}

abstract class Mob {
    abstract fun copy(): Mob
}

class Pigman: Mob() {
    override fun copy() = Pigman()
}

fun main() {
    val pigmanSpawner = Spawner<Pigman>(Pigman())
    pigmanSpawner.spawn()
}

Something I don't like about this is the type parameter isn't used and could be removed (if I changed the type of the

mob

property from

T

to

Mob

).

In general should we prefer using simple try-catch pattern instead of

runCatching

in cases where we care about only one type of exception or is this too much neatpicking? For example:

val result = runCatching { transaction() }
return result.getOrElse {
    if (it is IllegalArgumentException) return null else throw it
}

vs

return try {
    transaction()
} catch (e: IllegalArgumentException) {
    null
}

Thanks in advance for any answers !