Comment puis-je gérer efficacement des tranches de fonctions avec des signatures variables dans Go ?

package main

import (
    "fmt"
    "reflect"
)

func A() {
    fmt.Println("A")
}

func B(a int) {
    fmt.Println("B", a)
}

func C(a string, b float32) {
    fmt.Println("C", a, b)
}

func main() {
    f := []interface{}{A, B, C}

    for _, v := range f {
        fn := reflect.ValueOf(v)
        fmt.Printf("Function: %v\n", fn.Type())

        numArgs := fn.Type().NumIn()
        fmt.Printf("Number of arguments: %v\n", numArgs)

        for i := 0; i < numArgs; i++ {
            argType := fn.Type().In(i)
            fmt.Printf("Arg %v Type: %v\n", i+1, argType)
        }

        fmt.Printf("Calling function using reflection...\n")
        callArgs := []reflect.Value{}
        for i := 0; i < numArgs; i++ {
            switch fn.Type().In(i).Kind() {
            case reflect.Int:
                callArgs = append(callArgs, reflect.ValueOf(i+1))
            case reflect.String:
                callArgs = append(callArgs, reflect.ValueOf(fmt.Sprintf("Arg-%v", i+1)))
            case reflect.Float32:
                callArgs = append(callArgs, reflect.ValueOf(float32(i+1)))
            }
        }
        fn.Call(callArgs)
    }
}