decode hooks can take types or kinds

decode_hooks.go

diff --git a/decode_hooks.go b/decode_hooks.go
index 087a392..e5a949b 100644
--- a/decode_hooks.go
+++ b/decode_hooks.go
@@ -1,11 +1,59 @@
 package mapstructure
 
 import (
+	"errors"
 	"reflect"
 	"strconv"
 	"strings"
 )
 
+// typedDecodeHook takes a raw DecodeHookFunc (an interface{}) and turns
+// it into the proper DecodeHookFunc type, such as DecodeHookFuncType.
+func typedDecodeHook(h DecodeHookFunc) DecodeHookFunc {
+	// Create variables here so we can reference them with the reflect pkg
+	var f1 DecodeHookFuncType
+	var f2 DecodeHookFuncKind
+
+	// Fill in the variables into this interface and the rest is done
+	// automatically using the reflect package.
+	potential := []interface{}{f1, f2}
+
+	v := reflect.ValueOf(h)
+	vt := v.Type()
+	for _, raw := range potential {
+		p := reflect.ValueOf(raw)
+		pt := p.Type()
+		if vt.ConvertibleTo(pt) {
+			return v.Convert(pt).Interface()
+		}
+	}
+
+	return nil
+}
+
+// DecodeHookExec executes the given decode hook. This should be used
+// since it'll naturally degrade to the older backwards compatible DecodeHookFunc
+// that took reflect.Kind instead of reflect.Type.
+func DecodeHookExec(
+	raw DecodeHookFunc,
+	from reflect.Type, to reflect.Type,
+	data interface{}) (interface{}, error) {
+	// Build our arguments that reflect expects
+	argVals := make([]reflect.Value, 3)
+	argVals[0] = reflect.ValueOf(from)
+	argVals[1] = reflect.ValueOf(to)
+	argVals[2] = reflect.ValueOf(data)
+
+	switch f := typedDecodeHook(raw).(type) {
+	case DecodeHookFuncType:
+		return f(from, to, data)
+	case DecodeHookFuncKind:
+		return f(from.Kind(), to.Kind(), data)
+	default:
+		return nil, errors.New("invalid decode hook signature")
+	}
+}
+
 // ComposeDecodeHookFunc creates a single DecodeHookFunc that
 // automatically composes multiple DecodeHookFuncs.
 //
@@ -13,18 +61,18 @@
 // previous transformation.
 func ComposeDecodeHookFunc(fs ...DecodeHookFunc) DecodeHookFunc {
 	return func(
-		f reflect.Kind,
-		t reflect.Kind,
+		f reflect.Type,
+		t reflect.Type,
 		data interface{}) (interface{}, error) {
 		var err error
 		for _, f1 := range fs {
-			data, err = f1(f, t, data)
+			data, err = DecodeHookExec(f1, f, t, data)
 			if err != nil {
 				return nil, err
 			}
 
 			// Modify the from kind to be correct with the new data
-			f = getKind(reflect.ValueOf(data))
+			f = reflect.ValueOf(data).Type()
 		}
 
 		return data, nil

decode_hooks_test.go

diff --git a/decode_hooks_test.go b/decode_hooks_test.go
index b417dee..84e3fc5 100644
--- a/decode_hooks_test.go
+++ b/decode_hooks_test.go
@@ -23,7 +23,8 @@
 
 	f := ComposeDecodeHookFunc(f1, f2)
 
-	result, err := f(reflect.String, reflect.Slice, "")
+	result, err := DecodeHookExec(
+		f, reflect.TypeOf(""), reflect.TypeOf([]byte("")), "")
 	if err != nil {
 		t.Fatalf("bad: %s", err)
 	}
@@ -43,7 +44,8 @@
 
 	f := ComposeDecodeHookFunc(f1, f2)
 
-	_, err := f(reflect.String, reflect.Slice, 42)
+	_, err := DecodeHookExec(
+		f, reflect.TypeOf(""), reflect.TypeOf([]byte("")), 42)
 	if err.Error() != "foo" {
 		t.Fatalf("bad: %s", err)
 	}
@@ -69,7 +71,8 @@
 
 	f := ComposeDecodeHookFunc(f1, f2)
 
-	_, err := f(reflect.String, reflect.Slice, "")
+	_, err := DecodeHookExec(
+		f, reflect.TypeOf(""), reflect.TypeOf([]byte("")), "")
 	if err != nil {
 		t.Fatalf("bad: %s", err)
 	}
@@ -81,24 +84,26 @@
 func TestStringToSliceHookFunc(t *testing.T) {
 	f := StringToSliceHookFunc(",")
 
+	strType := reflect.TypeOf("")
+	sliceType := reflect.TypeOf([]byte(""))
 	cases := []struct {
-		f, t   reflect.Kind
+		f, t   reflect.Type
 		data   interface{}
 		result interface{}
 		err    bool
 	}{
-		{reflect.Slice, reflect.Slice, 42, 42, false},
-		{reflect.String, reflect.String, 42, 42, false},
+		{sliceType, sliceType, 42, 42, false},
+		{strType, strType, 42, 42, false},
 		{
-			reflect.String,
-			reflect.Slice,
+			strType,
+			sliceType,
 			"foo,bar,baz",
 			[]string{"foo", "bar", "baz"},
 			false,
 		},
 		{
-			reflect.String,
-			reflect.Slice,
+			strType,
+			sliceType,
 			"",
 			[]string{},
 			false,
@@ -106,7 +111,7 @@
 	}
 
 	for i, tc := range cases {
-		actual, err := f(tc.f, tc.t, tc.data)
+		actual, err := DecodeHookExec(f, tc.f, tc.t, tc.data)
 		if tc.err != (err != nil) {
 			t.Fatalf("case %d: expected err %#v", i, tc.err)
 		}
@@ -121,56 +126,59 @@
 func TestWeaklyTypedHook(t *testing.T) {
 	var f DecodeHookFunc = WeaklyTypedHook
 
+	boolType := reflect.TypeOf(true)
+	strType := reflect.TypeOf("")
+	sliceType := reflect.TypeOf([]byte(""))
 	cases := []struct {
-		f, t   reflect.Kind
+		f, t   reflect.Type
 		data   interface{}
 		result interface{}
 		err    bool
 	}{
 		// TO STRING
 		{
-			reflect.Bool,
-			reflect.String,
+			boolType,
+			strType,
 			false,
 			"0",
 			false,
 		},
 
 		{
-			reflect.Bool,
-			reflect.String,
+			boolType,
+			strType,
 			true,
 			"1",
 			false,
 		},
 
 		{
-			reflect.Float32,
-			reflect.String,
+			reflect.TypeOf(float32(1)),
+			strType,
 			float32(7),
 			"7",
 			false,
 		},
 
 		{
-			reflect.Int,
-			reflect.String,
+			reflect.TypeOf(int(1)),
+			strType,
 			int(7),
 			"7",
 			false,
 		},
 
 		{
-			reflect.Slice,
-			reflect.String,
+			sliceType,
+			strType,
 			[]uint8("foo"),
 			"foo",
 			false,
 		},
 
 		{
-			reflect.Uint,
-			reflect.String,
+			reflect.TypeOf(uint(1)),
+			strType,
 			uint(7),
 			"7",
 			false,
@@ -178,7 +186,7 @@
 	}
 
 	for i, tc := range cases {
-		actual, err := f(tc.f, tc.t, tc.data)
+		actual, err := DecodeHookExec(f, tc.f, tc.t, tc.data)
 		if tc.err != (err != nil) {
 			t.Fatalf("case %d: expected err %#v", i, tc.err)
 		}

mapstructure.go

diff --git a/mapstructure.go b/mapstructure.go
index 9fceaef..070495d 100644
--- a/mapstructure.go
+++ b/mapstructure.go
@@ -19,10 +19,12 @@
 // DecodeHookFunc is the callback function that can be used for
 // data transformations. See "DecodeHook" in the DecoderConfig
 // struct.
-type DecodeHookFunc func(
-	from reflect.Kind,
-	to reflect.Kind,
-	data interface{}) (interface{}, error)
+//
+// The type should be DecodeHookFuncType or DecodeHookFuncKind.
+type DecodeHookFunc interface{}
+
+type DecodeHookFuncType func(reflect.Type, reflect.Type, interface{}) (interface{}, error)
+type DecodeHookFuncKind func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error)
 
 // DecoderConfig is the configuration that is used to create a new decoder
 // and allows customization of various aspects of decoding.
@@ -181,7 +183,9 @@
 	if d.config.DecodeHook != nil {
 		// We have a DecodeHook, so let's pre-process the data.
 		var err error
-		data, err = d.config.DecodeHook(getKind(dataVal), getKind(val), data)
+		data, err = DecodeHookExec(
+			d.config.DecodeHook,
+			dataVal.Type(), val.Type(), data)
 		if err != nil {
 			return err
 		}