Post History

There's one big difficulty with the proposed pattern. Enum instances are singleton instances of their particular class, and in general two enums from different classes are not equal even if they wrap the same int value. So an expression like `foobar == EnumProtocol.FOO` is never going to be true if `foobar` is any enum instance.

If you're okay with adapting that to `foobar.value == EnumProtocol.FOO`, then you can do this:

```python
from typing import Literal, Protocol

from enum import Enum

class EnumProtocol(Protocol):
    FOO: Literal[1] = 1
    BAR: Literal[2] = 2

    # You could move these properties into a superprotocol
    @property
    def name(self) -> str:
        pass
    
    @property
    def value(self) -> int:
        pass

def useit(foobar: EnumProtocol) -> None:
    if foobar.value == EnumProtocol.FOO:
        print("foo")
    elif foobar.value == EnumProtocol.BAR:
        print("bar")
    else:
        print(f"{foobar.name} = {foobar.value}")

# The following class fulfils the protocol
class GoodEnum(Enum):
    FOO = 1
    BAR = 2
    BAZ = 3

useit(GoodEnum.FOO) # ok, prints "foo"
useit(GoodEnum.BAZ) # ok, prints "BAZ = 3"

# The following class violates the protocol by having wrong values
class BadEnum(Enum):
    FOO = 2
    BAR = 3

useit(BadEnum.FOO) # type checking gives error

# The following class violates the protocol by missing BAR
class UglyEnum(Enum):
    FOO = 1
    BAZ = 3

useit(UglyEnum.FOO) # type checking gives error
```