Re: GOOPS: Customizing class instantiation

[Ludovic Courtès]

Hi,

Nobody won the prize, because nobody gave the correct answer.  For those
of you who played, I'm giving the correct answer below.  ;-)

address@hidden (Ludovic Courtès) writes:

>   (use-modules (oop goops))
>   (read-set! keywords 'prefix)
>
>   (define-class <my-class> (<class>)
>     (the-slot :init-value #t))
>
>
>   (define-method (compute-cpl (c <my-class>))
>     (format (current-error-port) "CPL (~a)~%" c)
>     (list c <top>))
>
>   (define-method (make-instance (c <my-class>))
>     (format (current-error-port) "make-instance (~a)~%" c)
>     (next-method))
>
>
>   (define (make-a-class name)
>     (let ((c (make <my-class>)))
>       (slot-set! c 'name name)
>       c))
>
> The issue is that when instantiating an instance of `<my-class>' (read
> that twice ;-)), I'm getting the following error:
>
>   ;; Create a class (instance of `<my-class>').
>   guile> (define c (make-a-class 'paf))
>   CPL (#<<my-class> ??? 301f8930>)
>   guile> c
>   #<<my-class> paf 301f8930>
>
>   ;; Instantiate it.
>   guile> (make c)
>   make-instance (#<<my-class> paf 301f8930>)
>
>   <unnamed port>: In expression (let* (#) (format # "make-instance (~a)~%" 
> ...) ...):
>   <unnamed port>: No applicable method for #<<generic> initialize (10)> in 
> call (initialize #<struct 301f8930:301f7320> ())
>   ABORT: (goops-error)

The whole issue here is that `%allocate-instance'
(aka. `scm_sys_allocate_instance') returns an apparently improperly
initialized object (a raw struct) instead of a regular GOOPS object that
has a class, etc.  Since there are no `initialize' methods for raw
structs, we get this no-applicable-method error.

But why is it so?  Looking at `goops.c', it's actually `wrap_init ()'
that returns the offending struct.  However, `wrap_init ()' _does_
specify class information as part of the type tag.  So perhaps it is the
class information that is not properly initialized in the case of an
instance of `<my-class>'?

The correct way to instantiate a class is found in `make-class' in
`goops.scm'.  This function passes several keyword arguments to `make'
that my `make-a-class' function did not provide.  In particular, the
`:dsupers' argument is the one that must not be forgotten:

  guile> (make (make <my-class>))
  [...]
  <unnamed port>: No applicable method for #<<generic> initialize (11)> in call 
(initialize #<struct 104ac060:104ae270> ())

  guile> (make (make <my-class> :dsupers (list <top>)))
  #<??? 104321b0>

Note that the `compute-cpl' method specialized for `<my-class>' is still
needed and it must contain a class for which an `initialize' method
exists (i.e., not `<top>'):

  (define-method (compute-cpl (c <my-class>))
    (list c <object> <top>))

Notice: `compute-cpl' and `:dsupers' don't even have to agree...

Now, this does not really explain why an instance of such an
improperly-initialized class would show up as a raw struct.  Well,
clarifying is left as an exercise to the reader.  :-)


In short, the lesson is: one should use `make-class' (although
it's undocumented) rather than `(make <class> ...)' when instantiating a
new class.

Thanks,
Ludovic.