Re: Go

C'est cool ça.

En Haskell, le newtype est un type équivalent, mais non compatible :

 newtype MyInt = MyInt Int

Après on peut convertir un Int en MyInt de plusieurs manière, en utilisant le constructeur, par pattern matching ou via des casts sécurisés.

Dans d'autres langages, ce serait contraignant car il faudrait écrire toutes les méthodes / fonctions associées. En haskell, on peut lui demander de dériver automatiquement tout comportement (class) implementée par le sous type.

Exemple, si on veut faire un sous type qui se comporte comme un String (au moins pour certaines opérations) mais qui n'est pas compatible avec une String:

newtype MyString = MyString String deriving (Show, Monoid, Eq, Ord)

Monoid fournissant la concaténation de chaîne via (<>), Show fournissant l'affichage. Eq et Ord fournissant respectivement les relations d'égalité et d'ordre. Cet exemple utilise l'extension GeneralizedNewtypeDeriving.

> MyString "hello" <> MyString "you"
MyString "helloyou"
> MyString "hello" == MyString "you"
False
> sort [MyString "hello", MyString "you", MyString "world"]
[MyString "hello",MyString "world",MyString "you"]

Ce genre de chose est malheureusement difficile à réaliser dans d'autre langage, et souvent il faut réaliser une classe englobante et propager toutes les méthodes intéressantes, c'est beaucoup de code lourd pour pas grande chose.

En C++ on peut s'en sortir avec des types phantoms :

struct TagColor
{};
struct TagPosition
{};
struct TagDirection
{};
template<typename Tag>
struct Point3
{
 float x, y, z;
 Point3<Tag> operator+(Point3<Tag> &other)
 {
 return {x + other.x, y + other.y, z + other.z};
 };
};
using Color = Point3<TagColor>;
using Position = Point3<TagPosition>;
using Direction = Point3<TagDirection>;
int main()
{
 Color c{1, 1, 0};
 Color c2{0, 0, 1};
 Color c3 = c + c2;
 Position p{0, 0, 0};
 // Erreur de compilation, on ne peut pas additionner un point et une couleur
 Position p2 = p + c;
}

Mais cette solution devient vite embêtante quand on veut pouvoir définir un sous ensemble d'opération pour chaque type. Par exemple, l'addition entre deux couleurs peut avoir du sens, alors qu'entre deux positions ?

À ce niveau, la meilleur solution que je connaisse c'est de faire une classe Point qui contient toutes les opérations nécessaires, et des classes Position, Direction, Couleur qui encapsulent un Point de manière privée et qui n'exposent que les fonctions nécessaires.