რა არის ტიპების ჯამი და როგორ განვახორციელოთ იგი…

ტიპების ჯამი (ან მითითებული ერთობლიობა, დისიუნქტული ერთობლიობა) — ეს მონაცემთა ტიპია, რომელიც შეიძლება მიიღოს ერთ-ერთი რამდენიმე წინასწარ განსაზღვრული ვარიანტიდან. განსხვავებით ტიპების პროდუქტებისგან (სტრუქტურები), სადაც მნიშვნელობა შეიცავს ყველა ველს ერთდროულად, ჯამური ტიპები შეიცავს მხოლოდ ერთ შესაძლო მნიშვნელობას.

Go-ში პირდაპირი მხარდაჭერა ჯამური ტიპებისთვის არ არსებობს, როგორც Haskell ან Rust (enum) ენებში. ჯამური ტიპების იმიტაცია შესაძლებელია რამდენიმე გზით:

ინტერფეისები და ტიპის დადასტურება (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("უცნობი ფორმა")
		}
	}
}

ბულიან ფლაგებით სტრუქტურები (მცირე გამოყენება):

სტრუქტურა შეიცავს ყველა შესაძლო ვარიანტის ველებს და ბულიან ფლაგებს, რათა იწეროს, რომელი ვარიანტი აქტიურია. ეს უსაფრთხო არ არის და რთული შენარჩუნებისთვის.

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)
	}
}

ნულოვანი მნიშვნელობის მქონე სტრუქტურები (ხშირად გამოიყენება 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-ის გამოყენება. ეს უზრუნველყოფს, რომ მხოლოდ ერთი ვარიანტი იქნება აქტიური და მუშაობს ტიპის უსაფრთხოებასთან ერთად.

რა არის ტიპების ჯამი და როგორ განვახორციელოთ იგი Go-ში?