როგორ შეიძლება განახორციელოთ ტიპების ჯამი (type sum) ენის Go-ში?

Go-ში პირდაპირი მხარდაჭერა არ არსებობს ტიპების ჯამისთვის (type sum), როგორც ზოგიერთი ფუნქციონალური ენის (Haskell, Scala) შემთხვევაში. თუმცა, მსგავსი ეფექტის მიღწევა შესაძლებელია ინტერფეისებისა და type switch-ის გამოყენებით.

Go-ში ინტერფეისი აღწერს მეთოდების სეტს, და ნებისმიერი ტიპი, რომელიც ამ მეთოდებს ახორციელებს, აკმაყოფილებს ინტერფეისს. ჯამური ტიპების განხორციელებისთვის, შეიძლება განსაზღვროს მეთოდების გარეშე (ცარიელი) interface{} ინტერფეისი ან საერთო მეთოდების მქონე, და შემდეგ გამოიყენოს type switch კონკრეტული ტიპის განსაზღვრებისთვის შესრულების დროს:

მაგალითი:

package main

import "fmt"

type Shape interface{} // ცარიელი ინტერფეისი, შეიძლება იყოს ნებისმიერი ტიპი

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
}

ამ გზით, ინტერფეისი და type switch საშუალებას იძლევა განახორციელოს ქცევა, რომელიც მსგავსია ტიპების ჯამის, სადაც ცვლადი შეიძლება მიიღოს სხვადასხვა ტიპის მნიშვნელობები, და შესაბამისად, შესრულდება შესაბამისი ლოგიკა.