Sum Types

What sum types are for

Sum types model a choice between alternatives, rather than a bundle of everything at once. They let a program represent “one of these shapes” in a way the compiler can track, so downstream code can treat each possibility as a first-class case instead of relying on ad hoc flags, null checks, or implicit assumptions.

That makes sum types especially useful where the valid states are mutually exclusive. The type itself encodes the decision boundary, which reduces ambiguity for readers and tools alike and makes it harder for invalid combinations of fields to appear unnoticed.

How sum types are structured

Each variant in a sum type has its own constructor, tag, or discriminant, and its own associated fields. The key idea is that the runtime value always belongs to exactly one variant, while the type system preserves which variant is active so pattern matching or equivalent branching logic can handle it explicitly.

In practice, this separates the shared abstraction from the variant-specific payload. A sum type can describe very different cases under one name, but each case remains structurally precise, which is why these types are often used for parse results, protocol messages, state machines, and domain events.

The design also improves readability when the alternatives are genuinely distinct. Instead of one broad structure with many optional fields, the code expresses the real domain choice directly, which usually makes both constructors and consumers easier to understand.

Why sum types reduce invalid states

Sum types are valuable because they prevent combinations that do not make sense. If a value can only be one variant at a time, the compiler can enforce that logic at compile time rather than leaving it to runtime checks scattered through the codebase.

This is particularly helpful when one branch requires different data from another branch. The type system can require the right fields for the selected case and reject incomplete or contradictory values before they become production defects.

They also make refactoring safer. When a new variant is added or an existing one changes, code that consumes the type is more likely to fail loudly in the right places, which is preferable to silently misinterpreting a value because a manual convention was missed.

Where sum types fit in real code

Sum types are a foundation of many functional and strongly typed languages, but the underlying idea appears more broadly in tagged unions, enums with payloads, and discriminated unions. The exact syntax varies, but the core semantics remain the same: one value, one active variant, explicit handling.

They are often paired with pattern matching because pattern matching forces the caller to consider each case. That combination helps keep business logic aligned with the actual model instead of allowing control flow to drift away from the domain shape.

In APIs and data interchange, sum types can also make contracts clearer. A response can state exactly which forms are possible, and client code can branch on the declared variant instead of inferring meaning from absent fields or loosely interpreted status codes.

Related resources from NHI Mgmt Group

• Guide: UNECE R156 Software Update Management System Guide
• What NHI types do Agentic AI systems typically use?
• How should security teams govern machine identities separately from other NHI types?
• How should security teams govern sensitive data in file types that cannot be labeled?
• How should organisations choose passwordless methods for different user types?