Hoe implementeer je de som van type-varianten (type sum) in de Go-taal?

In Go is er geen directe ondersteuning voor somtypes (type sum), zoals in sommige functionele talen (Haskell, Scala). Echter, een vergelijkbaar effect kan worden bereikt met behulp van interfaces en type switch.

Een interface in Go beschrijft een set methoden, en elk type dat deze methoden implementeert, voldoet aan de interface. Om somtypes te implementeren, kan je een interface zonder methoden (lege interface interface{}) of met gemeenschappelijke methoden definiëren, en vervolgens een type switch gebruiken om het specifieke type tijdens runtime te bepalen.

Voorbeeld:

package main

import "fmt"

type Shape interface{} // lege interface, kan elk type zijn

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
}

Op deze manier maken interface en type switch het mogelijk om gedrag te implementeren dat lijkt op een som van types, waarbij de variabele waarden van verschillende types kan aannemen en afhankelijk van het type de juiste logica wordt uitgevoerd.