You don't need Queue or Stack when you have Deque and ArrayDeque

And you probably don't need LinkedList either since you don't want to be performing random access on it

i have a sealed class with two subtypes for which i'm trying to make comparable. i want the common property to dictate sort, then subtype, then the subtype properties. is there an easy way to do this with the comparator chain creation functions?

Like

compareBy { it.commonProp }.thenBy { it.subtype }.thenBy { when(it) { is SubType1 -> it.subtypeProp1 ... } }

?

Thoughts on

std-lib

having

sample()

functions for randomly selecting elements? I'm using these a lot for research purposes.

@thomasnield uploaded a file: Untitled

It would be interesting to have samplings based on distributions too, but I'll research that in the near future and may put it in

kotlin-statistics

first.

Not so sure about all of the

toList()

-ing, I'd say sampling is something you can only do on lists.

Actually you could implement it for sets too, pick the index first and then start iterating until you get to it. Should be a lot faster.

@karelpeeters implementation details aside, do ya'll think this is something KEEP-worthy?

What do you think, what % of Kotlin developers will use it ever? Those who will, how often?

@orangy My guess is if there's a need to generate random numbers, there also may be a need to select random elements. Selecting a single random element is probably much more common than selecting multiple though. The latter often comes up when you are doing statistical or math-driven problems requiring sampling.

Either way, I can see a lot of folks using it. It feels like a pretty common task although I have my biases (and speculations) like everyone else.

Is there another (non-scientific) language with such a function in standard library? We could try to gauge it’s usage there

• Python

random.choice

• Rust (de facto stdlib via the random crate)

rand::thread_rng().choose

• C++17

std::sample

• PHP

array_rand

• Ruby

array.sample

I agree that it's not a "mainstream" thing to want to do, but I have personally copy/pasted this a couple of times between projects too.

I think the rule of thumb would be something like this. Consider a 2x2 matrix, on one axis “all devs” and “some devs”, on another “use often” and “use rarely”. Basically, if the feature falls into “all often” it should be in stdlib. If it’s “all rarely” or “some often” then we need additional justification, like it saves a lot of code, make code better to read, etc. “some rarely” is almost always no go.

Then, if a function is few lines of code anyway, and it’s not all/often – then probably it doesn’t worth it.

Also note, that every stdlib function cost a lot – not just by bytecode size, but also multiplied by platforms (if its not common code), docs, maintenance, number of overloads (for arrays for primitive types) and method count (Android), etc, etc.

I'm developing it, but we're discussing if it's confusing or not, maybe some of you may spark some thoughts into the discussion

What about splitting ranges into a list of parts (like when trying to resolve ranges to download):

infix fun LongRange.split(partSize: Long): List<LongRange> = (first..last step partSize).map {
		it..min(it + partSize - 1, last)
	}

How about dynamic typing in kotlin? (Semillar to def in groovy), it's an awesome feture, that could fit in the language

var x = 0 x = "hello" Creates an array x that contains these values that's how groovy implements it

Maybe not dynamic typing but an auto change to Any when there is a situation like that

What is real use case? Except interop with dynamic languages like groovy or js?

Also this is not a topic for stdlib, there are #language-proposals or #general

Is it possible to have something like

java.nio.Buffer

?

Do you want to write something like

Buffer

in Kotlin? What specifically do you have in mind?

it's to interface with opengl, something like https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/graphics/glutils/VertexBufferObjectWithVAO.java#L119

That code just uses a

Buffer

, which is definitely possible in Kotlin.