Tried to use the

replace

function

inline fun CharSequence.replace(regex: Regex,  noinline transform: (MatchResult) -> CharSequence): String

And found out that I can't easily destructure the lambda parameter and have to use

MatchResult.destructured

instead http://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/-match-result/destructured.html Why the most intuitive usage

text.replace(Regex("(\\d+)(\\w+)")) { (digits, letters) -> ""}

was not supported? What's the point of having a separate wrapper for desctructuring? http://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/-match-result/-destructured/index.html Shouldn't we add

componentN()

extension function to

MatchResult

?

@voddan

What's the point of having a separate wrapper for desctructuring?

The wrapper changes the group numbering, so that

component1

corresponds to the group with index 1, rather than 0. We had experimented with the design when

MatchResult

can be destructured immediately, but found that very confusing https://discuss.kotlinlang.org/t/public-review-of-the-standard-library-apis-closed/1362/76

📣📣📣 A quick survey about immutable collections. 📣📣📣 If you had the immutable collections in Kotlin, what would you use them for? We need to gather some use cases to better understand which implementations of immutable collections should be provided/should be default.

I think by far, the most common use-case is going to be combining collections (either a union of two sets, or concatenating two lists)

Would a PR for adding a pow() extension for BigDecimal be welcome in MathJvm?

What's the canonical way of zipping 3 lists?

@mg6maciej Zipping lists is IMO better when preserving type information but it requires boilerplate for the different arities:

data class Tuple3<A, B, C>(val a: A, val b: B, val c: C)

fun <A, B, C> List<A>.zip(g: List<B>, h: List<C>): List<Tuple3<A, B, C>> =
  this.zip(g).zip(h).map { (ab, c) ->
    val (a, b) = ab
    Tuple3(a, b, c)
  }

fun main (args: Array<String>) {

    val l1: List<Int> = listOf(1, 2, 3)
    val l2: List<Char> = listOf('1', '2', '3')
    val l3: List<String> = listOf("1", "2", "3")

    val zipped: List<Tuple3<Int, Char, String>> = l1.zip(l2, l3)

    println(zipped) //[Tuple3(a=1, b=1, c=1), Tuple3(a=2, b=2, c=2), Tuple3(a=3, b=3, c=3)]

}

you should also add

func: (A, B, C) -> T = ::Triple

if you can

what's

kotlin.internal.contracts

is used for?

When random will be added to stdlib

and to answer your second question: yes they are, but they also enable a unified API that can be ported to other platforms which do not have

java.lang.Math

(which is required for #multiplatform)

for(x in 0 until prices.size) {
            if(prices[x]<min) min=prices[x]
            else max=Math.max(max,prices[x]-min)
        }

on leetcode took 332ms

@asad.awadia Why not:

val minPrize = prices.min()
val maxProfit = prices.min() - minPrize

?

example, I have a geometry lib (https://github.com/kotlin-graphics/glm), where I'd like to write

val color = Vec4()
val vertexData = floatArrayOf(*color)

Should I use

someMap.filterValues { it != null }.mapValues { it.value as Any }

or is there anything like

someList.filterNotNull()

for `Map`s?

Using

org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.2.30

I cannot use

use

on

AutoCloseable

, is that correct? How can I "use" an

AutoCloseable

?

Or simply

boolarr.contains(true)

. An IDE warning here would be nice indeed.

Is there a ticket for it?

Is there a way to disable not null checks? https://stackoverflow.com/questions/49360740/disable-not-null-checks-in-kotlin

hey gents, regarding list/set/sequence extension functions, is there a discussion about including those same extension functions that take custom equality comparators? EG:

public infix fun <T> Iterable<T>.intersect(other: Iterable<T>): Set<T> {
    val set = this.toMutableSet()
    set.retainAll(other)
    return set
}

public fun <T, C> Iterable<T>.intersect(other: Iterable<T>, comparator: (T, T) -> Boolean) { //...

Yes. But

kotlin.Throwable

isn’t extending

java.lang.Throwable

. Also the docs are not too helpful: https://kotlinlang.org/docs/reference/exceptions.html states that

All exception classes in Kotlin are descendants of the class Throwable

but I could not find any example in the stdlib. E.g. see kotlin.KotlinNullPointerException as a counter-example.

Some ideas to make std better: file I/O functionalities Generate random number (rand()) Make more collections: SortedSet, SortedMap, LinkedList, TreeMap. Make constructors for Map and Set (interfaces) Native implementation of List.shuffle

Got more ideas: Theads. Pointers (as mentioned in #kotlin-native, It will be a great addition) And @ilya.gorbunov, in the brackets we can use Pair() or A to B similar to mapOf()

Hi everyone, I was reasoning about the semantic meanining of the stdlib’s

public inline fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean

with my colleagues and I realized that a lot of them have different intuitive expectations about the output of the function when called on an empty list. Can someone provide some insights about the decision of make it return

true

if the list is empty? Thanks!

Hi! How do I replace last space in sting:

one two three

->

one two\nthree

. There's

replaceFirst

, but no

replaceLast

Hello! I'm doing some research on type aliases, so I'm looking through the standard library to see how

typealias

is used. I've found that it's most frequently used to map some common classes (e.g., exceptions,

StringBuilder

,

ArrayList

,

Serializable

) to the corresponding Java classes. I was curious if @ilya.gorbunov or someone else at JB can fill me in on the purpose of these particular aliases in the standard library. Are they intended to save on imports (e.g., no need to import

java.util.*

if

ArrayList

is found in

kotlin.collections

)? Or to give Kotlin the flexibility to expand on the interface of those classes in the future? Or something else? Thanks!

(This is probably not the right channel but I'm not sure what would be) How does the Kotlin compiler decide when the class generated for a lambda includes the

this

reference? I'm using Apache Spark and my jobs is failing due to the task not being serializable because one of my lambda's generated class includes the

SparkJob

reference (which I don't want

Serializable

). The reference is included as a class field even though it's not actually accessed. Then in my other spark jobs I have plenty other lambdas that also don't access the

this

reference and properly do not have that code generated.

Such implicit argument conversion will cause huge performance issues. When I write

5.pow(4)

I expect it to perform the most efficient way, using the information that both arguments are integers