제네릭를 언어별로 비교하기

// 타입 제약이 있는 제네릭 클래스
class SortedList<T : Comparable<T>> {
    private val items = mutableListOf<T>()

    fun add(item: T) {
        items.add(item)
        items.sort()
    }

    fun getAll(): List<T> = items.toList()
    fun min(): T? = items.firstOrNull()
    fun max(): T? = items.lastOrNull()
}

// 여러 타입 파라미터
class Result<out S, out E>(
    val value: S? = null,
    val error: E? = null
) {
    val isSuccess get() = value != null
    fun <R> map(transform: (S) -> R): Result<R, E> =
        if (isSuccess) Result(value = transform(value!!))
        else Result(error = error)
}

fun main() {
    val list = SortedList<Int>()
    listOf(5, 2, 8, 1).forEach { list.add(it) }
    println(list.getAll())  // [1, 2, 5, 8]

    val ok: Result<String, Exception> = Result(value = "성공")
    val mapped = ok.map { it.uppercase() }
    println(mapped.value)  // 성공
}

from typing import TypeVar, Generic

T = TypeVar('T')
N = TypeVar('N', int, float)  # 제한된 TypeVar

# 제네릭 함수
def first(items: list[T]) -> T:
    return items[0]

print(first([1, 2, 3]))       # 1 (int)
print(first(["a", "b"]))      # "a" (str)

# 제한된 TypeVar
def add_nums(a: N, b: N) -> N:
    return a + b

print(add_nums(1, 2))       # 3
print(add_nums(1.5, 2.3))   # 3.8

# 제네릭 클래스 (Python 3.12+는 class Box[T]: 가능)
class Box(Generic[T]):
    def __init__(self, item: T) -> None:
        self.item = item
    def get(self) -> T:
        return self.item

box = Box(42)
print(box.get())  # 42

package main

import (
	"fmt"
	"golang.org/x/exp/constraints"
)

// 타입 파라미터 — [T constraint]
func Map[T, U any](s []T, fn func(T) U) []U {
	result := make([]U, len(s))
	for i, v := range s { result[i] = fn(v) }
	return result
}

func Filter[T any](s []T, fn func(T) bool) []T {
	var result []T
	for _, v := range s {
		if fn(v) { result = append(result, v) }
	}
	return result
}

// constraints.Ordered — 정렬 가능한 타입 제약
func Min[T constraints.Ordered](a, b T) T {
	if a < b { return a }
	return b
}

// 제네릭 구조체
type Stack[T any] struct {
	data []T
}

func (s *Stack[T]) Push(v T)     { s.data = append(s.data, v) }
func (s *Stack[T]) Pop() (T, bool) {
	if len(s.data) == 0 {
		var zero T
		return zero, false
	}
	n := len(s.data) - 1
	v := s.data[n]
	s.data = s.data[:n]
	return v, true
}
func (s *Stack[T]) Len() int { return len(s.data) }

// 커스텀 타입 제약
type Number interface {
	~int | ~int32 | ~int64 | ~float32 | ~float64
}

func Sum[T Number](nums []T) T {
	var total T
	for _, n := range nums { total += n }
	return total
}

func main() {
	nums := []int{1, 2, 3, 4, 5}
	doubled := Map(nums, func(n int) int { return n * 2 })
	fmt.Println(doubled) // [2 4 6 8 10]

	strs := Map(nums, func(n int) string {
		return fmt.Sprintf("item%d", n)
	})
	fmt.Println(strs)

	evens := Filter(nums, func(n int) bool { return n%2 == 0 })
	fmt.Println(evens) // [2 4]

	fmt.Println(Min(3, 5))       // 3
	fmt.Println(Min("a", "b"))   // a

	var s Stack[string]
	s.Push("hello"); s.Push("world")
	if v, ok := s.Pop(); ok { fmt.Println(v) } // world

	fmt.Println(Sum([]float64{1.1, 2.2, 3.3}))
}

import java.util.*;

public class GenericMethods {
    // 제네릭 메서드 — 반환 타입 앞에 <T> 선언
    static <T> List<T> listOf(T... items) {
        return new ArrayList<>(Arrays.asList(items));
    }

    // Bounded 타입 파라미터
    static <T extends Comparable<T>> T max(T a, T b) {
        return a.compareTo(b) >= 0 ? a : b;
    }

    // 여러 타입 파라미터
    static <K, V> Map<K, V> mapOf(K key, V value) {
        Map<K, V> map = new HashMap<>();
        map.put(key, value);
        return map;
    }

    public static void main(String[] args) {
        List<String> names = listOf("Alice", "Bob");
        int bigger = max(10, 20);             // 타입 추론
        String later = max("apple", "banana");
        Map<String, Integer> m = mapOf("age", 30);
        System.out.printf("%s, %d, %s, %s%n", names, bigger, later, m);
    }
}

// 제네릭 함수
function add(a, b) {
  return a + b;
}
console.log(add(17, 2));

// 제네릭 함수
function add(a: number, b: number): number {
  return a + b;
}
console.log(add(17, 2));

// 제네릭 함수
using System;

int Add(int a, int b) => a + b;
Console.WriteLine(Add(17, 2));

// 제네릭 함수
#include <iostream>

int add(int a, int b) { return a + b; }
int main() {
    std::cout << add(17, 2) << "\n";
}

// 제네릭 함수
fn add(a: i32, b: i32) -> i32 { a + b }
fn main() {
    println!("{}", add(17, 2));
}