I have a question about contracts. For me it looks like the implies result can only be handled directly and not with an intermediate variable. (code in thread)

Just published my writeup about CVE-2020-29582. A vulnerability in the Kotlin Standardlib from last year. Unfortunately, JetBrains does, what is in my opinion, a terrible job of disclosing their own vulnerability details. I've brought this up before, but they haven't done anything to improve the situation. Anyways, here's the disclosure: https://github.com/JLLeitschuh/security-research/security/advisories/GHSA-5w9v-8x7x-rfqm

Hi , is there any reason kotlin forbids identity equality for value class !?

import Three.Companion.toThree

@JvmInline
value class Three private constructor(val value: Int) {

  init {
    require(value >= 1)
    require(value <= 3)
  }


  companion object {
    private val array by lazy {
      arrayOf(Three(1), Three(2), Three(3))
    }

    fun Int.toThree(): Three {
      return if (this in 1..3) {
        array[this - 1]
      } else {
        val index = (this % 3).let { r -> if (r == 0) 3 else r }.let { v -> if (v < 1) v + 3 else v }
        array[index - 1]
      }
    }
  }
}


fun main() {
    println(1.toThree() == 4.toThree())
    println(1.toThree() === 4.toThree()) // Identity equality for arguments of types Three and Three is forbidden
}

Online playground here : https://pl.kotl.in/uBVYwgQgO?theme=darcula

If I create a new class that only inherits from

Any

, what is the default

equals()

implementation, given I don’t override it myself? The source code for

Any

doesn’t show what the default is

public open operator fun equals(other: Any?): Boolean

Is there a reason

kotlin.Array<E>

doesn't implement

kotlin.collections.Iterable<E>

? They both define

public operator fun iterator(): Iterator<E>

. I know Java arrays don't, but does that limit Kotlin ones? (I've often thought it would be convenient if

Array<E> : FixedLengthMutableList<E>

&

FixedLengthMutableList<E> : List<E>

, if that could all be done synthetically at compile time - is it reflection that prevents this? If so another reason to loathe reflection...)

What is the path to

Regex.matchAt

/

Regex.matchesAt

being stable? The issue which added the API (in 1.5.30?) was referenced on the issue for stabilizations in 1.6 but those APIs did not become stable in 1.6. Are things automatically bumped to be looked at in 1.7? Or is stabilizing in a 1.6.x an option? Does there need to be an issue tracking this?

Is it planned a

dropLastOrEmpty

(or

dropLastOrNull

?

We have functional interfaces/single abstract method (SAM) interfaces e.g.

fun interface MyInterface {
    fun myMethod(): Int
}

which can be created with a lambda

val myInterface: MyInterface = { 4 }

but is there an equivalent for single abstract property interfaces? It could look like

fun interface MyInterface {
    val myProperty(): Int
}

and be called like

val myInterface: MyInterface = 4

Is there an

appendLines

in

buildString

or the only way is something like

list.forEach(::appendLine)

?

Recently I saw a post for Kotlin 1.5.0 and I decided to use

assertIs

method in whole instance checks in my tests, and I replaced many of

assertTrue { it is SomeClass }

with

assertIs<SomeClass>(it)

Now, I am checking my coverage and it decreased, all the

assertIs

methods seems partially covered Is it expected? are they really partially covered ?

Hi, I was interested in suggesting a new standard library function in kotlin.collections and in writing it myself and making a pull request to contribute, Is this something that would be of interest? I found myself wanting this function but it not existing in the standard library, it would be

binarySearchIndexed

With a signature of perhaps

fun <T : Comparable<T>> List<T>.binarySearchIndexed(
    fromIndex: Int = 0,
    toIndex: Int = size,
    comparison: (T, Int) -> Int,
): Int

Thread in Slack Conversation

given a list of String with the following content, what is a idiomatic way to split the list into sublists according to this example?

val l = listOf(”P”, ”s”, ”P”, ”s”, ”s”, ”P”, ”P”, ”s”)

l.foo() -> [[”P”, ”s”], [”P”, ”s”, ”s”], [”P”], [”P”, ”s”]]

Guys from kotlin stdlib/core team, can we have something similar to this in kotlin? https://forums.swift.org/t/pitch-regex-builder-dsl/56007

Our Java code use in-house developed helper functions

hasContent

and

noContent

which are overloaded for strings, collections, maps, stringbuilders, ... and treat

null

as "no content". While switching to Kotlin, we try to use as much of Kotlin stdlib methods as possible. Our

noContent

easily translates to

isNullOrEmpty

, but

hasContent

results in

!isNullOrEmpty

which is not pretty, especially if that is at the end of a chain because it separates the

!

from the method:

!foo.bar.baz.isNullOrEmpty()

. Is there a place for

isNotNullOrEmpty()

in stdlib? (And yes, I realize that once we finished our journey from Java to Kotlin, we can drastically reduce the usage of nullable types and thus often use

isNotEmpty()

. But that is still a long and windy road). Update: I should have searched for this in YouTrack before asking: was rejected in KT-33689 because it claimed we could "shortly" write `foo.bar.baz.!isNullOrEmpty()`as described in KT-5351 . I guess that time will only come though after K2 went GA.

Does anyone know why the Kotlin standard library provides a type-preserving

filter

on

Map<K, out V>

but not

Set<T>

? Writing

set.filter { ... }.toSet()

seems a little repetitive. https://kotlinlang.org/docs/collection-filtering.html#filter-by-predicate

Is there any reason why "startsWith" is not marked as infix?

Just recently (in an answer in #getting-started) I found myself writing these functions:

fun <A, B,    R> ((A, B   ) -> R).curry(a: A): (B   ) -> R = { b: B       -> this(a, b   ) }
fun <A, B, C, R> ((A, B, C) -> R).curry(a: A): (B, C) -> R = { b: B, c: C -> this(a, b, c) }

Do they already exist in the stdlib? Or are they a bit too Haskelly for Kotlin?

With the new context receivers, is there a difference between:

context(Foo)
fun bar() {
    ...
}

and

fun Foo.bar() {
    ...
}

? If not, will the 2nd way of writing be eventually deprecated?

From the announcement, is seems that there are no changes to stdlib between 1.6.10 and 1.6.20. Is that correct?

Could we add

fun String.startsWith(

prefix: Regex,

ignoreCase: Boolean = false

): Boolean

(and also

endsWith

)? The

ignoreCase

parameter would be debatable, but since the

String

variant has it and it's easy to add to the implementation, I would vote to keep it.

Does anyone know of a delegate like lazy that supports vars?

When building a map, which of these two guidelines do you think is better: 1. Use

mapOf

unless it has to be a hashmap, in which case use

hashMapOf

. 2. Use

mapOf

to document to your readers that entry order is important, or

hashMapOf

to document that order doesn't matter.

Any alternative to

List.zip(List).toMap(mutableMapOf())

?

Is

MutableCollection.addAll(Collection/Iterable/Sequence/Array

) faster if the input and/or output are certain types of collections?

Is the answer to that question just a Java question on the JVM? Are all Kotlin collections just aliases to Java collections? Or are there some Kotlin collections and the performance would be different for those?

Noticed this warning today,

Non exhaustive 'when' statements on sealed class/interface will be prohibited in 1.7, add 'else' branch

Does that mean using a sealed class/interface will no longer be exhaustive in a

when

. I thought that was a feature of ``sealed`?

Hey all, I have a best practices question regarding stdlib lists vs sequences. My understanding is when it comes to list builtins like map and filter, they will create a new list whereas sequences will lazily evaluate and combine the operations when appropriate. If I am using more than one of the collection builtins, should I always prefer to transform it to a sequence? Or combine them myself into one

.mapNotNull

if possible? Or is it strictly a judgement call based on the size of the data expected since iterating over a list of size 2 twice is really not a big deal

whats the best way to get an exhaustive map? (with an enum as a key). I could use a when and copy its output to a map with a utility method that calls the when for every key. is there a better way?

Just curious, what is the motivation for

kotlin.ranges.coerceAtLeast

and

kotlin.ranges.coerceAtMost

, any reason these should be used in place of

maxOf

/

minOf

? It surprises me that their implementation is not just

Math.max

and

Math.min

, but maybe I’m missing something!

Is there any reason why

Sequence<T>.drop(n: Int)

param type is

Int

instead of

Long

? I thought Kotlin’s sequence is equivalent to Java’s stream, and presuming the type should be the same as

Stream<T> skip(long n);