The implementation should look something like

class MyMap<K: Any, V: Any>: ConcurrentMap<K, V>

and all would be fine.

Is there anything to replace these wrappers

Collections.unmodifiableLias(Arrays.asList(...))

with a single one?

if you're using Java 9, you can use

List.of(..)

, if not you can make it based on its implementation https://github.com/netroby/jdk9-dev/blob/master/jdk/src/java.base/share/classes/java/util/ImmutableCollections.java

What happens if

elements

is empty? https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-set/contains-all.html#containsall

Then it should return true iff the passed collection is empty.

Can I ask if there is any reason why the filter is not keeping the shape of the container?

arrayOf("A", "B").filter{}

returns

List<String>

instead of an

Array<String>

Should we have an implementation of filter on higher kind type to be able to return the same container?

Because you don't know the size of the result in advance, and so behind the scenes you pretty much have to use a List. Might as well return that then.

yeah that’s a good point, also found that the Sequence implementation returns Sequence<T> 👍 thanks !

By the way, I have my own

Array<T>.mapToArray

extension, but

filter

, of course, is not the case.

Assuming I have a list of objects, each having a string field 'foo', is there a collection method that I can call on the list to create a concatenated string of all objects 'foo' strings? This is in lieu of looping through each item. Likewise, assuming I have a list of objects with type <pojo> fields, is there a one time method I can call on the list that that would create a new list of type <pojo> extracted from the parent list? I want to do this without iterating through each item.

For the first

list.joinToString { it.foo }

And I don't understand your second one, do you mean

list.map { it.foo }

?

thank you @karelpeeters, those were the two methods I was looking for

Just for clarity. These functions iterate through the list, just you're not explicitly defining the iteration. No magic here.

Is it intentional that

IntRange

and

ComparableRange<Int>

with same

start

and

endInclusive

aren't equal? From the outside they're both

ClosedRange<Int>

.

val a: ClosedRange<Int> = 1 .. 2
val b: ClosedRange<Int> = ((1 as Comparable<Any>) .. (2 as Comparable<Any>)) as ClosedRange<Int>

println(a == b) // false

True, one just needs to be careful not to break symmetry

First thing that comes to mind is

mapIndexed

, but that might not exactly be the best route

I don't think index will help with a sequence?

That’s true

It would be nice to have a

runCatching<SpecificException> { }

version somehow... or/and

onFailure<SpecificException> { e: SpecificException }

I find myself with extra boilerplate (and nesting) `if`s or `when`s in those blocks when I'm only expecting a certain range of Exception types and they need different treatment (and others need to actually be thrown, so I need to call

getOrThrow()

at the end just to rethrow those other exceptions even when I don't need the result...

Can you give an example of the boilerplate you'd like to replace with this?

runCatching { code() }
          .onFailure { 
                 if (it is DomainException) handleDomainError(it) 
         }.getOrThrow()  // To throw other errors that are not domain related, if there are.

// This might be much better
runCatching { code() }
       .onFailure<DomainException> { handleDomainError(it) }
       .onFailure<DomainException2> { handleOtherDomainError(it) }
// If there's another error it throws here without using getOrThrow()
// this is like having multiple 'catch's in a try/catch, and is easier to compose and use with lists of results... also there's no nesting.

@karelpeeters

Hi. Is the kotlin.random.Random interchangeable with java.util.Random, in the same way as collections?

That is, if I write an API that returns a kotlin.random.Random, can I pass that Random instance to functions that expect a java.util.Random?

No,

kotlin.random.Random

is a separate API, which is available also outside the JVM.

Use outside the JVM is not implemented by the multiplatform language features?

You can use

asJavaRandom

and

asKotlinRandom

to convert between the two.

Ok. That’ll do.

Thanks