diff --git a/float32.go b/float32.go
index 1dd28a5..ff76e0d 100644
--- a/float32.go
+++ b/float32.go
@@ -102,16 +102,17 @@ func (s stdRecipes) structToFloat32(c Converter, in StructValue, out *float32) e
 	return err
 }
 
+type toFloat32 interface {
+	Float32() float32
+}
+type toFloat32WithErr interface {
+	Float32() (float32, error)
+}
+
 func (s stdRecipes) baseStructToFloat32(_ Converter, in reflect.Value, out *float32) error {
 	if !in.CanInterface() {
 		return errors.New("unable to make interface")
 	}
-	type toFloat32 interface {
-		Float32() float32
-	}
-	type toFloat32WithErr interface {
-		Float32() (float32, error)
-	}
 
 	// check for struct.Float32()
 	if i, ok := in.Interface().(toFloat32); ok {
@@ -124,5 +125,16 @@ func (s stdRecipes) baseStructToFloat32(_ Converter, in reflect.Value, out *floa
 		return err
 	}
 
+	// check for struct.Float64()
+	if i, ok := in.Interface().(toFloat64); ok {
+		*out = float32(i.Float64())
+		return nil
+	}
+	if i, ok := in.Interface().(toFloat64WithErr); ok {
+		f, err := i.Float64()
+		*out = float32(f)
+		return err
+	}
+
 	return fmt.Errorf("%s has no Float32() function", in.Type().String())
 }
diff --git a/float32_test.go b/float32_test.go
index 16bedff..620cc4b 100644
--- a/float32_test.go
+++ b/float32_test.go
@@ -88,6 +88,18 @@ func TestFloat32(t *testing.T) {
 
 		{SomeStructWithFloat32WithErrFuncPtr{}, float32(0), float32(10), "", nil},
 		{&SomeStructWithFloat32WithErrFuncPtr{}, float32(0), float32(10), "", nil},
+
+		{SomeStructWithFloat64Func{}, float32(0), float32(10), "", nil},
+		{&SomeStructWithFloat64Func{}, float32(0), float32(10), "", nil},
+
+		{SomeStructWithFloat64FuncPtr{}, float32(0), float32(10), "", nil},
+		{&SomeStructWithFloat64FuncPtr{}, float32(0), float32(10), "", nil},
+
+		{SomeStructWithFloat64WithErrFunc{}, float32(0), float32(10), "", nil},
+		{&SomeStructWithFloat64WithErrFunc{}, float32(0), float32(10), "", nil},
+
+		{SomeStructWithFloat64WithErrFuncPtr{}, float32(0), float32(10), "", nil},
+		{&SomeStructWithFloat64WithErrFuncPtr{}, float32(0), float32(10), "", nil},
 	}
 
 	for i, test := range tests {
diff --git a/float64.go b/float64.go
index 53591b3..160dbca 100644
--- a/float64.go
+++ b/float64.go
@@ -102,16 +102,17 @@ func (s stdRecipes) structToFloat64(c Converter, in StructValue, out *float64) e
 	return err
 }
 
+type toFloat64 interface {
+	Float64() float64
+}
+type toFloat64WithErr interface {
+	Float64() (float64, error)
+}
+
 func (s stdRecipes) baseStructToFloat64(_ Converter, in reflect.Value, out *float64) error {
 	if !in.CanInterface() {
 		return errors.New("unable to make interface")
 	}
-	type toFloat64 interface {
-		Float64() float64
-	}
-	type toFloat64WithErr interface {
-		Float64() (float64, error)
-	}
 
 	// check for struct.Float64()
 	if i, ok := in.Interface().(toFloat64); ok {
@@ -124,5 +125,16 @@ func (s stdRecipes) baseStructToFloat64(_ Converter, in reflect.Value, out *floa
 		return err
 	}
 
+	// check for struct.Float32()
+	if i, ok := in.Interface().(toFloat32); ok {
+		*out = float64(i.Float32())
+		return nil
+	}
+	if i, ok := in.Interface().(toFloat32WithErr); ok {
+		f, err := i.Float32()
+		*out = float64(f)
+		return err
+	}
+
 	return fmt.Errorf("%s has no Float64() function", in.Type().String())
 }
diff --git a/float64_test.go b/float64_test.go
index ad04e85..c11cbca 100644
--- a/float64_test.go
+++ b/float64_test.go
@@ -77,6 +77,18 @@ func TestFloat64(t *testing.T) {
 		// time
 		{time.Unix(10, 10), float64(10.00000001), float64(10.00000001), "", nil},
 
+		{SomeStructWithFloat32Func{}, float64(0), float64(10), "", nil},
+		{&SomeStructWithFloat32Func{}, float64(0), float64(10), "", nil},
+
+		{SomeStructWithFloat32FuncPtr{}, float64(0), float64(10), "", nil},
+		{&SomeStructWithFloat32FuncPtr{}, float64(0), float64(10), "", nil},
+
+		{SomeStructWithFloat32WithErrFunc{}, float64(0), float64(10), "", nil},
+		{&SomeStructWithFloat32WithErrFunc{}, float64(0), float64(10), "", nil},
+
+		{SomeStructWithFloat32WithErrFuncPtr{}, float64(0), float64(10), "", nil},
+		{&SomeStructWithFloat32WithErrFuncPtr{}, float64(0), float64(10), "", nil},
+
 		{SomeStructWithFloat64Func{}, float64(0), float64(10), "", nil},
 		{&SomeStructWithFloat64Func{}, float64(0), float64(10), "", nil},
 
diff --git a/int.go b/int.go
index ab8d94a..30ce6ac 100644
--- a/int.go
+++ b/int.go
@@ -101,16 +101,17 @@ func (s stdRecipes) structToInt(c Converter, in StructValue, out *int) error {
 	return err
 }
 
+type toInt interface {
+	Int() int
+}
+type toIntWithErr interface {
+	Int() (int, error)
+}
+
 func (s stdRecipes) baseStructToInt(_ Converter, in reflect.Value, out *int) error {
 	if !in.CanInterface() {
 		return errors.New("unable to make interface")
 	}
-	type toInt interface {
-		Int() int
-	}
-	type toIntWithErr interface {
-		Int() (int, error)
-	}
 
 	// check for struct.Int()
 	if i, ok := in.Interface().(toInt); ok {
@@ -123,5 +124,105 @@ func (s stdRecipes) baseStructToInt(_ Converter, in reflect.Value, out *int) err
 		return err
 	}
 
+	if ok, i, err := genericIntConvert(in); ok {
+		if err != nil {
+			return err
+		}
+		*out = int(i)
+		return nil
+	}
+
 	return fmt.Errorf("%s has no Int() function", in.Type().String())
 }
+
+func genericIntConvert(in reflect.Value) (bool, int64, error) {
+	// check for struct.Int()
+	if i, ok := in.Interface().(toInt); ok {
+		return true, int64(i.Int()), nil
+	}
+	if i, ok := in.Interface().(toIntWithErr); ok {
+		v, err := i.Int()
+		return true, int64(v), err
+	}
+
+	// check for struct.Int8()
+	if i, ok := in.Interface().(toInt8); ok {
+		return true, int64(i.Int8()), nil
+	}
+	if i, ok := in.Interface().(toInt8WithErr); ok {
+		v, err := i.Int8()
+		return true, int64(v), err
+	}
+
+	// check for struct.Int16()
+	if i, ok := in.Interface().(toInt16); ok {
+		return true, int64(i.Int16()), nil
+	}
+	if i, ok := in.Interface().(toInt16WithErr); ok {
+		v, err := i.Int16()
+		return true, int64(v), err
+	}
+
+	// check for struct.Int32()
+	if i, ok := in.Interface().(toInt32); ok {
+		return true, int64(i.Int32()), nil
+	}
+	if i, ok := in.Interface().(toInt32WithErr); ok {
+		v, err := i.Int32()
+		return true, int64(v), err
+	}
+
+	// check for struct.Int64()
+	if i, ok := in.Interface().(toInt64); ok {
+		return true, int64(i.Int64()), nil
+	}
+	if i, ok := in.Interface().(toInt64WithErr); ok {
+		v, err := i.Int64()
+		return true, v, err
+	}
+
+	// check for struct.Uint()
+	if i, ok := in.Interface().(toUint); ok {
+		return true, int64(i.Uint()), nil
+	}
+	if i, ok := in.Interface().(toUintWithErr); ok {
+		v, err := i.Uint()
+		return true, int64(v), err
+	}
+
+	// check for struct.Uint8()
+	if i, ok := in.Interface().(toUint8); ok {
+		return true, int64(i.Uint8()), nil
+	}
+	if i, ok := in.Interface().(toUint8WithErr); ok {
+		v, err := i.Uint8()
+		return true, int64(v), err
+	}
+
+	// check for struct.Uint16()
+	if i, ok := in.Interface().(toUint16); ok {
+		return true, int64(i.Uint16()), nil
+	}
+	if i, ok := in.Interface().(toUint16WithErr); ok {
+		v, err := i.Uint16()
+		return true, int64(v), err
+	}
+
+	// check for struct.Uint32()
+	if i, ok := in.Interface().(toUint32); ok {
+		return true, int64(i.Uint32()), nil
+	}
+	if i, ok := in.Interface().(toUint32WithErr); ok {
+		v, err := i.Uint32()
+		return true, int64(v), err
+	}
+	// check for struct.Uint64()
+	if i, ok := in.Interface().(toUint64); ok {
+		return true, int64(i.Uint64()), nil
+	}
+	if i, ok := in.Interface().(toUint64WithErr); ok {
+		v, err := i.Uint64()
+		return true, int64(v), err
+	}
+	return false, 0, nil
+}
diff --git a/int16.go b/int16.go
index 4e357c0..5d0ebfe 100644
--- a/int16.go
+++ b/int16.go
@@ -101,16 +101,17 @@ func (s stdRecipes) structToInt16(c Converter, in StructValue, out *int16) error
 	return err
 }
 
+type toInt16 interface {
+	Int16() int16
+}
+type toInt16WithErr interface {
+	Int16() (int16, error)
+}
+
 func (s stdRecipes) baseStructToInt16(_ Converter, in reflect.Value, out *int16) error {
 	if !in.CanInterface() {
 		return errors.New("unable to make interface")
 	}
-	type toInt16 interface {
-		Int16() int16
-	}
-	type toInt16WithErr interface {
-		Int16() (int16, error)
-	}
 
 	// check for struct.Int16()
 	if i, ok := in.Interface().(toInt16); ok {
@@ -123,5 +124,13 @@ func (s stdRecipes) baseStructToInt16(_ Converter, in reflect.Value, out *int16)
 		return err
 	}
 
+	if ok, i, err := genericIntConvert(in); ok {
+		if err != nil {
+			return err
+		}
+		*out = int16(i)
+		return nil
+	}
+
 	return fmt.Errorf("%s has no Int16() function", in.Type().String())
 }
diff --git a/int16_test.go b/int16_test.go
index 81384ef..1505dfa 100644
--- a/int16_test.go
+++ b/int16_test.go
@@ -77,6 +77,30 @@ func TestInt16(t *testing.T) {
 		// time
 		{time.Unix(10, 10), int16(10), int16(10), "", nil},
 
+		{SomeStructWithIntFunc{}, int16(0), int16(8), "", nil},
+		{&SomeStructWithIntFunc{}, int16(0), int16(8), "", nil},
+
+		{SomeStructWithIntFuncPtr{}, int16(0), int16(8), "", nil},
+		{&SomeStructWithIntFuncPtr{}, int16(0), int16(8), "", nil},
+
+		{SomeStructWithIntWithErrFunc{}, int16(0), int16(8), "", nil},
+		{&SomeStructWithIntWithErrFunc{}, int16(0), int16(8), "", nil},
+
+		{SomeStructWithIntWithErrFuncPtr{}, int16(0), int16(8), "", nil},
+		{&SomeStructWithIntWithErrFuncPtr{}, int16(0), int16(8), "", nil},
+
+		{SomeStructWithInt8Func{}, int16(0), int16(8), "", nil},
+		{&SomeStructWithInt8Func{}, int16(0), int16(8), "", nil},
+
+		{SomeStructWithInt8FuncPtr{}, int16(0), int16(8), "", nil},
+		{&SomeStructWithInt8FuncPtr{}, int16(0), int16(8), "", nil},
+
+		{SomeStructWithInt8WithErrFunc{}, int16(0), int16(8), "", nil},
+		{&SomeStructWithInt8WithErrFunc{}, int16(0), int16(8), "", nil},
+
+		{SomeStructWithInt8WithErrFuncPtr{}, int16(0), int16(8), "", nil},
+		{&SomeStructWithInt8WithErrFuncPtr{}, int16(0), int16(8), "", nil},
+
 		{SomeStructWithInt16Func{}, int16(0), int16(16), "", nil},
 		{&SomeStructWithInt16Func{}, int16(0), int16(16), "", nil},
 
@@ -88,6 +112,90 @@ func TestInt16(t *testing.T) {
 
 		{SomeStructWithInt16WithErrFuncPtr{}, int16(0), int16(16), "", nil},
 		{&SomeStructWithInt16WithErrFuncPtr{}, int16(0), int16(16), "", nil},
+
+		{SomeStructWithInt32Func{}, int16(0), int16(32), "", nil},
+		{&SomeStructWithInt32Func{}, int16(0), int16(32), "", nil},
+
+		{SomeStructWithInt32FuncPtr{}, int16(0), int16(32), "", nil},
+		{&SomeStructWithInt32FuncPtr{}, int16(0), int16(32), "", nil},
+
+		{SomeStructWithInt32WithErrFunc{}, int16(0), int16(32), "", nil},
+		{&SomeStructWithInt32WithErrFunc{}, int16(0), int16(32), "", nil},
+
+		{SomeStructWithInt32WithErrFuncPtr{}, int16(0), int16(32), "", nil},
+		{&SomeStructWithInt32WithErrFuncPtr{}, int16(0), int16(32), "", nil},
+
+		{SomeStructWithInt64Func{}, int16(0), int16(64), "", nil},
+		{&SomeStructWithInt64Func{}, int16(0), int16(64), "", nil},
+
+		{SomeStructWithInt64FuncPtr{}, int16(0), int16(64), "", nil},
+		{&SomeStructWithInt64FuncPtr{}, int16(0), int16(64), "", nil},
+
+		{SomeStructWithInt64WithErrFunc{}, int16(0), int16(64), "", nil},
+		{&SomeStructWithInt64WithErrFunc{}, int16(0), int16(64), "", nil},
+
+		{SomeStructWithInt64WithErrFuncPtr{}, int16(0), int16(64), "", nil},
+		{&SomeStructWithInt64WithErrFuncPtr{}, int16(0), int16(64), "", nil},
+
+		{SomeStructWithUintFunc{}, int16(0), int16(16), "", nil},
+		{&SomeStructWithUintFunc{}, int16(0), int16(16), "", nil},
+
+		{SomeStructWithUintFuncPtr{}, int16(0), int16(16), "", nil},
+		{&SomeStructWithUintFuncPtr{}, int16(0), int16(16), "", nil},
+
+		{SomeStructWithUintWithErrFunc{}, int16(0), int16(16), "", nil},
+		{&SomeStructWithUintWithErrFunc{}, int16(0), int16(16), "", nil},
+
+		{SomeStructWithUintWithErrFuncPtr{}, int16(0), int16(16), "", nil},
+		{&SomeStructWithUintWithErrFuncPtr{}, int16(0), int16(16), "", nil},
+
+		{SomeStructWithUint8Func{}, int16(0), int16(8), "", nil},
+		{&SomeStructWithUint8Func{}, int16(0), int16(8), "", nil},
+
+		{SomeStructWithUint8FuncPtr{}, int16(0), int16(8), "", nil},
+		{&SomeStructWithUint8FuncPtr{}, int16(0), int16(8), "", nil},
+
+		{SomeStructWithUint8WithErrFunc{}, int16(0), int16(8), "", nil},
+		{&SomeStructWithUint8WithErrFunc{}, int16(0), int16(8), "", nil},
+
+		{SomeStructWithUint8WithErrFuncPtr{}, int16(0), int16(8), "", nil},
+		{&SomeStructWithUint8WithErrFuncPtr{}, int16(0), int16(8), "", nil},
+
+		{SomeStructWithUint16Func{}, int16(0), int16(16), "", nil},
+		{&SomeStructWithUint16Func{}, int16(0), int16(16), "", nil},
+
+		{SomeStructWithUint16FuncPtr{}, int16(0), int16(16), "", nil},
+		{&SomeStructWithUint16FuncPtr{}, int16(0), int16(16), "", nil},
+
+		{SomeStructWithUint16WithErrFunc{}, int16(0), int16(16), "", nil},
+		{&SomeStructWithUint16WithErrFunc{}, int16(0), int16(16), "", nil},
+
+		{SomeStructWithUint16WithErrFuncPtr{}, int16(0), int16(16), "", nil},
+		{&SomeStructWithUint16WithErrFuncPtr{}, int16(0), int16(16), "", nil},
+
+		{SomeStructWithUint32Func{}, int16(0), int16(32), "", nil},
+		{&SomeStructWithUint32Func{}, int16(0), int16(32), "", nil},
+
+		{SomeStructWithUint32FuncPtr{}, int16(0), int16(32), "", nil},
+		{&SomeStructWithUint32FuncPtr{}, int16(0), int16(32), "", nil},
+
+		{SomeStructWithUint32WithErrFunc{}, int16(0), int16(32), "", nil},
+		{&SomeStructWithUint32WithErrFunc{}, int16(0), int16(32), "", nil},
+
+		{SomeStructWithUint32WithErrFuncPtr{}, int16(0), int16(32), "", nil},
+		{&SomeStructWithUint32WithErrFuncPtr{}, int16(0), int16(32), "", nil},
+
+		{SomeStructWithUint64Func{}, int16(0), int16(64), "", nil},
+		{&SomeStructWithUint64Func{}, int16(0), int16(64), "", nil},
+
+		{SomeStructWithUint64FuncPtr{}, int16(0), int16(64), "", nil},
+		{&SomeStructWithUint64FuncPtr{}, int16(0), int16(64), "", nil},
+
+		{SomeStructWithUint64WithErrFunc{}, int16(0), int16(64), "", nil},
+		{&SomeStructWithUint64WithErrFunc{}, int16(0), int16(64), "", nil},
+
+		{SomeStructWithUint64WithErrFuncPtr{}, int16(0), int16(64), "", nil},
+		{&SomeStructWithUint64WithErrFuncPtr{}, int16(0), int16(64), "", nil},
 	}
 
 	for i, test := range tests {
diff --git a/int32.go b/int32.go
index 69928e6..6d5ed84 100644
--- a/int32.go
+++ b/int32.go
@@ -101,16 +101,17 @@ func (s stdRecipes) structToInt32(c Converter, in StructValue, out *int32) error
 	return err
 }
 
+type toInt32 interface {
+	Int32() int32
+}
+type toInt32WithErr interface {
+	Int32() (int32, error)
+}
+
 func (s stdRecipes) baseStructToInt32(_ Converter, in reflect.Value, out *int32) error {
 	if !in.CanInterface() {
 		return errors.New("unable to make interface")
 	}
-	type toInt32 interface {
-		Int32() int32
-	}
-	type toInt32WithErr interface {
-		Int32() (int32, error)
-	}
 
 	// check for struct.Int32()
 	if i, ok := in.Interface().(toInt32); ok {
@@ -123,5 +124,13 @@ func (s stdRecipes) baseStructToInt32(_ Converter, in reflect.Value, out *int32)
 		return err
 	}
 
+	if ok, i, err := genericIntConvert(in); ok {
+		if err != nil {
+			return err
+		}
+		*out = int32(i)
+		return nil
+	}
+
 	return fmt.Errorf("%s has no Int32() function", in.Type().String())
 }
diff --git a/int32_test.go b/int32_test.go
index 89d025c..b28c694 100644
--- a/int32_test.go
+++ b/int32_test.go
@@ -77,6 +77,42 @@ func TestInt32(t *testing.T) {
 		// time
 		{time.Unix(10, 10), int32(10), int32(10), "", nil},
 
+		{SomeStructWithIntFunc{}, int32(0), int32(8), "", nil},
+		{&SomeStructWithIntFunc{}, int32(0), int32(8), "", nil},
+
+		{SomeStructWithIntFuncPtr{}, int32(0), int32(8), "", nil},
+		{&SomeStructWithIntFuncPtr{}, int32(0), int32(8), "", nil},
+
+		{SomeStructWithIntWithErrFunc{}, int32(0), int32(8), "", nil},
+		{&SomeStructWithIntWithErrFunc{}, int32(0), int32(8), "", nil},
+
+		{SomeStructWithIntWithErrFuncPtr{}, int32(0), int32(8), "", nil},
+		{&SomeStructWithIntWithErrFuncPtr{}, int32(0), int32(8), "", nil},
+
+		{SomeStructWithInt8Func{}, int32(0), int32(8), "", nil},
+		{&SomeStructWithInt8Func{}, int32(0), int32(8), "", nil},
+
+		{SomeStructWithInt8FuncPtr{}, int32(0), int32(8), "", nil},
+		{&SomeStructWithInt8FuncPtr{}, int32(0), int32(8), "", nil},
+
+		{SomeStructWithInt8WithErrFunc{}, int32(0), int32(8), "", nil},
+		{&SomeStructWithInt8WithErrFunc{}, int32(0), int32(8), "", nil},
+
+		{SomeStructWithInt8WithErrFuncPtr{}, int32(0), int32(8), "", nil},
+		{&SomeStructWithInt8WithErrFuncPtr{}, int32(0), int32(8), "", nil},
+
+		{SomeStructWithInt16Func{}, int32(0), int32(16), "", nil},
+		{&SomeStructWithInt16Func{}, int32(0), int32(16), "", nil},
+
+		{SomeStructWithInt16FuncPtr{}, int32(0), int32(16), "", nil},
+		{&SomeStructWithInt16FuncPtr{}, int32(0), int32(16), "", nil},
+
+		{SomeStructWithInt16WithErrFunc{}, int32(0), int32(16), "", nil},
+		{&SomeStructWithInt16WithErrFunc{}, int32(0), int32(16), "", nil},
+
+		{SomeStructWithInt16WithErrFuncPtr{}, int32(0), int32(16), "", nil},
+		{&SomeStructWithInt16WithErrFuncPtr{}, int32(0), int32(16), "", nil},
+
 		{SomeStructWithInt32Func{}, int32(0), int32(32), "", nil},
 		{&SomeStructWithInt32Func{}, int32(0), int32(32), "", nil},
 
@@ -88,6 +124,78 @@ func TestInt32(t *testing.T) {
 
 		{SomeStructWithInt32WithErrFuncPtr{}, int32(0), int32(32), "", nil},
 		{&SomeStructWithInt32WithErrFuncPtr{}, int32(0), int32(32), "", nil},
+
+		{SomeStructWithInt64Func{}, int32(0), int32(64), "", nil},
+		{&SomeStructWithInt64Func{}, int32(0), int32(64), "", nil},
+
+		{SomeStructWithInt64FuncPtr{}, int32(0), int32(64), "", nil},
+		{&SomeStructWithInt64FuncPtr{}, int32(0), int32(64), "", nil},
+
+		{SomeStructWithInt64WithErrFunc{}, int32(0), int32(64), "", nil},
+		{&SomeStructWithInt64WithErrFunc{}, int32(0), int32(64), "", nil},
+
+		{SomeStructWithInt64WithErrFuncPtr{}, int32(0), int32(64), "", nil},
+		{&SomeStructWithInt64WithErrFuncPtr{}, int32(0), int32(64), "", nil},
+
+		{SomeStructWithUintFunc{}, int32(0), int32(16), "", nil},
+		{&SomeStructWithUintFunc{}, int32(0), int32(16), "", nil},
+
+		{SomeStructWithUintFuncPtr{}, int32(0), int32(16), "", nil},
+		{&SomeStructWithUintFuncPtr{}, int32(0), int32(16), "", nil},
+
+		{SomeStructWithUintWithErrFunc{}, int32(0), int32(16), "", nil},
+		{&SomeStructWithUintWithErrFunc{}, int32(0), int32(16), "", nil},
+
+		{SomeStructWithUintWithErrFuncPtr{}, int32(0), int32(16), "", nil},
+		{&SomeStructWithUintWithErrFuncPtr{}, int32(0), int32(16), "", nil},
+
+		{SomeStructWithUint8Func{}, int32(0), int32(8), "", nil},
+		{&SomeStructWithUint8Func{}, int32(0), int32(8), "", nil},
+
+		{SomeStructWithUint8FuncPtr{}, int32(0), int32(8), "", nil},
+		{&SomeStructWithUint8FuncPtr{}, int32(0), int32(8), "", nil},
+
+		{SomeStructWithUint8WithErrFunc{}, int32(0), int32(8), "", nil},
+		{&SomeStructWithUint8WithErrFunc{}, int32(0), int32(8), "", nil},
+
+		{SomeStructWithUint8WithErrFuncPtr{}, int32(0), int32(8), "", nil},
+		{&SomeStructWithUint8WithErrFuncPtr{}, int32(0), int32(8), "", nil},
+
+		{SomeStructWithUint16Func{}, int32(0), int32(16), "", nil},
+		{&SomeStructWithUint16Func{}, int32(0), int32(16), "", nil},
+
+		{SomeStructWithUint16FuncPtr{}, int32(0), int32(16), "", nil},
+		{&SomeStructWithUint16FuncPtr{}, int32(0), int32(16), "", nil},
+
+		{SomeStructWithUint16WithErrFunc{}, int32(0), int32(16), "", nil},
+		{&SomeStructWithUint16WithErrFunc{}, int32(0), int32(16), "", nil},
+
+		{SomeStructWithUint16WithErrFuncPtr{}, int32(0), int32(16), "", nil},
+		{&SomeStructWithUint16WithErrFuncPtr{}, int32(0), int32(16), "", nil},
+
+		{SomeStructWithUint32Func{}, int32(0), int32(32), "", nil},
+		{&SomeStructWithUint32Func{}, int32(0), int32(32), "", nil},
+
+		{SomeStructWithUint32FuncPtr{}, int32(0), int32(32), "", nil},
+		{&SomeStructWithUint32FuncPtr{}, int32(0), int32(32), "", nil},
+
+		{SomeStructWithUint32WithErrFunc{}, int32(0), int32(32), "", nil},
+		{&SomeStructWithUint32WithErrFunc{}, int32(0), int32(32), "", nil},
+
+		{SomeStructWithUint32WithErrFuncPtr{}, int32(0), int32(32), "", nil},
+		{&SomeStructWithUint32WithErrFuncPtr{}, int32(0), int32(32), "", nil},
+
+		{SomeStructWithUint64Func{}, int32(0), int32(64), "", nil},
+		{&SomeStructWithUint64Func{}, int32(0), int32(64), "", nil},
+
+		{SomeStructWithUint64FuncPtr{}, int32(0), int32(64), "", nil},
+		{&SomeStructWithUint64FuncPtr{}, int32(0), int32(64), "", nil},
+
+		{SomeStructWithUint64WithErrFunc{}, int32(0), int32(64), "", nil},
+		{&SomeStructWithUint64WithErrFunc{}, int32(0), int32(64), "", nil},
+
+		{SomeStructWithUint64WithErrFuncPtr{}, int32(0), int32(64), "", nil},
+		{&SomeStructWithUint64WithErrFuncPtr{}, int32(0), int32(64), "", nil},
 	}
 
 	for i, test := range tests {
diff --git a/int64.go b/int64.go
index 18e4370..f965e2f 100644
--- a/int64.go
+++ b/int64.go
@@ -101,16 +101,17 @@ func (s stdRecipes) structToInt64(c Converter, in StructValue, out *int64) error
 	return err
 }
 
+type toInt64 interface {
+	Int64() int64
+}
+type toInt64WithErr interface {
+	Int64() (int64, error)
+}
+
 func (s stdRecipes) baseStructToInt64(_ Converter, in reflect.Value, out *int64) error {
 	if !in.CanInterface() {
 		return errors.New("unable to make interface")
 	}
-	type toInt64 interface {
-		Int64() int64
-	}
-	type toInt64WithErr interface {
-		Int64() (int64, error)
-	}
 
 	// check for struct.Int64()
 	if i, ok := in.Interface().(toInt64); ok {
@@ -123,5 +124,13 @@ func (s stdRecipes) baseStructToInt64(_ Converter, in reflect.Value, out *int64)
 		return err
 	}
 
+	if ok, i, err := genericIntConvert(in); ok {
+		if err != nil {
+			return err
+		}
+		*out = i
+		return nil
+	}
+
 	return fmt.Errorf("%s has no Int64() function", in.Type().String())
 }
diff --git a/int64_test.go b/int64_test.go
index c168a4c..7ea3ce6 100644
--- a/int64_test.go
+++ b/int64_test.go
@@ -77,6 +77,54 @@ func TestInt64(t *testing.T) {
 		// time
 		{time.Unix(10, 10), int64(10), int64(10), "", nil},
 
+		{SomeStructWithIntFunc{}, int64(0), int64(8), "", nil},
+		{&SomeStructWithIntFunc{}, int64(0), int64(8), "", nil},
+
+		{SomeStructWithIntFuncPtr{}, int64(0), int64(8), "", nil},
+		{&SomeStructWithIntFuncPtr{}, int64(0), int64(8), "", nil},
+
+		{SomeStructWithIntWithErrFunc{}, int64(0), int64(8), "", nil},
+		{&SomeStructWithIntWithErrFunc{}, int64(0), int64(8), "", nil},
+
+		{SomeStructWithIntWithErrFuncPtr{}, int64(0), int64(8), "", nil},
+		{&SomeStructWithIntWithErrFuncPtr{}, int64(0), int64(8), "", nil},
+
+		{SomeStructWithInt8Func{}, int64(0), int64(8), "", nil},
+		{&SomeStructWithInt8Func{}, int64(0), int64(8), "", nil},
+
+		{SomeStructWithInt8FuncPtr{}, int64(0), int64(8), "", nil},
+		{&SomeStructWithInt8FuncPtr{}, int64(0), int64(8), "", nil},
+
+		{SomeStructWithInt8WithErrFunc{}, int64(0), int64(8), "", nil},
+		{&SomeStructWithInt8WithErrFunc{}, int64(0), int64(8), "", nil},
+
+		{SomeStructWithInt8WithErrFuncPtr{}, int64(0), int64(8), "", nil},
+		{&SomeStructWithInt8WithErrFuncPtr{}, int64(0), int64(8), "", nil},
+
+		{SomeStructWithInt16Func{}, int64(0), int64(16), "", nil},
+		{&SomeStructWithInt16Func{}, int64(0), int64(16), "", nil},
+
+		{SomeStructWithInt16FuncPtr{}, int64(0), int64(16), "", nil},
+		{&SomeStructWithInt16FuncPtr{}, int64(0), int64(16), "", nil},
+
+		{SomeStructWithInt16WithErrFunc{}, int64(0), int64(16), "", nil},
+		{&SomeStructWithInt16WithErrFunc{}, int64(0), int64(16), "", nil},
+
+		{SomeStructWithInt16WithErrFuncPtr{}, int64(0), int64(16), "", nil},
+		{&SomeStructWithInt16WithErrFuncPtr{}, int64(0), int64(16), "", nil},
+
+		{SomeStructWithInt32Func{}, int64(0), int64(32), "", nil},
+		{&SomeStructWithInt32Func{}, int64(0), int64(32), "", nil},
+
+		{SomeStructWithInt32FuncPtr{}, int64(0), int64(32), "", nil},
+		{&SomeStructWithInt32FuncPtr{}, int64(0), int64(32), "", nil},
+
+		{SomeStructWithInt32WithErrFunc{}, int64(0), int64(32), "", nil},
+		{&SomeStructWithInt32WithErrFunc{}, int64(0), int64(32), "", nil},
+
+		{SomeStructWithInt32WithErrFuncPtr{}, int64(0), int64(32), "", nil},
+		{&SomeStructWithInt32WithErrFuncPtr{}, int64(0), int64(32), "", nil},
+
 		{SomeStructWithInt64Func{}, int64(0), int64(64), "", nil},
 		{&SomeStructWithInt64Func{}, int64(0), int64(64), "", nil},
 
@@ -88,6 +136,66 @@ func TestInt64(t *testing.T) {
 
 		{SomeStructWithInt64WithErrFuncPtr{}, int64(0), int64(64), "", nil},
 		{&SomeStructWithInt64WithErrFuncPtr{}, int64(0), int64(64), "", nil},
+
+		{SomeStructWithUintFunc{}, int64(0), int64(16), "", nil},
+		{&SomeStructWithUintFunc{}, int64(0), int64(16), "", nil},
+
+		{SomeStructWithUintFuncPtr{}, int64(0), int64(16), "", nil},
+		{&SomeStructWithUintFuncPtr{}, int64(0), int64(16), "", nil},
+
+		{SomeStructWithUintWithErrFunc{}, int64(0), int64(16), "", nil},
+		{&SomeStructWithUintWithErrFunc{}, int64(0), int64(16), "", nil},
+
+		{SomeStructWithUintWithErrFuncPtr{}, int64(0), int64(16), "", nil},
+		{&SomeStructWithUintWithErrFuncPtr{}, int64(0), int64(16), "", nil},
+
+		{SomeStructWithUint8Func{}, int64(0), int64(8), "", nil},
+		{&SomeStructWithUint8Func{}, int64(0), int64(8), "", nil},
+
+		{SomeStructWithUint8FuncPtr{}, int64(0), int64(8), "", nil},
+		{&SomeStructWithUint8FuncPtr{}, int64(0), int64(8), "", nil},
+
+		{SomeStructWithUint8WithErrFunc{}, int64(0), int64(8), "", nil},
+		{&SomeStructWithUint8WithErrFunc{}, int64(0), int64(8), "", nil},
+
+		{SomeStructWithUint8WithErrFuncPtr{}, int64(0), int64(8), "", nil},
+		{&SomeStructWithUint8WithErrFuncPtr{}, int64(0), int64(8), "", nil},
+
+		{SomeStructWithUint16Func{}, int64(0), int64(16), "", nil},
+		{&SomeStructWithUint16Func{}, int64(0), int64(16), "", nil},
+
+		{SomeStructWithUint16FuncPtr{}, int64(0), int64(16), "", nil},
+		{&SomeStructWithUint16FuncPtr{}, int64(0), int64(16), "", nil},
+
+		{SomeStructWithUint16WithErrFunc{}, int64(0), int64(16), "", nil},
+		{&SomeStructWithUint16WithErrFunc{}, int64(0), int64(16), "", nil},
+
+		{SomeStructWithUint16WithErrFuncPtr{}, int64(0), int64(16), "", nil},
+		{&SomeStructWithUint16WithErrFuncPtr{}, int64(0), int64(16), "", nil},
+
+		{SomeStructWithUint32Func{}, int64(0), int64(32), "", nil},
+		{&SomeStructWithUint32Func{}, int64(0), int64(32), "", nil},
+
+		{SomeStructWithUint32FuncPtr{}, int64(0), int64(32), "", nil},
+		{&SomeStructWithUint32FuncPtr{}, int64(0), int64(32), "", nil},
+
+		{SomeStructWithUint32WithErrFunc{}, int64(0), int64(32), "", nil},
+		{&SomeStructWithUint32WithErrFunc{}, int64(0), int64(32), "", nil},
+
+		{SomeStructWithUint32WithErrFuncPtr{}, int64(0), int64(32), "", nil},
+		{&SomeStructWithUint32WithErrFuncPtr{}, int64(0), int64(32), "", nil},
+
+		{SomeStructWithUint64Func{}, int64(0), int64(64), "", nil},
+		{&SomeStructWithUint64Func{}, int64(0), int64(64), "", nil},
+
+		{SomeStructWithUint64FuncPtr{}, int64(0), int64(64), "", nil},
+		{&SomeStructWithUint64FuncPtr{}, int64(0), int64(64), "", nil},
+
+		{SomeStructWithUint64WithErrFunc{}, int64(0), int64(64), "", nil},
+		{&SomeStructWithUint64WithErrFunc{}, int64(0), int64(64), "", nil},
+
+		{SomeStructWithUint64WithErrFuncPtr{}, int64(0), int64(64), "", nil},
+		{&SomeStructWithUint64WithErrFuncPtr{}, int64(0), int64(64), "", nil},
 	}
 
 	for i, test := range tests {
diff --git a/int8.go b/int8.go
index a6f80f9..2843bcb 100644
--- a/int8.go
+++ b/int8.go
@@ -101,16 +101,17 @@ func (s stdRecipes) structToInt8(c Converter, in StructValue, out *int8) error {
 	return err
 }
 
+type toInt8 interface {
+	Int8() int8
+}
+type toInt8WithErr interface {
+	Int8() (int8, error)
+}
+
 func (s stdRecipes) baseStructToInt8(_ Converter, in reflect.Value, out *int8) error {
 	if !in.CanInterface() {
 		return errors.New("unable to make interface")
 	}
-	type toInt8 interface {
-		Int8() int8
-	}
-	type toInt8WithErr interface {
-		Int8() (int8, error)
-	}
 
 	// check for struct.Int8()
 	if i, ok := in.Interface().(toInt8); ok {
@@ -123,5 +124,13 @@ func (s stdRecipes) baseStructToInt8(_ Converter, in reflect.Value, out *int8) e
 		return err
 	}
 
+	if ok, i, err := genericIntConvert(in); ok {
+		if err != nil {
+			return err
+		}
+		*out = int8(i)
+		return nil
+	}
+
 	return fmt.Errorf("%s has no Int8() function", in.Type().String())
 }
diff --git a/int8_test.go b/int8_test.go
index e10abff..7465a6d 100644
--- a/int8_test.go
+++ b/int8_test.go
@@ -77,6 +77,18 @@ func TestInt8(t *testing.T) {
 		// time
 		{time.Unix(10, 10), int8(10), int8(10), "", nil},
 
+		{SomeStructWithIntFunc{}, int8(0), int8(8), "", nil},
+		{&SomeStructWithIntFunc{}, int8(0), int8(8), "", nil},
+
+		{SomeStructWithIntFuncPtr{}, int8(0), int8(8), "", nil},
+		{&SomeStructWithIntFuncPtr{}, int8(0), int8(8), "", nil},
+
+		{SomeStructWithIntWithErrFunc{}, int8(0), int8(8), "", nil},
+		{&SomeStructWithIntWithErrFunc{}, int8(0), int8(8), "", nil},
+
+		{SomeStructWithIntWithErrFuncPtr{}, int8(0), int8(8), "", nil},
+		{&SomeStructWithIntWithErrFuncPtr{}, int8(0), int8(8), "", nil},
+
 		{SomeStructWithInt8Func{}, int8(0), int8(8), "", nil},
 		{&SomeStructWithInt8Func{}, int8(0), int8(8), "", nil},
 
@@ -88,6 +100,102 @@ func TestInt8(t *testing.T) {
 
 		{SomeStructWithInt8WithErrFuncPtr{}, int8(0), int8(8), "", nil},
 		{&SomeStructWithInt8WithErrFuncPtr{}, int8(0), int8(8), "", nil},
+
+		{SomeStructWithInt16Func{}, int8(0), int8(16), "", nil},
+		{&SomeStructWithInt16Func{}, int8(0), int8(16), "", nil},
+
+		{SomeStructWithInt16FuncPtr{}, int8(0), int8(16), "", nil},
+		{&SomeStructWithInt16FuncPtr{}, int8(0), int8(16), "", nil},
+
+		{SomeStructWithInt16WithErrFunc{}, int8(0), int8(16), "", nil},
+		{&SomeStructWithInt16WithErrFunc{}, int8(0), int8(16), "", nil},
+
+		{SomeStructWithInt16WithErrFuncPtr{}, int8(0), int8(16), "", nil},
+		{&SomeStructWithInt16WithErrFuncPtr{}, int8(0), int8(16), "", nil},
+
+		{SomeStructWithInt32Func{}, int8(0), int8(32), "", nil},
+		{&SomeStructWithInt32Func{}, int8(0), int8(32), "", nil},
+
+		{SomeStructWithInt32FuncPtr{}, int8(0), int8(32), "", nil},
+		{&SomeStructWithInt32FuncPtr{}, int8(0), int8(32), "", nil},
+
+		{SomeStructWithInt32WithErrFunc{}, int8(0), int8(32), "", nil},
+		{&SomeStructWithInt32WithErrFunc{}, int8(0), int8(32), "", nil},
+
+		{SomeStructWithInt32WithErrFuncPtr{}, int8(0), int8(32), "", nil},
+		{&SomeStructWithInt32WithErrFuncPtr{}, int8(0), int8(32), "", nil},
+
+		{SomeStructWithInt64Func{}, int8(0), int8(64), "", nil},
+		{&SomeStructWithInt64Func{}, int8(0), int8(64), "", nil},
+
+		{SomeStructWithInt64FuncPtr{}, int8(0), int8(64), "", nil},
+		{&SomeStructWithInt64FuncPtr{}, int8(0), int8(64), "", nil},
+
+		{SomeStructWithInt64WithErrFunc{}, int8(0), int8(64), "", nil},
+		{&SomeStructWithInt64WithErrFunc{}, int8(0), int8(64), "", nil},
+
+		{SomeStructWithInt64WithErrFuncPtr{}, int8(0), int8(64), "", nil},
+		{&SomeStructWithInt64WithErrFuncPtr{}, int8(0), int8(64), "", nil},
+
+		{SomeStructWithUintFunc{}, int8(0), int8(16), "", nil},
+		{&SomeStructWithUintFunc{}, int8(0), int8(16), "", nil},
+
+		{SomeStructWithUintFuncPtr{}, int8(0), int8(16), "", nil},
+		{&SomeStructWithUintFuncPtr{}, int8(0), int8(16), "", nil},
+
+		{SomeStructWithUintWithErrFunc{}, int8(0), int8(16), "", nil},
+		{&SomeStructWithUintWithErrFunc{}, int8(0), int8(16), "", nil},
+
+		{SomeStructWithUintWithErrFuncPtr{}, int8(0), int8(16), "", nil},
+		{&SomeStructWithUintWithErrFuncPtr{}, int8(0), int8(16), "", nil},
+
+		{SomeStructWithUint8Func{}, int8(0), int8(8), "", nil},
+		{&SomeStructWithUint8Func{}, int8(0), int8(8), "", nil},
+
+		{SomeStructWithUint8FuncPtr{}, int8(0), int8(8), "", nil},
+		{&SomeStructWithUint8FuncPtr{}, int8(0), int8(8), "", nil},
+
+		{SomeStructWithUint8WithErrFunc{}, int8(0), int8(8), "", nil},
+		{&SomeStructWithUint8WithErrFunc{}, int8(0), int8(8), "", nil},
+
+		{SomeStructWithUint8WithErrFuncPtr{}, int8(0), int8(8), "", nil},
+		{&SomeStructWithUint8WithErrFuncPtr{}, int8(0), int8(8), "", nil},
+
+		{SomeStructWithUint16Func{}, int8(0), int8(16), "", nil},
+		{&SomeStructWithUint16Func{}, int8(0), int8(16), "", nil},
+
+		{SomeStructWithUint16FuncPtr{}, int8(0), int8(16), "", nil},
+		{&SomeStructWithUint16FuncPtr{}, int8(0), int8(16), "", nil},
+
+		{SomeStructWithUint16WithErrFunc{}, int8(0), int8(16), "", nil},
+		{&SomeStructWithUint16WithErrFunc{}, int8(0), int8(16), "", nil},
+
+		{SomeStructWithUint16WithErrFuncPtr{}, int8(0), int8(16), "", nil},
+		{&SomeStructWithUint16WithErrFuncPtr{}, int8(0), int8(16), "", nil},
+
+		{SomeStructWithUint32Func{}, int8(0), int8(32), "", nil},
+		{&SomeStructWithUint32Func{}, int8(0), int8(32), "", nil},
+
+		{SomeStructWithUint32FuncPtr{}, int8(0), int8(32), "", nil},
+		{&SomeStructWithUint32FuncPtr{}, int8(0), int8(32), "", nil},
+
+		{SomeStructWithUint32WithErrFunc{}, int8(0), int8(32), "", nil},
+		{&SomeStructWithUint32WithErrFunc{}, int8(0), int8(32), "", nil},
+
+		{SomeStructWithUint32WithErrFuncPtr{}, int8(0), int8(32), "", nil},
+		{&SomeStructWithUint32WithErrFuncPtr{}, int8(0), int8(32), "", nil},
+
+		{SomeStructWithUint64Func{}, int8(0), int8(64), "", nil},
+		{&SomeStructWithUint64Func{}, int8(0), int8(64), "", nil},
+
+		{SomeStructWithUint64FuncPtr{}, int8(0), int8(64), "", nil},
+		{&SomeStructWithUint64FuncPtr{}, int8(0), int8(64), "", nil},
+
+		{SomeStructWithUint64WithErrFunc{}, int8(0), int8(64), "", nil},
+		{&SomeStructWithUint64WithErrFunc{}, int8(0), int8(64), "", nil},
+
+		{SomeStructWithUint64WithErrFuncPtr{}, int8(0), int8(64), "", nil},
+		{&SomeStructWithUint64WithErrFuncPtr{}, int8(0), int8(64), "", nil},
 	}
 
 	for i, test := range tests {
diff --git a/int_test.go b/int_test.go
index afcbd06..8539536 100644
--- a/int_test.go
+++ b/int_test.go
@@ -76,17 +76,125 @@ func TestInt(t *testing.T) {
 		// time
 		{time.Unix(10, 10), int(10), int(10), "", nil},
 
-		{SomeStructWithIntFunc{}, 0, 8, "", nil},
-		{&SomeStructWithIntFunc{}, 0, 8, "", nil},
+		{SomeStructWithIntFunc{}, int(0), int(8), "", nil},
+		{&SomeStructWithIntFunc{}, int(0), int(8), "", nil},
 
-		{SomeStructWithIntFuncPtr{}, 0, 8, "", nil},
-		{&SomeStructWithIntFuncPtr{}, 0, 8, "", nil},
+		{SomeStructWithIntFuncPtr{}, int(0), int(8), "", nil},
+		{&SomeStructWithIntFuncPtr{}, int(0), int(8), "", nil},
 
-		{SomeStructWithIntWithErrFunc{}, 0, 8, "", nil},
-		{&SomeStructWithIntWithErrFunc{}, 0, 8, "", nil},
+		{SomeStructWithIntWithErrFunc{}, int(0), int(8), "", nil},
+		{&SomeStructWithIntWithErrFunc{}, int(0), int(8), "", nil},
 
-		{SomeStructWithIntWithErrFuncPtr{}, 0, 8, "", nil},
-		{&SomeStructWithIntWithErrFuncPtr{}, 0, 8, "", nil},
+		{SomeStructWithIntWithErrFuncPtr{}, int(0), int(8), "", nil},
+		{&SomeStructWithIntWithErrFuncPtr{}, int(0), int(8), "", nil},
+
+		{SomeStructWithInt8Func{}, int(0), int(8), "", nil},
+		{&SomeStructWithInt8Func{}, int(0), int(8), "", nil},
+
+		{SomeStructWithInt8FuncPtr{}, int(0), int(8), "", nil},
+		{&SomeStructWithInt8FuncPtr{}, int(0), int(8), "", nil},
+
+		{SomeStructWithInt8WithErrFunc{}, int(0), int(8), "", nil},
+		{&SomeStructWithInt8WithErrFunc{}, int(0), int(8), "", nil},
+
+		{SomeStructWithInt8WithErrFuncPtr{}, int(0), int(8), "", nil},
+		{&SomeStructWithInt8WithErrFuncPtr{}, int(0), int(8), "", nil},
+
+		{SomeStructWithInt16Func{}, int(0), int(16), "", nil},
+		{&SomeStructWithInt16Func{}, int(0), int(16), "", nil},
+
+		{SomeStructWithInt16FuncPtr{}, int(0), int(16), "", nil},
+		{&SomeStructWithInt16FuncPtr{}, int(0), int(16), "", nil},
+
+		{SomeStructWithInt16WithErrFunc{}, int(0), int(16), "", nil},
+		{&SomeStructWithInt16WithErrFunc{}, int(0), int(16), "", nil},
+
+		{SomeStructWithInt16WithErrFuncPtr{}, int(0), int(16), "", nil},
+		{&SomeStructWithInt16WithErrFuncPtr{}, int(0), int(16), "", nil},
+
+		{SomeStructWithInt32Func{}, int(0), int(32), "", nil},
+		{&SomeStructWithInt32Func{}, int(0), int(32), "", nil},
+
+		{SomeStructWithInt32FuncPtr{}, int(0), int(32), "", nil},
+		{&SomeStructWithInt32FuncPtr{}, int(0), int(32), "", nil},
+
+		{SomeStructWithInt32WithErrFunc{}, int(0), int(32), "", nil},
+		{&SomeStructWithInt32WithErrFunc{}, int(0), int(32), "", nil},
+
+		{SomeStructWithInt32WithErrFuncPtr{}, int(0), int(32), "", nil},
+		{&SomeStructWithInt32WithErrFuncPtr{}, int(0), int(32), "", nil},
+
+		{SomeStructWithInt64Func{}, int(0), int(64), "", nil},
+		{&SomeStructWithInt64Func{}, int(0), int(64), "", nil},
+
+		{SomeStructWithInt64FuncPtr{}, int(0), int(64), "", nil},
+		{&SomeStructWithInt64FuncPtr{}, int(0), int(64), "", nil},
+
+		{SomeStructWithInt64WithErrFunc{}, int(0), int(64), "", nil},
+		{&SomeStructWithInt64WithErrFunc{}, int(0), int(64), "", nil},
+
+		{SomeStructWithInt64WithErrFuncPtr{}, int(0), int(64), "", nil},
+		{&SomeStructWithInt64WithErrFuncPtr{}, int(0), int(64), "", nil},
+
+		{SomeStructWithUintFunc{}, int(0), int(16), "", nil},
+		{&SomeStructWithUintFunc{}, int(0), int(16), "", nil},
+
+		{SomeStructWithUintFuncPtr{}, int(0), int(16), "", nil},
+		{&SomeStructWithUintFuncPtr{}, int(0), int(16), "", nil},
+
+		{SomeStructWithUintWithErrFunc{}, int(0), int(16), "", nil},
+		{&SomeStructWithUintWithErrFunc{}, int(0), int(16), "", nil},
+
+		{SomeStructWithUintWithErrFuncPtr{}, int(0), int(16), "", nil},
+		{&SomeStructWithUintWithErrFuncPtr{}, int(0), int(16), "", nil},
+
+		{SomeStructWithUint8Func{}, int(0), int(8), "", nil},
+		{&SomeStructWithUint8Func{}, int(0), int(8), "", nil},
+
+		{SomeStructWithUint8FuncPtr{}, int(0), int(8), "", nil},
+		{&SomeStructWithUint8FuncPtr{}, int(0), int(8), "", nil},
+
+		{SomeStructWithUint8WithErrFunc{}, int(0), int(8), "", nil},
+		{&SomeStructWithUint8WithErrFunc{}, int(0), int(8), "", nil},
+
+		{SomeStructWithUint8WithErrFuncPtr{}, int(0), int(8), "", nil},
+		{&SomeStructWithUint8WithErrFuncPtr{}, int(0), int(8), "", nil},
+
+		{SomeStructWithUint16Func{}, int(0), int(16), "", nil},
+		{&SomeStructWithUint16Func{}, int(0), int(16), "", nil},
+
+		{SomeStructWithUint16FuncPtr{}, int(0), int(16), "", nil},
+		{&SomeStructWithUint16FuncPtr{}, int(0), int(16), "", nil},
+
+		{SomeStructWithUint16WithErrFunc{}, int(0), int(16), "", nil},
+		{&SomeStructWithUint16WithErrFunc{}, int(0), int(16), "", nil},
+
+		{SomeStructWithUint16WithErrFuncPtr{}, int(0), int(16), "", nil},
+		{&SomeStructWithUint16WithErrFuncPtr{}, int(0), int(16), "", nil},
+
+		{SomeStructWithUint32Func{}, int(0), int(32), "", nil},
+		{&SomeStructWithUint32Func{}, int(0), int(32), "", nil},
+
+		{SomeStructWithUint32FuncPtr{}, int(0), int(32), "", nil},
+		{&SomeStructWithUint32FuncPtr{}, int(0), int(32), "", nil},
+
+		{SomeStructWithUint32WithErrFunc{}, int(0), int(32), "", nil},
+		{&SomeStructWithUint32WithErrFunc{}, int(0), int(32), "", nil},
+
+		{SomeStructWithUint32WithErrFuncPtr{}, int(0), int(32), "", nil},
+		{&SomeStructWithUint32WithErrFuncPtr{}, int(0), int(32), "", nil},
+
+		{SomeStructWithUint64Func{}, int(0), int(64), "", nil},
+		{&SomeStructWithUint64Func{}, int(0), int(64), "", nil},
+
+		{SomeStructWithUint64FuncPtr{}, int(0), int(64), "", nil},
+		{&SomeStructWithUint64FuncPtr{}, int(0), int(64), "", nil},
+
+		{SomeStructWithUint64WithErrFunc{}, int(0), int(64), "", nil},
+		{&SomeStructWithUint64WithErrFunc{}, int(0), int(64), "", nil},
+
+		{SomeStructWithUint64WithErrFuncPtr{}, int(0), int(64), "", nil},
+		{&SomeStructWithUint64WithErrFuncPtr{}, int(0), int(64), "", nil},
 	}
 
 	for i, test := range tests {
diff --git a/uint.go b/uint.go
index 61dcd68..a945967 100644
--- a/uint.go
+++ b/uint.go
@@ -101,16 +101,17 @@ func (s stdRecipes) structToUint(c Converter, in StructValue, out *uint) error {
 	return err
 }
 
+type toUint interface {
+	Uint() uint
+}
+type toUintWithErr interface {
+	Uint() (uint, error)
+}
+
 func (s stdRecipes) baseStructToUint(_ Converter, in reflect.Value, out *uint) error {
 	if !in.CanInterface() {
 		return errors.New("unable to make interface")
 	}
-	type toUint interface {
-		Uint() uint
-	}
-	type toUintWithErr interface {
-		Uint() (uint, error)
-	}
 
 	// check for struct.Uint()
 	if i, ok := in.Interface().(toUint); ok {
@@ -123,5 +124,13 @@ func (s stdRecipes) baseStructToUint(_ Converter, in reflect.Value, out *uint) e
 		return err
 	}
 
+	if ok, i, err := genericIntConvert(in); ok {
+		if err != nil {
+			return err
+		}
+		*out = uint(i)
+		return nil
+	}
+
 	return fmt.Errorf("%s has no Uint() function", in.Type().String())
 }
diff --git a/uint16.go b/uint16.go
index a1eea2d..fbc25d7 100644
--- a/uint16.go
+++ b/uint16.go
@@ -101,16 +101,17 @@ func (s stdRecipes) structToUint16(c Converter, in StructValue, out *uint16) err
 	return err
 }
 
+type toUint16 interface {
+	Uint16() uint16
+}
+type toUint16WithErr interface {
+	Uint16() (uint16, error)
+}
+
 func (s stdRecipes) baseStructToUint16(_ Converter, in reflect.Value, out *uint16) error {
 	if !in.CanInterface() {
 		return errors.New("unable to make interface")
 	}
-	type toUint16 interface {
-		Uint16() uint16
-	}
-	type toUint16WithErr interface {
-		Uint16() (uint16, error)
-	}
 
 	// check for struct.Uint16()
 	if i, ok := in.Interface().(toUint16); ok {
@@ -123,5 +124,13 @@ func (s stdRecipes) baseStructToUint16(_ Converter, in reflect.Value, out *uint1
 		return err
 	}
 
+	if ok, i, err := genericIntConvert(in); ok {
+		if err != nil {
+			return err
+		}
+		*out = uint16(i)
+		return nil
+	}
+
 	return fmt.Errorf("%s has no Uint16() function", in.Type().String())
 }
diff --git a/uint16_test.go b/uint16_test.go
index d842326..4ebeb97 100644
--- a/uint16_test.go
+++ b/uint16_test.go
@@ -77,6 +77,90 @@ func TestUint16(t *testing.T) {
 		// time
 		{time.Unix(10, 10), uint16(10), uint16(10), "", nil},
 
+		{SomeStructWithIntFunc{}, uint16(0), uint16(8), "", nil},
+		{&SomeStructWithIntFunc{}, uint16(0), uint16(8), "", nil},
+
+		{SomeStructWithIntFuncPtr{}, uint16(0), uint16(8), "", nil},
+		{&SomeStructWithIntFuncPtr{}, uint16(0), uint16(8), "", nil},
+
+		{SomeStructWithIntWithErrFunc{}, uint16(0), uint16(8), "", nil},
+		{&SomeStructWithIntWithErrFunc{}, uint16(0), uint16(8), "", nil},
+
+		{SomeStructWithIntWithErrFuncPtr{}, uint16(0), uint16(8), "", nil},
+		{&SomeStructWithIntWithErrFuncPtr{}, uint16(0), uint16(8), "", nil},
+
+		{SomeStructWithInt8Func{}, uint16(0), uint16(8), "", nil},
+		{&SomeStructWithInt8Func{}, uint16(0), uint16(8), "", nil},
+
+		{SomeStructWithInt8FuncPtr{}, uint16(0), uint16(8), "", nil},
+		{&SomeStructWithInt8FuncPtr{}, uint16(0), uint16(8), "", nil},
+
+		{SomeStructWithInt8WithErrFunc{}, uint16(0), uint16(8), "", nil},
+		{&SomeStructWithInt8WithErrFunc{}, uint16(0), uint16(8), "", nil},
+
+		{SomeStructWithInt8WithErrFuncPtr{}, uint16(0), uint16(8), "", nil},
+		{&SomeStructWithInt8WithErrFuncPtr{}, uint16(0), uint16(8), "", nil},
+
+		{SomeStructWithInt16Func{}, uint16(0), uint16(16), "", nil},
+		{&SomeStructWithInt16Func{}, uint16(0), uint16(16), "", nil},
+
+		{SomeStructWithInt16FuncPtr{}, uint16(0), uint16(16), "", nil},
+		{&SomeStructWithInt16FuncPtr{}, uint16(0), uint16(16), "", nil},
+
+		{SomeStructWithInt16WithErrFunc{}, uint16(0), uint16(16), "", nil},
+		{&SomeStructWithInt16WithErrFunc{}, uint16(0), uint16(16), "", nil},
+
+		{SomeStructWithInt16WithErrFuncPtr{}, uint16(0), uint16(16), "", nil},
+		{&SomeStructWithInt16WithErrFuncPtr{}, uint16(0), uint16(16), "", nil},
+
+		{SomeStructWithInt32Func{}, uint16(0), uint16(32), "", nil},
+		{&SomeStructWithInt32Func{}, uint16(0), uint16(32), "", nil},
+
+		{SomeStructWithInt32FuncPtr{}, uint16(0), uint16(32), "", nil},
+		{&SomeStructWithInt32FuncPtr{}, uint16(0), uint16(32), "", nil},
+
+		{SomeStructWithInt32WithErrFunc{}, uint16(0), uint16(32), "", nil},
+		{&SomeStructWithInt32WithErrFunc{}, uint16(0), uint16(32), "", nil},
+
+		{SomeStructWithInt32WithErrFuncPtr{}, uint16(0), uint16(32), "", nil},
+		{&SomeStructWithInt32WithErrFuncPtr{}, uint16(0), uint16(32), "", nil},
+
+		{SomeStructWithInt64Func{}, uint16(0), uint16(64), "", nil},
+		{&SomeStructWithInt64Func{}, uint16(0), uint16(64), "", nil},
+
+		{SomeStructWithInt64FuncPtr{}, uint16(0), uint16(64), "", nil},
+		{&SomeStructWithInt64FuncPtr{}, uint16(0), uint16(64), "", nil},
+
+		{SomeStructWithInt64WithErrFunc{}, uint16(0), uint16(64), "", nil},
+		{&SomeStructWithInt64WithErrFunc{}, uint16(0), uint16(64), "", nil},
+
+		{SomeStructWithInt64WithErrFuncPtr{}, uint16(0), uint16(64), "", nil},
+		{&SomeStructWithInt64WithErrFuncPtr{}, uint16(0), uint16(64), "", nil},
+
+		{SomeStructWithUintFunc{}, uint16(0), uint16(16), "", nil},
+		{&SomeStructWithUintFunc{}, uint16(0), uint16(16), "", nil},
+
+		{SomeStructWithUintFuncPtr{}, uint16(0), uint16(16), "", nil},
+		{&SomeStructWithUintFuncPtr{}, uint16(0), uint16(16), "", nil},
+
+		{SomeStructWithUintWithErrFunc{}, uint16(0), uint16(16), "", nil},
+		{&SomeStructWithUintWithErrFunc{}, uint16(0), uint16(16), "", nil},
+
+		{SomeStructWithUintWithErrFuncPtr{}, uint16(0), uint16(16), "", nil},
+		{&SomeStructWithUintWithErrFuncPtr{}, uint16(0), uint16(16), "", nil},
+
+		{SomeStructWithUint8Func{}, uint16(0), uint16(8), "", nil},
+		{&SomeStructWithUint8Func{}, uint16(0), uint16(8), "", nil},
+
+		{SomeStructWithUint8FuncPtr{}, uint16(0), uint16(8), "", nil},
+		{&SomeStructWithUint8FuncPtr{}, uint16(0), uint16(8), "", nil},
+
+		{SomeStructWithUint8WithErrFunc{}, uint16(0), uint16(8), "", nil},
+		{&SomeStructWithUint8WithErrFunc{}, uint16(0), uint16(8), "", nil},
+
+		{SomeStructWithUint8WithErrFuncPtr{}, uint16(0), uint16(8), "", nil},
+		{&SomeStructWithUint8WithErrFuncPtr{}, uint16(0), uint16(8), "", nil},
+
 		{SomeStructWithUint16Func{}, uint16(0), uint16(16), "", nil},
 		{&SomeStructWithUint16Func{}, uint16(0), uint16(16), "", nil},
 
@@ -88,6 +172,30 @@ func TestUint16(t *testing.T) {
 
 		{SomeStructWithUint16WithErrFuncPtr{}, uint16(0), uint16(16), "", nil},
 		{&SomeStructWithUint16WithErrFuncPtr{}, uint16(0), uint16(16), "", nil},
+
+		{SomeStructWithUint32Func{}, uint16(0), uint16(32), "", nil},
+		{&SomeStructWithUint32Func{}, uint16(0), uint16(32), "", nil},
+
+		{SomeStructWithUint32FuncPtr{}, uint16(0), uint16(32), "", nil},
+		{&SomeStructWithUint32FuncPtr{}, uint16(0), uint16(32), "", nil},
+
+		{SomeStructWithUint32WithErrFunc{}, uint16(0), uint16(32), "", nil},
+		{&SomeStructWithUint32WithErrFunc{}, uint16(0), uint16(32), "", nil},
+
+		{SomeStructWithUint32WithErrFuncPtr{}, uint16(0), uint16(32), "", nil},
+		{&SomeStructWithUint32WithErrFuncPtr{}, uint16(0), uint16(32), "", nil},
+
+		{SomeStructWithUint64Func{}, uint16(0), uint16(64), "", nil},
+		{&SomeStructWithUint64Func{}, uint16(0), uint16(64), "", nil},
+
+		{SomeStructWithUint64FuncPtr{}, uint16(0), uint16(64), "", nil},
+		{&SomeStructWithUint64FuncPtr{}, uint16(0), uint16(64), "", nil},
+
+		{SomeStructWithUint64WithErrFunc{}, uint16(0), uint16(64), "", nil},
+		{&SomeStructWithUint64WithErrFunc{}, uint16(0), uint16(64), "", nil},
+
+		{SomeStructWithUint64WithErrFuncPtr{}, uint16(0), uint16(64), "", nil},
+		{&SomeStructWithUint64WithErrFuncPtr{}, uint16(0), uint16(64), "", nil},
 	}
 
 	for i, test := range tests {
diff --git a/uint32.go b/uint32.go
index 1f989e5..78a21b7 100644
--- a/uint32.go
+++ b/uint32.go
@@ -101,16 +101,17 @@ func (s stdRecipes) structToUint32(c Converter, in StructValue, out *uint32) err
 	return err
 }
 
+type toUint32 interface {
+	Uint32() uint32
+}
+type toUint32WithErr interface {
+	Uint32() (uint32, error)
+}
+
 func (s stdRecipes) baseStructToUint32(_ Converter, in reflect.Value, out *uint32) error {
 	if !in.CanInterface() {
 		return errors.New("unable to make interface")
 	}
-	type toUint32 interface {
-		Uint32() uint32
-	}
-	type toUint32WithErr interface {
-		Uint32() (uint32, error)
-	}
 
 	// check for struct.Uint32()
 	if i, ok := in.Interface().(toUint32); ok {
@@ -123,5 +124,13 @@ func (s stdRecipes) baseStructToUint32(_ Converter, in reflect.Value, out *uint3
 		return err
 	}
 
+	if ok, i, err := genericIntConvert(in); ok {
+		if err != nil {
+			return err
+		}
+		*out = uint32(i)
+		return nil
+	}
+
 	return fmt.Errorf("%s has no Uint32() function", in.Type().String())
 }
diff --git a/uint32_test.go b/uint32_test.go
index fcd79c8..54b23ff 100644
--- a/uint32_test.go
+++ b/uint32_test.go
@@ -77,6 +77,102 @@ func TestUint32(t *testing.T) {
 		// time
 		{time.Unix(10, 10), uint32(10), uint32(10), "", nil},
 
+		{SomeStructWithIntFunc{}, uint32(0), uint32(8), "", nil},
+		{&SomeStructWithIntFunc{}, uint32(0), uint32(8), "", nil},
+
+		{SomeStructWithIntFuncPtr{}, uint32(0), uint32(8), "", nil},
+		{&SomeStructWithIntFuncPtr{}, uint32(0), uint32(8), "", nil},
+
+		{SomeStructWithIntWithErrFunc{}, uint32(0), uint32(8), "", nil},
+		{&SomeStructWithIntWithErrFunc{}, uint32(0), uint32(8), "", nil},
+
+		{SomeStructWithIntWithErrFuncPtr{}, uint32(0), uint32(8), "", nil},
+		{&SomeStructWithIntWithErrFuncPtr{}, uint32(0), uint32(8), "", nil},
+
+		{SomeStructWithInt8Func{}, uint32(0), uint32(8), "", nil},
+		{&SomeStructWithInt8Func{}, uint32(0), uint32(8), "", nil},
+
+		{SomeStructWithInt8FuncPtr{}, uint32(0), uint32(8), "", nil},
+		{&SomeStructWithInt8FuncPtr{}, uint32(0), uint32(8), "", nil},
+
+		{SomeStructWithInt8WithErrFunc{}, uint32(0), uint32(8), "", nil},
+		{&SomeStructWithInt8WithErrFunc{}, uint32(0), uint32(8), "", nil},
+
+		{SomeStructWithInt8WithErrFuncPtr{}, uint32(0), uint32(8), "", nil},
+		{&SomeStructWithInt8WithErrFuncPtr{}, uint32(0), uint32(8), "", nil},
+
+		{SomeStructWithInt16Func{}, uint32(0), uint32(16), "", nil},
+		{&SomeStructWithInt16Func{}, uint32(0), uint32(16), "", nil},
+
+		{SomeStructWithInt16FuncPtr{}, uint32(0), uint32(16), "", nil},
+		{&SomeStructWithInt16FuncPtr{}, uint32(0), uint32(16), "", nil},
+
+		{SomeStructWithInt16WithErrFunc{}, uint32(0), uint32(16), "", nil},
+		{&SomeStructWithInt16WithErrFunc{}, uint32(0), uint32(16), "", nil},
+
+		{SomeStructWithInt16WithErrFuncPtr{}, uint32(0), uint32(16), "", nil},
+		{&SomeStructWithInt16WithErrFuncPtr{}, uint32(0), uint32(16), "", nil},
+
+		{SomeStructWithInt32Func{}, uint32(0), uint32(32), "", nil},
+		{&SomeStructWithInt32Func{}, uint32(0), uint32(32), "", nil},
+
+		{SomeStructWithInt32FuncPtr{}, uint32(0), uint32(32), "", nil},
+		{&SomeStructWithInt32FuncPtr{}, uint32(0), uint32(32), "", nil},
+
+		{SomeStructWithInt32WithErrFunc{}, uint32(0), uint32(32), "", nil},
+		{&SomeStructWithInt32WithErrFunc{}, uint32(0), uint32(32), "", nil},
+
+		{SomeStructWithInt32WithErrFuncPtr{}, uint32(0), uint32(32), "", nil},
+		{&SomeStructWithInt32WithErrFuncPtr{}, uint32(0), uint32(32), "", nil},
+
+		{SomeStructWithInt64Func{}, uint32(0), uint32(64), "", nil},
+		{&SomeStructWithInt64Func{}, uint32(0), uint32(64), "", nil},
+
+		{SomeStructWithInt64FuncPtr{}, uint32(0), uint32(64), "", nil},
+		{&SomeStructWithInt64FuncPtr{}, uint32(0), uint32(64), "", nil},
+
+		{SomeStructWithInt64WithErrFunc{}, uint32(0), uint32(64), "", nil},
+		{&SomeStructWithInt64WithErrFunc{}, uint32(0), uint32(64), "", nil},
+
+		{SomeStructWithInt64WithErrFuncPtr{}, uint32(0), uint32(64), "", nil},
+		{&SomeStructWithInt64WithErrFuncPtr{}, uint32(0), uint32(64), "", nil},
+
+		{SomeStructWithUintFunc{}, uint32(0), uint32(16), "", nil},
+		{&SomeStructWithUintFunc{}, uint32(0), uint32(16), "", nil},
+
+		{SomeStructWithUintFuncPtr{}, uint32(0), uint32(16), "", nil},
+		{&SomeStructWithUintFuncPtr{}, uint32(0), uint32(16), "", nil},
+
+		{SomeStructWithUintWithErrFunc{}, uint32(0), uint32(16), "", nil},
+		{&SomeStructWithUintWithErrFunc{}, uint32(0), uint32(16), "", nil},
+
+		{SomeStructWithUintWithErrFuncPtr{}, uint32(0), uint32(16), "", nil},
+		{&SomeStructWithUintWithErrFuncPtr{}, uint32(0), uint32(16), "", nil},
+
+		{SomeStructWithUint8Func{}, uint32(0), uint32(8), "", nil},
+		{&SomeStructWithUint8Func{}, uint32(0), uint32(8), "", nil},
+
+		{SomeStructWithUint8FuncPtr{}, uint32(0), uint32(8), "", nil},
+		{&SomeStructWithUint8FuncPtr{}, uint32(0), uint32(8), "", nil},
+
+		{SomeStructWithUint8WithErrFunc{}, uint32(0), uint32(8), "", nil},
+		{&SomeStructWithUint8WithErrFunc{}, uint32(0), uint32(8), "", nil},
+
+		{SomeStructWithUint8WithErrFuncPtr{}, uint32(0), uint32(8), "", nil},
+		{&SomeStructWithUint8WithErrFuncPtr{}, uint32(0), uint32(8), "", nil},
+
+		{SomeStructWithUint16Func{}, uint32(0), uint32(16), "", nil},
+		{&SomeStructWithUint16Func{}, uint32(0), uint32(16), "", nil},
+
+		{SomeStructWithUint16FuncPtr{}, uint32(0), uint32(16), "", nil},
+		{&SomeStructWithUint16FuncPtr{}, uint32(0), uint32(16), "", nil},
+
+		{SomeStructWithUint16WithErrFunc{}, uint32(0), uint32(16), "", nil},
+		{&SomeStructWithUint16WithErrFunc{}, uint32(0), uint32(16), "", nil},
+
+		{SomeStructWithUint16WithErrFuncPtr{}, uint32(0), uint32(16), "", nil},
+		{&SomeStructWithUint16WithErrFuncPtr{}, uint32(0), uint32(16), "", nil},
+
 		{SomeStructWithUint32Func{}, uint32(0), uint32(32), "", nil},
 		{&SomeStructWithUint32Func{}, uint32(0), uint32(32), "", nil},
 
@@ -88,6 +184,18 @@ func TestUint32(t *testing.T) {
 
 		{SomeStructWithUint32WithErrFuncPtr{}, uint32(0), uint32(32), "", nil},
 		{&SomeStructWithUint32WithErrFuncPtr{}, uint32(0), uint32(32), "", nil},
+
+		{SomeStructWithUint64Func{}, uint32(0), uint32(64), "", nil},
+		{&SomeStructWithUint64Func{}, uint32(0), uint32(64), "", nil},
+
+		{SomeStructWithUint64FuncPtr{}, uint32(0), uint32(64), "", nil},
+		{&SomeStructWithUint64FuncPtr{}, uint32(0), uint32(64), "", nil},
+
+		{SomeStructWithUint64WithErrFunc{}, uint32(0), uint32(64), "", nil},
+		{&SomeStructWithUint64WithErrFunc{}, uint32(0), uint32(64), "", nil},
+
+		{SomeStructWithUint64WithErrFuncPtr{}, uint32(0), uint32(64), "", nil},
+		{&SomeStructWithUint64WithErrFuncPtr{}, uint32(0), uint32(64), "", nil},
 	}
 
 	for i, test := range tests {
diff --git a/uint64.go b/uint64.go
index f1862c6..b48ff5d 100644
--- a/uint64.go
+++ b/uint64.go
@@ -101,16 +101,17 @@ func (s stdRecipes) structToUint64(c Converter, in StructValue, out *uint64) err
 	return err
 }
 
+type toUint64 interface {
+	Uint64() uint64
+}
+type toUint64WithErr interface {
+	Uint64() (uint64, error)
+}
+
 func (s stdRecipes) baseStructToUint64(_ Converter, in reflect.Value, out *uint64) error {
 	if !in.CanInterface() {
 		return errors.New("unable to make interface")
 	}
-	type toUint64 interface {
-		Uint64() uint64
-	}
-	type toUint64WithErr interface {
-		Uint64() (uint64, error)
-	}
 
 	// check for struct.Uint64()
 	if i, ok := in.Interface().(toUint64); ok {
@@ -123,5 +124,13 @@ func (s stdRecipes) baseStructToUint64(_ Converter, in reflect.Value, out *uint6
 		return err
 	}
 
+	if ok, i, err := genericIntConvert(in); ok {
+		if err != nil {
+			return err
+		}
+		*out = uint64(i)
+		return nil
+	}
+
 	return fmt.Errorf("%s has no Uint64() function", in.Type().String())
 }
diff --git a/uint64_test.go b/uint64_test.go
index aa43373..6ba2454 100644
--- a/uint64_test.go
+++ b/uint64_test.go
@@ -77,6 +77,114 @@ func TestUint64(t *testing.T) {
 		// time
 		{time.Unix(10, 10), uint64(10), uint64(10), "", nil},
 
+		{SomeStructWithIntFunc{}, uint64(0), uint64(8), "", nil},
+		{&SomeStructWithIntFunc{}, uint64(0), uint64(8), "", nil},
+
+		{SomeStructWithIntFuncPtr{}, uint64(0), uint64(8), "", nil},
+		{&SomeStructWithIntFuncPtr{}, uint64(0), uint64(8), "", nil},
+
+		{SomeStructWithIntWithErrFunc{}, uint64(0), uint64(8), "", nil},
+		{&SomeStructWithIntWithErrFunc{}, uint64(0), uint64(8), "", nil},
+
+		{SomeStructWithIntWithErrFuncPtr{}, uint64(0), uint64(8), "", nil},
+		{&SomeStructWithIntWithErrFuncPtr{}, uint64(0), uint64(8), "", nil},
+
+		{SomeStructWithInt8Func{}, uint64(0), uint64(8), "", nil},
+		{&SomeStructWithInt8Func{}, uint64(0), uint64(8), "", nil},
+
+		{SomeStructWithInt8FuncPtr{}, uint64(0), uint64(8), "", nil},
+		{&SomeStructWithInt8FuncPtr{}, uint64(0), uint64(8), "", nil},
+
+		{SomeStructWithInt8WithErrFunc{}, uint64(0), uint64(8), "", nil},
+		{&SomeStructWithInt8WithErrFunc{}, uint64(0), uint64(8), "", nil},
+
+		{SomeStructWithInt8WithErrFuncPtr{}, uint64(0), uint64(8), "", nil},
+		{&SomeStructWithInt8WithErrFuncPtr{}, uint64(0), uint64(8), "", nil},
+
+		{SomeStructWithInt16Func{}, uint64(0), uint64(16), "", nil},
+		{&SomeStructWithInt16Func{}, uint64(0), uint64(16), "", nil},
+
+		{SomeStructWithInt16FuncPtr{}, uint64(0), uint64(16), "", nil},
+		{&SomeStructWithInt16FuncPtr{}, uint64(0), uint64(16), "", nil},
+
+		{SomeStructWithInt16WithErrFunc{}, uint64(0), uint64(16), "", nil},
+		{&SomeStructWithInt16WithErrFunc{}, uint64(0), uint64(16), "", nil},
+
+		{SomeStructWithInt16WithErrFuncPtr{}, uint64(0), uint64(16), "", nil},
+		{&SomeStructWithInt16WithErrFuncPtr{}, uint64(0), uint64(16), "", nil},
+
+		{SomeStructWithInt32Func{}, uint64(0), uint64(32), "", nil},
+		{&SomeStructWithInt32Func{}, uint64(0), uint64(32), "", nil},
+
+		{SomeStructWithInt32FuncPtr{}, uint64(0), uint64(32), "", nil},
+		{&SomeStructWithInt32FuncPtr{}, uint64(0), uint64(32), "", nil},
+
+		{SomeStructWithInt32WithErrFunc{}, uint64(0), uint64(32), "", nil},
+		{&SomeStructWithInt32WithErrFunc{}, uint64(0), uint64(32), "", nil},
+
+		{SomeStructWithInt32WithErrFuncPtr{}, uint64(0), uint64(32), "", nil},
+		{&SomeStructWithInt32WithErrFuncPtr{}, uint64(0), uint64(32), "", nil},
+
+		{SomeStructWithInt64Func{}, uint64(0), uint64(64), "", nil},
+		{&SomeStructWithInt64Func{}, uint64(0), uint64(64), "", nil},
+
+		{SomeStructWithInt64FuncPtr{}, uint64(0), uint64(64), "", nil},
+		{&SomeStructWithInt64FuncPtr{}, uint64(0), uint64(64), "", nil},
+
+		{SomeStructWithInt64WithErrFunc{}, uint64(0), uint64(64), "", nil},
+		{&SomeStructWithInt64WithErrFunc{}, uint64(0), uint64(64), "", nil},
+
+		{SomeStructWithInt64WithErrFuncPtr{}, uint64(0), uint64(64), "", nil},
+		{&SomeStructWithInt64WithErrFuncPtr{}, uint64(0), uint64(64), "", nil},
+
+		{SomeStructWithUintFunc{}, uint64(0), uint64(16), "", nil},
+		{&SomeStructWithUintFunc{}, uint64(0), uint64(16), "", nil},
+
+		{SomeStructWithUintFuncPtr{}, uint64(0), uint64(16), "", nil},
+		{&SomeStructWithUintFuncPtr{}, uint64(0), uint64(16), "", nil},
+
+		{SomeStructWithUintWithErrFunc{}, uint64(0), uint64(16), "", nil},
+		{&SomeStructWithUintWithErrFunc{}, uint64(0), uint64(16), "", nil},
+
+		{SomeStructWithUintWithErrFuncPtr{}, uint64(0), uint64(16), "", nil},
+		{&SomeStructWithUintWithErrFuncPtr{}, uint64(0), uint64(16), "", nil},
+
+		{SomeStructWithUint8Func{}, uint64(0), uint64(8), "", nil},
+		{&SomeStructWithUint8Func{}, uint64(0), uint64(8), "", nil},
+
+		{SomeStructWithUint8FuncPtr{}, uint64(0), uint64(8), "", nil},
+		{&SomeStructWithUint8FuncPtr{}, uint64(0), uint64(8), "", nil},
+
+		{SomeStructWithUint8WithErrFunc{}, uint64(0), uint64(8), "", nil},
+		{&SomeStructWithUint8WithErrFunc{}, uint64(0), uint64(8), "", nil},
+
+		{SomeStructWithUint8WithErrFuncPtr{}, uint64(0), uint64(8), "", nil},
+		{&SomeStructWithUint8WithErrFuncPtr{}, uint64(0), uint64(8), "", nil},
+
+		{SomeStructWithUint16Func{}, uint64(0), uint64(16), "", nil},
+		{&SomeStructWithUint16Func{}, uint64(0), uint64(16), "", nil},
+
+		{SomeStructWithUint16FuncPtr{}, uint64(0), uint64(16), "", nil},
+		{&SomeStructWithUint16FuncPtr{}, uint64(0), uint64(16), "", nil},
+
+		{SomeStructWithUint16WithErrFunc{}, uint64(0), uint64(16), "", nil},
+		{&SomeStructWithUint16WithErrFunc{}, uint64(0), uint64(16), "", nil},
+
+		{SomeStructWithUint16WithErrFuncPtr{}, uint64(0), uint64(16), "", nil},
+		{&SomeStructWithUint16WithErrFuncPtr{}, uint64(0), uint64(16), "", nil},
+
+		{SomeStructWithUint32Func{}, uint64(0), uint64(32), "", nil},
+		{&SomeStructWithUint32Func{}, uint64(0), uint64(32), "", nil},
+
+		{SomeStructWithUint32FuncPtr{}, uint64(0), uint64(32), "", nil},
+		{&SomeStructWithUint32FuncPtr{}, uint64(0), uint64(32), "", nil},
+
+		{SomeStructWithUint32WithErrFunc{}, uint64(0), uint64(32), "", nil},
+		{&SomeStructWithUint32WithErrFunc{}, uint64(0), uint64(32), "", nil},
+
+		{SomeStructWithUint32WithErrFuncPtr{}, uint64(0), uint64(32), "", nil},
+		{&SomeStructWithUint32WithErrFuncPtr{}, uint64(0), uint64(32), "", nil},
+
 		{SomeStructWithUint64Func{}, uint64(0), uint64(64), "", nil},
 		{&SomeStructWithUint64Func{}, uint64(0), uint64(64), "", nil},
 
diff --git a/uint8.go b/uint8.go
index 9f2dad3..75298f7 100644
--- a/uint8.go
+++ b/uint8.go
@@ -102,16 +102,17 @@ func (s stdRecipes) structToUint8(c Converter, in StructValue, out *uint8) error
 	return err
 }
 
+type toUint8 interface {
+	Uint8() uint8
+}
+type toUint8WithErr interface {
+	Uint8() (uint8, error)
+}
+
 func (s stdRecipes) baseStructToUint8(_ Converter, in reflect.Value, out *uint8) error {
 	if !in.CanInterface() {
 		return errors.New("unable to make interface")
 	}
-	type toUint8 interface {
-		Uint8() uint8
-	}
-	type toUint8WithErr interface {
-		Uint8() (uint8, error)
-	}
 
 	// check for struct.Uint8()
 	if i, ok := in.Interface().(toUint8); ok {
@@ -124,5 +125,13 @@ func (s stdRecipes) baseStructToUint8(_ Converter, in reflect.Value, out *uint8)
 		return err
 	}
 
+	if ok, i, err := genericIntConvert(in); ok {
+		if err != nil {
+			return err
+		}
+		*out = uint8(i)
+		return nil
+	}
+
 	return fmt.Errorf("%s has no Uint8() function", in.Type().String())
 }
diff --git a/uint8_test.go b/uint8_test.go
index ce76512..e0a656e 100644
--- a/uint8_test.go
+++ b/uint8_test.go
@@ -77,6 +77,78 @@ func TestUint8(t *testing.T) {
 		// time
 		{time.Unix(10, 10), uint8(10), uint8(10), "", nil},
 
+		{SomeStructWithIntFunc{}, uint8(0), uint8(8), "", nil},
+		{&SomeStructWithIntFunc{}, uint8(0), uint8(8), "", nil},
+
+		{SomeStructWithIntFuncPtr{}, uint8(0), uint8(8), "", nil},
+		{&SomeStructWithIntFuncPtr{}, uint8(0), uint8(8), "", nil},
+
+		{SomeStructWithIntWithErrFunc{}, uint8(0), uint8(8), "", nil},
+		{&SomeStructWithIntWithErrFunc{}, uint8(0), uint8(8), "", nil},
+
+		{SomeStructWithIntWithErrFuncPtr{}, uint8(0), uint8(8), "", nil},
+		{&SomeStructWithIntWithErrFuncPtr{}, uint8(0), uint8(8), "", nil},
+
+		{SomeStructWithInt8Func{}, uint8(0), uint8(8), "", nil},
+		{&SomeStructWithInt8Func{}, uint8(0), uint8(8), "", nil},
+
+		{SomeStructWithInt8FuncPtr{}, uint8(0), uint8(8), "", nil},
+		{&SomeStructWithInt8FuncPtr{}, uint8(0), uint8(8), "", nil},
+
+		{SomeStructWithInt8WithErrFunc{}, uint8(0), uint8(8), "", nil},
+		{&SomeStructWithInt8WithErrFunc{}, uint8(0), uint8(8), "", nil},
+
+		{SomeStructWithInt8WithErrFuncPtr{}, uint8(0), uint8(8), "", nil},
+		{&SomeStructWithInt8WithErrFuncPtr{}, uint8(0), uint8(8), "", nil},
+
+		{SomeStructWithInt16Func{}, uint8(0), uint8(16), "", nil},
+		{&SomeStructWithInt16Func{}, uint8(0), uint8(16), "", nil},
+
+		{SomeStructWithInt16FuncPtr{}, uint8(0), uint8(16), "", nil},
+		{&SomeStructWithInt16FuncPtr{}, uint8(0), uint8(16), "", nil},
+
+		{SomeStructWithInt16WithErrFunc{}, uint8(0), uint8(16), "", nil},
+		{&SomeStructWithInt16WithErrFunc{}, uint8(0), uint8(16), "", nil},
+
+		{SomeStructWithInt16WithErrFuncPtr{}, uint8(0), uint8(16), "", nil},
+		{&SomeStructWithInt16WithErrFuncPtr{}, uint8(0), uint8(16), "", nil},
+
+		{SomeStructWithInt32Func{}, uint8(0), uint8(32), "", nil},
+		{&SomeStructWithInt32Func{}, uint8(0), uint8(32), "", nil},
+
+		{SomeStructWithInt32FuncPtr{}, uint8(0), uint8(32), "", nil},
+		{&SomeStructWithInt32FuncPtr{}, uint8(0), uint8(32), "", nil},
+
+		{SomeStructWithInt32WithErrFunc{}, uint8(0), uint8(32), "", nil},
+		{&SomeStructWithInt32WithErrFunc{}, uint8(0), uint8(32), "", nil},
+
+		{SomeStructWithInt32WithErrFuncPtr{}, uint8(0), uint8(32), "", nil},
+		{&SomeStructWithInt32WithErrFuncPtr{}, uint8(0), uint8(32), "", nil},
+
+		{SomeStructWithInt64Func{}, uint8(0), uint8(64), "", nil},
+		{&SomeStructWithInt64Func{}, uint8(0), uint8(64), "", nil},
+
+		{SomeStructWithInt64FuncPtr{}, uint8(0), uint8(64), "", nil},
+		{&SomeStructWithInt64FuncPtr{}, uint8(0), uint8(64), "", nil},
+
+		{SomeStructWithInt64WithErrFunc{}, uint8(0), uint8(64), "", nil},
+		{&SomeStructWithInt64WithErrFunc{}, uint8(0), uint8(64), "", nil},
+
+		{SomeStructWithInt64WithErrFuncPtr{}, uint8(0), uint8(64), "", nil},
+		{&SomeStructWithInt64WithErrFuncPtr{}, uint8(0), uint8(64), "", nil},
+
+		{SomeStructWithUintFunc{}, uint8(0), uint8(16), "", nil},
+		{&SomeStructWithUintFunc{}, uint8(0), uint8(16), "", nil},
+
+		{SomeStructWithUintFuncPtr{}, uint8(0), uint8(16), "", nil},
+		{&SomeStructWithUintFuncPtr{}, uint8(0), uint8(16), "", nil},
+
+		{SomeStructWithUintWithErrFunc{}, uint8(0), uint8(16), "", nil},
+		{&SomeStructWithUintWithErrFunc{}, uint8(0), uint8(16), "", nil},
+
+		{SomeStructWithUintWithErrFuncPtr{}, uint8(0), uint8(16), "", nil},
+		{&SomeStructWithUintWithErrFuncPtr{}, uint8(0), uint8(16), "", nil},
+
 		{SomeStructWithUint8Func{}, uint8(0), uint8(8), "", nil},
 		{&SomeStructWithUint8Func{}, uint8(0), uint8(8), "", nil},
 
@@ -86,8 +158,44 @@ func TestUint8(t *testing.T) {
 		{SomeStructWithUint8WithErrFunc{}, uint8(0), uint8(8), "", nil},
 		{&SomeStructWithUint8WithErrFunc{}, uint8(0), uint8(8), "", nil},
 
-		{&SomeStructWithUint8WithErrFuncPtr{}, uint8(0), uint8(8), "", nil},
 		{SomeStructWithUint8WithErrFuncPtr{}, uint8(0), uint8(8), "", nil},
+		{&SomeStructWithUint8WithErrFuncPtr{}, uint8(0), uint8(8), "", nil},
+
+		{SomeStructWithUint16Func{}, uint8(0), uint8(16), "", nil},
+		{&SomeStructWithUint16Func{}, uint8(0), uint8(16), "", nil},
+
+		{SomeStructWithUint16FuncPtr{}, uint8(0), uint8(16), "", nil},
+		{&SomeStructWithUint16FuncPtr{}, uint8(0), uint8(16), "", nil},
+
+		{SomeStructWithUint16WithErrFunc{}, uint8(0), uint8(16), "", nil},
+		{&SomeStructWithUint16WithErrFunc{}, uint8(0), uint8(16), "", nil},
+
+		{SomeStructWithUint16WithErrFuncPtr{}, uint8(0), uint8(16), "", nil},
+		{&SomeStructWithUint16WithErrFuncPtr{}, uint8(0), uint8(16), "", nil},
+
+		{SomeStructWithUint32Func{}, uint8(0), uint8(32), "", nil},
+		{&SomeStructWithUint32Func{}, uint8(0), uint8(32), "", nil},
+
+		{SomeStructWithUint32FuncPtr{}, uint8(0), uint8(32), "", nil},
+		{&SomeStructWithUint32FuncPtr{}, uint8(0), uint8(32), "", nil},
+
+		{SomeStructWithUint32WithErrFunc{}, uint8(0), uint8(32), "", nil},
+		{&SomeStructWithUint32WithErrFunc{}, uint8(0), uint8(32), "", nil},
+
+		{SomeStructWithUint32WithErrFuncPtr{}, uint8(0), uint8(32), "", nil},
+		{&SomeStructWithUint32WithErrFuncPtr{}, uint8(0), uint8(32), "", nil},
+
+		{SomeStructWithUint64Func{}, uint8(0), uint8(64), "", nil},
+		{&SomeStructWithUint64Func{}, uint8(0), uint8(64), "", nil},
+
+		{SomeStructWithUint64FuncPtr{}, uint8(0), uint8(64), "", nil},
+		{&SomeStructWithUint64FuncPtr{}, uint8(0), uint8(64), "", nil},
+
+		{SomeStructWithUint64WithErrFunc{}, uint8(0), uint8(64), "", nil},
+		{&SomeStructWithUint64WithErrFunc{}, uint8(0), uint8(64), "", nil},
+
+		{SomeStructWithUint64WithErrFuncPtr{}, uint8(0), uint8(64), "", nil},
+		{&SomeStructWithUint64WithErrFuncPtr{}, uint8(0), uint8(64), "", nil},
 	}
 
 	for i, test := range tests {
diff --git a/uint_test.go b/uint_test.go
index 9e65aff..cb7d0ac 100644
--- a/uint_test.go
+++ b/uint_test.go
@@ -76,6 +76,66 @@ func TestUint(t *testing.T) {
 		// time
 		{time.Unix(10, 10), uint(10), uint(10), "", nil},
 
+		{SomeStructWithIntFunc{}, uint(0), uint(8), "", nil},
+		{&SomeStructWithIntFunc{}, uint(0), uint(8), "", nil},
+
+		{SomeStructWithIntFuncPtr{}, uint(0), uint(8), "", nil},
+		{&SomeStructWithIntFuncPtr{}, uint(0), uint(8), "", nil},
+
+		{SomeStructWithIntWithErrFunc{}, uint(0), uint(8), "", nil},
+		{&SomeStructWithIntWithErrFunc{}, uint(0), uint(8), "", nil},
+
+		{SomeStructWithIntWithErrFuncPtr{}, uint(0), uint(8), "", nil},
+		{&SomeStructWithIntWithErrFuncPtr{}, uint(0), uint(8), "", nil},
+
+		{SomeStructWithInt8Func{}, uint(0), uint(8), "", nil},
+		{&SomeStructWithInt8Func{}, uint(0), uint(8), "", nil},
+
+		{SomeStructWithInt8FuncPtr{}, uint(0), uint(8), "", nil},
+		{&SomeStructWithInt8FuncPtr{}, uint(0), uint(8), "", nil},
+
+		{SomeStructWithInt8WithErrFunc{}, uint(0), uint(8), "", nil},
+		{&SomeStructWithInt8WithErrFunc{}, uint(0), uint(8), "", nil},
+
+		{SomeStructWithInt8WithErrFuncPtr{}, uint(0), uint(8), "", nil},
+		{&SomeStructWithInt8WithErrFuncPtr{}, uint(0), uint(8), "", nil},
+
+		{SomeStructWithInt16Func{}, uint(0), uint(16), "", nil},
+		{&SomeStructWithInt16Func{}, uint(0), uint(16), "", nil},
+
+		{SomeStructWithInt16FuncPtr{}, uint(0), uint(16), "", nil},
+		{&SomeStructWithInt16FuncPtr{}, uint(0), uint(16), "", nil},
+
+		{SomeStructWithInt16WithErrFunc{}, uint(0), uint(16), "", nil},
+		{&SomeStructWithInt16WithErrFunc{}, uint(0), uint(16), "", nil},
+
+		{SomeStructWithInt16WithErrFuncPtr{}, uint(0), uint(16), "", nil},
+		{&SomeStructWithInt16WithErrFuncPtr{}, uint(0), uint(16), "", nil},
+
+		{SomeStructWithInt32Func{}, uint(0), uint(32), "", nil},
+		{&SomeStructWithInt32Func{}, uint(0), uint(32), "", nil},
+
+		{SomeStructWithInt32FuncPtr{}, uint(0), uint(32), "", nil},
+		{&SomeStructWithInt32FuncPtr{}, uint(0), uint(32), "", nil},
+
+		{SomeStructWithInt32WithErrFunc{}, uint(0), uint(32), "", nil},
+		{&SomeStructWithInt32WithErrFunc{}, uint(0), uint(32), "", nil},
+
+		{SomeStructWithInt32WithErrFuncPtr{}, uint(0), uint(32), "", nil},
+		{&SomeStructWithInt32WithErrFuncPtr{}, uint(0), uint(32), "", nil},
+
+		{SomeStructWithInt64Func{}, uint(0), uint(64), "", nil},
+		{&SomeStructWithInt64Func{}, uint(0), uint(64), "", nil},
+
+		{SomeStructWithInt64FuncPtr{}, uint(0), uint(64), "", nil},
+		{&SomeStructWithInt64FuncPtr{}, uint(0), uint(64), "", nil},
+
+		{SomeStructWithInt64WithErrFunc{}, uint(0), uint(64), "", nil},
+		{&SomeStructWithInt64WithErrFunc{}, uint(0), uint(64), "", nil},
+
+		{SomeStructWithInt64WithErrFuncPtr{}, uint(0), uint(64), "", nil},
+		{&SomeStructWithInt64WithErrFuncPtr{}, uint(0), uint(64), "", nil},
+
 		{SomeStructWithUintFunc{}, uint(0), uint(16), "", nil},
 		{&SomeStructWithUintFunc{}, uint(0), uint(16), "", nil},
 
@@ -87,6 +147,54 @@ func TestUint(t *testing.T) {
 
 		{SomeStructWithUintWithErrFuncPtr{}, uint(0), uint(16), "", nil},
 		{&SomeStructWithUintWithErrFuncPtr{}, uint(0), uint(16), "", nil},
+
+		{SomeStructWithUint8Func{}, uint(0), uint(8), "", nil},
+		{&SomeStructWithUint8Func{}, uint(0), uint(8), "", nil},
+
+		{SomeStructWithUint8FuncPtr{}, uint(0), uint(8), "", nil},
+		{&SomeStructWithUint8FuncPtr{}, uint(0), uint(8), "", nil},
+
+		{SomeStructWithUint8WithErrFunc{}, uint(0), uint(8), "", nil},
+		{&SomeStructWithUint8WithErrFunc{}, uint(0), uint(8), "", nil},
+
+		{SomeStructWithUint8WithErrFuncPtr{}, uint(0), uint(8), "", nil},
+		{&SomeStructWithUint8WithErrFuncPtr{}, uint(0), uint(8), "", nil},
+
+		{SomeStructWithUint16Func{}, uint(0), uint(16), "", nil},
+		{&SomeStructWithUint16Func{}, uint(0), uint(16), "", nil},
+
+		{SomeStructWithUint16FuncPtr{}, uint(0), uint(16), "", nil},
+		{&SomeStructWithUint16FuncPtr{}, uint(0), uint(16), "", nil},
+
+		{SomeStructWithUint16WithErrFunc{}, uint(0), uint(16), "", nil},
+		{&SomeStructWithUint16WithErrFunc{}, uint(0), uint(16), "", nil},
+
+		{SomeStructWithUint16WithErrFuncPtr{}, uint(0), uint(16), "", nil},
+		{&SomeStructWithUint16WithErrFuncPtr{}, uint(0), uint(16), "", nil},
+
+		{SomeStructWithUint32Func{}, uint(0), uint(32), "", nil},
+		{&SomeStructWithUint32Func{}, uint(0), uint(32), "", nil},
+
+		{SomeStructWithUint32FuncPtr{}, uint(0), uint(32), "", nil},
+		{&SomeStructWithUint32FuncPtr{}, uint(0), uint(32), "", nil},
+
+		{SomeStructWithUint32WithErrFunc{}, uint(0), uint(32), "", nil},
+		{&SomeStructWithUint32WithErrFunc{}, uint(0), uint(32), "", nil},
+
+		{SomeStructWithUint32WithErrFuncPtr{}, uint(0), uint(32), "", nil},
+		{&SomeStructWithUint32WithErrFuncPtr{}, uint(0), uint(32), "", nil},
+
+		{SomeStructWithUint64Func{}, uint(0), uint(64), "", nil},
+		{&SomeStructWithUint64Func{}, uint(0), uint(64), "", nil},
+
+		{SomeStructWithUint64FuncPtr{}, uint(0), uint(64), "", nil},
+		{&SomeStructWithUint64FuncPtr{}, uint(0), uint(64), "", nil},
+
+		{SomeStructWithUint64WithErrFunc{}, uint(0), uint(64), "", nil},
+		{&SomeStructWithUint64WithErrFunc{}, uint(0), uint(64), "", nil},
+
+		{SomeStructWithUint64WithErrFuncPtr{}, uint(0), uint(64), "", nil},
+		{&SomeStructWithUint64WithErrFuncPtr{}, uint(0), uint(64), "", nil},
 	}
 
 	for i, test := range tests {