Just as all mainstream languages now have lambda functions, I predict sum types are the next construct to spread outward from the typed functional programming community to the mainstream. Sum types are very useful, and after living with them in Haskell for a while, I miss them deeply when using languages without them. Fortunately, sum types seem to be catching on: both Rust and Swift have them, and it sounds like TypeScript's developers are at least open to the idea. I am writing this article because, while sum types are conceptually simple, most programmers I know don't have hands-on experience with them don't have a good sense of their usefulness. In this article, I'll explain what sum types are, how they're typically represented, and why they're useful. I will also dispel some common misconceptions that cause people to argue sum types aren't necessary. What is a Sum Type? Sum types can be explained a couple ways. First, I'll compare them to product types, which are extremely familiar to all programmers. Then I'll show how sum types look (unsafely) implemented in C. Every language has product types - tuples and structs or records. They are called product types because they're analogous to the cartesian products of sets. That is, int * float is the set of pairs of values (int, float). Each pair contains an int AND a float. If product types correspond to AND, sum types correspond to OR. A sum type indicates a value that is either X or Y or Z or ... Let's take a look at enumerations and unions and show how sum types are a safe generalization of the two. Sum types are a more general form of enumerations. Consider C enums: enum Quality { LOW, MEDIUM, HIGH }; A value of type Quality must be one of LOW, MEDIUM, or HIGH (excepting uninitialized data or unsafe casts -- we are talking about C of course). C also has a union language feature: union Event { struct ClickEvent ce; struct PaintEvent pe; }; ClickEvent and PaintEvent share the same storage location in the union, so