diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..7f3fe9a
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,7 @@
+language: go 
+
+go: 
+  - 1.4
+  
+script:
+  - go test 
diff --git a/decode_hooks.go b/decode_hooks.go
index 087a392..aa91f76 100644
--- a/decode_hooks.go
+++ b/decode_hooks.go
@@ -1,11 +1,59 @@
 package mapstructure
 
 import (
+	"errors"
 	"reflect"
 	"strconv"
 	"strings"
+	"time"
 )
 
+// 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 {
+		pt := reflect.ValueOf(raw).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
@@ -51,6 +99,25 @@
 	}
 }
 
+// StringToTimeDurationHookFunc returns a DecodeHookFunc that converts
+// strings to time.Duration.
+func StringToTimeDurationHookFunc() DecodeHookFunc {
+	return func(
+		f reflect.Type,
+		t reflect.Type,
+		data interface{}) (interface{}, error) {
+		if f.Kind() != reflect.String {
+			return data, nil
+		}
+		if t != reflect.TypeOf(time.Duration(5)) {
+			return data, nil
+		}
+
+		// Convert it by parsing
+		return time.ParseDuration(data.(string))
+	}
+}
+
 func WeaklyTypedHook(
 	f reflect.Kind,
 	t reflect.Kind,
diff --git a/decode_hooks_test.go b/decode_hooks_test.go
index b417dee..53289af 100644
--- a/decode_hooks_test.go
+++ b/decode_hooks_test.go
@@ -4,6 +4,7 @@
 	"errors"
 	"reflect"
 	"testing"
+	"time"
 )
 
 func TestComposeDecodeHookFunc(t *testing.T) {
@@ -23,7 +24,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 +45,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 +72,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 +85,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 +112,36 @@
 	}
 
 	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)
+		}
+		if !reflect.DeepEqual(actual, tc.result) {
+			t.Fatalf(
+				"case %d: expected %#v, got %#v",
+				i, tc.result, actual)
+		}
+	}
+}
+
+func TestStringToTimeDurationHookFunc(t *testing.T) {
+	f := StringToTimeDurationHookFunc()
+
+	strType := reflect.TypeOf("")
+	timeType := reflect.TypeOf(time.Duration(5))
+	cases := []struct {
+		f, t   reflect.Type
+		data   interface{}
+		result interface{}
+		err    bool
+	}{
+		{strType, timeType, "5s", 5 * time.Second, false},
+		{strType, timeType, "5", time.Duration(0), true},
+		{strType, strType, "5", "5", false},
+	}
+
+	for i, tc := range cases {
+		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 +156,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 +216,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)
 		}
diff --git a/mapstructure.go b/mapstructure.go
index 6abe075..d48ac95 100644
--- a/mapstructure.go
+++ b/mapstructure.go
@@ -19,10 +19,20 @@
 // 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.
+// Either is accepted. Types are a superset of Kinds (Types can return
+// Kinds) and are generally a richer thing to use, but Kinds are simpler
+// if you only need those.
+//
+// The reason DecodeHookFunc is multi-typed is for backwards compatibility:
+// we started with Kinds and then realized Types were the better solution,
+// but have a promise to not break backwards compat so we now support
+// both.
+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.
@@ -51,6 +61,7 @@
 	//   - string to bool (accepts: 1, t, T, TRUE, true, True, 0, f, F,
 	//     FALSE, false, False. Anything else is an error)
 	//   - empty array = empty map and vice versa
+	//   - negative numbers to overflowed uint values (base 10)
 	//
 	WeaklyTypedInput bool
 
@@ -180,7 +191,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
 		}
@@ -319,11 +332,21 @@
 
 	switch {
 	case dataKind == reflect.Int:
-		val.SetUint(uint64(dataVal.Int()))
+		i := dataVal.Int()
+		if i < 0 && !d.config.WeaklyTypedInput {
+			return fmt.Errorf("cannot parse '%s', %d overflows uint",
+				name, i)
+		}
+		val.SetUint(uint64(i))
 	case dataKind == reflect.Uint:
 		val.SetUint(dataVal.Uint())
 	case dataKind == reflect.Float32:
-		val.SetUint(uint64(dataVal.Float()))
+		f := dataVal.Float()
+		if f < 0 && !d.config.WeaklyTypedInput {
+			return fmt.Errorf("cannot parse '%s', %f overflows uint",
+				name, f)
+		}
+		val.SetUint(uint64(f))
 	case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
 		if dataVal.Bool() {
 			val.SetUint(1)
diff --git a/mapstructure_test.go b/mapstructure_test.go
index 036e6b5..0c9a31f 100644
--- a/mapstructure_test.go
+++ b/mapstructure_test.go
@@ -261,6 +261,43 @@
 	}
 }
 
+func TestDecode_DecodeHookType(t *testing.T) {
+	t.Parallel()
+
+	input := map[string]interface{}{
+		"vint": "WHAT",
+	}
+
+	decodeHook := func(from reflect.Type, to reflect.Type, v interface{}) (interface{}, error) {
+		if from.Kind() == reflect.String &&
+			to.Kind() != reflect.String {
+			return 5, nil
+		}
+
+		return v, nil
+	}
+
+	var result Basic
+	config := &DecoderConfig{
+		DecodeHook: decodeHook,
+		Result:     &result,
+	}
+
+	decoder, err := NewDecoder(config)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	err = decoder.Decode(input)
+	if err != nil {
+		t.Fatalf("got an err: %s", err)
+	}
+
+	if result.Vint != 5 {
+		t.Errorf("vint should be 5: %#v", result.Vint)
+	}
+}
+
 func TestDecode_Nil(t *testing.T) {
 	t.Parallel()
 
@@ -658,6 +695,42 @@
 	if derr.Errors[0] != "'Vstring' expected type 'string', got unconvertible type 'int'" {
 		t.Errorf("got unexpected error: %s", err)
 	}
+
+	inputNegIntUint := map[string]interface{}{
+		"vuint": -42,
+	}
+
+	err = Decode(inputNegIntUint, &result)
+	if err == nil {
+		t.Fatal("error should exist")
+	}
+
+	derr, ok = err.(*Error)
+	if !ok {
+		t.Fatalf("error should be kind of Error, instead: %#v", err)
+	}
+
+	if derr.Errors[0] != "cannot parse 'Vuint', -42 overflows uint" {
+		t.Errorf("got unexpected error: %s", err)
+	}
+
+	inputNegFloatUint := map[string]interface{}{
+		"vuint": -42.0,
+	}
+
+	err = Decode(inputNegFloatUint, &result)
+	if err == nil {
+		t.Fatal("error should exist")
+	}
+
+	derr, ok = err.(*Error)
+	if !ok {
+		t.Fatalf("error should be kind of Error, instead: %#v", err)
+	}
+
+	if derr.Errors[0] != "cannot parse 'Vuint', -42.000000 overflows uint" {
+		t.Errorf("got unexpected error: %s", err)
+	}
 }
 
 func TestMetadata(t *testing.T) {