Add int() and float() builtins

Author: antonmedv

builtin/builtin.go

@@ -8,6 +8,7 @@ import (
 var (
 	anyType     = reflect.TypeOf(new(interface{})).Elem()
 	integerType = reflect.TypeOf(0)
+	floatType   = reflect.TypeOf(float64(0))
 )
 
 type Function struct {
@@ -21,6 +22,8 @@ type Function struct {
 const (
 	Len = iota + 1
 	Abs
+	Int
+	Float
 )
 
 var Builtins = []*Function{
@@ -52,4 +55,40 @@ var Builtins = []*Function{
 			return anyType, fmt.Errorf("invalid argument for abs (type %s)", args[0])
 		},
 	},
+	{
+		Name:      "int",
+		BuiltinId: Int,
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments for int (expected 1, got %d)", len(args))
+			}
+			switch args[0].Kind() {
+			case reflect.Interface:
+				return integerType, nil
+			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:
+				return integerType, nil
+			case reflect.String:
+				return integerType, nil
+			}
+			return anyType, fmt.Errorf("invalid argument for int (type %s)", args[0])
+		},
+	},
+	{
+		Name:      "float",
+		BuiltinId: Float,
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments for float (expected 1, got %d)", len(args))
+			}
+			switch args[0].Kind() {
+			case reflect.Interface:
+				return floatType, nil
+			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:
+				return floatType, nil
+			case reflect.String:
+				return floatType, nil
+			}
+			return anyType, fmt.Errorf("invalid argument for float (type %s)", args[0])
+		},
+	},
 }

builtin/builtin_test.go

@@ -16,6 +16,12 @@ var tests = []struct {
 	{`len("hello")`, 5},
 	{`abs(-5)`, 5},
 	{`abs(-.5)`, .5},
+	{`int(5.5)`, 5},
+	{`int(5)`, 5},
+	{`int("5")`, 5},
+	{`float(5)`, 5.0},
+	{`float(5.5)`, 5.5},
+	{`float("5.5")`, 5.5},
 }
 
 func TestBuiltin(t *testing.T) {
@@ -37,6 +43,10 @@ var errorTests = []struct {
 	{`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)`},
+	{`int()`, `invalid number of arguments for int (expected 1, got 0)`},
+	{`int(1, 2)`, `invalid number of arguments for int (expected 1, got 2)`},
+	{`float()`, `invalid number of arguments for float (expected 1, got 0)`},
+	{`float(1, 2)`, `invalid number of arguments for float (expected 1, got 2)`},
 }
 
 func TestBuiltinErrors(t *testing.T) {

vm/runtime/runtime.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"math"
 	"reflect"
+	"strconv"
 )
 
 func Fetch(from, i interface{}) interface{} {
@@ -325,6 +326,12 @@ func ToInt(a interface{}) int {
 		return int(x)
 	case uint64:
 		return int(x)
+	case string:
+		i, err := strconv.Atoi(x)
+		if err != nil {
+			panic(fmt.Sprintf("invalid operation: int(%s)", x))
+		}
+		return i
 	default:
 		panic(fmt.Sprintf("invalid operation: int(%T)", x))
 	}
@@ -387,8 +394,14 @@ func ToFloat64(a interface{}) float64 {
 		return float64(x)
 	case uint64:
 		return float64(x)
+	case string:
+		f, err := strconv.ParseFloat(x, 64)
+		if err != nil {
+			panic(fmt.Sprintf("invalid operation: float(%s)", x))
+		}
+		return f
 	default:
-		panic(fmt.Sprintf("invalid operation: float64(%T)", x))
+		panic(fmt.Sprintf("invalid operation: float(%T)", x))
 	}
 }
 

vm/vm.go

@@ -373,6 +373,10 @@ func (vm *VM) Run(program *Program, env interface{}) (_ interface{}, err error)
 				vm.push(runtime.Len(vm.pop()))
 			case builtin.Abs:
 				vm.push(runtime.Abs(vm.pop()))
+			case builtin.Int:
+				vm.push(runtime.ToInt(vm.pop()))
+			case builtin.Float:
+				vm.push(runtime.ToFloat64(vm.pop()))
 			}
 
 		case OpArray: