Comment peut-on implémenter la somme de variantes de types (type sum) dans le langage Go?

En Go, il n’y a pas de support direct pour les types somme (type sum), comme dans certains langages fonctionnels (Haskell, Scala). Cependant, un effet similaire peut être obtenu avec des interfaces et des switch de type.

Une interface en Go décrit un ensemble de méthodes, et tout type qui implémente ces méthodes satisfait l’interface. Pour réaliser des types somme, on peut définir une interface sans méthodes (interface vide interface{}) ou avec des méthodes communes, puis utiliser un switch de type pour déterminer le type à l’exécution.

Exemple :

package main

import "fmt"

type Shape interface{} // interface vide, peut être n’importe quel type

func area(s Shape) float64 {
    switch v := s.(type) {
    case Circle:
        return 3.14 * v.Radius * v.Radius
    case Rectangle:
        return v.Width * v.Height
    default:
        return 0
    }
}

type Circle struct {
    Radius float64
}

type Rectangle struct {
    Width, Height float64
}

func main() {
    c := Circle{Radius: 5}
    r := Rectangle{Width: 3, Height: 4}

    fmt.Println(area(c)) // 78.5
    fmt.Println(area(r)) // 12
}

Ainsi, l’interface et le switch de type permettent de réaliser un comportement semblable à la somme de types, où la variable peut prendre des valeurs de différents types, et selon le type, la logique appropriée est exécutée.