... overload stuff is called from the code that interprets the de-referencing opcodes ... If it's slow, that's probably not because it has to determine the kind of reference needed,

Exactly. It knows what it's got to do. It only needs to chase a few pointers in magic to find the callback--and still it is notoriously slow.

A cursory peek at want.xs shows an aweful lot of logic, including several physically and logically nested loops tracing opcode trees. I won't pretend to have understood half of what I saw in there, but it looks expensive, which supports my findings from a while ago.

My point is that it might be faster, and simpler, to have gimme_a_ref() return a ref blessed into a package that overloads the dereference operators. Especially as Alter is already using (as far as I understood your other thread), two levels of inside-out-style dereferencing which is already slow.

Additionally, what happens if someone assigns the return from gimme_a_ref() to a scalar, and then attempts to dereference it later? You'll have no applicable 'current context' at the time of the call from which to determine what use will be made of what you return.

Admittedly that can be addressed through documentation, but you'll be denying flexibility. You'll also create the situation of requiring the additional overhead of determining the calling context for every use.