fix builtin signatures

core/vm.go

@@ -549,7 +549,13 @@ var DefaultGlobals = map[string]Value{
 	"int": &BuiltinFunctionValue{
 		"int",
 		&FunctionSignature{
-			[]TypeSignature{&AnySignature{}},
+			[]TypeSignature{
+				quickComposite(
+					&IntegerSignature{},
+					&FloatSignature{},
+					&StringSignature{},
+				),
+			},
 			&CompositeSignature{
 				&IntegerSignature{},
 				&NilSignature{},
@@ -570,7 +576,7 @@ var DefaultGlobals = map[string]Value{
 
 				return &IntegerValue{n}, nil
 			default:
-				return nil, errors.New(fmt.Sprintf("%s cannot become an integer", v))
+				return nil, errors.New(fmt.Sprintf("%s cannot become an integer (undefined)", v))
 			}
 		},
 		nil,
@@ -579,19 +585,25 @@ var DefaultGlobals = map[string]Value{
 	"float": &BuiltinFunctionValue{
 		"float",
 		&FunctionSignature{
-			[]TypeSignature{&AnySignature{}},
-			&CompositeSignature{
+			[]TypeSignature{
+				quickComposite(
+					&FloatSignature{},
+					&IntegerSignature{},
+					&StringSignature{},
+				),
+			},
+			quickComposite(
 				&FloatSignature{},
 				&NilSignature{},
-			},
+			),
 		},
 		func(vm *VM, _ Value, args []Value) (Value, error) {
 			switch v := args[0].(type) {
 			case *IntegerValue:
 				n, _ := v.Number.Float64()
-				return &FloatValue{n}, nil // this might need to clone the value instead
+				return &FloatValue{n}, nil
 			case *FloatValue:
-				return &FloatValue{v.Number}, nil
+				return v.Clone(), nil
 			case *StringValue:
 				num, err := strconv.ParseFloat(v.Text, FloatSize)
 				if err != nil {
@@ -600,7 +612,7 @@ var DefaultGlobals = map[string]Value{
 
 				return &FloatValue{num}, nil
 			default:
-				return nil, errors.New(fmt.Sprintf("%s cannot become an integer", v))
+				return nil, errors.New(fmt.Sprintf("%s cannot become an integer (undefined)", v))
 			}
 		},
 		nil,
@@ -660,12 +672,12 @@ var DefaultGlobals = map[string]Value{
 	"roundd": &BuiltinFunctionValue{
 		"roundd",
 		&FunctionSignature{
-			[]TypeSignature{&FloatSignature{}, &FloatSignature{}},
+			[]TypeSignature{&FloatSignature{}, &IntegerSignature{}},
 			&FloatSignature{},
 		},
 		func(vm *VM, this Value, args []Value) (Value, error) {
 			x := args[0].(*FloatValue).Number
-			decimals := args[1].(*FloatValue).Number
+			decimals, _ := args[1].(*IntegerValue).Number.Float64()
 			multiplier := math.Pow(10, decimals)
 			return &FloatValue{math.Round(x*multiplier) / multiplier}, nil
 		},