Go语言中函数类型转换与泛型模拟：闭包与类型断言实践

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

package main

import "fmt"

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

func main() {
    // 原始函数
    fmt.Printf("Original add type: %T\n", add) // main.add

    // 使用闭包进行封装
    wrap := func(args ...interface{}) interface{} {
        // 对传入的interface{}参数进行类型断言
        // 注意：这里假设args中至少有两个int类型的参数
        return interface{}(add(args[0].(int), args[1].(int)))
    }

    fmt.Printf("Wrapped function type: %T\n", wrap) // func(...interface {}) interface {}

    // 调用封装后的函数
    result := wrap(10, 20)
    fmt.Printf("Result of wrap(10, 20): %v (Type: %T)\n", result, result) // 30 (Type: int)

    // 尝试传入错误类型的参数会导致运行时panic
    // _ = wrap("hello", "world") // 这会引发panic: interface conversion: interface {} is string, not int
}

package main

import (
    "errors"
    "fmt"
)

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

func main() {
    wrapWithErr := func(args ...interface{}) (interface{}, error) {
        if len(args) < 2 {
            return nil, errors.New("expected at least two arguments")
        }

        // 安全的类型断言
        a, okA := args[0].(int)
        b, okB := args[1].(int)

        if !okA || !okB {
            return nil, errors.New("arguments must be of type int")
        }
        return add(a, b), nil
    }

    // 成功调用
    result, err := wrapWithErr(10, 20)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Printf("Result with error handling: %v (Type: %T)\n", result, result)
    }

    // 传入错误类型参数
    result, err = wrapWithErr("hello", "world")
    if err != nil {
        fmt.Println("Error with wrong types:", err) // Output: Error with wrong types: arguments must be of type int
    }

    // 传入参数不足
    result, err = wrapWithErr(10)
    if err != nil {
        fmt.Println("Error with insufficient arguments:", err) // Output: Error with insufficient arguments: expected at least two arguments
    }
}

package main

import "fmt"

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

func addFloat64s(a, b float64) float64 {
    return a + b
}

func main() {
    wrapGeneric := func(args ...interface{}) interface{} {
        if len(args) < 2 {
            // 实际应用中这里应返回错误，简化示例直接panic
            panic("expected at least two arguments")
        }

        // 使用type switch根据第一个参数的类型决定执行逻辑
        switch args[0].(type) {
        case int:
            // 假设所有参数类型一致
            return interface{}(addInts(args[0].(int), args[1].(int)))
        case float64:
            // 假设所有参数类型一致
            return interface{}(addFloat64s(args[0].(float64), args[1].(float64)))
        default:
            // 实际应用中这里应返回错误，简化示例直接panic
            panic("unsupported argument types")
        }
    }

    // 调用处理整数的逻辑
    intResult := wrapGeneric(10, 20)
    fmt.Printf("Generic wrap (int): %v (Type: %T)\n", intResult, intResult) // 30 (Type: int)

    // 调用处理浮点数的逻辑
    floatResult := wrapGeneric(10.5, 20.3)
    fmt.Printf("Generic wrap (float64): %v (Type: %T)\n", floatResult, floatResult) // 30.8 (Type: float64)

    // 尝试传入不支持的类型会导致panic
    // _ = wrapGeneric("hello", "world") // 这会引发panic: unsupported argument types
}