Hi, I’m relatively new to Julia but feel like I’m mostly getting the hang of it.

I have a project where I need to parse a large number of arbitrary expressions (e.g. ax^b, a+bx^2, etc.) into a function, but I’m running into significant performance issues with my current implementation. My implementation involves generating an array of anonymous functions which are then parsed into the main function and evaluated, but this evaluation is much slower than if the expressions are explicitly defined in the main function.

A minimal example is as follows (note that this example only involves one form of expression, to allow for the comparison with the explicit definition):

```
using BenchmarkTools
coefficients = rand(1000)
exponents = rand(1000)
y = zeros(1000)
functions = []
for i in 1:1000
push!(functions, x -> coefficients[i]*x^exponents[i])
end
function callfunc(functions,x,y)
for i in 1:1000
y[i] = functions[i](x)
end
end
function explicitfunc(coefficients,exponents,x,y)
for i in 1:1000
y[i] = coefficients[i]*x^exponents[i]
end
end
@btime callfunc(functions,1.23,y)
@btime explicitfunc(coefficients,exponents,1.23,y)
```

The returned btimes are

```
193.799 μs (7467 allocations: 116.67 KiB) # callfunc
61.686 μs (0 allocations: 0 bytes) # explicitfunc
```

Furthermore, if I then run the for loop in parallel with @threads on a 4 core cpu, the times are 180.434 μs and 17.477 μs, respectively.

I’ve gone through the documentation, performance tips, and online forums as much as I could and I haven’t been able to figure out a way to improve the performance. Is there a way to parse expressions directly into the function and evaluate them in the local scope (e.g. like eval(Meta.parse(“expression”)) for a local scope), or else is there a way to eliminate whatever overhead is causing the slowdown and allocations in the evaluation of the anonymous functions?

Any help would be greatly appreciated.