[Discussion]: Unions

[MadsTorgersen]

Several union proposals were consolidated into one. Here is a place to discuss the one.

Proposal document:
https://github.com/dotnet/csharplang/blob/main/proposals/unions.md

Issue for proposal:
#9662

[AndersKehlet]

// Union of exiting types

*existing, I assume

[mattwar]

Maybe exciting?

[nuiva]

Also, this is missing union keyword:

// Union with function member
public OneOrMore<T>(T, IEnumerable<T>)

[TahirAhmadov]

What is the purpose for having the null state of a union?

[HaloFour]

Any union over reference types will have to handle the possibility of a null value:

class Foo { }
class Bar { }
union FooOrBar(Foo, Bar);

var u = new FooOrBar((Foo) null);
// or
var u = default(FooOrBar);

if (u is Foo foo) { ... } // nope
if (u is Bar bar) { ... } // also nope

It would be interesting to see if/how NRTs and unions would interact with each other, beyond how the Value property is declared on that particular union.

[2xRon]

Does exhautiveness work for "partial" unions (a "sub-union")?

class Foo { }
class Bar { }
class Baz { }
union FooOrBar(Foo, Bar)
union BarOrBaz(Bar, Baz)
union FooOrBarOrBaz(Foo, Bar, Baz)

var u = FooOrBarOrBaz(new Baz())

var name = u switch
{
    Foo foo => ...,
    BarOrBaz fob => ...,
    // Warning?
};

A related question, can we return a sub-union?

private bool GetError(out UnionTypedResults<BadResult, Unauthorized> error) => ...;

public async Task<UnionTypedResults<BadRequest, Unauthorized, Ok<string>>> MyEndpoint()
{
    if (GetError(out var error))
        return error;
    UnionTypedResults.Ok("It worked!");
}

[mattwar]

1st part, no. The value of the union is not the other union type so it will fail.

2nd part, no. This is a union to union conversion and is not part of the proposal. We may end up with some helpers or extensions that do conversions.

[full-ing-arr]

for my opinion add static multi-inheritance for struct

other cases we can resolve with [Offsets]

[nuiva]

If by "static multi-inheritance" you mean compile-time subtyping, I believe it was considered in one of the early proposals, but the idea was dropped because lack of runtime support would cause too much friction. It would be a new kind of subtyping that doesn't play nicely across assemblies.

[full-ing-arr]

i'm about next

struct A { ... }
struct B { ... }
struct AB: A, B { ... }

var b = new B ...
var ab = new AB ...

arr[0] = b;
arr[1] = ab //copy only part B

for (int i = 0; i < 10; i++)
  if (arr[i] is A a)
    a.Smth() //just call without use data of B type, its track that arr[1] assign with C type, C has A part

or if we need runtime data

B[] arr = new union B[10]{ } //may be other way notation that array store link on data that located in stack
arr[0] = new A(); //can link but value be default when we try get its
arr[1] = new B(); //just store link on this
arr[2] = new AB(); //just store link on this

for (int i = 0; i < 10; i++)
  if (arr[i] is A a)
    a.Smth() //call with use data that contains in arr[i] and get part of B inside itselfs

Whole idea may be comparasing with multiarrays of structs in ZIG, but works inside and hide like for iterators, hided from developer

main part of idea is store different struct with different data and size in one array, and have instrument to operate them, may be its a same problem that not boxing when cast struct to interface, but a little cap deeply

B[] arr = new B[] ...

foreach(var el in arr) 
  el.Smth ...

may be like this

foreach(arr => 
  A => some code for A
  B => some code for B
)

but in actualy code its will be

A[] arrA = ...
B[] arrB = ...
AB[] arrC = ...
MultiArr<B> arr_ids = ...

foreach (var a = arraA)
  some code for A ...

foreach (var b = arraB)
  some code for B ...

[HaloFour]

Are you proposing that AB is a way to express a union of A or B? I'm not really sure I understand what you're proposing or how it relates to unions, which don't have anything to do with arrays.

[mattwar]

Multiple inheritance is about having a single type act as multiple types at the same time. Unions are about having a single type act as multiple types at different times (never at the same time). A multiple inheritance solution will not get you unions, unless you add a tag and restrict access to only the parts corresponding to the tag, which negates the benefit of having the multiple inheritance.

[jnm2]

What about this syntax, since C# has recently added the keyword allows? This would mean the same thing as Java's permits, and it would have the benefit of working on non-union closed hierarchies too:

union Pet allows Cat, Dog, Bird;
closed record Pet2 allows Cat, Dog, Bird;

I feel no conflict having commas once the parens are gone, interestingly.

[BreyerW]

Mb 'use' was probably wrong word here, 'declare' would be more appropiate and in retrospect should have added record keyword to illustrate its inline declaration of cat (inside union instead of having separate types for union and cat)

[BreyerW]

@HaloFour in that case yeah it wont be an issue, at the same time a bit unfortunate not to be able to use single template for union

[HaloFour]

I don't think this is too terrible, honestly, if we wanted a syntax that allows declaring a union of both existing types and newly-declared types.

union FooBarBaz
    allows Foo, Bar
{
    case Baz(string name, int id);
}

[mattwar]

You are allowed to mix them. We just don't think it will be common to do so.

[mattwar]

@jnm2 I tried to come up with a better keyword, but I cannot find one that both sort of works for unions and closed classes/records. There was a suggestion to use 'of':

union Pet of Cat, Dog;

However, for unions with type parameters it gets weird.

union U<T> of T, int;

Since the type parameter itself is associated with saying 'of'. Saying, "union U of T of T or int" is awkward. :-)

[TahirAhmadov]

Isn't it possible to make a tagged union implementation behind the scenes when all of the cases are struct types, and maintain the same surface area? Basically, Value boxes, but strong-typed TryGetValue methods don't, and this way no boxing occurs at all when using a union of struct typed-cases in a strongly typed manner. (Perhaps even a strategy can be envisioned when some of the cases are struct typed and others are not; I'm not sure if this is allowed at all at this point.)

[mattwar]

Yes, this is what the TryGetValue methods are for.

[HaloFour]

I think the question is if you used the built-in union syntax would the compiler support emitting the union struct with a storage strategy that could avoid boxing, such as a tagged union.

[mattwar]

No currently, but its left open for the future.