Are there any generalized functions like joinToString ? Currently I just need something like a forEach but with a sideeffect between elements.

Hi often find myself having a mutableMap where the values are mutable collections, and so I created this extension :

fun <K, V> MutableMap<K,V>.getOrCreate(key : K, create : ()->V?) : V? {
    return if (containsKey(key) ) {
        get(key)
    } else {
        put(key, create())
    }
}

https://github.com/JetBrains/kotlin/pull/3087 running again and again into situations where I need a

when

expression to be exhaustive and it is exhaustive but the compiler cannot know, current example is

java.nio.ByteOrder

which has exactly two instances but is not defined as an enum.

is there something like

fun <T, K> List<T>.toMapBy(keySelector: (T) -> K): Map<K, T>

? i know there is

.groupBy

but that returns a map of lists, while most of the time i'd want the equivalent of

myList.map { it.myKey to it }.toMap()

small proposal that seemingly does not exist yet:

/** merge another map into this map,
 * storing the result of applying the given remapping function to the two values if there is a key-conflict. */
fun <K, V> MutableMap<K, V>.putAllWith(other: Map<K, V>, remappingFn: (V, V) -> V) = other.forEach { (k, v) ->
    merge(k, v, remappingFn)
}

any maybe a matching

plus

-like operation (

unionWith

?)

I find myself usually finding an item by a variable and then return the variable itself, ie: `

items.list.filter { .. }.maxBy { it.depth }?.depth ?: -1

what about providing a

maxOf((E)->T)

?

What about adding the opposite of

@Suppress

? E.g.

@Enforce

. For example with non-exhaustive

when

expressions:

‘when’ expression on sealed classes is recommended to be exhaustive, add ‘is …’ branch or ‘else’ branch instead

With

@Suppress("NON_EXHAUSTIVE_WHEN_ON_SEALED_CLASS")

the warning is gone. With

@Enforce("NON_EXHAUSTIVE_WHEN_ON_SEALED_CLASS")

the warning will turn into an error. That would allow catching missing branches earlier (e.g. when adding a new subclass to a sealed class). It would even allow developers to turn any warning into an error for specific code, i.e. depending on the use case. I guess that would be most useful for compiler warnings as the non-exhaustive

when

warning is an inspection and wouldn’t cause the compilation process to actually fail 🤔

Just saw this comment about the experimental time measurement API.

Clock

,

ClockMark

, etc are being renamed to

TimeSource

,

TimeMark

, etc. https://github.com/Kotlin/KEEP/issues/190#issuecomment-591081265

Didn't find it but is there a

substring

method :

fun String.substring(maxLength : Int): String {
    return if (length > maxLength) substring(0, maxLength) else this
}

https://blog.jetbrains.com/kotlin/2020/03/kotlin-1-3-70-released/

You know this convention in Kotlin: having a pair of functions, where the first one throws an exception if the operation isn’t possible, and the second one returns 

null

, like 

string.toInt()

 and 

string.toIntOrNull()

. Now we’ve added new 

randomOrNull()

 and 

reduceOrNull()

 counterpart functions, following the same convention

If this is a convention, then why there is no

max(): T

and

maxOrNull(): T?

and instead we have a

max(): T?

? We had a discussion about it here https://kotlinlang.slack.com/archives/C1H43FDRB/p1551864308014200

This message was deleted.

Is 1.4's

Result

binary compatible with 1.3.70's? Or, put another way, how dangerous would it be to ship a library which uses

Result

with 1.3.70 in anticipation of it being available for use in 1.4?

Hey! I was browsing reddit and saw an article with some fuel for thought. https://www.reddit.com/r/Kotlin/comments/ftnvzd/stop_scan_and_scanreduce_before_its_too_late/

Hello, I spotted this very interesting KEEP about

fun CharSequence.occurencesOf

. It's shown as "Implemented" (with no version specified), but I'm not finding it in autocomplete in Kotlin 1.3.72. Is that a mistake or is there a way to access it? https://github.com/Kotlin/KEEP/blob/master/proposals/stdlib/occurrences-of.md

Shouldn't stdlib contain such a function?

fun CharSequence.equalsIgnoreCase(that: CharSequence): Boolean {
    val len = length
    if (that.length != len) return false
    return regionMatches(0, that, 0, len, ignoreCase = true)
}

Dealing with `CharSequence`s is pretty painful in Java, I'd like Kotlin to fix this…

Hello, World! Hey I'm very often finding myself needing a

indexOf

but with a default value (instead of -1). Is this something that exists? If not, I'm gonna make my own extension - what would you name it? 🙂

Question: why is

emptyList()

a generic function that returns a

List<T>

, instead of a non-generic function that returns a

List<Nothing>

? (Or even a constant or object?)

Btw, why Kotlin has its own

object EmptyList

? There are already

Collections.emptyList()

and `List.of()`…

I love such an idiom in Rust:

What about a function

inline fun <T> __apply(receiver: T, block: T.() -> Unit): T

(name tbd) which behaves excactly like the current`apply`. Reasoning: When using Java libraries I tend to avoid extension functions with "simple" names (such as

apply

,

run

,

let

, etc.) since it is always possible that a method with the same name is added to a class in a Java library. Due to Kotlin's resolution rules this could easily result in a source-incompatible change (depending on the exact method signature). However, with

__apply(object)

this would not be a problem. Additionally, there is already a similar pattern in the stdlib:

with

and

run

. (See also https://kotlinlang.org/docs/reference/scope-functions.html#function-selection) Bonus "real-world example": https://github.com/LWJGL/lwjgl3/issues/554

I understand the kotlin "equivalent" of java's try-with-resources is the use() library function However, if exceptions occurs, use will just fail silently. Is there any alternative function/idiom that allows to manage exceptions explicitly without having to manually close the used resource?

I would just use if/else

public infix fun IntProgression.step(step: Int): IntProgression {
    checkStepIsPositive(step > 0, step)
    return IntProgression.fromClosedRange(first, last, if (this.step > 0) step else -step)
}

else

branch is dead here

Hello, World! Is it still a fact that there is no MultiMap in the stdlib?

is there no equivalent

Regarding maxBy, I have the following situation: I want to use maxBy for a collection on a value which is nullable, and if the value is null I don’t actually want it but instead return null. The selector of maxBy requires the return value to be not null, so I have to write

maxBy { it.someNullableValue ?: Long.MIN_VALUE }

. This will return me the first value if the list is not empty, so I would have to append

.takeIf{ it?.someNullableValue != null}

, which is fine for short cases like this, but when the value to compare is not top level but itself created by a more complex expression like

it.someList.filter{…}.maxBy{…}?.someNullableValue

you need to write that same complex expression twice in the

takeIf

part. So I wrote

maxByOrNullIfNull

(kind of a bad name I know)

inline fun <T, R : Comparable<R>> Iterable<T>.maxByOrNullIfNull(selector: (T) -> R?): T? { // Allows selector to return R?
    val iterator = iterator()
    if (!iterator.hasNext()) return null
    var maxElem: T? = iterator.next()
    var maxValue: R? = selector(maxElem!!) // Here, we know maxElem is not null
    if(maxValue == null) {
        maxElem = null
    }
    if (!iterator.hasNext()) return maxElem
    do {
        val e: T = iterator.next()
        val v: R? = selector(e)
        if(v != null) {
            if(maxValue == null) {
                // If we don't have any non-null element yet, set the current element / value
                maxElem = e
                maxValue = v
            } else if (maxValue < v) {
                // Here, we know both values are not null, so we do the usual comparison
                maxElem = e
                maxValue = v
            }
        }
    } while (iterator.hasNext())
    return maxElem
}

I would argue that this would be a nicer default behavior for

maxBy

, as it doesn’t really change the behavior for non-null cases, but makes clear that null values will always be considered “less” than any actual value in the comparison (no more need for

?: Long.MIN_VALUE

or something) and that we want an element with an actual value, not one that has no value for the comparison.

IntRange.forEach

uses

Iterable.forEach

, so

(1..n).forEach { ... }

creates an

Iterator

, while

for (k in (1..n)) { ... }

is optimized to use a while-loop, not even creating the original

IntRange

object. Could

IntRange

receive its own

forEach

extension method to preserve this optimization, and perhaps receive additional optimizations for common methods like

map

?

Is there a better way to write these bit masks?

val impulseDownAllowed: Boolean = capabilitiesByte and 0x10.toByte() != 0.toByte()
val bleMovementAllowed: Boolean = capabilitiesByte and 0x20.toByte() != 0.toByte()

I've found myself implementing this in a couple of different projects now... do you guys think there might be a place for it in the standard library? The closest I've got using the existing functions is chaining

filterIsInstance

and

first

but I imagine this is a little better performance wise as we are returning after the first match. It's like

first

is to

filter

... `firstIsInstance`/`filterIsInstance` 😄

inline fun <reified T> Iterable<*>.firstIsInstance(): T? {
    for (element in this) {
        if (element is T) {
            return element
        }
    }

    return null
}