Question

In common-lisp, I want to implement a kind of reference system like this:

Suppose that I have:

(defclass reference () ((host) (port) (file)))

and also I have:

(defun fetch-remote-value (reference) ...) which fetches and deserializes a lisp object.

How could I intervene in the evaluation process so as whenever a reference object is being evaluated, the remote value gets fetched and re-evaluated again to produce the final result?

EDIT:

A more elaborate description of what I want to accomplish:

Using cl-store I serialize lisp objects and send them to a remote file(or db or anything) to be saved. Upon successful storage I keep the host,port and file in a reference object. I would like, whenever eval gets called on a reference object, to first retrieve the object, and then call eval on the retrieved value. Since a reference can be also serialized in other (parent) objects or aggregate types, I can get free recursive remote reference resolution by modyfing eval so i dont have to traverse and resolve the loaded object’s child references myself.

EDIT:
Since objects always evaluate to themselves, my question is a bit wrongly posed. Essentially what I would like to do is:

I would like intercept the evaluation of symbols so that when their value is an object of type REFERENCE then instead of returning the object as the result of the symbol evaluation, to return the result of (fetch-remote-value object) ?

Answer 1

In short: you cannot do this, except by rewriting the function eval and modifying your Lisp’s compiler. The rules of evaluation are fixed Lisp standard.

Edit After reading the augmented question, I don’t think, that you can achieve full transperency for your references here. In a scenario like

(defclass foo () (reference :accessor ref))
(ref some-foo)

The result of the call to ref is simply a value; it will not be considered for evaluation regardless of its type.

Of course, you could define your accessors in a way, which does the resolution transparently:

(defmacro defresolver (name class slot)
    `(defmethod ,name ((inst ,class))
        (fetch-remote-reference (slot-value inst ',slot))))

(defresolver foo-reference foo reference)

Edit You can (sort of) hook into the symbol resolution mechanism of Common Lisp using symbol macros:

(defmacro let-with-resolution (bindings &body body) 
    `(symbol-macrolet ,(mapcar #'(lambda (form) (list (car form) `(fetch-aux ,(cadr form)))) bindings) ,@body))

(defmethod fetch-aux ((any t)) any)
(defmethod fetch-aux ((any reference)) (fetch-remote-reference any))

However, now things become pretty arcane; and the variables are no longer variables, but magic symbols, which merely look like variables. For example, modifying the content of a variable “bound” by this macro is not possible. The best you can do with this approach is to provide a setf expansion for fetch-aux, which modifies the original place.