fix builtin signatures

core/types.go

@@ -357,6 +357,26 @@ func (s *CompositeSignature) String() string {
 	return fmt.Sprintf("%s|%s", s.A, s.B)
 }
 
+func quickComposite(a ...TypeSignature) TypeSignature {
+	switch len(a) {
+	case 0:
+		panic("quick composite: empty array")
+	case 1:
+		return a[0]
+	}
+
+	s := a[0]
+	for i := 1; i < len(a); i++ {
+		v := a[i]
+		s = &CompositeSignature{
+			A: s,
+			B: v,
+		}
+	}
+
+	return s
+}
+
 type InnerSignature struct{}
 
 func (*InnerSignature) Type() Type {

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{}},
+			[]TypeSignature{
-			&CompositeSignature{
+				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
 		},