goops and equal?

goops and equal?

[Jan Nieuwenhuizen]

Hi,

In the example below, my implementation of equal? is only being 
used if both types are the same.  That surprised me; the manual
says equal? becomes a generic and for normal generics this works
as I expect.

How do I get the magic equal? to do what show the same result as the
simple generic type-equal?

And also, do we want such surprises?

Greetings,
Jan

(read-set! keywords 'prefix)
(use-modules (oop goops))

(define-class <type> ()
  (name :accessor .name :init-value #f :init-keyword :name))

(define-method (equal? (a <type>) (b <type>))
  (display "<type>equal?\n")
  (eq? (.name a) (.name b)))

(define-method (equal? (a <type>) (b <symbol>))
  (display "<type0>equal?\n")
  (eq? (.name a) b))

(define-method (type-equal? (a <type>) (b <symbol>))
  (display "<type1>equal?\n")
  (eq? (.name a) b))

(format #t "equal?: ~a\n" (equal? (make <type> :name 'a) (make <type> :name 'a)))
(newline)
(format #t "equal?: ~a\n" (equal? (make <type> :name 'a) 'a))
(newline)
(format #t "type-equal?: ~a\n" (type-equal? (make <type> :name 'a) 'a))
(newline)


-- 
Jan Nieuwenhuizen <janneke@gnu.org> | GNU LilyPond http://lilypond.org
Freelance IT http://JoyofSource.com | Avatar®  http://AvatarAcademy.nl  

Re: goops and equal?

[Nala Ginrut]

[-- Attachment #1: Type: text/plain, Size: 1506 bytes --]

I think you have to define your specific certain-class-equal?
So does record-type.
 2014年11月10日 下午8:58于 "Jan Nieuwenhuizen" <janneke@gnu.org>写道：

> Hi,
>
> In the example below, my implementation of equal? is only being
> used if both types are the same.  That surprised me; the manual
> says equal? becomes a generic and for normal generics this works
> as I expect.
>
> How do I get the magic equal? to do what show the same result as the
> simple generic type-equal?
>
> And also, do we want such surprises?
>
> Greetings,
> Jan
>
> (read-set! keywords 'prefix)
> (use-modules (oop goops))
>
> (define-class <type> ()
>   (name :accessor .name :init-value #f :init-keyword :name))
>
> (define-method (equal? (a <type>) (b <type>))
>   (display "<type>equal?\n")
>   (eq? (.name a) (.name b)))
>
> (define-method (equal? (a <type>) (b <symbol>))
>   (display "<type0>equal?\n")
>   (eq? (.name a) b))
>
> (define-method (type-equal? (a <type>) (b <symbol>))
>   (display "<type1>equal?\n")
>   (eq? (.name a) b))
>
> (format #t "equal?: ~a\n" (equal? (make <type> :name 'a) (make <type>
> :name 'a)))
> (newline)
> (format #t "equal?: ~a\n" (equal? (make <type> :name 'a) 'a))
> (newline)
> (format #t "type-equal?: ~a\n" (type-equal? (make <type> :name 'a) 'a))
> (newline)
>
>
> --
> Jan Nieuwenhuizen <janneke@gnu.org> | GNU LilyPond http://lilypond.org
> Freelance IT http://JoyofSource.com | Avatar®  http://AvatarAcademy.nl
>
>

[-- Attachment #2: Type: text/html, Size: 2231 bytes --]

Re: goops and equal?

[Mark H Weaver]

Jan Nieuwenhuizen <janneke@gnu.org> writes:

> In the example below, my implementation of equal? is only being 
> used if both types are the same.  That surprised me; the manual
> says equal? becomes a generic and for normal generics this works
> as I expect.

'equal?' is actually a "primitive generic", which means that it's a core
C function that handles the cases it knows about, and only calls out to
user-defined GOOPS methods for cases that aren't handled internally.

One of the facts known by core 'equal?' is that objects of different
types are not equal.

It may be that we should relax this somewhat, but IMO it's probably a
bad idea to allow instances of your user-defined type to be 'equal?' to
symbols.  Out of curiosity, why do you want this?

BTW, in order to allow user-defined types to be 'equal?' to built-in
types, we'd also need to change our hashing function for 'equal?'-based
hash tables.

      Regards,
        Mark

Re: goops and equal?

[Jan Nieuwenhuizen]

Mark H Weaver writes:

> 'equal?' is actually a "primitive generic", which means that it's a core
> C function that handles the cases it knows about, and only calls out to
> user-defined GOOPS methods for cases that aren't handled internally.
>
> One of the facts known by core 'equal?' is that objects of different
> types are not equal.

That makes sense; once you know it.

> It may be that we should relax this somewhat, but IMO it's probably a
> bad idea to allow instances of your user-defined type to be 'equal?' to
> symbols.  Out of curiosity, why do you want this?

Mainly because of surprise/symmetry.  The manual says equal? becomes
a generic once Goops is loaded.

I agree that it's unwise or at least bad taste to implement equal?
for different objects to be the same.

I have a situation where the compared objects could be the same,
or one could be a symbol which has the same semantics.

   (define-class <type> ()
    (name :accessor .name :init-value 'void :init-keyword :name))

   (define-method (type-equal? (a <type>) (b <symbol>))
     (eq? (.name a) b))

Now I must provide a type-equal? wrapper for the equal? method
I already have, ie

   (define-method (type-equal? (a <type>) (b <type>))
     (equal? a b))

that I could omit if the first type-symbol one could be called equal?

Thanks!
Greetings, Jan

-- 
Jan Nieuwenhuizen <janneke@gnu.org> | GNU LilyPond http://lilypond.org
Freelance IT http://JoyofSource.com | Avatar®  http://AvatarAcademy.nl  

Re: goops and equal?

[Mark H Weaver]

Jan Nieuwenhuizen <janneke@gnu.org> writes:

> Mark H Weaver writes:
>
>> 'equal?' is actually a "primitive generic", which means that it's a core
>> C function that handles the cases it knows about, and only calls out to
>> user-defined GOOPS methods for cases that aren't handled internally.
>>
>> One of the facts known by core 'equal?' is that objects of different
>> types are not equal.
>
> That makes sense; once you know it.
>
>> It may be that we should relax this somewhat, but IMO it's probably a
>> bad idea to allow instances of your user-defined type to be 'equal?' to
>> symbols.  Out of curiosity, why do you want this?
>
> Mainly because of surprise/symmetry.  The manual says equal? becomes
> a generic once Goops is loaded.

I agree that we should improve that bit in the manual.

> I agree that it's unwise or at least bad taste to implement equal?
> for different objects to be the same.
>
> I have a situation where the compared objects could be the same,
> or one could be a symbol which has the same semantics.

They may have the same semantics in some of your code, but they have
different semantics for most other code in your Guile session.  The
problem with modifying 'equal?' in this way is that it would be a global
change, which could cause existing code to start misbehaving.

    Regards,
      Mark