On 12/19/24 10:49 AM, sfp wrote:
> Subject lines says it all

Although you clearly have a need for, virtual operators haven't been common in my experience. I always felt they could cause semantic issues.

For example, the two subclasses of an interface may not have the binary relation that the interface prescribes. I can think of the Animal hierarchy where Cat and Dog may have a certain relationship that may not make sense between Alligator and Mouse. Forcing such a binary function at the Interface level may not be right.

Having said that, and to contradict myself, this discussion reminded me of a fun DConf presentation by our friend Jean-Louis Leroy that included examples of such virtual functionality where it made sense:

"Open Methods for D (The Expression Problem - solved)"

  https://www.youtube.com/watch?v=MpwHeE2Vvfw&t=395s

But it uses his magical implementation (enabled by D) of open methods (and multi-methods).

Ali

On 12/20/24 10:40 AM, Ali Çehreli wrote:
> I always felt they could cause semantic issues.

I remembered one such case. What should happen if both Cat and Dog defined the "+" operator? Should we expect 'cat + dog' behave the same as 'dog + cat'?

Unfortunately, virtual functions are picked by the object that they are called on. The following example demonstrates this confusion with a function named mingleWith(). Different functions are called depending on the object.

import std.stdio;

interface Animal {
    void mingleWith(Animal);
}

class Dog : Animal {
    void mingleWith(Animal) {
        writeln("Dog with an Animal");
    }
}

class Cat : Animal {
    void mingleWith(Animal) {
        writeln("Cat with an Animal");
    }
}

void use(Animal a, Animal b) {
    a.mingleWith(b);
    b.mingleWith(a);      // <-- DIFFERENT BEHAVIOR
}

void main() {
    auto c = new Cat();
    auto d = new Dog();

    use(c, d);
}

This is too much complication for engineering, program correctness, and life. :)

Ali

On Friday, 20 December 2024 at 18:40:17 UTC, Ali Çehreli wrote:
> On 12/19/24 10:49 AM, sfp wrote:
> > Subject lines says it all
>
> Although you clearly have a need for, virtual operators haven't been common in my experience. I always felt they could cause semantic issues.
>
> ...
>
> But it uses his magical implementation (enabled by D) of open methods (and multi-methods).
>
> Ali

Right, the semantics can be a little odd, but there are definitely use cases for it which are very natural. Modeling how different kinds of animals mingle, I'm not sure... :-)

"Virtual binary operators" are quite useful in computational science (my field...). For instance, with a numerical linear algebra library, you might have sparse matrices, dense matrices, diagonal matrices, Toeplitz matrices, matrices which are only accessible indirectly via their action (e.g. you multiply with a discrete Fourier transform matrix by applying the FFT and do not store the matrix itself), *block* matrices (comprised of other matrices), etc, etc.

It is pretty common to mix and match these heterogeneously. MATLAB and Python have dense and sparse matrices, potentially other user-defined matrices/operators, and mixing and matching them is straightforward. Duck-typing is especially nice here, because there is no need to return a super type... multiply a dense matrix with a diagonal matrix and return a dense matrix (rather than a matrix supertype), no problem...

I actually saw this multimethod implementation in another forum post when searching around, but not the talk. Thanks for posting it. I will definitely take a look, but unless I'm mistaken, D doesn't have free binary operators?