A modern programming language that makes developers happier.

kotlinlang

Is this something Kotest would be interested in? <https://github.com/nomisRev/ktor-arrow-example/blob/main/src/test/kotlin/io/github/nomisrev/SuspendFun.kt>

I'm reluctant to add new specs since we already have 10, and probably 3/4 too many. Could this be added to existing specs without breaking any users code?

I've asked before about `suspend` constructors :stuck_out_tongue_winking_eye: I'm not entirely sure where it landed, I think it can be added without breaking binary. Not 100% on semantics

I remember the discussion, it was because you want suspendable extensions

There might be a slight change in order of initialisation.. :thinking_face:

Yes, exactly

I remember we looked into it in quite some depth

Either that, or I think I'm going to end up just going `runBlocking` route..

It might not be the end of the world to make SuspendFreeSpec or something ?

So its clear its the same thing, just with a suspendable body

Make a new version of each one, with the prefix Suspend

I'm still curious if we cannot fix it without breaking semantics, and binary.

I vaguely remember you mentioned you might consider it across a major version.. I need to dig up the conversation

My goal is that 6.0 lines up with when compiler plugins go stable, so we can build on them properly to allow you to run a single test in intellij for js and native. But right now they are breaking things too quickly to rely on compiler plugins anymore than we do.

I wonder if we could just change FunSpec (for example) to this:

```abstract class FunSpec(body: suspend FunSpec.() -&gt; Unit = {}) : DslDrivenSpec(), FunSpecRootScope {
   init {
      runBlocking { body() }
   }
}```

I cannot remember why we said this would change semantics

I think I mentioned something to avoid `runBlocking`, but I don't know how much it matters in regard to how everything is initialised.

```abstract class FunSpec(body: suspend FunSpec.() -&gt; Unit = {}) : DslDrivenSpec(), FunSpecRootScope {
}```
Where it's created:
```FunSpec().apply(body)```

ah runBlocking doesn't exist on JS of course

I think the issue was that in JS we don't have a promise at the time the instance is created.

Was the other problem that `FunSpec().apply(body)` runs the body after subclass inits, and right now the superclass init gets priority.