Explicit union tag values

[hasenj]

Is your feature request related to a problem? Please describe.

If you want robust serialization / deserialization of union values, you need the tag values to be explicit.

Suppose you have something like this:

hsl :: struct {
    h, s, l, a: u8,
}

rgb :: struct {
    r, g, b, a: u8
}

color :: union {
    hsl,
    rgb,
}

The two variants of this union have identical memory layout. The compiler currently seems to assign tag values sequentially, starting with 1, (I assume if the #no_nil modifier is provided then it starts with 0).

So in this case, a tag value of 1 indicates hsl, and a tag value of 2 indicates rgb.

Suppose with this, I serialize a color instance to a binary file by just dumping its memory as a byte stream.

Later, I change the code to add a new variant, and for whatever reason, I added it to the middle:

hsv :: struct {
    h, s, v, a: u8
}

color :: union {
    hsl,
    hsv,
    rgb,
}

The meanings of tag values have been changed without the explicit control of the programmer. If I do just a naive deserilization of a byte stream dumped from the previous version, it will not work. A tag value of 2 used to indicate rgb but now indicates hsv

Describe the solution you'd like

Just like enum values can be assigned explicitly, allow union tag values to be assigned explicitly:

color :: union {
    hsl = 1,
    hsv = 3,
    rgb = 2,
}

Another option is to allow arbitrary string tags, similar to structs: this allows the programmer to use whatever scheme they would like for deserialization without caring the specific tag value assigned by the compiler:

color :: union {
    hsl `tag=1`,
    hsv `tag=3`,
    rgb `tag=2`,
}

Additional context

Here's a short code sample that demonstrates the memory layout of a union value:

package main

hsl :: struct {
    h, s, l, a: u8,
}

rgb :: struct {
    r, g, b, a: u8
}

hsv :: struct {
    h, s, v, a: u8,
}

color :: union {
    hsl,
    hsv,
    rgb,
}

import "core:fmt"
import "core:mem"

main :: proc() {
    c1, c2: color;
    c1 = hsl { 200, 200, 120, 255 };
    c2 = rgb { 200, 200, 120, 255 };
    fmt.println("c1:", mem.ptr_to_bytes(&c1));
    fmt.println("c2:", mem.ptr_to_bytes(&c2));
}

Output:

c1: [200, 200, 120, 255, 1]
c2: [200, 200, 120, 255, 3]

This demonstrates that the compiler has assigned the tag value 1 to indicate hsl and 3 to indicate rgb. It also demonstrates that the tag is the last byte.

[Tetralux]

I dislike the hsv = 1 syntax because it looks too much like your assigning an int to a type.

Allowing struct-tags like

hsv: `tag=3`

could work quite well here, but you'd have to parse it - potentially every time you needed to process that field which is.... quite a big Ugh. 🤔

Could reuse the array index-assign syntax maybe?

color :: union {
    1 = hsl,
    2 = hsv,
    3 = rgb,
}

I'm not sure how much I like that, but. 🤔

[gingerBill]

Another approach would be to use @. Again, the syntax is not that important here as long it is consistent and makes the most sense with the rest of the language.

color :: union {
    hsl @ 1,
    hsv @ 2,
    rgb @ 3,
}

[hasenj]

To clarify my suggestion, the following:

color :: union {
    hsl `tag=1`,
    hsv `tag=3`,
    rgb `tag=2`,
}

is not an alternative syntax. It's user-level custom tags. The compiler does not care what's in them. User-level code may use it to setup some custom serialization/deserialization engine.

[gingerBill]

Union field tags, like struct field tags, is probably the best option. I'll give it a bit of a think.