my assumption was that the lambda in getOrElse should need to return Heros object as default value

Can I make an interface with variable types? interface IProcessor { fun <A> process(f: (A)-> Unit): ProcessorStatus }

I'm calling assertEquals on two lists in a test case, but unfortunately i've run into the issue that list equality calls

.equals()

instead of

==

, the two of which give me a different results.

>>> 0f == -0f
res0: kotlin.Boolean = true
>>> 0f.equals(-0f)
res0: kotlin.Boolean = false
>>> listOf(0f) == listOf(-0f)
res1: kotlin.Boolean = false

The best way I've come up with to solve this is by defining my own assertEquals function that works on List<Float>, but this doesn't seem very clean to me. Is there a better way to do this? Also, why doesn't list equality use

==

?

Listener registration not working in fragment to Dialog fragment communication. Am I missing anything for registration ?

override fun onAttach(context: Context) {
    AndroidSupportInjection.inject(this)
    super.onAttach(context)
    if (context is Listener) {
      listener = context
    }
  }

  override fun onDetach() {
    super.onDetach()
    listener = null
  }

how may I extract the

return

(short and elegantly)?

fun getArgCount(): Int {
        when (lastToken) {
            null -> return 1
            is Token.OpenParentheses, is Token.ArgumentSeparator -> {
                return 1
            }
            else -> (lastToken as? Token.Operator)?.operator?.let { lastOp ->
                if (lastOp.numOperands == 2 || lastOp.numOperands == 1 && !lastOp.isLeftAssociative)
                    return 1
            }
        }
        return 2
    }

hi guys, i needs some review for my code.

fun A(infoA: Info, conn: Connection, userId: Int): Result {
        val overSettingOfA: OverSetting = AppSetting.instance.retrieveA(infoA, conn, userId)
        // some code
        return Result(overSettingOfA)
    }



    fun B(infoB: Info, conn: Connection, userId: Int, someInfo: SomeInfo): Result {
        val overSettingOfB: OverSetting = AppSetting.instance.retrieveB(infoB, userId, conn, someInfo)
        // some code
        return Result(overSettingOfB)
    }

Both of 

fun A

 and 

fun B

 have the same logic, what they are doing is all the same. I m trying to do likes high order function but the problem is the argument is not the same, 

fun A

 has 3 arg and 

fun B

 has 4. Is there any a magical way? 😀

Hello, I am a beginner in Kotlin and in general statically typed language. I wanted to practice the OOP concepts using Kotlin, so I wrote some code for implementing singly linked list (one mutable and one immutable) as Kotlin’s Collection, referencing some codes from Kotlin’s source code. I’m yet not so confident with how I structure the code using interfaces and classes, so I’d like to get some comments. Thanks a lot in advance. An exemplary question that arose was: should I have used abstract class in between? (I am not yet sure what the differences between interfaces and abstract classes are, and when to use which.)

Do you prefer

abstract class A {
  abstract fun doSomething()
}

with

object: A() {
  override fun doSomething(){}
}

or

class A(private val doSomething: () -> Unit)

with

A() {...}

?

@LastExceed

val last = (0..3).flatMap { x ->
    (0..3).map { y ->
        offsets.sumBy { (first, second) ->
            arr[y + second][x + first]
        }
    }
}.max()

For filtering true booleans: 1️⃣

.filter { it }

or 2️⃣

.filter(true::equals)

I'm trying to update a property of a class in place, but the updates are having no effect unless I do it via re-assignment. I know there is a better way but I'm failing to find it...

data class counters(var small: Int, var big: Double)
fun Int.add3() : Int = this + 3   // accepts Int, returns Int
fun Double.times2pt5() : Double = this * 2.5 

fun main() {
    val mycounters : counters = counters(4, 201.0)
    mycounters.small.apply{ this.add3() }
    mycounters.apply { this.big.times2pt5() }
    println(mycounters) // prints 4, 201.0 -- same as original
    
    val uglyCounters : counters = counters(6, 401.0)
    uglyCounters.apply {
        this.small = this.small.add3()
        this.big = this.big.times2pt5()
    }
    println(uglyCounters) // works, prints 9, 1002.5, but is ugly
}

how can I optimize this piece of code?

Is there a more functional approach to this? I don't really like creating a new variable just to check if it is empty. Thanks guys!

val newSmth = listOfObjects.filter { ... }
        if (newSmth.isNotEmpty()) {
            otherWorkflow.process(newSmth)
        }

Hi people, I'm not sure about how to satisfy compiler. I wrote next code

class DebounceClickListener(val clickListener:View.OnClickListener): View.OnClickListener{}

Wrote a list/table syncing function in idiomatic Kotlin and without. I find the non-idiomatic one more readable right now. Would love to hear a better way to write it. Both pass my unit tests. https://gist.github.com/AfzalivE/48a9e225246c5cee144b06695f68731a

Do you prefer people to use

filterNot

or

filter { not condition }

. I missed

Not

in the

filterNot

recently in review. It is probably matter of time when I will be fine.

Is there a better way to do this?

class FlowDelegate<T>: ReadWriteProperty<Any, Flow<T>> {
    private val deferredFlow = CompletableDeferred<Flow<T>>()

    override fun setValue(thisRef: Any, property: KProperty<*>, value: Flow<T>) {
        deferredFlow.complete(value)
    }

    override fun getValue(thisRef: Any, property: KProperty<*>): Flow<T> {
        return if (deferredFlow.isCompleted) {
            deferredFlow.getCompleted()
        } else {
            flow {
                emitAll(deferredFlow.await())
            }
        }
    }
}

/** Usage */
class MySample {
    private var _sampleFlow by FlowDelegate<String>()

    val sampleFlow: Flow<String>
        get() = _sampleFlow

    fun init(args: ...) {
        _sampleFlow = flow<String> { /* based on args */ }
    }
}

Hello , how to write this function is best way ?

fun String?.trimTrailingZeros(): String? {
    if (isNullOrEmpty() || this!!.indexOf(".") < 0) return this
    return replace("0*$".toRegex(), "").replace("\\.$".toRegex(), "")
}

Is there a collection function to pair one element with all others from the same list? For example: given

listOf(A,B,C)

I would like to end up with the following pairs:

A to B, A to C, B to C

Currently I got something like this but it feels non-idiomatic and inefficient...

val users = listOf(User("A"), User("B"), User("C"))
	val chats = users.flatMap{ u1 ->
        users.filterNot { u1 == it }
            .map { u2 -> Chat(setOf(u1, u2)) }
    }.toSet() // filters out duplicates

in a api like this:

data class User(
    val name: String,
    val birthday: LocalDate
)
Find<User>().where(User::name.like("blah%").and(User::birthday.between(date1, date2)))

can i somehow change it to make it possible to remove the

User::

part and rewrite it like

Find<User>().where(::name.like("blah%").and(::birthday.between(date1, date2)))e

I’ve got a

Sequence

of `String`s and apply lots of mapping operations. Now, after these mappings I want to access the original index in the sequence. However, if I use

mapIndexedValue

then I need to change each mapping operation implementation. Instead, is it recommended to declare and use something like this (not tested) so that we can continue to use the same transforms as before? Side note: is there a danger in using mutable values like this?

data class IndexedMutableValue<T>(val index: Int, var value: T)

fun <T> Sequence<T>.withIndexedMutableValue(): Sequence<IndexedMutableValue<T>> =
    mapIndexed { index, t -> 
        IndexedMutableValue(index, t)
    }

fun <T> Sequence<IndexedMutableValue<T>>.mapIndexedMutable(transform: (T) -> T): Sequence<IndexedMutableValue<T>> {
    forEach { it.value = transform(it.value) }
    return this
}

fun <T> Sequence<IndexedMutableValue<T>>.mapIndexedMutableNotNull(transform: (T) -> T?): Sequence<IndexedMutableValue<T>> {
    forEach { it.value = transform(it.value) ?: return@forEach }
    return this
}

fun <T> Sequence<IndexedMutableValue<T>>.flatMapIndexedMutable(transform: (T) -> Sequence<T>): Sequence<IndexedMutableValue<T>> {
    return sequence {
        forEach { indexedValue ->
            transform(indexedValue.value).forEach { newValue ->
                yield(indexedValue.copy(value = newValue))
            }
        }
    }
}

Any better way than this to transform a string to a map?

private fun cookieStringToMap(string: String): Map<String, String> {
    val map = mutableMapOf<String, String>()
    string.split(";").forEach { entry ->
        val parts = entry.split("=")
        map[parts[0]] = parts[1]
    }
        
    return map
}

is there a simpler way to write this:

return if (value != null)
            (value as Number).toDouble()
        else
            null

(not

(value as? Number).toDouble()

, which acts differently)

I gave https://adventofcode.com/2020/day/11 a try and this is my solution. It works, but i'm not happy with it. any ideas how to improve the readability ? or is functional style bound to be unreadable ?

I am playing around with different ways of defining a factory function to map a scalar to an enum. For instance:

enum class OpCode(val code: Int) {
    QUERY(0), IQUERY(1), STATUS(2), NOTIFY(4), UPDATE(5), UNSUPPORTED(-1);
}

fun Int.toOpCode(): OpCode {
    return OpCode.values().find { it.code == this } ?: OpCode.UNSUPPORTED.also {
        log.error { "Unsupported DNS OpCode $this" }
    }
}

This uses a receiver function, which I like in general, and obviously there are many different ways of writing this function (such as

fun toOpcode(code:Int): Opcode

) etc. Now, it occurred to me that this is also possible:

enum class OpCode(val code: Int) {
    QUERY(0), IQUERY(1), STATUS(2), NOTIFY(4), UPDATE(5), UNSUPPORTED(-1);

    companion object {
        operator fun invoke(code: Int): OpCode {
            return values().find { it.code == code } ?: UNSUPPORTED.also {
                log.error { "Unsupported DNS OpCode $this" }
            }
        }
    }
}

This allows the caller to map an

Int

to an

OpCode

using what looks like a constructor:

val code = OpCode(0)

What would you say if you saw this in a pull request? Is this clever and nice, or horrible and confusing and just showing off? I keep switching sides myself... 🙂

I’m surprised there is not something for this in the standard lib. Is this okay or maybe remove inline/reified?

inline fun <reified K, V> Map<out K?, V>.filterKeyNotNull(): Map<K, V> =
    mapNotNull { (key, value) -> if (key != null) key to value else null }.toMap()

I have this (ugly) code that works :

lifecycleScope.launch {
    viewModel.state.collect { updateState(it, binding) }
}
lifecycleScope.launch {
    viewModel.load()
}

I cannot have

viewModel.load()

inside the first block after

collect

since it never ends and if I put it before I miss a bunch of events. Is there a way to write this in a better way?

When using slf4j (or other) loggers, do you use 1️⃣ string interpolation -

<http://logger.info|logger.info>("the value is $value")

2️⃣ passing additional arguments -

<http://logger.info|logger.info>("the value is {}", value)

3️⃣ :thread-please: something else?

What name should I use instead of

toNumber()

for the following code to follow the kotlin style guide.

class ArrayND {
    var data: ArrayList<Double> = {...}
    var shape: Array<Int> = {...}

    operator fun get(vararg indicies: Int): ArrayND {...}

    fun toNumber(): Double {
        if (data.size == 1) {
            return data[0]
        } else {
            Throw Error
        }
    }
}