It's possible to take the first approach of finding whether there is at least one duplicate and extend it to yield a sequence of all duplicate values:

buildSequence {
        val uniques = mutableSetOf<Int>()
        list.forEach { if (!uniques.add(it)) yield(it) }
}.distinct()

or the same with filter:

mutableSetOf<Int>().let { uniques -> list.filterNotTo(mutableSetOf(), uniques::add) }

the lazy one is super interesting because it minimizes the work in the already-distinct case

i'm basically doing this to validate something and then if it's violated then i enumerate and create a list of all duplicates for the error message

Hmm, you need to iterate the entire collection to find whether it has duplicates anyway

true. i guess it's only a fast-path in the duplicate case but then since i'm enumerating all anyway it always degrades to the worst case

i don't really need performance or anything. just an interesting exercise to see what you can do with the stdlib

not sure it's common enough to warrant inclusion in the stdlib, although

distinct(): List<T>

potentially sets a precedent for a

duplicates(): List<T>

You can file a request to YT

thanks https://youtrack.jetbrains.com/issue/KT-18405

@oleksandr.samsonov has left the channel

is

Closeable

going to move into the stdlib as a facade interface?

i'm playing around with the multiplatform stuff and noticing that i can only

.use

on the JVM because it's only available on java.io.Closeable

Or AutoCloseable?

Honestly I like Disposable from C# better, as a name. Not bound semantically to IO

Note there is

Disposable

in rx.

Disposable would be fine

Something for resource management

Especially for cross-platform

Yes, but then we have a problem with automatic disposing, e.g. of iterators

Anything in stdlib to convert byte array to hex? I've made

byteArrayOf().joinToString("") { "%02x".format(it) }

.

Funny that I was implementing that today, but my implementation is longer xP

fun byteArrayToHexString(b: ByteArray) = b.joinToString(
        separator = "",
        transform = { byte -> Integer.toString((byte.toInt() and 0xFF) + 0x100, 16).substring(1) }
)

It would be nice to have such helper in stdlib

I feel there's a way using

BigInteger

I agree there should be a way to convert

ByteArray

to a hex string. It would be quite obvious to name this extension

ByteArray.toHexString()

. However I'm not sure where to provide the inverse function.

maybe as a fake constructor?

arrays already have fake constructors so it wouldn't be unheard of

I would prefer toHexString

Just proposition:

fun ByteArray.toHexString() = joinToString("") { byte -> Integer.toString((byte.toInt() and 0xFF) + 0x100, 16).substring(1) }

or

fun ByteArray.toHexString() = joinToString("") { byte -> "%02x".format(byte) }

But I would need to unit-test it to be sure if this one is ok