利用闭包在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() {
    // 使用闭包封装add函数
    var wrap func(args ...interface{}) interface{} = func(args ...interface{}) interface{} {
        // 确保参数数量正确，并进行类型断言
        // 注意：这里的类型断言如果失败会导致运行时panic
        num1 := args[0].(int)
        num2 := args[1].(int)
        result := add(num1, num2)
        return interface{}(result) // 将结果转换为interface{}类型返回
    }

    // 示例调用
    result := wrap(10, 20)
    fmt.Println("加法结果:", result.(int)) // 结果需要再次进行类型断言
    // fmt.Println(wrap(10, "hello")) // 这行代码会导致panic
}

package main

import (
    "errors"
    "fmt"
)

// 原始加法函数
func add(a, b int) int {
    return a + b
}

func main() {
    // 带有错误处理的通用封装函数
    var wrapSafe func(args ...interface{}) (interface{}, error) = func(args ...interface{}) (interface{}, error) {
        if len(args) < 2 {
            return nil, errors.New("参数数量不足，期望2个整数")
        }

        // 安全地进行类型断言
        a, ok1 := args[0].(int)
        b, ok2 := args[1].(int)

        if !ok1 || !ok2 {
            return nil, errors.New("参数类型错误，期望两个整数")
        }
        return add(a, b), nil
    }

    // 示例调用
    result1, err1 := wrapSafe(10, 20)
    if err1 != nil {
        fmt.Println("Error:", err1)
    } else {
        fmt.Println("安全加法结果:", result1.(int))
    }

    result2, err2 := wrapSafe(10, "hello") // 错误示例
    if err2 != nil {
        fmt.Println("Error:", err2) // Output: Error: 参数类型错误，期望两个整数
    } else {
        fmt.Println("安全加法结果:", result2)
    }

    result3, err3 := wrapSafe(10) // 错误示例
    if err3 != nil {
        fmt.Println("Error:", err3) // Output: Error: 参数数量不足，期望2个整数
    } else {
        fmt.Println("安全加法结果:", result3)
    }
}

package main

import "fmt"

// 整数加法函数
func addInts(a, b int) int {
    return a + b
}

// 浮点数加法函数
func addFloat64s(a, b float64) float64 {
    return a + b
}

func main() {
    // 使用类型开关实现多类型适配的通用封装函数
    var wrapGeneric func(args ...interface{}) interface{} = func(args ...interface{}) interface{} {
        if len(args) < 2 {
            // 可以选择返回nil或panic，取决于具体需求
            // 这里为了简化，假设调用者会确保参数数量
            fmt.Println("参数数量不足，期望至少2个参数")
            return nil
        }

        // 对第一个参数的类型进行开关判断
        switch args[0].(type) {
        case int:
            // 假设所有参数类型相同
            num1 := args[0].(int)
            num2 := args[1].(int)
            return interface{}(addInts(num1, num2))
        case float64:
            // 假设所有参数类型相同
            num1 := args[0].(float64)
            num2 := args[1].(float64)
            return interface{}(addFloat64s(num1, num2))
        default:
            // 处理未知类型，例如返回nil或错误
            fmt.Printf("不支持的参数类型: %T\n", args[0])
            return nil
        }
    }

    // 示例调用
    intResult := wrapGeneric(10, 20)
    if intResult != nil {
        fmt.Println("整数和:", intResult.(int))
    }

    floatResult := wrapGeneric(10.5, 20.5)
    if floatResult != nil {
        fmt.Println("浮点数和:", floatResult.(float64))
    }

    unsupportedResult := wrapGeneric("hello", "world")
    if unsupportedResult == nil {
        fmt.Println("不支持的类型已处理，返回nil")
    }
}