A modern programming language that makes developers happier.

kotlinlang

<@U4UGS5FC7> serious? I have recently just managed to learn how Either, Try, Option and Validated works. Are you planning to deprecate all of them?

<@U4UGS5FC7>, thanks for clarifying. interesting! if it can do something big and different to Scala and Haskell then it can do everything:grinning:

yes, we are in a different direction now following the philosophy that Kotlin already promotes of removing nesting

This is at the core of receiver and extension functions and it can also be in terms of data types that can be asimilated by lang features

For example Either is eliminated by union types and you gain arbitrary arity and exaustive match in all cases with automatic conversion to nullable types. This eliminates the need to use Left and Right to construct values of the union

so it treats Either the same way Kotlin treats Nullable types assimilating it’s syntax into the lang

same when we implicitly convert suspend to IO and back:
```
val a: IO&lt;A&gt; = TODO()
suspend fun doInIO(): A = a //.suspended() is eliminated 
```
```
suspend foo(): A = IO.fx { a }
```

what's are the benefits of using union over either?

Leaner runtime, supports up to 22 args, eliminates the constructor syntax and accepts values of the union directly and converts to nullable values of the union directly . Can be derived from existing sealed hierarchies, etc.

We will add proper docs when we finish the current prototype in meta

Have you a syntax to resolve ambiguities about creating Unions with same types (eg Union&lt;A, A&gt;) ?

Do you have an example of the ambiguity ?

Ok Union&lt;A,A&gt; is A. The ide plugins should propose this optimisation.  Maybe, in case of duplicate type, you should return an error at the compilation level. Yeah, It's a good design to promote disjoint types :+1:

Then, Union&lt;A,B,A&gt; will be Union&lt;A,B&gt; and so on... That's also mean that Union&lt;A,B&gt; will be equal to Union&lt;B,A&gt;. Is the case in Scala ?

The type proof plugin already provides proofs for all positions of A in the union

The type proof plugin proofs morphisms between types and can inject them for free with an inlined runtime

And selectively eliminate the syntax like in the case of unions where you have proofs for all A back to A? if anywhere present in the union

What about type alias ? eg, if we have A&amp;B for C, what will be &lt;A,B&gt; ? A,B,C or you will preserve &lt;A,B&gt; ? I said that because if for any reason we have spaghetti types, it could be difficult to determine the common type; and, the resulting type could be ambiguous for the developper. point of view.

A Union&lt;A, B&gt; is a type alias for Union22&lt;A, B, Any?, Any?…&gt;

there is a single interface Union22 that eliminates the need to nest and recurse in the type checker