Add abs() builtin

Author: antonmedv

builtin/builtin.go

@@ -7,23 +7,98 @@ import (
 	"github.com/antonmedv/expr/vm/runtime"
 )
 
+var (
+	anyType     = reflect.TypeOf(new(interface{})).Elem()
+	integerType = reflect.TypeOf(0)
+)
+
 type Function struct {
 	Name     string
-	Func     func(params ...interface{}) (interface{}, error)
+	Func     func(args ...interface{}) (interface{}, error)
 	Types    []reflect.Type
-	Validate func(args []reflect.Type) error
+	Validate func(args []reflect.Type) (reflect.Type, error)
 }
 
 var Builtins = []*Function{
 	{
 		Name: "len",
 		Func: runtime.Len,
-		Validate: func(args []reflect.Type) error {
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments for len (expected 1, got %d)", len(args))
+			}
 			switch args[0].Kind() {
 			case reflect.Array, reflect.Map, reflect.Slice, reflect.String, reflect.Interface:
-				return nil
+				return integerType, nil
+			}
+			return anyType, fmt.Errorf("invalid argument for len (type %s)", args[0])
+		},
+	},
+	{
+		Name: "abs",
+		Func: func(args ...interface{}) (interface{}, error) {
+			x := args[0]
+			switch x.(type) {
+			case float32:
+				if x.(float32) < 0 {
+					return -x.(float32), nil
+				}
+			case float64:
+				if x.(float64) < 0 {
+					return -x.(float64), nil
+				}
+			case int:
+				if x.(int) < 0 {
+					return -x.(int), nil
+				}
+			case int8:
+				if x.(int8) < 0 {
+					return -x.(int8), nil
+				}
+			case int16:
+				if x.(int16) < 0 {
+					return -x.(int16), nil
+				}
+			case int32:
+				if x.(int32) < 0 {
+					return -x.(int32), nil
+				}
+			case int64:
+				if x.(int64) < 0 {
+					return -x.(int64), nil
+				}
+			case uint:
+				if x.(uint) < 0 {
+					return -x.(uint), nil
+				}
+			case uint8:
+				if x.(uint8) < 0 {
+					return -x.(uint8), nil
+				}
+			case uint16:
+				if x.(uint16) < 0 {
+					return -x.(uint16), nil
+				}
+			case uint32:
+				if x.(uint32) < 0 {
+					return -x.(uint32), nil
+				}
+			case uint64:
+				if x.(uint64) < 0 {
+					return -x.(uint64), nil
+				}
+			}
+			return nil, fmt.Errorf("invalid argument for abs (type %T)", x)
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments for abs (expected 1, got %d)", len(args))
+			}
+			switch args[0].Kind() {
+			case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Interface:
+				return args[0], nil
 			}
-			return fmt.Errorf("invalid argument for len (type %s)", args[0])
+			return anyType, fmt.Errorf("invalid argument for abs (type %s)", args[0])
 		},
 	},
 }

builtin/builtin_test.go

@@ -0,0 +1,50 @@
+package builtin_test
+
+import (
+	"testing"
+
+	"github.com/antonmedv/expr"
+	"github.com/stretchr/testify/assert"
+)
+
+var tests = []struct {
+	input string
+	want  interface{}
+}{
+	{`len(1..10)`, 10},
+	{`len({foo: 1, bar: 2})`, 2},
+	{`len("hello")`, 5},
+	{`abs(-5)`, 5},
+	{`abs(-.5)`, .5},
+}
+
+func TestBuiltin(t *testing.T) {
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
+			out, err := expr.Eval(test.input, nil)
+			assert.NoError(t, err)
+			assert.Equal(t, test.want, out)
+		})
+	}
+}
+
+var errorTests = []struct {
+	input string
+	err   string
+}{
+	{`len()`, `invalid number of arguments for len (expected 1, got 0)`},
+	{`len(1)`, `invalid argument for len (type int)`},
+	{`abs()`, `invalid number of arguments for abs (expected 1, got 0)`},
+	{`abs(1, 2)`, `invalid number of arguments for abs (expected 1, got 2)`},
+	{`abs("foo")`, `invalid argument for abs (type string)`},
+}
+
+func TestBuiltinErrors(t *testing.T) {
+	for _, test := range errorTests {
+		t.Run(test.input, func(t *testing.T) {
+			_, err := expr.Eval(test.input, nil)
+			assert.Error(t, err)
+			assert.Contains(t, err.Error(), test.err)
+		})
+	}
+}

checker/checker.go

@@ -480,9 +480,11 @@ func (v *visitor) CallNode(node *ast.CallNode) (reflect.Type, info) {
 			for i, arg := range node.Arguments {
 				args[i], _ = v.visit(arg)
 			}
-			if err := f.Validate(args); err != nil {
+			t, err := f.Validate(args)
+			if err != nil {
 				return v.error(node, "%v", err)
 			}
+			return t, info{}
 		}
 		if len(f.Types) == 0 {
 			t, err := v.checkFunc(f.Name, functionType, false, node)