Create algebraic data types (ADTs) easily, using syntax modeled on the enum module.

In simple terms, picture enriching the enum module with support for member classes in addition to constant values.

class Event(ADT):
    QUIT = "quit"

    @dataclass
    class Message:
        msg: str

def process_event(event: Event) -> str:
    match event:
        case Event.QUIT:
            return "quit"
        case Event.Message(msg):
            return f"Message: {msg}"

>>> process_event(Event.Message("test"))
"Message: test"

The focus is on sum types, since product types are already well-served by the language.

ADTs may also be generic:

from __future__ import annotations

T = TypeVar("T")


class Tree(ADT[T]):
    EMPTY = "empty"

    @dataclass
    class Node:
        left: Tree[T]
        right: Tree[T]

This requires the postponed evaluation of annotations (aka PEP 563), which is activated by importing annotations from __future__.

A class member will have access to any method on the enum. Since this involves replacing the class with a special subclass, class members must be defined inside the enum.

class MyADT(ADT):
    @dataclass
    class Inner:
        b: int

    def a_method(self) -> int:
        return 1

>>> MyADT.Inner(1).a_method()
1

Enums may mix in a class for their members.

class IntEnum(int, Enum):
    A = 1

This adds the mixed-in class to each member's MRO, so isinstance(IntEnum.A, int) holds.

Since ADTs can be heterogenous, no class may be mixed in.

Enums support a class-level __getitem__, which allows fetching enum members by name.

class MyEnum(Enum):
    A = 1

>>> MyEnum['A']
<MyEnum.A: 1>

Since ADTs need to be able to be generic, this syntax conflicts with parametrizing a generic ADT, so it is not supported.

T = TypeVar("T")
E = TypeVar("E", bound=BaseException)

class Result(ADT[T, E]):
    @dataclass
    class Ok:
        val: T

    @dataclass
    class Err:
        err: E