Function init

lang/funcs/operators/operators.go:58–587

()

)

func init() {
	info := &simple.Info{
		Pure: true,
		Memo: true,
		Fast: true,
		Spec: true,
	}
	RegisterOperator("+", &simple.Scaffold{
		I: info,
		T: types.NewType("func(?1, ?1) ?1"),
		C: simple.TypeMatch([]string{
			"func(str, str) str",       // concatenation
			"func(int, int) int",       // addition
			"func(float, float) float", // floating-point addition
		}),
		F: func(ctx context.Context, input []types.Value) (types.Value, error) {
			if l := len(input); l != 2 { // catch programming bugs
				return nil, fmt.Errorf("invalid len %d", l)
			}
			// Both args should be the same type for this function.
			if err := input[0].Type().Cmp(input[1].Type()); err != nil {
				// This check is required because of speculation.
				// Perhaps a bug in our earlier speculation code?
				return nil, errwrap.Wrapf(err, "invalid arg types")
				// TODO: speculation error instead?
				//return nil, funcs.ErrCantSpeculate
			}

			switch k := input[0].Type().Kind; k {
			case types.KindStr:
				return &types.StrValue{
					V: input[0].Str() + input[1].Str(),
				}, nil

			case types.KindInt:
				// FIXME: check for overflow?
				return &types.IntValue{
					V: input[0].Int() + input[1].Int(),
				}, nil

			case types.KindFloat:
				return &types.FloatValue{
					V: input[0].Float() + input[1].Float(),
				}, nil

			default:
				return nil, fmt.Errorf("unsupported kind: %+v", k)
			}
		},
	})

	RegisterOperator("-", &simple.Scaffold{
		I: info,
		T: types.NewType("func(?1, ?1) ?1"),
		C: simple.TypeMatch([]string{
			"func(int, int) int",       // subtraction
			"func(float, float) float", // floating-point subtraction
		}),