Hi! Is there a method for

MutableMap

which accepts key and the lambda :

(V?) -> V

and replaces a value at that key with what lambda returns (or puts value if it's absent)? I haven't found it, so thinking maybe I've missed some idiom...

mapValues

work for

Map

you may implement your version of it for your mutable map

yes, I want something tailored for mutable variant. Sure, can implement, just thought if missed some existing solution...

In jdk8 support you have map.compute, if thats any help

nope, android here... 🙂

Hello everyone.

Standard.kt

has two

run()

functions - one takes a receiver and one does not. I'm trying to find a good use case for the one that does not take a receiver.

I've not been able to find anything that it allows you to do that you can't do in other ways.

I did notice that it could add some readability to code in some cases:

fun welcome() = "Hello"
    fun farewell() = "Good-bye"
    fun getFunction(b: Boolean) = if (b) ::welcome else ::farewell

    // Not very readable
    println(getFunction(true)())

    // A little more readable
    println(getFunction(true).invoke())

    // Also a little more readable - possible use case for `run()`
    println(run(getFunction(true)))

Just wondering if anyone can think of other use cases that I might be missing.

Might be useful as the default value for a lamda parameter?

eg

fun foo(event: () -> Unit = run) { ... }

run

without receiver can be invoked in a scope, where you don't have a receiver, for example in top level function. The original use case of

run

was to execute a block of code and return the result of its last expression:

val result = run {
    val a = getA()
    val b = getB()
    a + b
}

Later it was generalized with an overload with receiver, so one could change the value of

this

inside the lambda.

@ilya.gorbunov I tend to use that also sometimes instead of

init{ }

on class properties when it's just 2/3 loc..

Thanks for your feedback, everyone. And thanks @ilya.gorbunov for the extra historical context.

Hey guys, I added kotlinx.immutable.collections to my project and I cant seem to call the

operator plus

extension functions, it seems locked to using the

kotlin.collections

(non) immutable extension functions instead

is this because of some update to the way kotlin resolves overloaded functions?

ahh no, it was a mistaken import, I had both guava's and kotlinx-immutable's

ImmutableMap

on my path

@groostav without an explicit import of

kotlinx.collections.immutable.*

the operators for read-only collections are chosen, because they are imported by default.

Given how subtle this difference is, we plan to remove read-only collection interfaces from bases of immutable ones, so that an explicit conversion to read-only would be requried, see this issue: https://github.com/Kotlin/kotlinx.collections.immutable/issues/10

it'd be nice to have

until

on `Enum`s

also, it looks like I can use

rangeTo

inside the

Enum

itself without issues, but outside I get error

@elect Could you illustrate what error do you get and why do you need to use rangeTo/until for enums?

sure, it's a nice to have feature, so that I could loop

Format

as following https://github.com/kotlin-graphics/gli/blob/working/src/test/kotlin/gli_/coreLoadGen1d.kt#L14

about the error, here I can use

..

even if I comment out

rangeTo

at the end of the same enum https://github.com/kotlin-graphics/gli/blob/working/src/main/kotlin/gli_/format.kt#L264

but once I comment that out, the

..

I am using in the test doesnt work anymore

If you comment that operator, then the

Comparable<T>.rangeTo

is used. And it creates just range, not a progression, so it can't be iterated.

so it's as planned

nevertheless, it'd be nice to have

I don’t understand ceil, floor, round functions in the version 1.2 of the lib. The doc says :

Rounds the given value [a] to an integer towards negative infinity.

and the implementation (js) is:

public inline fun floor(a: Double): Double = nativeMath.floor(a).unsafeCast<Double>()

Why returning a Double and not an Int?