Hi, Apologies in advance if this is the wrong place to ask this. I’m not sure if i’ve misunderstood how readln() should work, but given this code

fun main() {
    val first = readln()
    val second = readln()
    println("[$first] [$second]")
}

and this input

1
2

I’m getting this output

[1] []

I would expect

[1] [2]

Or?

I was surprised Kotlin stdlib doesn’t have standard function for list comprehension to get head and tail of the list:

fun <T> List<T>.headAndTail() = Pair(first(), drop(1))

Does Kotlin offer more idiomatic approach to do this?

Any reason why

capitalize()

was removed ? It was so util and the new way to do it is great but looks so raw compared to the methods the String class has, also a method

titlecase()

would be great :)

what are default options?

Regex

constructors ain't even documented..

Is there an idiomatic way to go from

Map<Key,

Set<Value>>

to

Map<Value,

Key>

?

Is there something in the standard library to perform a

zip

but with the catch that the second

Iterable

contains a count property to indicate the number of items to consume from the first

Iterable

? Perhaps a running fold can do this, but I can’t quite get my head around it! At the moment, I can get the desired results by separately maintaining an

Iterator

on the first

Iterable

, but this doesn’t feel very clean to me.

val list1 = listOf('a', 'b', 'c', 'd', 'e', 'f')
val list2 = listOf(Type2(count = 2), Type2(count = 1), Type2(count = 3))

val expected = listOf(
    Pair(listOf('a', 'b'), Type2(count = 2)),
    Pair(listOf('c'), Type2(count = 1)),
    Pair(listOf('d', 'e', 'f'), Type2(count = 3)),
)

class Type2(val count: Int) {
	...
}

I’d like to create a scheduler app that contains a list of events. Each event has a

startDate

and an

endDate

. I’d like to determine which events overlap so I can place events in a different column. Is there a way to apply some sort of

groupBy

function to accomplish a way for me to group them?

Why doesn't

Regex

override

equals

?

Is drop/skip the same as a seek (like in a file) in a sequence? Any way to support seeking to a particularl location instead of doing a noop loop

What is the easiest way to get a diff of two `List<Int>`'s?

minus()

won't do it, since

list2 - list1

only shows what

list2

has what

list1

hasn't.

Given that

Entry

has a

toPair()

method, why does

Pair

does not have a

toEntry()

method?

Is there a way to convert basic sql to kotlin sequences/collections operations?

I'm confused by the

SuspiciousCollectionReassignment

inspection. The description says:

fun test() {
      var list = listOf(0)
      list += 42 // new list is created, variable 'list' still contains only '0'
  }

But doing the same thing in playground yields

[0, 42]

. What am I missing?

Just stumpled accross this and though this should be a feature: 1. Optional catch variable

try {

throw Error("Oh no!")

} catch {

console.log("Something bad happened, but don't know what")

}

2. Inline try catch without braces

var result = try throw Error("Oh no!") catch console.log("Something bad happened")

The question has been transfered to #compiler (https://kotlinlang.slack.com/archives/C7L3JB43G/p1655913770902479)

how the 🦆 ?

Is it possible to have nested lambdas which uses different

DslMarker

markers and picking the nested one? If I have two function with the same name, the outermost is used

kotlin {
    android() // from kotlin
    multiplatform {
        common()
        android() // from kotlin, should be from multiplatform
        jvm()
    }
}

As per the suggestion cross-posting into #stdlib

Wouldn't it be nice if package kotlin.io.path was included in the list of default imports? It includes many functions that are preferable to those with the same names in the kotlin.io package. One consequence of it not being included is that, for example, if you start writing "createT", IntelliJ IDEA offers to complete it to "createTempFile" from kotlin.io which is deprecated in favour of kotlin.io.path.createTempFile due to security concerns. But you won't even see the option to choose the latter in the list of suggested completions.

Would it make sense if

log(x, base)

took a default value of

E

for

base

so as to make

log(x)

work just as it does in Java, C, and most other languages, instead of requiring the base to be explicitly passed? It would also form a counterpart of

exp(x)

which already implicitly uses a base of

E

.

This feels a bit random, but anyone else feel like

.filter { }

could have gotten a better name? Everytime I see

.filter { }

, my brain has to stand still and figure out if it actually means "filter out" or not. I think

.where { }

would have been a more easier name to scan and understand what it does

Explicit/Short hand methods for lazy delegations(In addition to

lazy()

, as in

lazyNone()

,

lazyPublication()

, and

lazySyncronized()

, instead of

lazy(LazyThreadSafetyMode)

When using the duration api why is it d.toDouble(DurationUnit.HOURS) instead of the now deprecated (but seemingly more concise) d.inHours?

Is it planned to add common collection aggregators for kotlin.time.Duration such as sumOf? Or listOf(1.hours, 2.minutes).sum()?

Is it a bug or a feature?

fun main() {
    var numbers = emptySequence<Int>()

    numbers = sequence {
        yieldAll(numbers)
        yield(1)
    }

    println(numbers.iterator().next()) // throws StackOverflowError
}

I do realize that such an approach to build up a sequence may seem unnatural, but for my case (I have to implement Kotlin Serialization’s Encoder interface which methods adds/yields next value for the sequence) I haven’t figured out an alternative.

is there a ticket for adding a BiMap to stdlib that I can vote for?

there should be

LazyList<T>

that consumes

Lazy<T>

and produces

T

Why doesn't

Lazy

implement

equals

and

hashcode

?

I'd like to check if a range is within another range, ie

i-2..i+2 in wd.indices