[ENH] Indices are immutable by definition and should take advantage of that

[wence-]

Is your feature request related to a problem? Please describe.

Indices advertise a bunch of properties (for example is_monotonic_increasing). These are implemented by inheriting from Frame or SingleColumnFrame. But those latter classes are mutable, and so their implementation of the property must recompute every time.

For an index, this is not the case, and so we lose some performance (for example, every time we do a slice .loc we'll run a libcudf kernel to check if the index is sorted).

Describe the solution you'd like

Index properties (especially where they return scalars, and therefore the memory footprint is negligible) should use functools.cached_property to provide their (immutable) properties.

Describe alternatives you've considered

None

[wence-]

Here's a (possibly too magic) way of implementing this without too much code duplication:

from functools import cached_property

class Immutable(type):
    __immutable_properties__ = ()
    def __init__(cls, name, bases, dict):
        super().__init__(name, bases, dict)
        for prop in cls.__immutable_properties__:
            cprop = cached_property(lambda self: getattr(super(cls, self), prop))
            cprop.__set_name__(cls, prop)
            setattr(cls, prop, cprop)


class Index(SingleColumnFrame, metaclass=Immutable):
    __immutable_properties__ = ("is_monotonic_increasing", ...)
    ...

[vyasr]

Related to #9593 (the immutability is also mentioned there).