Doing anything by a string of the function name fundamentally removes the ability for Construct to do things like update all references to the function when you rename it, or show accurate results for "Find all references", etc. It would force you to go back to having to review the project when you make certain changes, which is slow, error-prone and laborious, and exactly what the new functions feature is designed to avoid.
I think it should be possible to support this without using expressions for function names, though. The equivalent in a programming language would be a map or a switch-case of a string to a function call. Construct doesn't yet have any equivalent, but we could add one. It could work something like this. Suppose you have "Call function <string>" which can call one of "Red", "Green" or "Blue". That could be replicated with a "function map" feature along the lines of this:
+ On start of layout
-> Create function map "color"
-> Map "color" string "Red" to RedFunction
-> Map "color" string "Green" to GreenFunction
-> Map "color" string "Blue" to BlueFunction
Note that RedFunction, GreenFunction and BlueFunction refer to built-in functions, and aren't strings (this would be some kind of new function-picker parameter). Then instead of "Call function <string>", you could use:
-> Call function from "color" map with <string>
This would then look up the string in the color map and call the corresponding function. E.g. call fucntion from "color" map with "Red" will call RedFunction. This should be the best of both worlds: you can dispatch function calls by a string, and it separates the concept of the string lookup from the function name. So if you rename one of the built-in functions all the references update and nothing is broken, and "Find all references" can still give you exact results.
This doesn't cover passing parameters though. One way of solving that would be to forward the parameters of another function call. So you could add a function like:
* On function ColorCall
* Parameter colorType
* Parameter someNumber
-> Call function from "color" map with string colorType and forward parameters from index 1
This would skip the first parameter (colorType) and just forward someNumber. So RedFunction, BlueFunction and GreenFunction all get called with one parameter (someNumber). Then in your events you can do:
-> Call function ColorCall (colorType: <string>, someNumber: <number>)
This then calls RedFunction(someNumber), GreenFunction(someNumber) or BlueFunction(someNumber) depending on the string 'colorType'. So you essentially get the same thing as calling a function by an expression, but you never used an expression for a function name.
Does that sound like it would cover this case?