[QUESTION] - Is it possible to define custom functions at once and use them to parse expr without the need to pass on Compile? about expr HOT 4 OPEN

There is no mechanism that works quite like the outline you suggest above, because the compiler does not maintain state from one compile to the next. Are you concerned about performance? Code you write in go is compiled once, when you go build; expr.Compile is more like linking those already-compiled go functions into your expression, so there is little performance cost. For performance improvement on an expression that you will run many times, you can break the process into expr.Compile (once), then expr.Run (many times).

from expr.

without the need to pass on each Compile?

Why this is a problem?

from expr.

@antonmedv It's not a problem but just with some ease to add custom functions in one place and use them for any patterns we pass. For e.g.

type customFunction struct {
	funcs map[string]func(params ...any) (any, error)
	mu    *sync.RWMutex
}

var customFunctions *customFunction

func init() {
	customFunctions = &customFunction{
		funcs: make(map[string]func(params ...any) (any, error)),
		mu:    &sync.RWMutex{},
	}
}

func AddFunction(name string, handler func(params ...any) (any, error)) {
	customFunctions.mu.Lock()
	defer customFunctions.mu.Unlock()
	customFunctions.funcs[name] = handler
}

func Parse(expr string) (*vm.Program, error) {
	var opts []Option
	for name, handler := range customFunctions.funcs {
		opts = append(opts, Function(name, handler))
	}
	return Compile(expr, opts...)
}

// vm/program.go
func (program *Program) Eval(param any) (any, error) {
	return Run(program, param)
}

from expr.

It is doable of course. But I prefer the API to be more simple and straightforward, without any shared state. It is anyway possible to create such API as a wrapper for the Expr package.

from expr.