Go-তে Generics কীভাবে কাজ করে?

Question

Accepted Answer

**Generics** (Go 1.18-এ যোগ করা হয়েছে) আপনাকে এমন ফাংশন এবং টাইপ লিখতে দেয় যা **একাধিক টাইপ** এর সাথে কাজ করে type parameters এর মাধ্যমে, কম্পাইল-টাইম type safety বজায় রেখে। এটি পুরানো ট্রেড-অফ দূর করে — প্রতিটি টাইপের জন্য কোড ডুপ্লিকেট করা অথবা `interface{}` এর সাথে নিরাপত্তা হারানো।

## Generics যে সমস্যা সমাধান করে

```go
// ❌ before generics — either duplicate per type...
func MaxInt(a, b int) int { ... }
func MaxFloat(a, b float64) float64 { ... }   // copy-paste for each type

// ...or use interface{} and lose type safety + need casts/assertions
func Max(a, b interface{}) interface{} { ... }   // unsafe, clunky
```

## একটি generic ফাংশন

```go
// T is a type parameter constrained to be "ordered" (comparable with < >)
func Max[T constraints.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}

Max(3, 5)         // T inferred as int → 5
Max(2.5, 1.1)     // T inferred as float64 → 2.5
Max("a", "b")     // T inferred as string → "b"
```

`[T constraints.Ordered]` একটি type parameter `T` ঘোষণা করে একটি **constraint** এর সাথে (কোন টাইপগুলি অনুমতিপ্রাপ্ত)। কম্পাইলার `T` কে arguments থেকে অনুমান করে — একটি implementation অনেক টাইপের জন্য কাজ করে, সম্পূর্ণ type-safe।

## Type constraints

```go
// a constraint is an interface listing allowed types or required methods
type Number interface {
    ~int | ~int64 | ~float64        // the | union means "any of these"
}

func Sum[T Number](nums []T) T {
    var total T
    for _, n := range nums {
        total += n                   // safe — T is constrained to numeric types
    }
    return total
}
Sum([]int{1, 2, 3})       // 6
Sum([]float64{1.5, 2.5})  // 4.0

// built-in constraints:
any                        // any type (alias for interface{})
comparable                 // types usable with == (for map keys, etc.)
// golang.org/x/exp/constraints: Ordered, Integer, Float, etc.
```

Constraints সংজ্ঞায়িত করে কী operations type parameter এর উপর বৈধ (the `~` মানে "যেকোনো টাইপ যার underlying type এটি")।

## Generic types

```go
// a generic stack that works for any type
type Stack[T any] struct {
    items []T
}
func (s *Stack[T]) Push(item T) { s.items = append(s.items, item) }
func (s *Stack[T]) Pop() T {
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item
}

intStack := Stack[int]{}       // a stack of ints
strStack := Stack[string]{}     // a stack of strings — same code
```

## কখন ব্যবহার করবেন (এবং করবেন না) generics

```text
✓ Generic data structures (stacks, trees, sets), utility functions over collections
  (Map, Filter, Reduce), type-safe containers
✗ Don't overuse — if interfaces or a concrete type work simply, prefer them.
  Go's philosophy still favors simplicity; generics are a tool, not a default.
```

## কেন এটি গুরুত্বপূর্ণ

Generics ছিল Go-তে একটি বড়, দীর্ঘপ্রতীক্ষিত সংযোজন (1.18) যা একটি বাস্তব সমস্যার সমাধান করেছে: এর আগে, একাধিক টাইপের জন্য পুনর্ব্যবহারযোগ্য কোড লেখা আপনাকে বাধ্য করেছিল প্রতিটি টাইপের জন্য এটি ডুপ্লিকেট করতে (অপ্রয়োজনীয়ভাবে বিস্তৃত, রক্ষণাবেক্ষণ করা কঠিন) অথবা `interface{}` ব্যবহার করতে (compile-time type safety হারিয়ে ফেলা এবং runtime assertions প্রয়োজন)।

Generics আপনাকে type-safe, পুনর্ব্যবহারযোগ্য ফাংশন এবং ডেটা স্ট্রাকচার (containers, collection utilities যেমন Map/Filter/Reduce) একবার লিখতে দেয়, কম্পাইলার সঠিকতা জোরদার করে এবং টাইপ অনুমান করে।

Type parameters, constraints (যার মধ্যে `any`, `comparable`, এবং union/`~` syntax), এবং generic types বোঝা ক্রমবর্ধমান গুরুত্বপূর্ণ হচ্ছে কারণ ecosystem সেগুলি গ্রহণ করছে।

সমান গুরুত্বপূর্ণ হল Go মানসিকতা যে generics একটি **সত্যিকারের পুনর্ব্যবহারের সরঞ্জাম, ডিফল্ট নয়** — সেগুলি অতিরিক্ত ব্যবহার করা Go-এর simplicity দর্শনের বিপরীত কাজ করে।

এটি একটি বর্তমান, ঘন ঘন আলোচিত বিষয় যা আধুনিক Go-তে দক্ষতা প্রতিফলিত করে।