Call () que llamará a la función con el nombre de la función (en cadena) y parámetros (cualquier tipo)

Aquí está el ejemplo, este fue mi primer pensamiento y me quedé aquí. ¿Cómo puedo hacerlo o hay otro enfoque para hacer esto?

Objetivo: Call () que llamará a la función con el nombre de la función (en cadena) y parámetros (cualquier tipo)

fn diplay(input: i32){
 println!("{}", input);
}
fn diplay_float(input: f32){
 println!("{}", input);
}
call(name: &str, params: x){
 match name{
 "display" => display(params),
 "display_float" => display(params),
 _ => println!("Invalid input")
 }
}

Actualización de la pregunta: tal vez haya muchas funciones y quería usar run("func name", param);para llamar a la función. ¿Hay algún enfoque para hacer esto?

struct First;
struct Second;
Impl First{
 fn some_function(param: i32){
...
 };
}
Impl Second{
 fn some_other_function(param: i32, param2: i32){
...
 };
}
trait MyTrait{
 fn run(name: str, params:?);
}
fn main(){
 run("some_function", 23);
}

Solución del problema

La forma Rust de hacer esto es definir su función en un rasgo, luego implementar ese rasgo para los tipos que desea admitir:

trait MyDisplay {
 fn display (&self);
}
impl MyDisplay for i32 {
 fn display (&self) {
 println!("{}", self);
 }
}
impl MyDisplay for f32 {
 fn display (&self) {
 println!("{}", self);
 }
}
fn call<T: MyDisplay> (input: T) {
 input.display();
}
fn main() {
 let i = 42i32;
 let f = std::f32::consts::PI;
 call (i);
 call (f);
}

Patio de recreo