Maybe add a API to DynamicFunction to generate required ArgList?

[ameaninglessname]

bevy

https://bevyengine.org/news/bevy-0-15/#function-reflection

When reading this, it's feeling like error prone to hand craft the arguments list, while we already have the FunctionInfo.

I imagine something like DynamicFunction::newArgswould return the correct crafted argument list for me (which might be a dynamic type).

for example:

let args = function.newArgs();

// set argument by name (or by index or tuple ? with error checking implemented like ensuring type is matching)
args.set("a", 2);
args.set("b", 2);
...

let result = function.call(args);

I'm not a bevy / rust user but a big fan of bevy😉. I'm currently a game developer using UnrealEngine.

unreal

I happen to build something similar recently with things in Unreal: creating a task object to call any reflected function(UFUNCTION) with arguments specified in parameters(FInstancedPropertyBag similar to dynamic type) in the unreal editor.

//// data

// reflection data about a class, which has the information of all reflected functions in the class
UPROPERTY(EditAnywhere)
TObjectPtr<UClass> FunctionOwnerClass;

// any unreal object
UPROPERTY(EditAnywhere, Category= "Input")
TObjectPtr<UObject> ContextObject;

UPROPERTY(EditAnywhere)
FName FunctionName;

// dynamic struct (a bag of properties), will be filled with parameters (and return value if any) of selected function in the editor
UPROPERTY(EditAnywhere, meta = (FixedLayout))
FInstancedPropertyBag Parameters;

//// logic
auto* Function = FunctionOwnerClass->FindFunctionByName(FunctionName);
ContextObject->ProcessEvent(Function, Parameters.GetMutableValue().GetMemory());

//// editor logic (customization)
// todo

[MrGVSV]

Unfortunately we can't set arguments by name because most of the time those aren't actually set unless the DynamicFunction is manually created (Rust doesn't provide any information about argument names which means bevy_reflect can't set those automatically).

However, we could potentially create a method that returns a ArgBuilder or something that is checked against the FunctionInfo for every insert. We already check arguments when calling, but this would help move that check to argument creation for those that want to get that sort of error checking sooner.

We'll have to design such a system with function overloading (#15074) in mind, though, since that's on my agenda for 0.16 function reflection.