Como implementar a soma de variantes de tipos (type sum) na linguagem Go?

Em Go, não há suporte direto para tipos soma (type sum), como em algumas linguagens funcionais (Haskell, Scala). No entanto, um efeito semelhante pode ser alcançado usando interfaces e switch de tipo.

Uma interface em Go descreve um conjunto de métodos, e qualquer tipo que implemente esses métodos satisfaz a interface. Para implementar tipos soma, pode-se definir uma interface sem métodos (interface vazia interface{}) ou com métodos comuns, e então usar um switch de tipo para determinar o tipo em tempo de execução.

Exemplo:

package main

import "fmt"

type Shape interface{} // interface vazia, pode ser qualquer tipo

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
}

Dessa forma, a interface e o switch de tipo permitem implementar um comportamento semelhante à soma de tipos, onde a variável pode assumir valores de diferentes tipos, e dependendo do tipo, a lógica correspondente é executada.