Enough metaprogramming for dataclass

from operator import OpSpec
from __spy__ import unroll_range

@blue.generic
def dataclass(cls):
    @blue
    def get_fields():
        # needs: read cls's annotated body as an ordered {name: type} dict,
        # the way @struct itself already must do internally for a normal
        # `field: T` class body. Not yet exposed to user-level blue code
        # in any of the examples above.
        return cls.__annotations__

    fields = get_fields()
    names = (*fields.keys(),)
    types = (*fields.values(),)
    N = len(names)

    @struct
    class _dc:
        __extra_fields__ = fields

        @blue.metafunc
        def __new__(m_self, *args_m):
            arg_types = args_m.types
            # could raise TypeError here if arg_types != types

            def new(*args: *arg_types) -> _dc:
                return _dc.__make__(*args)

            return OpSpec(impl, [*args_m])

        @blue.metafunc
        def __eq__(m_self, m_other):
            def impl(self: _dc, other: _dc) -> bool:
                ok = True
                for i in unroll_range(N):
                    if getattr(self, names[i]) != getattr(other, names[i]):
                        ok = False
                return ok
            return OpSpec(impl, [m_self, m_other])

        @blue.metafunc
        def __repr__(m_self):
            def impl(self: _dc) -> str:
                s = "Point("
                for i in unroll_range(N):
                    if i > 0:
                        s = s + ", "
                    s = s + names[i] + "=" + repr(getattr(self, names[i]))
                return s + ")"
            return OpSpec(impl, [m_self])

    return _dc

@dataclass
class Point:
    x: f64
    y: f64