Reducing JVM Boilerplate with Ceylon Union and Intersection Types

The problem: Null-checks and interface bloat

In traditional JVM languages, developers often struggle with two specific architectural frictions:

• Optionality: Values that might be absent are typically represented as null. This forces the developer to pepper the codebase with defensive if (x != null) checks to avoid the dreaded NullPointerException.
• Constraint Composition: When a method requires an object to satisfy multiple contracts (e.g., it must be both Drawable and Serializable), the standard approach is to create a new interface that extends both. This leads to a proliferation of "marker" interfaces that exist only to satisfy the type system, cluttering the domain model.

These patterns introduce boilerplate and shift the burden of safety from the compiler to the developer's discipline.

Thesis: Expressive types for safer domain modeling

Ceylon solves these issues by treating union and intersection types as first-class citizens. Instead of creating wrapper classes or relying on runtime checks, you can express optionality and composition directly in the type signature. This allows the compiler to enforce safety at build time while generating efficient JVM bytecode without runtime overhead.

Union types for optionality

A union type A|B represents a value that is either an A or a B. In Ceylon, the Null type is distinct. By defining a variable as String|Null, you explicitly tell the compiler (and other developers) that the value may be missing. The compiler then prevents you from calling String methods on that variable until you have used a type guard to prove the value exists.

Intersection types for composition

An intersection type A&B represents a value that is simultaneously an A and a B. This eliminates the need for intermediate interfaces. You can define a function that accepts Drawable&Serializable, and any class that implements both interfaces can be passed in directly. This keeps the type hierarchy flat and flexible.

Worked Example: A Resource Processor

This example demonstrates how to handle optional configuration and multi-interface requirements using Ceylon SDK (version 1.3.3 or later).

Setup: Run these commands in your terminal to initialize a project.

# Initialize a new Ceylon project
ceylon new resource-demo
cd resource-demo

Create a source file at source/resource-demo/main.ceylon:

shared void run() {
    // Union type: value can be String or Null
    value config = getSetting("timeout");
    handleSetting(config);

    // Intersection type: must be both Loggable and Closable
    value logger = FileLogger();
    processResource(logger);
}

String|Null getSetting(String key) {
    return null; // Simulate missing setting
}

void handleSetting(String|Null setting) {
    if (exists setting) {
        // Inside this block, 'setting' is narrowed to String
        print("Setting found: " + setting.value);
    } else {
        print("Using default setting");
    }
}

interface Loggable { void log(String msg); }
interface Closable { void close(); }

class FileLogger() satisfies Loggable & Closable {
    void log(String msg) => print("Logging: " + msg);
    void close() => print("Closing logger");
}

void processResource(Loggable&Closable resource) {
    resource.log("Processing started");
    resource.close();
}

Verification: Compile and run the project using the following commands:

# Compile the project
ceylon compile resource-demo
# Run the main function
ceylon run resource-demo

Expected Results:

• The program should output: Using default setting, Logging: Processing started, and Closing logger.
• If you attempt to pass a class that only implements Loggable to processResource, the compiler will throw an error, preventing a runtime ClassCastException.

Trade-offs and Limitations

While these features increase expressiveness, they introduce two practical challenges:

1. Diagnostic Verbosity: Because the type system is more complex, compiler error messages can become verbose. A mismatch involving multiple unions and intersections may result in long type signatures in the console, requiring a moment of study to parse.
2. Java Interoperability: Java does not understand union or intersection types. When passing a Ceylon union (like String|Null) to a Java method expecting a String, you may need to provide explicit type annotations or write small adapter functions to bridge the gap.

Actionable Closing

To improve the robustness of your JVM-based domain models, start by identifying your most frequent null checks and interface hierarchies. Replace nullable types with T|Null and use the exists guard to handle them safely. For complex constraints, replace marker interfaces with intersection types (A&B). This shift moves your safety checks from runtime to compile-time, reducing boilerplate and increasing code clarity.