Unions etiquetadas y switch

A plain union forgets which field is active. A tagged union pairs the value with an enum tag that records the current variant.

You write union(enum) to let Zig generate a matching tag automatically, one tag name per field.

Now the value carries its own tag, like .int or .text. The union always knows which variant it currently holds.

Use switch on a tagged union to branch by variant. Each case names one tag and handles that shape of the value.

Add a capture with vertical bars to pull out the inner value of the active field, ready to use inside that branch.

Zig requires every variant to be handled. Forget a case and the compiler stops you, so you never silently miss one.

When you want to handle the rest in one place, add an else branch to cover any variants you did not list explicitly.

A switch can produce a value, so each branch returns something. You assign the whole switch to a variable in one step.

Capture by pointer with |*field| when you want to change the payload in place rather than copy it out of the union.

Tagged unions are Zig's safe sum types: one value, many shapes, and a switch that the compiler proves you handled completely.

This pattern fits tokens, AST nodes, and state machines beautifully: model each case once and let switch route the logic.

What does writing union(enum) give you over a plain union?

You met tagged unions: union(enum) tracks the active variant. Switch over it, capture payloads with bars, and the compiler enforces every case. 🧩