kotlinlang #stdlib

public static<T, R> Collector<T, R, R> of(Supplier<R> supplier,
                                              BiConsumer<R, T> accumulator,
                                              BinaryOperator<R> combiner,
                                              Characteristics... characteristics)

The problem is, that the kotlin version (taking kotlin functions instead of SAMs) doesn't have vararg Characteristics, but instead Array<Characteristics>

Andreas Sinz

03/22/2017, 8:29 AM

@mathiasbn what exactly is the problem?

mathiasbn

03/22/2017, 8:32 AM

The problem is that the vararg characteristics are converted to an Array. So a call without characteristics has to end with

Copy code

,emptyArray()

dmitry.petrov

03/22/2017, 8:35 AM

The same thing (creating a new empty array for empty vararg parameter) also happens in Java.

mathiasbn

03/22/2017, 8:43 AM

Ok i'll try again 🙂 This doesn't work:

Copy code

Collectors.of( {MySupplier()}, {r,t -> r.add(t)}, {r1,r2 -> r1.combine(r2)})

This does work:

Copy code

Collectors.of( {MySupplier()}, {r,t -> r.add(t)}, {r1,r2 -> r1.combine(r2)}, emptyArray())

dmitry.petrov

03/22/2017, 8:44 AM

That looks rather strange (1st one should work as well). Could you please file a bug?

mathiasbn

03/22/2017, 8:59 AM

KT-16998 Collectors#of from java stdlib loses vararg in kotlin version

beholder

03/22/2017, 9:04 AM

First method works if explicit SAM intefaces specified

Copy code

val collector = Collector.of<String, StringBuilder>(
            Supplier { StringBuilder() },
            BiConsumer { b, s -> b.append(s) },
            BinaryOperator { b1, b2 -> b1.append(b2) })

mathiasbn

03/22/2017, 9:09 AM

yes, but that was not the intent i think

beholder

03/22/2017, 9:12 AM

Compiler message is clear: "Type inference failed: Not enough information to infer parameter ...... Please specify it explicitly."

mathiasbn

03/22/2017, 9:15 AM

Try remove the explicit SAM interfaces and the add

,emptyArray()

to your call

beholder

03/22/2017, 9:20 AM

I think it's not a bug, but real impossibility for compiler to determine exact types

dmitry.petrov

03/22/2017, 9:26 AM

Well, it's somewhat strange that adding an

emptyArray()

parameter that doesn't add any type information fixes the lambdas case. At least it deserves looking at.

holgerbrandl

03/23/2017, 9:44 AM

Is there a more elegant way to filter a list by type and cast the remaining elements to that type than:

elements.filter { it is RAssignmentStatement }.map { it as RAssignmentStatement}

vmironov

03/23/2017, 9:46 AM

filterIsInstance<RAssignmentStatement>()

👍 1

dmitry.petrov

03/23/2017, 9:49 AM

mapNotNull { it as? RAssignmentStatement }

, which is a bit more flexible in terms of fusing with other container traversing operations

holgerbrandl

03/23/2017, 9:56 AM

oh cool, thank you both!

mg6maciej

03/24/2017, 10:14 AM

Nothing in the #stdlib regarding randomness? Should I just use

java.util.Collections.shuffle

mg6maciej

03/24/2017, 10:41 AM

Added

fun <T> List<T>.shuffled(r: Random): List<T> = ...

tho

kirillrakhman

03/24/2017, 12:02 PM

does it copy the list?

miha-x64

03/24/2017, 12:37 PM

Did I miss something or there is no function for mapping array to array? (there is only array to list) 1 reply I didn’t find one.

Copy code

inline fun <T, reified R> Array<out T>.mapToArray(transform: (T) -> R): Array<R> =
        Array<R>(size, { i -> transform(this[i]) })

benleggiero

03/24/2017, 2:42 PM

P.S. @beholder if you're not yet comfortable using Lists instead of Arrays, I recommend you become comfortable, since they can be truly immutable 🙂

teedee

03/24/2017, 3:49 PM

@teedee has left the channel

mg6maciej

03/25/2017, 4:41 PM

Anything in #stdlib to create a list with element repeated n times?

mg6maciej

03/28/2017, 11:48 AM

val newList = list.removed(index)

miha-x64

03/28/2017, 11:52 AM

what about

removed(T)

removedAt(Int)

mg6maciej

03/28/2017, 11:52 AM

removed

already exists, it's called

minus

and

minusElement

louiscad

03/28/2017, 11:59 AM

@mg6maciej

val newList = list.minusIndex(i)

10 replies Here you go:

fun<E> List<E>.minusIndex(index: Int) = subList(0, index) + subList(index + 1, size)

mg6maciej

03/28/2017, 12:44 PM

Nothing there to help with Cartesian product apart from normal:

list1.flatMap { e1 -> list2.flatMap { e2 -> list3.map { e3 -> /*work with e1, e2, e3*/ } }

mg6maciej

03/30/2017, 10:06 AM

filterIndexedIsInstance