생각하는 Go 언어 프로그래밍 : Go 제네릭의 이해

func add(a, b int) int {
    return a + b
}

var a float32 = 3.14
var b float32 = 1.43

c := add(a, b)            // build failed

func addFloat32(a, b float32) float32 {
    return a + b
}

package main

import (
    "constraints"
    "fmt"
)

func add[T constraints.Integer | constraints.Float](a, b T) T {   // ❶
    return a + b
}

func main() {
    var a int = 1
    var b int = 2
    fmt.Println(add(a, b))

    var f1 float64 = 3.14
    var f2 float64 = 1.43
    fmt.Println(add(f1, f2))
}

func Print[T any](a, b T) {
    fmt.Println(a, b) 
}

Print(1, 2)
Print(3.14, 1.43)
Print("Hello", "World")

Print(1, "Hello")

default type string of "Hello" does not match inferred type int for T

func Print(a, b int) {
    fmt.Println(a, b) 
}

func Print[T1 any, T2 any](a T1, b T2) {
    fmt.Println(a, b) 
}

package main

import "fmt"

func Print[T1 any, T2 any](a T1, b T2) {    // ❶
    fmt.Println(a, b)
}

func Print2(a, b interface{}) {             // ❷
    fmt.Println(a, b)
}

func main() {
    Print(1, 2)
    Print(3.14, 1.43)
    Print("Hello", "World")
    Print(1, "Hello")

    Print2(1, 2)
    Print2(3.14, 1.43)
    Print2("Hello", "World")
    Print2(1, "Hello")
}

func add[T any](a, b T) T {
    return a + b
}

invalid operation: operator + not defined on a (variable of type T constrained by any)

func add[T int8 | int16 | int32 | int64 | int](a, b T) T {
    return a + b
}

// 타입 제한 선언
type Integer interface {
    int8 | int16 | int32 | int64 | int
}

func add[T Integer](a, b T) T {
    return a + b
}

func add[T constraints.Integer | constraints.Float](a, b T) T {
    return a + b
}

type Float interface {
    ~float32 | ~float64
}

package main

type Integer interface {        // ❶ 타입 제한
    int8 | int16 | int32 | int64 | int
}

func add[T Integer](a, b T) T { // ❷ add() 함수 정의
    return a + b
}

type MyInt int                  // ❸ 별칭 타입 정의

func main() {
    add(1, 2)
    var a MyInt = 3
    var b MyInt = 5
    add(a, b)                 // ❹ 에러 발생
}

type Integer interface {
    ~int8 | ~int16 | ~int32 | ~int64 | ~int
}

package main

import (
    "fmt"
    "hash/fnv"
)

type ComparableHasher interface {           // ❶
    comparable
    Hash() uint32
}

type MyString string                           // ❷

func (s MyString) Hash() uint32 {
    h := fnv.New32a()
    h.Write([]byte(s))
    return h.Sum32()
}

func Equal[T ComparableHasher](a, b T) bool {  // ❸ 
    if a == b {
        return true
    }
    return a.Hash() == b.Hash()
}

func main() {
    var str1 MyString = "Hello"
    var str2 MyString = "World"
    fmt.Println(Equal(str1, str2))
}

package main

import (
    "fmt"
    "strings"
    "strconv"
)

func Map[F, T any](s []F, f func(F) T) []T {      // ❶
    rst := make([]T, len(s))
    for i, v := range s {
        rst[i] = f(v)
    }
    return rst
}

func main() {
    doubled := Map([]int{1, 2, 3}, func(v int) int {  // ❷ 
        return v * 2
    })
    uppered := Map([]string{"hello", "world", "abc"}, func(v string) string { // ❸
        return strings.ToUpper(v)
    })
    tostring := Map([]int{1, 2, 3}, func(v int) string { // ❹
        return "str" + strconv.Itoa(v)
    })

    fmt.Println(doubled)
    fmt.Println(uppered)
    fmt.Println(tostring)
}

type Node[T any] struct {
    val T
    next *Node[T]
}

package main

import "fmt"

type Node[T any] struct {
    val  T
    next *Node[T]
}

func NewNode[T any](v T) *Node[T] {              // ❶
    return &Node[T]{val: v}
}

func (n *Node[T]) Push(v T) *Node[T] {        // ❷
    node := NewNode(v)
    n.next = node
    return node
}

func main() {
    node1 := NewNode(1)                    // ❸
    node1.Push(2).Push(3).Push(4)

    for node1 != nil {
        fmt.Print(node1.val, " - ")
        node1 = node1.next
    }
    fmt.Println()

    node2 := NewNode("Hi")                // ❹
    node2.Push("Hello").Push("How are you")

    for node2 != nil {
        fmt.Print(node2.val, " - ")
        node2 = node2.next
    }
    fmt.Println()
}

type Node[T1 any, T2 any] struct {
    val1 T1
    val2 T2
    next *Node[T]
}

func (n *Node[T1, T2]) Push(val1 T1, val2 T2) *Node[T1, T2] { ... }

type Node struct {
    val  interface{}
    next *Node
}

package main

import "fmt"

type NodeType1 struct {                   // ❶
    val  interface{}
    next *NodeType1
}

type NodeType2[T any] struct {           // ❷ 
    val  T
    next *NodeType2[T]
}

func main() {
    node1 := &NodeType1{val: 1}         // ❸
    node2 := &NodeType2[int]{val: 2}

    var v1 int = node1.val              // ❹ 에러 발생
    fmt.Println(v1)
    var v2 int = node2.val              // ➎
    fmt.Println(v2)
}

var v1 int = node1.val.(int)

var v1 int = 3
var v2 interface{} = v1             // boxing
var v3 int = v2.(int)               // unboxing

package main

import "fmt"

func main() {
    var v1 int = 3
    var v2 interface{} = &v1  // boxing
    var v3 int = *(v2.(*int)) // unboxing

    fmt.Printf("v1: %x %T\n", &v1, &v1)
    fmt.Printf("v2: %x %T\n", &v2, &v2)
    fmt.Printf("v3: %x %T\n", &v3, &v3)
}

func add[T constraints.Integer | constraints.Float](a, b T) T {
    return a + b
}

add(1, 3)
add(3.14, 1.43)

// io package
type Reader interface {
    Read(p []byte) (n int, err error)
}

// bufio package
func NewReader(rd io.Reader) *Reader