How to efficiently create large env for expression evaluation

[purplefox]

I have a large number of built-in functions in my env - these are always present for every expression. I also have a smaller number of variables that I add to the env which are specific to the evaluation.

Right now, I have to copy all the built-in functions into a fresh env, and then add the specific variables on every evaluation. This is quite expensive as there are many entries in the built-in functions map.

I was wondering if there was a more efficient way of doing this? E.g. have some kind of global env I could pass in (with the built-in functions) along with a separate invocation scoped env. This would avoid copying the global env each time.

[antonmedv]

This is quite expensive

Not sure I get why? Try to use expr.Function() and only links will be copied.

[purplefox]

Perhaps I have misunderstood how envs and options are passed to expr.

Right now I have a map which contains all my functions, there could be hundreds of these. I pass that map as the env into the compile step, but it seems I also have to pass it in as an env into the evaluate step too. At least, I tried not doing that and it complained about not finding the function. Unfortunately I can't pass the same instance of the global map in to evaluate as there are also a smaller number of invocation scoped variables which also have to be passed in. So I end up with copying the entire big map into the invocation scoped env - this means creating a new map and iterating through the hundreds of entries and adding them to the invocation scoped env. Seeing this has to be done on every invocation of a function that could be in an inner loop, it seems quite an overhead?

I just played around with your suggestion of using expr.Function. It seems that if I do this then the functions only need to be defined at the compile step, and don't need to be passed in at evaluation time. This seems what I want :) However I don't quite understand why function definitions are required at eval time too when using an env.

[antonmedv]

This is a good idea. Functions from env can be the safe same way as expr.Function.

But it will break the use case with "dummy" func in compile step:

    env := map[string]interface{}{
        "sprintf": new(func (s string, param any) string),
    }

    program, err := expr.Compile(code, expr.Env(env))
    if err != nil {
        panic(err)
    }


    env := map[string]interface{}{
        "sprintf": fmt.Sprintf,
    }

    output, err := expr.Run(program, env)
    if err != nil {
        panic(err)
    }

    fmt.Print(output)