Что такое сумма типов и как ее реализовать в Go?

Сумма типов (или размеченное объединение, дизъюнктное объединение) — это тип данных, который может принимать значение одного из нескольких предопределенных вариантов. В отличие от произведения типов (структур), где значение содержит все поля одновременно, сумма типов содержит только одно из возможных значений.

В Go нет прямой поддержки сумм типов как в языках вроде Haskell или Rust (enum). Сумму типов можно эмулировать несколькими способами:

1. Интерфейсы и утверждение типа (Type Assertion):

   Создать интерфейс, который будут реализовывать все возможные варианты. Значение типа суммы будет представлять собой этот интерфейс, а для определения конкретного варианта используется утверждение типа или type switch.

   package main
   
   import "fmt"
   
   // Shape - интерфейс, представляющий сумму типов
   type Shape interface {
   	Area() float64
   }
   
   // Circle - один из вариантов
   type Circle struct {
   	Radius float64
   }
   
   func (c Circle) Area() float64 {
   	return 3.14 * c.Radius * c.Radius
   }
   
   // Rectangle - другой вариант
   type Rectangle struct {
   	Width, Height float64
   }
   
   func (r Rectangle) Area() float64 {
   	return r.Width * r.Height
   }
   
   func main() {
   	shapes := []Shape{Circle{Radius: 5}, Rectangle{Width: 3, Height: 4}}
   
   	for _, s := range shapes {
   		// Использование type switch для определения варианта
   		switch v := s.(type) {
   		case Circle:
   			fmt.Printf("Круг с радиусом %.2f, площадь: %.2f\n", v.Radius, v.Area())
   		case Rectangle:
   			fmt.Printf("Прямоугольник с размерами %.2f x %.2f, площадь: %.2f\n", v.Width, v.Height, v.Area())
   		default:
   			fmt.Println("Неизвестная форма")
   		}
   	}
   }
   

2. Структуры с булевыми флагами (редко используется):

   Структура содержит поля для всех возможных вариантов и булевы флаги для указания, какой вариант активен. Небезопасно и сложно в поддержке.

   package main
   
   import "fmt"
   
   type Result struct {
   	Value int  // Поле для успешного результата
   	Err   error // Поле для ошибки
   
   	IsValue bool // Флаг, указывающий, является ли активным Value
   	IsErr   bool  // Флаг, указывающий, является ли активным Err
   }
   
   func Process(input int) Result {
   	if input > 0 {
   		return Result{Value: input * 2, IsValue: true}
   	}
   	return Result{Err: fmt.Errorf("отрицательное число: %d", input), IsErr: true}
   }
   
   func main() {
   	res1 := Process(10)
   	if res1.IsValue {
   		fmt.Printf("Результат: %d\n", res1.Value)
   	} else if res1.IsErr {
   		fmt.Printf("Ошибка: %v\n", res1.Err)
   	}
   
   	res2 := Process(-5)
   	if res2.IsValue {
   		fmt.Printf("Результат: %d\n", res2.Value)
   	} else if res2.IsErr {
   		fmt.Printf("Ошибка: %v\n", res2.Err)
   	}
   }
   

3. Структуры с нулевым значением для неактивных полей (часто используется для Optional/Result):

   Структура содержит поля для всех возможных вариантов, но только одно из них будет ненулевым. Работает хорошо для указателей или типов, имеющих четкое "нулевое" значение.

   package main
   
   import "fmt"
   
   // Option - эмуляция Some/None из опционального типа
   type Option struct {
   	Value *int // Ненулевое, если есть значение
   }
   
   // None создает нулевое значение Option
   func None() Option {
   	return Option{}
   }
   
   // Some создает Option со значением
   func Some(val int) Option {
   	return Option{Value: &val}
   }
   
   func main() {
   	opt1 := Some(10)
   	if opt1.Value != nil {
   		fmt.Printf("Значение есть: %d\n", *opt1.Value)
   	} else {
   		fmt.Println("Значения нет")
   	}
   
   	opt2 := None()
   	if opt2.Value != nil {
   		fmt.Printf("Значение есть: %d\n", *opt2.Value)
   	} else {
   		fmt.Println("Значения нет")
   	}
   }
   

Наиболее идиоматичным и безопасным способом эмуляции сумм типов в Go является использование интерфейсов и type switch. Это позволяет гарантировать, что только один из вариантов присутствует, и обеспечивает типобезопасность при работе с ним.