A modern programming language that makes developers happier.

kotlinlang

It might be nice to add something like:
`public fun &lt;T&gt; Array&lt;out T&gt;.random(random: Random): T`
for Prepared's random... I don't know if this is good practice, but currently I just did:
`FooEnum.entries.toTypedArray().random(random.accessUnsafe())`

What does this do? Is it to get a random element of an array? In which case did you want to use this?

Making test data in a prepared block... I guess this is getting close to property testing, but I still feel there's a difference, since I'm not generating tons of random test cases but rather expressing that I don't care what the value of that property is for that one test.

Since it's an enum, wouldn't it be better to brute-force all cases?

Anyone you can write:
```suspend fun &lt;T&gt; TestDsl.randomOf(array: Array&lt;T&gt;) =
    array.random(random.accessUnsafe())```
but I can't do anything much better before context parameters

&gt; Since it's an enum, wouldn't it be better to brute-force all cases?
In this case it doesn't involve any logic... so I just randomize it so that my hard-coded TDD first test won't pass...
&gt; Anyone you can write: ...
Yeah, I was wondering if accessUnsafe() was safe over here. And yeah... I guess until context params come out things are less pleasant... I didn't think of that that you needed the TestDsl context too :man-shrugging::skin-tone-3:.

The "unsafe" part here is about multi-threading

but honestly it's a bit weird anyway because, even if it is supposedly safe to use with multiple threads, you'll get non-deterministic results…

&gt; I didn't think of that that you needed the TestDsl context too
Guess what! `random` is a prepared value internally :sweat_smile:

<https://gitlab.com/opensavvy/groundwork/prepared/-/blob/main/suite/src/commonMain/kotlin/Random.kt?ref_type=heads#L37>

:open_mouth:
```val TestDsl.random: Random
	get() = Random(this)```
It creates a new instance for each call to random?

A new instance of <https://gitlab.com/opensavvy/groundwork/prepared/-/blob/main/suite/src/commonMain/kotlin/Random.kt?ref_type=heads#L45>, not of kotlin.random.Random

the actual random source is in a prepared value

Yeah, I understood, but why a new instance of even that?

(it is a stateless wrapper, yes; `time` and other helpers do the same)

Where would that value class be stored? I can't make this a global variable, since it must be different for each test.

If what you pass to the constructor is stored, then "creating" the value class is "free" so it doesn't need to be stored...

Sure, but this is a stateless helper, escape analysis will remove it anyway.

And that wouldn't work for `time` since it takes 2 arguments

&gt; escape analysis will remove it anyway
I guess if that's so, then it's not a problem... I always tried making such wrappers value classes, but I'm not such an expert on compiler optimisations... interesting to know this...!

I don't know about other platforms, but at the very least on the JVM, such extremely short-lived objects are basically free (generational GCs for the win!). It's the same as `java.lang.Optional`