lol j'étais là mais j'étais occupé (petit déj)
euh sinon Pollux, d'après toi les objets ça sert à quoi hein ?
exemple débile :
# let (<) x y = x#compare y;;
val ( < ) : < compare : 'a -> 'b; .. > -> 'a -> 'b = <fun>
# class entier (x : int) = object method contenu = x
method compare (autre : entier) = x > autre#contenu end;;
class entier :
int -> object method compare : entier -> bool method contenu : int end
# class flottant (x : float) = object method contenu = x
method compare (autre : flottant) = x < autre#contenu end;;
class flottant :
float ->
object method compare : flottant -> bool method contenu : float end
# new flottant 1. < new flottant 2.;;
- : bool = true
# new entier 1 < new entier 2;;
- : bool = false
Si j'ai bien compris c'est ça que tu appelles de la surcharge non ?
Bon par contre c'est vrai que les opérateurs de comparaison ont un type polymorphe qui ne te permet pas de les redéfinir en conservant ce polymorphisme... ceci dit je ne vois pas du tout en quoi c'est indispensable... c'est utile, certes, ça permet d'alléger la syntaxe, mais à part pour ( == ) dont le statut est un peu particulier et le polymorphisme justifié, ça ne me dérangerait pas vraiment pour ma part de devoir utiliser <. ou =. etc.
mais est aussi constitué de l'ensemble des exceptions qu'elle peut lancer (et qui sont en fait des valeurs de retour comme les autres).
Euh alors là j'ai du mal à voir en quoi c'est des valeurs de retour « comme les autres »
. Si c'en était, ça voudrait dire qu'on revient au calcul de l'expression appelante en utilisant la valeur de l'exception ?
"exn" a la particularité d'être un type incomplet : encore une de ces nombreuses features built-in, qui ont à la fois la caractéristique d'être utiles et qui, en même temps, sont complètement non-extensibles
I don't understand what you say...
[>`a] est aussi un type incomplet, non ? ou alors je ne vois pas ce que tu appelles un type incomplet...
Bon sinon pour en revenir à la surcharge : je ne comprends toujours pas très bien ce que c'est. Qu'est-ce qui te fait dire que la fonction de comparaison utilise une surcharge (« C'est qd même implémenté de manière surchargée... ») ? est-ce la présence de ce switch/case :
static long compare_val(value v1, value v2)
{
struct compare_item * sp;
tag_t t1, t2;
[...]
t1 = Tag_val(v1);
t2 = Tag_val(v2);
[...]
switch(t1) {
case String_tag: {
[...]
case Double_tag: {
[...]
case Abstract_tag:
compare_free_stack();
invalid_argument("equal: abstract value");
case Closure_tag:
case Infix_tag:
compare_free_stack();
invalid_argument("equal: functional value");
case Object_tag: {
long oid1 = Oid_val(v1);
long oid2 = Oid_val(v2);
if (oid1 != oid2) return oid1 - oid2;
break;
}
case Custom_tag: {
[...]
default: {
mlsize_t sz1 = Wosize_val(v1);
mlsize_t sz2 = Wosize_val(v2);
/* Compare sizes first for speed */
if (sz1 != sz2) return sz1 - sz2;
if (sz1 == 0) break;
[...]
} ? enfin ça ne correspond pas aux définitions qu'ont données Hippo et vince de la surcharge il me semble (il n'y a bien qu'une fonction, elle a quand même le droit de distinguer des cas...)
. Si c'en était, ça voudrait dire qu'on revient au calcul de l'expression appelante en utilisant la valeur de l'exception ? 
)
