Emulating integer in Python's type system: addition and subtraction

counting_using_generics.py

from __future__ import annotations
from typing import Protocol


class _Int(Protocol):
    def __int__(self) -> int: ...
    def __pos__(self) -> _Int: ...
    def __neg__(self) -> _Int: ...


class O:
    __match_args__ = ()

    def __int__(self) -> int:
        return 0

    def __pos__(self) -> P[O]:
        return P(self)

    def __neg__(self) -> N[O]:
        return N(self)


class _XNum[X: _Int]:
    __match_args__ = ('x',)
    x: X

    def __init__(self, x: X, /):
        self.x = x


class P[X: _Int](_XNum[X]):
    def __int__(self) -> int:
        return int(self.x) + 1

    def __pos__(self: P[X]) -> P[P[X]]:
        return P(self)

    def __neg__(self) -> X:
        return self.x


class N[X: _Int](_XNum[X]):
    def __int__(self) -> int:
        return int(self.x) - 1

    def __pos__(self) -> X:
        return self.x

    def __neg__(self: N[X]) -> N[N[X]]:
        return N(self)


o = O()
reveal_type(++o)        # Type of "++o" is "P[P[O]]"
reveal_type(--o)        # Type of "--o" is "N[N[O]]"
reveal_type(+-o)        # Type of "+-o" is "O"
reveal_type(-+o)        # Type of "-+o" is "O"
reveal_type(++-+++-+-o) # Type of "++-+++-+-o" is "P[P[P[O]]]"