Add type() builtin

Author: antonmedv

builtin/builtin.go

@@ -48,6 +48,11 @@ var Builtins = []*Function{
 			return anyType, fmt.Errorf("invalid argument for len (type %s)", args[0])
 		},
 	},
+	{
+		Name:     "type",
+		Builtin1: Type,
+		Types:    types(new(func(interface{}) string)),
+	},
 	{
 		Name:     "abs",
 		Builtin1: Abs,

builtin/builtin_test.go

@@ -289,3 +289,43 @@ func TestBuiltin_EnableBuiltin(t *testing.T) {
 		assert.Equal(t, 6, out)
 	})
 }
+
+func TestBuiltin_type(t *testing.T) {
+	type Foo struct{}
+	var b interface{} = 1
+	var a interface{} = &b
+	tests := []struct {
+		obj  interface{}
+		want string
+	}{
+		{nil, "nil"},
+		{true, "bool"},
+		{1, "int"},
+		{int8(1), "int"},
+		{uint(1), "uint"},
+		{1.0, "float"},
+		{float32(1.0), "float"},
+		{"string", "string"},
+		{[]string{"foo", "bar"}, "array"},
+		{map[string]interface{}{"foo": "bar"}, "map"},
+		{func() {}, "func"},
+		{time.Now(), "time.Time"},
+		{time.Second, "time.Duration"},
+		{Foo{}, "github.com/antonmedv/expr/builtin_test.Foo"},
+		{struct{}{}, "struct"},
+		{a, "int"},
+	}
+	for _, test := range tests {
+		t.Run(test.want, func(t *testing.T) {
+			env := map[string]interface{}{
+				"obj": test.obj,
+			}
+			program, err := expr.Compile(`type(obj)`, expr.Env(env))
+			require.NoError(t, err)
+
+			out, err := expr.Run(program, env)
+			require.NoError(t, err)
+			assert.Equal(t, test.want, out)
+		})
+	}
+}

builtin/func.go

@@ -18,6 +18,48 @@ func Len(x interface{}) interface{} {
 	}
 }
 
+func Type(arg interface{}) interface{} {
+	if arg == nil {
+		return "nil"
+	}
+	v := reflect.ValueOf(arg)
+	for {
+		if v.Kind() == reflect.Ptr {
+			v = v.Elem()
+		} else if v.Kind() == reflect.Interface {
+			v = v.Elem()
+		} else {
+			break
+		}
+	}
+	if v.Type().Name() != "" && v.Type().PkgPath() != "" {
+		return fmt.Sprintf("%s.%s", v.Type().PkgPath(), v.Type().Name())
+	}
+	switch v.Type().Kind() {
+	case reflect.Invalid:
+		return "invalid"
+	case reflect.Bool:
+		return "bool"
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return "int"
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return "uint"
+	case reflect.Float32, reflect.Float64:
+		return "float"
+	case reflect.String:
+		return "string"
+	case reflect.Array, reflect.Slice:
+		return "array"
+	case reflect.Map:
+		return "map"
+	case reflect.Func:
+		return "func"
+	case reflect.Struct:
+		return "struct"
+	}
+	return "unknown"
+}
+
 func Abs(x interface{}) interface{} {
 	switch x.(type) {
 	case float32:

builtin/utils.go

@@ -8,6 +8,7 @@ var (
 	anyType     = reflect.TypeOf(new(interface{})).Elem()
 	integerType = reflect.TypeOf(0)
 	floatType   = reflect.TypeOf(float64(0))
+	stringType  = reflect.TypeOf("")
 	arrayType   = reflect.TypeOf([]interface{}{})
 )
 

docs/Language-Definition.md

@@ -237,6 +237,19 @@ len(filter(array, predicate))
 
 Returns the length of an array, a map or a string.
 
+### type(v)
+
+Returns the type of the given value `v`.
+Returns on of the following types: `nil`, `bool`, `int`, `uint`, `float`, `string`, `array`, `map`.
+For named types and structs, the type name is returned.
+
+
+```expr
+type(42) == "int"
+type("hello") == "string"
+type(now()) == "time.Time"
+```
+
 ### abs(v)
 
 Returns the absolute value of a number.

test/coredns/coredns_test.go

@@ -25,7 +25,7 @@ func TestCoreDNS(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
-			_, err := expr.Compile(test.input, expr.Env(env))
+			_, err := expr.Compile(test.input, expr.Env(env), expr.DisableBuiltin("type"))
 			assert.NoError(t, err)
 		})
 	}