faster reflect approach suggestion

[glycerine]

Massimiliano had some good suggestions; quoting his email.

In glycerine/luar/luar.go the func goToLuaFunction() contains:

    t := v.Type()
    nIn := t.NumIn()
    argsT := make([]reflect.Type, nIn)
    for i := range argsT {
            argsT[i] = t.In(i)
    }

    // NB (jea): we wish their was a more efficient way to distinguish
    // methods (with a receiver argument) from functions (no receiver)
    // with reflect. However this is what I could come up with.
    // Better methods welcome, but this appears to work for now.
    //
    fname := getFunctionName(v)
    isMethod := fname == "reflect.methodValueCall"

I think the question whether the reflect.Value 'v' (which contains a
function or method) already includes the receiver or not can be answered
as follows:

it depends on how 'v' was obtained, see my example at

https://play.golang.org/p/QJ-33HOBR3p

1. if the method was obtained directly from receiver's reflect.Value
   with reflect.Value.Method(int) or reflect.Value.MethodByName(string)
   then the receiver will be already bound

2. if the method was obtained from from receiver's reflect.Value.Type()
   with reflect.Type.Method(int) or reflect.Value.MethodByName(string)
   (they both return reflect.Method)
   and then extracting the field reflect.Method.Func,
   then the receiver will not be bound

Attempts to distinguish the two cases purely by inspecting the
reflect.Value that contains the method are possible, as you have shown,
but I believe they are both non-portable and fragile.

Regards,

Massimiliano Ghilardi
(cosmos72)

[glycerine]

the playground code (in case it disappears):

package main

import (
	"fmt"
	"reflect"
	"time"
)

func main() {
	a := time.Now()
	va := reflect.ValueOf(a)

	// case 1. get method directly from receiver's reflect.Value 'va'
	// => receiver is already bound to va
	method1 := va.MethodByName("After")   // returns a reflect.Value
	type1 := method1.Type()               //
	fmt.Println(type1)                    // func(time.Time) bool
	fmt.Println("NumIn =", type1.NumIn()) // 1, receiver is already bound

	// case 2. get method through receiver's reflect.Type 'va.Type()'
	// => receiver is not bound
	ta := va.Type()                        // time.Time
	method2, _ := ta.MethodByName("After") // returns a reflect.Method
	method2v := method2.Func               // extract the reflect.Value
	type2 := method2v.Type()               //
	fmt.Println(type2)                     // func(time.Time, time.Time) bool
	fmt.Println("NumIn =", type2.NumIn())  // 2, receiver is not bound
}