A modern programming language that makes developers happier.

kotlinlang

basically, it's a timeout for flow, it closes after timedOut

Would something like this work?
```fun &lt;T&gt; Flow&lt;T&gt;.timeout(millis: Long) = flow {
    this@timeout.collect {
        withTimeout(millis) {
            emit(it)
        }
    }
}```

hm, the timeout would be to the overall emissions, not on each one. i managed to get this solution. what do you think?

```fun &lt;T&gt; Flow&lt;T&gt;.timeout(durationInMillis: Long): Flow&lt;T&gt; =
    flow {
        coroutineScope {
            val outerScope = this
            launch {
                try {
                    delay(durationInMillis)
                    outerScope.cancel()
                } catch (e: CancellationException) {
                    outerScope.cancel(e) // cancel outer scope on cancellation exception, too
                }
            }
            collect { emit(it) }
        }
    }```


yes, it works. gona write some tests for it

```fun &lt;T&gt; Flow&lt;T&gt;.timeout(millis: Long) = flow {
    withTimeout(millis) {
        this@timeout.collect {
            emit(it)
        }
    }
}```