Ceylon's Union and Intersection Types: Practical Static Typing on the JVM

The Problem: Modeling Heterogeneous Data Without Losing Type Safety

When working with JSON-like structures or API responses on the JVM, developers face a painful trade-off: either use loosely-typed Object references that sacrifice compile-time safety, or create verbose wrapper classes for every possible combination of types. Ceylon solves this with first-class union and intersection types.

Union and Intersection Types in Practice

Ceylon's type system natively supports String|Integer (union) and Serializable&Cloneable (intersection) directly in the language. This means a variable can hold values of multiple distinct types without requiring a common supertype, while the compiler maintains exhaustive type checking.

The type T? (optional) is syntactic sugar for T|Null, making nullability a natural part of the type system rather than a special case. This enables precise modeling of data that can be one of several types, with the compiler ensuring all cases are handled.

Worked Example: Parsing API Responses

// Variable can hold String, Integer, or null
value apiResponse = "success";

// Compiler infers type as String|Integer|Null
if (is String apiResponse) {
    print("Got string: " + apiResponse);
} else if (is Integer apiResponse) {
    print("Got integer: " + apiResponse.string);
} else {
    print("Got null");
}

// Union type with intersection for complex constraints
class Handler satisfies Exception&Cloneable {
    // Must implement both interfaces
}

Compiler Intelligence and Type Inference

Ceylon's compiler computes principal types for expressions, reducing the need for explicit type annotations. When a function returns different types based on conditions, the compiler infers the union type automatically.

This local type inference works across complex control flows, meaning switch expressions and if-else chains can narrow union types safely. The result is code that reads naturally while maintaining static guarantees.

Trade-offs and Limitations

Ceylon development ceased around 2017; the language is no longer actively maintained by Red Hat. This creates practical concerns:

• IDE plugins and build tools may not work with recent JDK versions
• Union and intersection types can produce verbose compiler errors when inference fails
• Deeply nested generics may overwhelm the type inference engine
• Java interoperability requires careful mapping, as Java's raw types don't translate cleanly

Practical Verification

To verify current behavior, run the Ceylon compiler on sample code demonstrating union/intersection inference. Check the Ceylon language specification (version 1.3.3) for authoritative semantics on type expressions and principal typing.

For production use, consider that while the type system is powerful, the lack of maintenance means you may encounter compatibility issues with modern Java ecosystems.