Go 제네릭 완벽 가이드 2026: 타입 파라미터, 제약조건, 면접 대비

// 타입 파라미터 T를 가진 기본 제네릭 함수
func PrintSlice[T any](items []T) {
    for _, item := range items {
        fmt.Println(item)
    }
}

// 사용 - 타입 추론이 자동으로 T를 결정
func main() {
    PrintSlice([]int{1, 2, 3})        // T는 int
    PrintSlice([]string{"a", "b"})     // T는 string
}

// any: 모든 타입을 허용 (interface{}의 별칭)
func Process[T any](value T) T {
    return value
}

// comparable: == 와 !=를 지원하는 타입만
func Contains[T comparable](slice []T, target T) bool {
    for _, v := range slice {
        if v == target {  // 이 비교에는 comparable이 필요
            return true
        }
    }
    return false
}

// 이것은 컴파일됨
Contains([]int{1, 2, 3}, 2)

// 이것은 실패: 슬라이스는 comparable이 아님
// Contains([][]int{{1}, {2}}, []int{1})

// 타입 유니온을 사용한 커스텀 제약조건
type Number interface {
    int | int8 | int16 | int32 | int64 |
    uint | uint8 | uint16 | uint32 | uint64 |
    float32 | float64
}

// 숫자 타입으로 제약된 제네릭 함수
func Sum[T Number](values []T) T {
    var total T
    for _, v := range values {
        total += v  // 모든 Number 타입이 +를 지원하므로 작동
    }
    return total
}

func main() {
    fmt.Println(Sum([]int{1, 2, 3}))         // 6
    fmt.Println(Sum([]float64{1.5, 2.5}))    // 4.0
}

// ~int는 int와 기본 타입이 int인 모든 타입과 매칭
type Signed interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}

// 기본 타입이 int인 커스텀 타입
type UserID int
type Temperature int64

func Abs[T Signed](value T) T {
    if value < 0 {
        return -value
    }
    return value
}

func main() {
    var id UserID = -42
    var temp Temperature = -10
    
    fmt.Println(Abs(id))    // 42 - ~int가 UserID와 매칭되어 작동
    fmt.Println(Abs(temp))  // 10 - ~int64가 Temperature와 매칭되어 작동
}

// 제네릭 Stack 타입
type Stack[T any] struct {
    items []T
}

// Push는 스택에 요소를 추가
func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

// Pop은 최상위 요소를 제거하고 반환
func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T  // 타입 T의 제로 값
        return zero, false
    }
    index := len(s.items) - 1
    item := s.items[index]
    s.items = s.items[:index]
    return item, true
}

func main() {
    intStack := Stack[int]{}
    intStack.Push(10)
    intStack.Push(20)
    
    val, ok := intStack.Pop()  // val=20, ok=true
}

// 이것은 유효한 Go 코드가 아님
type Container[T any] struct {
    value T
}

// 오류: 메서드는 타입 파라미터를 가질 수 없음
// func (c *Container[T]) Transform[U any](fn func(T) U) U {
//     return fn(c.value)
// }

// 유효한 대안: 독립 함수 사용
func Transform[T, U any](c *Container[T], fn func(T) U) U {
    return fn(c.value)
}

func Map[T, R any](input []T, transform func(T) R) []R {
    result := make([]R, len(input))
    for i, v := range input {
        result[i] = transform(v)
    }
    return result
}

func main() {
    numbers := []int{1, 2, 3}
    
    // 타입 추론: T=int, R=string이 인자로부터 추론됨
    strings := Map(numbers, func(n int) string {
        return fmt.Sprintf("%d", n)
    })
    
    // 복잡한 경우에는 명시적 타입이 필요할 수 있음
    // Map[int, string](numbers, converter)
}

import (
    "cmp"
    "slices"
)

func main() {
    numbers := []int{3, 1, 4, 1, 5, 9}
    
    // slices.Sort는 내부적으로 cmp.Ordered 제약조건 사용
    slices.Sort(numbers)  // [1, 1, 3, 4, 5, 9]
    
    // 정렬된 슬라이스에서 이진 검색
    index, found := slices.BinarySearch(numbers, 4)
    
    // cmp.Compare는 -1, 0, 또는 1을 반환
    result := cmp.Compare(3, 5)  // -1
    
    // cmp.Or는 첫 번째 0이 아닌 값을 반환
    value := cmp.Or(0, 0, 42, 100)  // 42
}

import (
    "sync"
    "time"
)

type Cache[K comparable, V any] struct {
    mu    sync.RWMutex
    items map[K]cacheItem[V]
}

type cacheItem[V any] struct {
    value      V
    expiration time.Time
}

func NewCache[K comparable, V any]() *Cache[K, V] {
    return &Cache[K, V]{
        items: make(map[K]cacheItem[V]),
    }
}

func (c *Cache[K, V]) Set(key K, value V, ttl time.Duration) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.items[key] = cacheItem[V]{
        value:      value,
        expiration: time.Now().Add(ttl),
    }
}

func (c *Cache[K, V]) Get(key K) (V, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    
    item, exists := c.items[key]
    if !exists || time.Now().After(item.expiration) {
        var zero V
        return zero, false
    }
    return item.value, true
}

// 슬라이스가 비어있을 때 제로 값 반환
func First[T any](slice []T) T {
    if len(slice) == 0 {
        var zero T  // 제로 값: int는 0, string은 "", 포인터는 nil
        return zero
    }
    return slice[0]
}

// 대안: 모호함을 피하기 위해 포인터 반환
func FirstOrNil[T any](slice []T) *T {
    if len(slice) == 0 {
        return nil
    }
    return &slice[0]
}

// 순서와 문자열 변환 모두를 요구하는 제약조건
type Stringable interface {
    String() string
}

type OrderedStringable interface {
    cmp.Ordered
    Stringable
}

// 대안: 인라인으로 여러 제약조건을 가진 타입 파라미터 사용
func PrintSorted[T interface{ cmp.Ordered; fmt.Stringer }](items []T) {
    slices.Sort(items)
    for _, item := range items {
        fmt.Println(item.String())
    }
}