Replace "Functions" return type from ExprFunc to interface/struct

[bogdandrutu]

Describe the issue you're reporting

Currently ExprFunc is a concrete type type ExprFunc[K any] func(ctx K) interface{}. This does not allow us to extend the functionality in the future (as defined currently). Proposal is to replace this with an interface or a struct that allows us to extend the functionality/capabilities in the future.

If we use interface we can define optional interfaces in the future that we can extend. If we use a struct, we can add more members or extend that. Here is the struct example:

type ExprFunc[K any] func(K) interface{}

func (f ExprFunc) Exec(ctx K) {
  f(ctx)
}

type Expr struct {
   ExprFunc
   // In the future we can add more members that have different capabilities/options to this.
}

[TylerHelmuth]

@bogdandrutu in this situation

type Expr[K any] struct {
  ExprFunc[K]
}

func (e Expr[K]) Eval(ctx context.Context, tCtx K) {
  return e.ExprFunc(ctx, tCtx)
}

type ExprFunc[K any] func(ctx context.Context, tCtx K) (interface{}, error)

can't we get away without the Eval function and instead do

var x Expr[K]
x.ExprFunc(...)

If Eval is providing something that I'm missing I'd prefer to unexport ExprFunc so that users can't see both Eval and ExprFunc on the Expr[K] struct.

Unxporting ExprFunc means functions need to create an Expr[K] via a New function. If the only field on the Expr[K] struct is ever going to be an ExprFunc, then we could do.

func NewExpr[K any](f exprFunc[K]) Expr[K] {
	return Expr[K]{f}
}

func Concat[K any](vals []ottl.Getter[K], delimiter string) (ottl.Expr[K], error) {
	return ottl.NewExpr[K](func(ctx context.Context, tCtx K) interface{} {
		builder := strings.Builder{}
		for i, rv := range vals {
			switch val := rv.Get(ctx, tCtx).(type) {
			case string:
				builder.WriteString(val)
			case []byte:
				builder.WriteString(fmt.Sprintf("%x", val))
			case int64:
				builder.WriteString(fmt.Sprint(val))
			case float64:
				builder.WriteString(fmt.Sprint(val))
			case bool:
				builder.WriteString(fmt.Sprint(val))
			case nil:
				builder.WriteString(fmt.Sprint(val))
			}

			if i != len(vals)-1 {
				builder.WriteString(delimiter)
			}
		}
		return builder.String()
	}), nil
}

[bogdandrutu]

Can you summarize the proposal in one comment, hard to follow :)

[TylerHelmuth]

@bogdandrutu summarized.

[TylerHelmuth]

Ended up going with a simpler approach that my above comments. opening PR shortly