Comment désagréger les définitions de l'opérateur entre objets / classes dans un langage de programmation?

Je vais répondre à cette question en disant "duh, ne fais pas de définitions ambiguës".

Si je recrée votre exemple en C ++ (à l'aide d'une fonction f code> au lieu de + opérateur et int code> / float code> au lieu de a code> / b code>, mais il n'y a vraiment pas beaucoup de différence) .. . P>

template<class t>
void f(int a, t b)
{
    std::cout << "me! me! me!";
}

template<class t>
void f(t a, float b)
{
    std::cout << "no, me!";
}

int main(void)
{
    f(1, 1.0f);
    return 0;
}

Je suggérerais que donné x + y , le compilateur doit rechercher les deux x.op_plus (y) et y.op_added_to (x) ; Chaque mise en œuvre devrait inclure un attribut indiquant s'il devrait s'agir d'une mise en œuvre «préférée», «normale», «de replie», et éventuellement indiquant qu'il est "courant". Si les deux mises en œuvre sont définies et que les implémentations sont des priorités différentes (par exemple, «préférées» et «normale»), utilisez le type pour sélectionner une préférence. Si les deux sont définis comme étant de la même priorité, les deux sont "communs", favorisez le formulaire x.op_plus (y) . Si les deux sont définis avec la même priorité et qu'ils ne sont pas à la fois "communs", signalez une erreur.

Je suggérerais que la capacité de hiérarchiser les surcharges et les conversions aurait une caractéristique très importante pour avoir une langue. Il n'est pas utile que les langues squawk sur des surcharges ambiguës dans des cas où les deux candidats feraient la même chose, mais les langues devraient s'affronter dans des cas où deux surcharges possibles auraient différentes significations, chacune d'elles étant utile dans certains contextes. Par exemple, donné quelquefloat == Somedouble ou Somedouble == somelong , un compilateur devrait Squawk, car il peut y avoir une utilité pour savoir si le nombre de personnes numériques Quantités représentées par deux valeurs correspondant, et il peut également y avoir une utilité pour savoir si l'opérande gauche détient la meilleure représentation possible (pour son type) de la valeur dans l'opérande de droite. Java et C # ne signent pas l'ambiguïté dans les deux cas, optant plutôt pour utiliser la première signification pour la première expression et la seconde pour la seconde, même si la signification pourrait être utile dans les deux cas. Je suggérerais qu'il serait préférable de rejeter de telles comparaisons que de les avoir à mettre en œuvre une sémantique incohérente.

Dans l'ensemble, je vous suggérerais de philosophie qu'une bonne conception de la langue devrait laisser un programmeur indiquer ce qui est important et ce qui n'est pas. Si un programmeur sait que certaines "ambiguïtés" ne sont pas des problèmes, mais d'autres sont, il devrait être facile d'avoir le pavillon du compilateur, mais pas le premier.

addendum

J'ai regardé brièvement votre proposition; Il voit que vous attendez des liaisons entièrement dynamiques. J'ai travaillé avec une langue comme celle-là (Hypertalk, vers 1988) et c'était "intéressant". Considérez, par exemple, que "2x" <"3" <4 <10 <"11" <"2x". Double Dispatch peut parfois être utile, mais uniquement dans les cas où les opérateurs surchargent avec différentes sémantiques (par exemple, la chaîne et les comparaisons numériques) sont limitées à fonctionner sur des ensembles disjoints de choses. Interdire les opérations ambiguës au moment de la compilation est une bonne chose, car le programmeur sera en mesure de spécifier ce qui est destiné. Avoir une telle ambiguïté déclencher une erreur de temps d'exécution est une mauvaise chose, car le programmeur peut être passé longtemps au moment de la surface des erreurs. Par conséquent, je ne peux vraiment pas offrir de conseils pour comment faire une double envoi de temps d'exécution pour les opérateurs, sauf pour dire «ne», à moins que la compilation de la compilation, vous limitez les opérandes aux combinaisons dans lesquelles toute surcharge éventuelle aurait toujours la même sémantique. .

Par exemple, si vous avez eu une "liste immuable de nombres" abstraite, avec un membre pour signaler la longueur ou renvoyer le numéro à un index particulier, vous pouvez spécifier que deux instances sont égales si elles ont la même longueur, et chaque pour chaque index, ils renvoient le même numéro. Bien qu'il soit possible de comparer deux cas pour l'égalité en examinant chaque article, cela pourrait être inefficace si par exemple. Un exemple était un type "Bunchoftzeroes" qui a simplement tenu un entier N = 1000000 et ne stocke aucun objet, et l'autre était un "ncopiesofarray" qui détenait n = 500000 et {0,0} comme la matrice à copier . Si de nombreux cas de ces types seront comparés, l'efficacité pourrait être améliorée en disposant de telles comparaisons invoquées une méthode qui, après avoir vérifié la longueur de la matrice globale, vérifie si le tableau "Modèle" contient des éléments non nuls. Si ce n'est pas le cas, il peut être signalé comme étant égal à la matrice BUNCH-of-ZEROES sans avoir à effectuer 1 000 000 comparaisons d'éléments. Notez que l'invocation d'une telle méthode par double expédition ne modifierait pas le comportement du programme - il lui permettrait simplement d'exécuter plus rapidement.