Re: Reinitialization

[Gregor.pa@Xerox.COM]

    Date: 7 Apr 88 10:07 PDT
    From: Danny Bobrow <Bobrow.pa>

    I liked Dick's variation on our proposal; that is, I like using a function
    rather than a flag for variation.  I also support his proposed addition to
    with-added-methods of an option to specify the generic function.

    However, there is a bug in the proposal.  Since users never call class-changed
    or update-instance-structure (only the system does), there is no way to change
    the call, and shared-initialize will always be used (so why have an argument).

    Here are two proposals to fix the bug, neither of which I like a lot, though I
    prefer the first.

Unfortunately, I don't think either of these can work.  The first
reduces directly to a stripped down version of the original proposal,
the second doesn't work for other reasons.

    1) Have a generic function compute-initialization-function which returns
    a function to use:

    (defmethod compute-initialization-function ((instance standard-object))
      #'shared-initialize) 

    (defmethod initialize-instance ((instance standard-object) 
				     &rest initargs)

      (apply (compute-initialization-function instance) instance initargs))

     .
     .

The problem here is that because compute-intialization-function doesn't
accept an argument saying who the caller is, it will return the same
value when called by initialize-instance, update-instance-structure etc.
This in effect reduces this to the original proposal where
initialize-instance, class-changed etc. all call the same generic
function.  The only difference is that the function isn't called with an
argument that says who its caller is.
  
    2)  Have a special variable *initializer* with the a default value
    #'shared-initialize, and use that.  For some additonal flexibility, one could
    allow initialize-instance and reinitialize-instance to have keyword argument
    :initializer whose default value is *initializer*.

The problem with this is that the user can never know when
update-instance-structure is going to be called.  This means it is
impossible to control the binding of *intializer* around calls to
update-instance-structure.


Given this I see two alternatives:

    Modify proposal 1 above so that there are three generic functions,
initialize-instance-initializer, update-instance-structure-initializer,
and class-changed-intiailizer.  The standard method on each of these
would return #'shared-initialize.  Users could define their own methods
on these generic function to control what shared initializer got used.
This is essentially Dick's proposal debugged.

    Go back to the proposal Danny and I had originally.
-------