A modern programming language that makes developers happier.

kotlinlang

<@U2E974ELT> Would you be interested in this contribution?
```
public suspend inline fun &lt;T : Closeable?, R&gt; T.useCancellably(
        crossinline block: (T) -&gt; R
): R = suspendCancellableCoroutine { cont -&gt;
    cont.invokeOnCancellation { this?.close() }
    use(block)
}
```

What kind of blocking java work? Example?

Example:
```
    runBlocking {
        val foo = launch(<http://Dispatchers.IO|Dispatchers.IO>) {
            ServerSocket(PORT).useCancellably {
                it.accept()
                // ...
            }
        }

        delay(100)

        print("Cancelling")
        foo.cancel()
    }
```

Why would use blocking scokets with coroutines?

What’s wrong with a regular `use` inside a coroutine? I don’t see why you need a special function.

But the issue is that without that function, calling `cancel` doesn't do anything

With `useCancellably`, it throws an exception and aborts the connection attempt

That's also relevant for raw `URL` streams

Current cancellability is confusing because nothing happens since the blocking work just keeps blocking indefinitely

`isActive` is only useful for computational work

I see the point. The only problem is that is it a very dangerous thing to give to users in a lib. Many blocking closeable things in Java cannot be concurrently closed (example: JDBC connections) and by trying to close them concurrently you’ll just make it worse

I’ll leave it to people who know what they are actually doing and they can write this function for themselves

Do you think it would be worth showing in the docs?

I don’t know. Our docs are already too large. They need more simpler examples and explanations for basic concepts.

I think I'll just write a short Medium post or something