Re: Struct Comparison

[Andrei Alexandrescu]

dsimcha wrote:
Regarding recent discussions in Bugzilla:  I wonder if we could somehow define
a super-efficient struct opEquals that performs introspection and only tests
expensive members if it's necessary.  For example, here is a simple case of it:
enum opEqualsMixin = q{
    bool opEquals(typeof(this) rhs) {
        foreach(tupleIndex, elem; this.tupleof) {
            static if(isIntegral!(typeof(elem))) {
                 // Compare integers first.  They're cheap.
                 if(elem != rhs.tupleof[tupleIndex]) {
                     return false;
            }
        }

        foreach(tupleIndex, elem; this.tupleof) {
            static if(isFloatingPoint!(typeof(elem))) {
                 // Compare floats.  They're also cheap.
                 if(elem != rhs.tupleof[tupleIndex]) {
                     return false;
            }
        }

        foreach(tupleIndex, elem; this.tupleof) {
            static if(!isIntegral!(typeof(elem)) &&
                !isFloatingPoint!(typeof(elem))) {

                 // All the cheap elements were equal.
                 // Resort to more expensive comparisons.
                 if(elem != rhs.tupleof[tupleIndex]) {
                     return false;
            }
        }

        return true;
    }
}

Looks cool. I think a first shot would be to make it a standalone function.

Of course, we could get even fancier.  We could recursively introspect struct
types and use various heuristics to calculate the optimal comparison order at
compile time.  Similar stuff could be done for a generic opCmp that gives a
struct an arbitrary total ordering as long as all of its members have a total
ordering.

This can be done if you associate a cost with each operation (e.g. 
comparing numbers has cost 1, comparing strings has cost 10, comparing 
using a user-defined function has cost 40 etc.) and then optimize for 
smallest average cost.


Andrei