Fun with the reflection package to analyse any function.

funcAnalyse.go

package main 

import (

	"fmt"
	"reflect"
	"strconv"

)

type Test struct {

}
func (t *Test) SayHello(name string, d int, s Test ) (bool)  {

	return true
}

func FuncAnalyse(m interface{}) {
        
        //Reflection type of the underlying data of the interface
	x := reflect.TypeOf(m)

	numIn := x.NumIn() //Count inbound parameters
	numOut := x.NumOut() //Count outbounding parameters
	
	fmt.Println("Method:", x.String()) 
	fmt.Println("Variadic:", x.IsVariadic()) // Used (<type> ...) ?
	fmt.Println("Package:", x.PkgPath())


	for i := 0; i < numIn; i++ {
		
		inV := x.In(i)
		in_Kind := inV.Kind() //func
		fmt.Printf("\nParameter IN: "+strconv.Itoa(i)+"\nKind: %v\nName: %v\n-----------",in_Kind,inV.Name())
	}
	for o := 0; o < numOut; o++ {
		
		returnV := x.Out(0)
		return_Kind := returnV.Kind()
		fmt.Printf("\nParameter OUT: "+strconv.Itoa(o)+"\nKind: %v\nName: %v\n",return_Kind,returnV.Name())
	}


}

func main() {
	
	var n *Test = &Test{}
	methodValue := n.SayHello

	FuncAnalyse(methodValue)

}

/*

Method: func(string, int, main.Test) bool
Variadic: false
Package: 

Parameter IN: 0
Kind: string
Name: string
-----------
Parameter IN: 1
Kind: int
Name: int
-----------
Parameter IN: 2
Kind: struct
Name: Test
-----------
Parameter OUT: 0
Kind: bool
Name: bool


*/