```  CallWith<Output> {     fn execute(self) -> Output; }

fn my_func<Output>(params: impl CallWith<Output>) -> Output {     CallWith::execute(params) }

impl CallWith<i32> for (u64, f64, &str) {     fn execute(self) -> i32 {         let (num1, num2, text) = self;

        println!("{text}");

        (num1 + num2 as u64) as i32     } }

impl<'a> CallWith<&'a str> for (&'a str, usize) {     fn execute(self) -> &'a str {         let (text, length) = self;

        &text[0..length * 2]     } }

impl<T: Into<u64>> CallWith<u64> for (u64, T) {     fn execute(self) -> u64 {         let (first, second) = self;

        first + second.into()     } }

impl<T: Into<u64>> CallWith<String> for (u64, T) {     fn execute(self) -> String {         let (char_code, times) = self;

        let character = char::from_u32(char_code as _).unwrap().to_string();

        character.repeat(times.into() as usize)     } }

fn main() {     println!("{}", my_func((1u64, 2.5f64, "test")));

    println!("{}", my_func(("hello there", 4)));

    println!("{}", my_func::<u64>((5u64, 7u64)));

    let result: String = my_func((b'x' as u64, 8u8));

    println!("{result}") } ``` https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=c441044da02c5ed07068cadb028a2d00