feat: add alias resolution

Signed-off-by: Mark Sagi-Kazar <[email protected]>

Author: sagikazarmark

basic.go

@@ -58,6 +58,10 @@ func ToBoolE(i any) (bool, error) {
 
 		return false, fmt.Errorf(errorMsg, i, i, false)
 	default:
+		if i, ok := resolveAlias(i); ok {
+			return ToBoolE(i)
+		}
+
 		return false, fmt.Errorf(errorMsg, i, i, false)
 	}
 }
@@ -114,7 +118,11 @@ func ToStringE(i any) (string, error) {
 	case error:
 		return s.Error(), nil
 	default:
-		if i, ok := indirect(s); ok {
+		if i, ok := indirect(i); ok {
+			return ToStringE(i)
+		}
+
+		if i, ok := resolveAlias(i); ok {
 			return ToStringE(i)
 		}
 

basic_test.go

@@ -77,6 +77,10 @@ func TestBool(t *testing.T) {
 		{int32(-1), true, false},
 		{int64(-1), true, false},
 
+		// Alias
+		{MyBool(true), true, false},
+		{MyBool(false), false, false},
+
 		// Failure cases
 		{"test", false, true},
 		{testing.T{}, false, true},
@@ -124,6 +128,10 @@ func TestString(t *testing.T) {
 		{template.CSS("a"), "a", false},
 		{template.HTMLAttr("a"), "a", false},
 
+		// Alias
+		{MyString("foo"), "foo", false},
+
+		// Stringer and error
 		{foo{val: "bar"}, "bar", false},
 		{fu{val: "bar"}, "bar", false},
 

cast_test.go

@@ -223,3 +223,19 @@ func BenchmarkCast(b *testing.B) {
 		}
 	})
 }
+
+// Alias types for alias testing
+type MyString string
+type MyBool bool
+type MyInt int
+type MyInt8 int8
+type MyInt16 int16
+type MyInt32 int32
+type MyInt64 int64
+type MyUint uint
+type MyUint8 uint8
+type MyUint16 uint16
+type MyUint32 uint32
+type MyUint64 uint64
+type MyFloat32 float32
+type MyFloat64 float64

number.go

@@ -183,6 +183,10 @@ func toNumberE[T Number](i any, parseFn func(string) (T, error)) (T, error) {
 
 		return T(s.Float64()), nil
 	default:
+		if i, ok := resolveAlias(i); ok {
+			return toNumberE(i, parseFn)
+		}
+
 		return 0, fmt.Errorf(errorMsg, i, i, n)
 	}
 }
@@ -333,6 +337,10 @@ func toUnsignedNumberE[T Number](i any, parseFn func(string) (T, error)) (T, err
 
 		return T(v), nil
 	default:
+		if i, ok := resolveAlias(i); ok {
+			return toUnsignedNumberE(i, parseFn)
+		}
+
 		return 0, fmt.Errorf(errorMsg, i, i, n)
 	}
 }

number_test.go

@@ -47,7 +47,7 @@ var numberContexts = map[string]numberContext{
 		generic:     toAny(cast.ToNumber[int]),
 		specificErr: toAnyErr(cast.ToIntE),
 		genericErr:  toAnyErr(cast.ToNumberE[int]),
-		samples:     []any{int(0), int(1), int(8), int(-8), int(8), int(-8), math.MinInt, math.MaxInt, new(big.Int).Sub(big.NewInt(math.MinInt), big.NewInt(1)).String(), new(big.Int).Add(big.NewInt(math.MaxInt), big.NewInt(1)).String()},
+		samples:     []any{int(0), int(1), int(8), int(-8), int(8), int(-8), MyInt(8), math.MinInt, math.MaxInt, new(big.Int).Sub(big.NewInt(math.MinInt), big.NewInt(1)).String(), new(big.Int).Add(big.NewInt(math.MaxInt), big.NewInt(1)).String()},
 	},
 	"int8": {
 		to:          toAny(cast.To[int8]),
@@ -56,7 +56,7 @@ var numberContexts = map[string]numberContext{
 		generic:     toAny(cast.ToNumber[int8]),
 		specificErr: toAnyErr(cast.ToInt8E),
 		genericErr:  toAnyErr(cast.ToNumberE[int8]),
-		samples:     []any{int8(0), int8(1), int8(8), int8(-8), int8(8), int8(-8), int8(math.MinInt8), int8(math.MaxInt8), "-129", "128"},
+		samples:     []any{int8(0), int8(1), int8(8), int8(-8), int8(8), int8(-8), MyInt8(8), int8(math.MinInt8), int8(math.MaxInt8), "-129", "128"},
 	},
 	"int16": {
 		to:          toAny(cast.To[int16]),
@@ -65,7 +65,7 @@ var numberContexts = map[string]numberContext{
 		generic:     toAny(cast.ToNumber[int16]),
 		specificErr: toAnyErr(cast.ToInt16E),
 		genericErr:  toAnyErr(cast.ToNumberE[int16]),
-		samples:     []any{int16(0), int16(1), int16(8), int16(-8), int16(8), int16(-8), int16(math.MinInt16), int16(math.MaxInt16), "-32769", "32768"},
+		samples:     []any{int16(0), int16(1), int16(8), int16(-8), int16(8), int16(-8), MyInt16(8), int16(math.MinInt16), int16(math.MaxInt16), "-32769", "32768"},
 	},
 	"int32": {
 		to:          toAny(cast.To[int32]),
@@ -74,7 +74,7 @@ var numberContexts = map[string]numberContext{
 		generic:     toAny(cast.ToNumber[int32]),
 		specificErr: toAnyErr(cast.ToInt32E),
 		genericErr:  toAnyErr(cast.ToNumberE[int32]),
-		samples:     []any{int32(0), int32(1), int32(8), int32(-8), int32(8), int32(-8), int32(math.MinInt32), int32(math.MaxInt32), "-2147483649", "2147483648"},
+		samples:     []any{int32(0), int32(1), int32(8), int32(-8), int32(8), int32(-8), MyInt32(8), int32(math.MinInt32), int32(math.MaxInt32), "-2147483649", "2147483648"},
 	},
 	"int64": {
 		to:          toAny(cast.To[int64]),
@@ -83,7 +83,7 @@ var numberContexts = map[string]numberContext{
 		generic:     toAny(cast.ToNumber[int64]),
 		specificErr: toAnyErr(cast.ToInt64E),
 		genericErr:  toAnyErr(cast.ToNumberE[int64]),
-		samples:     []any{int64(0), int64(1), int64(8), int64(-8), int64(8), int64(-8), int64(math.MinInt64), int64(math.MaxInt64), "-9223372036854775809", "9223372036854775808"},
+		samples:     []any{int64(0), int64(1), int64(8), int64(-8), int64(8), int64(-8), MyInt64(8), int64(math.MinInt64), int64(math.MaxInt64), "-9223372036854775809", "9223372036854775808"},
 	},
 	"uint": {
 		to:          toAny(cast.To[uint]),
@@ -92,7 +92,7 @@ var numberContexts = map[string]numberContext{
 		generic:     toAny(cast.ToNumber[uint]),
 		specificErr: toAnyErr(cast.ToUintE),
 		genericErr:  toAnyErr(cast.ToNumberE[uint]),
-		samples:     []any{uint(0), uint(1), uint(8), uint(0), uint(8), uint(0), uint(0), uint(math.MaxUint), nil, nil},
+		samples:     []any{uint(0), uint(1), uint(8), uint(0), uint(8), uint(0), MyUint(8), uint(0), uint(math.MaxUint), nil, nil},
 	},
 	"uint8": {
 		to:          toAny(cast.To[uint8]),
@@ -101,7 +101,7 @@ var numberContexts = map[string]numberContext{
 		generic:     toAny(cast.ToNumber[uint8]),
 		specificErr: toAnyErr(cast.ToUint8E),
 		genericErr:  toAnyErr(cast.ToNumberE[uint8]),
-		samples:     []any{uint8(0), uint8(1), uint8(8), uint8(0), uint8(8), uint8(0), uint8(0), uint8(math.MaxUint8), "-1", "256"},
+		samples:     []any{uint8(0), uint8(1), uint8(8), uint8(0), uint8(8), uint8(0), MyUint8(8), uint8(0), uint8(math.MaxUint8), "-1", "256"},
 	},
 	"uint16": {
 		to:          toAny(cast.To[uint16]),
@@ -110,7 +110,7 @@ var numberContexts = map[string]numberContext{
 		generic:     toAny(cast.ToNumber[uint16]),
 		specificErr: toAnyErr(cast.ToUint16E),
 		genericErr:  toAnyErr(cast.ToNumberE[uint16]),
-		samples:     []any{uint16(0), uint16(1), uint16(8), uint16(0), uint16(8), uint16(0), uint16(0), uint16(math.MaxUint16), "-1", "65536"},
+		samples:     []any{uint16(0), uint16(1), uint16(8), uint16(0), uint16(8), uint16(0), MyUint16(8), uint16(0), uint16(math.MaxUint16), "-1", "65536"},
 	},
 	"uint32": {
 		to:          toAny(cast.To[uint32]),
@@ -119,7 +119,7 @@ var numberContexts = map[string]numberContext{
 		generic:     toAny(cast.ToNumber[uint32]),
 		specificErr: toAnyErr(cast.ToUint32E),
 		genericErr:  toAnyErr(cast.ToNumberE[uint32]),
-		samples:     []any{uint32(0), uint32(1), uint32(8), uint32(0), uint32(8), uint32(0), uint32(0), uint32(math.MaxUint32), "-1", "4294967296"},
+		samples:     []any{uint32(0), uint32(1), uint32(8), uint32(0), uint32(8), uint32(0), MyUint32(8), uint32(0), uint32(math.MaxUint32), "-1", "4294967296"},
 	},
 	"uint64": {
 		to:          toAny(cast.To[uint64]),
@@ -128,7 +128,7 @@ var numberContexts = map[string]numberContext{
 		generic:     toAny(cast.ToNumber[uint64]),
 		specificErr: toAnyErr(cast.ToUint64E),
 		genericErr:  toAnyErr(cast.ToNumberE[uint64]),
-		samples:     []any{uint64(0), uint64(1), uint64(8), uint64(0), uint64(8), uint64(0), uint64(0), uint64(math.MaxUint64), "-1", "18446744073709551616"},
+		samples:     []any{uint64(0), uint64(1), uint64(8), uint64(0), uint64(8), uint64(0), MyUint64(8), uint64(0), uint64(math.MaxUint64), "-1", "18446744073709551616"},
 	},
 	"float32": {
 		to:          toAny(cast.To[float32]),
@@ -137,7 +137,7 @@ var numberContexts = map[string]numberContext{
 		generic:     toAny(cast.ToNumber[float32]),
 		specificErr: toAnyErr(cast.ToFloat32E),
 		genericErr:  toAnyErr(cast.ToNumberE[float32]),
-		samples:     []any{float32(0), float32(1), float32(8), float32(-8), float32(8.31), float32(-8.31), float32(-math.MaxFloat32), float32(math.MaxFloat32), nil, nil},
+		samples:     []any{float32(0), float32(1), float32(8), float32(-8), float32(8.31), float32(-8.31), MyFloat32(8), float32(-math.MaxFloat32), float32(math.MaxFloat32), nil, nil},
 	},
 	"float64": {
 		to:          toAny(cast.To[float64]),
@@ -146,7 +146,7 @@ var numberContexts = map[string]numberContext{
 		generic:     toAny(cast.ToNumber[float64]),
 		specificErr: toAnyErr(cast.ToFloat64E),
 		genericErr:  toAnyErr(cast.ToNumberE[float64]),
-		samples:     []any{float64(0), float64(1), float64(8), float64(-8), float64(8.31), float64(-8.31), float64(-math.MaxFloat64), float64(math.MaxFloat64), nil, nil},
+		samples:     []any{float64(0), float64(1), float64(8), float64(-8), float64(8.31), float64(-8.31), MyFloat64(8), float64(-math.MaxFloat64), float64(math.MaxFloat64), nil, nil},
 	},
 }
 
@@ -157,10 +157,11 @@ func generateNumberTestCases(samples []any) []testCase {
 	eightNegative := samples[3]
 	eightPoint31 := samples[4]
 	eightPoint31Negative := samples[5]
-	min := samples[6]
-	max := samples[7]
-	underflowString := samples[8]
-	overflowString := samples[9]
+	aliasEight := samples[6]
+	min := samples[7]
+	max := samples[8]
+	underflowString := samples[9]
+	overflowString := samples[10]
 
 	_ = min
 	_ = max
@@ -222,6 +223,11 @@ func generateNumberTestCases(samples []any) []testCase {
 		{json.Number("-8.31"), eightPoint31Negative, isUint},
 		{json.Number(""), zero, false},
 
+		// Aliases
+		{aliasEight, eight, false},
+		{MyString("8"), eight, false},
+		{MyBool(true), one, false},
+
 		// Failure cases
 		{"test", zero, true},
 		{testing.T{}, zero, true},

time.go

@@ -88,6 +88,10 @@ func ToDurationE(i any) (time.Duration, error) {
 
 		return time.ParseDuration(s)
 	default:
+		if i, ok := resolveAlias(i); ok {
+			return ToDurationE(i)
+		}
+
 		return 0, fmt.Errorf(errorMsg, i, i, time.Duration(0))
 	}
 }

time_test.go

@@ -66,6 +66,8 @@ func TestTime(t *testing.T) {
 }
 
 func TestDuration(t *testing.T) {
+	type MyDuration time.Duration
+
 	var expected time.Duration = 5
 
 	testCases := []testCase{
@@ -92,6 +94,11 @@ func TestDuration(t *testing.T) {
 		{string("5m"), time.Minute * expected, false},
 		{string("5h"), time.Hour * expected, false},
 
+		// Aliases
+		{MyInt(5), expected, false},
+		{MyString("5"), expected, false},
+		{MyDuration(5), expected, false},
+
 		// Failure cases
 		{"test", time.Duration(0), true},
 		{testing.T{}, time.Duration(0), true},