WeaklyTypedHook

decode_hooks.go

diff --git a/decode_hooks.go b/decode_hooks.go
index f9ae144..2bbd54a 100644
--- a/decode_hooks.go
+++ b/decode_hooks.go
@@ -2,6 +2,7 @@
 
 import (
 	"reflect"
+	"strconv"
 	"strings"
 )
 
@@ -45,3 +46,35 @@
 		return strings.Split(raw, sep), nil
 	}
 }
+
+func WeaklyTypedHook(
+	f reflect.Kind,
+	t reflect.Kind,
+	data interface{}) (interface{}, error) {
+	dataVal := reflect.ValueOf(data)
+	switch t {
+	case reflect.String:
+		switch f {
+		case reflect.Bool:
+			if dataVal.Bool() {
+				return "1", nil
+			} else {
+				return "0", nil
+			}
+		case reflect.Float32:
+			return strconv.FormatFloat(dataVal.Float(), 'f', -1, 64), nil
+		case reflect.Int:
+			return strconv.FormatInt(dataVal.Int(), 10), nil
+		case reflect.Slice:
+			dataType := dataVal.Type()
+			elemKind := dataType.Elem().Kind()
+			if elemKind == reflect.Uint8 {
+				return string(dataVal.Interface().([]uint8)), nil
+			}
+		case reflect.Uint:
+			return strconv.FormatUint(dataVal.Uint(), 10), nil
+		}
+	}
+
+	return data, nil
+}

decode_hooks_test.go

diff --git a/decode_hooks_test.go b/decode_hooks_test.go
index 6a226a7..454d1f3 100644
--- a/decode_hooks_test.go
+++ b/decode_hooks_test.go
@@ -110,3 +110,75 @@
 		}
 	}
 }
+
+func TestWeaklyTypedHook(t *testing.T) {
+	var f DecodeHookFunc = WeaklyTypedHook
+
+	cases := []struct {
+		f, t   reflect.Kind
+		data   interface{}
+		result interface{}
+		err    bool
+	}{
+		// TO STRING
+		{
+			reflect.Bool,
+			reflect.String,
+			false,
+			"0",
+			false,
+		},
+
+		{
+			reflect.Bool,
+			reflect.String,
+			true,
+			"1",
+			false,
+		},
+
+		{
+			reflect.Float32,
+			reflect.String,
+			float32(7),
+			"7",
+			false,
+		},
+
+		{
+			reflect.Int,
+			reflect.String,
+			int(7),
+			"7",
+			false,
+		},
+
+		{
+			reflect.Slice,
+			reflect.String,
+			[]uint8("foo"),
+			"foo",
+			false,
+		},
+
+		{
+			reflect.Uint,
+			reflect.String,
+			uint(7),
+			"7",
+			false,
+		},
+	}
+
+	for i, tc := range cases {
+		actual, err := 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)
+		}
+	}
+}