A modern programming language that makes developers happier.

kotlinlang

Hi! can someone pls help me if I am using `IOPool` in conjunction with `parTraverse` in the right way? I couldn't find any documentation about it.
```@Test
    fun `IODispatcher + parTraverse + blocking`() {
        val time = measureTimeMillis {
            runBlocking {
                evalOn(IODispatchers.IOPool) {
                    (1..20).parTraverse {
                        blockingWork(it)
                    }
                }
            }
        }
        println("Done in $time ms [${Thread.currentThread().name}]")
    }

 private fun blockingWork(i: Int) {
        Thread.sleep(1000)
        println("Work $i done [${Thread.currentThread().name}]")
    }```


there should be a `parTraverse(IODispatchers.IOPool) { // effect here }`  method

<@UDAV1EN4W>, how is using IOPool making parTraverse faster? What happens underneath?
I compared these:
```@Test
    fun `parTraverse + blocking`() {
        val time = measureTimeMillis {
            runBlocking {
                (1..20).parTraverse {
                    blockingWork(it)
                }
            }
        }
        // 3s, multiple blocked bg threads
        println("Done in $time ms [${Thread.currentThread().name}]")
    }

@Test
    fun `IOPool + parTraverse + blocking`() {
        val time = measureTimeMillis {
            runBlocking {
                (1..20).parTraverse(IODispatchers.IOPool) {
                    blockingWork(it)
                }
            }
        }
        // 1s
        println("Done in $time ms [${Thread.currentThread().name}]")
    }```

AFIK `IOPool` is backed by unbounded thread pool, so it's suitable for blocking work

not sure what the default thread pool is (I would assume computation, which is backed by a thread pool with a cap determined by number of cores/processors)

Oh yes, I got confused seeing `ForkJoinPool-1-worker-15` on my 4 core machine for default dispatcher, but just realized there can be some hyperthreading on my core

not sure how the naming of threads is :slightly_smiling_face:

but the main idea is: blocking IO goes on unbounded thread pool, computational work goes on a bounded one

I mean there were 16 threads on bounded pool

<https://gist.github.com/djspiewak/46b543800958cf61af6efa8e072bfd5c>