Union

// A union lays several members over the same bytes. It is as large as its largest member, not
// the sum of them, because only one member is meant to be in use at a time.
//
// What a union does not do is remember which one that is. A `variant` keeps a hidden tag and
// will only hand out the case that was stored; a union keeps nothing. Keeping track is the
// program's job, usually with an explicit tag beside it, as `Setting` does below.
//
// That job matters because reading a member other than the one last written is not a
// conversion. It hands back the same bytes reinterpreted as another type: what comes out depends
// on how the target lays out numbers, and it may not even be a valid value of that type, such
// as a `bool` that is neither `true` nor `false`. The compiler will not stop such a read.
//
// So prefer a `variant` whenever it will do. Reach for a union when the exact layout is the
// point: a fixed format shared with other code, or saving space where the tag is already known.
import Io::PrintLine;

// Members are separated by commas, not ended with semicolons as struct fields are.
union Payload {
    whole: int64,
    real: float64,
    flag: bool
}

// For comparison: the same three values side by side.
struct AllThree {
    whole: int64;
    real: float64;
    flag: bool;
}

enum Kind {
    Whole,
    Real,
    Flag
}

// The tag says which member of `payload` holds a value. Every function that builds a `Setting`
// must set both together, and every reader must check the tag first.
struct Setting {
    kind: Kind;
    payload: Payload;
}

func Describe(setting: Setting) {
    match setting.kind {
        .Whole => PrintLine("whole number {}", setting.payload.whole),
        .Real => PrintLine("real number  {}", setting.payload.real),
        .Flag => PrintLine("flag         {}", setting.payload.flag)
    }
}

func Main() -> int {
    PrintLine("sizeof(Payload)  {}", sizeof(Payload));
    PrintLine("sizeof(AllThree) {}", sizeof(AllThree));

    // A union literal names exactly one member: the one that becomes active.
    Describe(Setting { kind: Kind::Whole, payload: Payload { whole: 42 } });
    Describe(Setting { kind: Kind::Real, payload: Payload { real: 0.5 } });
    Describe(Setting { kind: Kind::Flag, payload: Payload { flag: true } });

    // Switching members means writing the new member and the tag together. After this, `whole`
    // is no longer meaningful: its bytes now belong to `real`.
    var setting = Setting { kind: Kind::Whole, payload: Payload { whole: 7 } };
    setting.payload.real = 2.25;
    setting.kind = Kind::Real;
    Describe(setting);
    return 0;
}