##
### What are dispatchers?

A **dispatcher** is an essential functionality provided by Kotlin coroutines. It helps us to conclude which coroutine will run on which thread from a pool of threads.

### Types of dispatchers
There are four types of dispatchers depending on the work we want the coroutine to do.
1. Default dispatcher
2. Main dispatcher
3. IO dispatcher
4. Unconfined dispatcher


### Default dispatcher
We use the default dispatcher when we want to run CPU-intensive functions. If we forget to choose our dispatcher, this dispatcher will be selected by default.

### Syntax
```
launch(Dispatchers.Default)
```

### Main dispatcher
It is not used very often. It's only used in Android applications when we want to interact with the UI. It is restricted to the main thread as it is only used when we want to run our coroutine on the main thread. If we're going to use this, we first need to set a dispatcher using `Dispatchers.setMain(dispatcher)`.

### Syntax
```
launch(Dispatchers.Main)
```

### IO dispatcher
It is used when we want to block threads with I/O (input-output) operations, such as when we want to read/write files.

### Syntax
```
launch(Dispatchers.IO)
```

### Unconfined dispatcher
An unconfined dispatcher isn't restricted to a particular thread. This dispatcher contrasts with those mentioned earlier as it changes no threads. At the point when it is begun, it runs on the thread on which it was begun.

### Syntax
```
launch(Dispatchers.Unconfined)
```

### Example


suspend fun main(): Unit = coroutineScope{

    launch(Dispatchers.Default) {
        println("Default : Thread ${Thread.currentThread().name}")
    }

    launch(Dispatchers.Unconfined) {
        println("Unconfined : Thread ${Thread.currentThread().name}")
    }

    launch(Dispatchers.IO) {
        println("IO : Thread ${Thread.currentThread().name}")
    }
}

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


Kotlin

React

Dart

GoJS React

Typescript React

Vue.js

### Explanation
- **Line 1:** Wrap a suspending main body using `coroutineScope`.
- **Line 3:** Start a coroutine on `Dispatcher.Default`.
- **Line 4:** Start a coroutine on `Dispatcher.Unconfined`.
- **Line 5:** Start a coroutine on `Dispatcher.IO`.


kot.tar.gz

What are dispatchers in Kotlin coroutines?

Dispatchers in Kotlin coroutines determine which thread a coroutine runs on. Types include Default, Main, IO, and Unconfined.