jeu poster le plus tard possible - Page 187

bool isOdd(int x) {
return (x / 2) != (x / 2.0);
}

Quand je vois ça, je dis caml powa ... ^^

Clairement :

let isOdd x =
  float_of_int (x / 2) != (float_of_int x) /. 2.0;;

Ué fin bon y a quand mêmes les gardes-fous du float_of_int et du /., pour être sûr qu'on écrit pas des horreurs pareilles ...

C'est surtout parce que Caml est incapable de gérer des fonctions surchargées Ca se voit que tu n'as pas eu la mauvaise idée de faire un compresseur MP3 en CAML... La syntaxe est vraiment lourdingue au possible.

Caml est incapable de gérer des fonctions surchargées

C'est bien l'intérêt : ça évite d'écrire ces horreurs!

Quelles horreurs? C'est complètement indispensable! D'ailleurs, les développeurs de CAML aussi l'ont bien compris en essayant de créer une sorte de surcharge pour les fonctions de comparaison. Mais c'est affreusement mal foutu : on ne peut pas faire un ordre personnalisé, ni faire une fonction qui ressemble à la fonction d'ordre. Bof, quoi.

une sorte de surcharge pour les fonctions de comparaison.

Mu?

on ne peut pas faire un ordre personnalisé, ni faire une fonction qui ressemble à la fonction d'ordre.

Mu?

µ

^^

J'aimerais bien comprendre skidi...

il faut se mettre à sa place pour cela, et je n'en prendrais pas le risque...

Pollux > qu'est-ce que tu veux faire avec des fonctions surchargées ? (et c'ets quoi exactement une fonction surchargée d'ailleurs ?)

Je dirais : ce sont deux fonctions différentes qui ont le même nom (mais pas le même type), le compilateur décidant de la fonction à utiliser selon le type des données.

ou alors ce sont deux prototypes de fonction qui pointent sur le même binaire, comme ça tu peux appeler l'un ou l'autre, ça plantera pas pareil

En tout cas, rien de tel n'existe en caml. Les fonctions de comparaison ne sont pas surchargées, elles ont un type polymorphe...

Hippohmu
:

une sorte de surcharge pour les fonctions de comparaison.

Mu?

prefix < : 'a -> 'a -> bool

on ne peut pas faire un ordre personnalisé, ni faire une fonction qui ressemble à la fonction d'ordre.

Mu?

Faire une fonction de comparaison qui, par exemple, compare les chaînes avec un ordre case-insensitive et qui compare les autres normalement.

Ce n'est qu'un exemple, mais ma critique porte en fait principalement sur le fait qu'il y a clairement une exception pour les fonctions de comparaisons, et que donc :
- les développeurs de CAML se sont bien rendu compte que c'était nécessaire d'avoir une forme de surcharge dans certains cas
- comme c'est built-in, on ne peut pas faire des trucs de ce style soi-même

Hippohmu
: En tout cas, rien de tel n'existe en caml. Les fonctions de comparaison ne sont pas surchargées, elles ont un type polymorphe...

Oui, et? C'est qd même implémenté de manière surchargée... Je ne peux pas faire une telle fonction polymorphe moi-même, à moins de me restreindre justement aux fonctions de comparaison.

Pollux
: prefix < : 'a -> 'a -> bool

Ben où est la surcharge?
C'est un type polymorphe (pas un scoop en caml..)

- les développeurs de CAML se sont bien rendu compte que c'était nécessaire d'avoir une forme de surcharge dans certains cas

Il n'y a pas de surcharge !!


(Je réfléchis à tes autres remarques )

ododo !!

hippo> Si, dans l'implémentation. C'est là tout le pb.

Pollux
: Je ne peux pas faire une telle fonction polymorphe moi-même, à moins de me restreindre justement aux fonctions de comparaison.

let contrepollux x y =
   [x;y]; true ;;


val contrepollux : 'a -> 'a -> bool = <fun>

sabrina
: ododo !!

allez vide ton sac !

Hippohmu
:

Pollux
: Je ne peux pas faire une telle fonction polymorphe moi-même, à moins de me restreindre justement aux fonctions de comparaison.

let contrepollux x y =
  let hd = function a::_ -> a in
   [x;y;hd [] ]; true ;;


val contrepollux : 'a -> 'a -> bool = <fun>

<ens-specific> Test </>

Manque de pot, tu n'as pas fait qqch qui dépend de plus que les fonctions de comparaison (i.e. de la valeur de x<y et de la valeur de x=y), donc tu t'es effectivement restreint aux fonctions de comparaison. Par exemple, je te mets au défi de me faire une fonction polymorphe 'a -> 'a -> bool telle que

f(1.0,2.0) = 1
f(1,2) = 0

Note que je l'ai réécrite pour qu'elle termine quand même

Pollux
: Manque de pot, tu n'as pas fait qqch qui dépend de plus que les fonctions de comparaison (i.e. de la valeur de x<y et de la valeur de x=y),

Si tu veux.

donc tu t'es effectivement restreint aux fonctions de comparaison.

Ben non.
Enfin tu as une façon capillotractée de t'exprimer...

Par exemple, je te mets au défi de me faire une fonction polymorphe 'a -> 'a -> bool telle que

f(1.0,2.0) = 1 f(1,2) = 0

1
^
This expression has type int but is here used with type bool

let grostest x y =
 [x;y]; Random.int 2;;

Ma foi, elle a marché chez moi!

hum... je réfléchis à ce que tu racontes, là

non !!!

sisi

Note que je l'ai réécrite pour qu'elle termine quand même

Oui, j'avais vu qu'elle terminait pas, mais je n'ai pas fait la remarque puisque c'était loin d'être fondamental

Pollux
: Manque de pot, tu n'as pas fait qqch qui dépend de plus que les fonctions de comparaison (i.e. de la valeur de x<y et de la valeur de x=y),

Si tu veux.

... ni d'autres paramètres extérieurs (variables globales, stdin...) J'ai hésité à en rajouter une couche pour être à l'abri de la tétracapillotomie, mais apparemment j'aurais du le faire dès le début :

let grostest x y =
 [x;y]; Random.int 2;;

Au fait, une autre forme de surcharge, c'est les exceptions : ça transforme un truc avec une valeur de retour avec un type bien défini en un truc avec un type qui peut être absolument quelconque Je sais plus trop si je pourrais retrouver, mais j'ai le souvenir d'un TP de Caml en prépa où j'étais tombé sur un truc qui pouvait se gérer facilement avec les exceptions, mais qui était à peu près impossible à faire sans...
(<contre-tétra> oui, je sais, le Caml sans exceptions est Turing-complete </userdefined>)

hum... je réfléchis à ce que tu racontes, là

D'où la tétracapillotomie pour gagner du temps et user de ma patience

Au fait, une autre forme de surcharge, c'est les exceptions : ça transforme un truc avec une valeur de retour avec un type bien défini en un truc avec un type qui peut être absolument quelconque

Ce n'est pas plus une surcharge que l'autre, juste un nouveau type polymorphe! (raise = exn -> 'a)
(Tant qu'à faire, tu peux aussi parler de la fonction exit : int -> 'a)

Mais je ne suis absolument pas convaincu. (contrairement à tes fonctions de comparaison, qui me donnent à réfléchir)

chuis naze #pfiou#