A modern programming language that makes developers happier.

kotlinlang

what's the usage of
```either { ... } ?```
I can't find documents about it, related to
```Either.fx&lt;A,B&gt; { ... } ?```

Hey <@UKPUBT3GF>,

What do you mean usage? It works the same as `Either.fx` but it no longer uses the `Monad` interface underneath and works much more efficiently.

The `either { }` version also allows for suspension to go through, which wasn't the case with `fx`.
If you want a DSL that returns immediately instead of doing `suspend` there is also `either.eager { }` .

<@U0RM4EPC7> I don't know it's a DSL, I found this article <https://arrow-kt.io/docs/apidocs/arrow-core/arrow.core.computations/either/index.html#either>
but it doesn't say much more about it, I hope there's a document to tell how to use it and when it's better than Either.fx

Yes, the documentation is still a bit lacking in those places :disappointed:

Here is a little bit more info:
<https://arrow-kt.io/docs/effects/io/#suspend----eithere-a>

It's 100% better to use than `Either.fx`, and you can use it exactly the same as `Either.fx`. Actually, `either { }` is more powerful than `Either.fx` and can do more.

<@U0RM4EPC7> I saw that
```IO.fx { 
 continueOn(main)
 effect { updateUI }.bind()
 continueOn(backgroud)
 effect { doIO }.bind()
}```
if with
```suspend () -&gt; Either&lt;A,B&gt;```
how to express that inside
```either { ... }?```
continueOn is available inside either ?

`continueOn` is not available anymore in favor of `withContext` from KotlinX.

```either {
  withContext(main) { updateUI.bind() }
  withContext(background) { doIO.bind() }
}```


Assuming that `updateUI` and `doIO` return `Either` and/or are `suspend`

<@U0RM4EPC7> IO has
```unsafeRunAsync```
KotlinX has
```CoroutineScope.async(<http://Dispatchers.IO|Dispatchers.IO>) {...}```
for async IO, how to do that inside
```either {...}?```

You can safely mix-and-match these patterns now.

```val res: Either&lt;Stirng, Int&gt; =
  either&lt;String, Int&gt; {
     val task: Deferred&lt;Either&lt;String, Int&gt;&gt; = scope.async(<http://Dispatchers.IO|Dispatchers.IO>) { delay(1000); 1.right() }

     ...

     task.await().bind()
  }```

<@U0RM4EPC7> so KotlinX's
```runBlocking { ... } ```
is also availabel inside either { ... } just like scope.async?