Ինչ է տիպերի գումարը և ինչպես իրականացնել այն 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 {
   		// Տիպ 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 օգտագործումը։ Դա ապահովում է, որ միայն մեկը տարբերակներից է ներկայում, և ապահովում է տիպային անվտանգություն։