How to declare "type of function, passed as an argument, which should have it's type inferred"? (or if D had an "any" type)

[evilrat]

On Monday, 29 March 2021 at 15:13:04 UTC, Gavin Ray wrote:
> Brief question, is it possible to write this so that the "alias 
> fn" here appears as the final argument?
>
>   auto my_func(alias fn)(string name, string description, auto 
> otherthing)
>
> The above seems to work, since the type of "fn" can vary and it 
> gets called inside of "my_func", but from an ergonomics point 
> I'd love to be able to put the function last and write it 
> inline:
>
>   my_func("name", "description", "otherthing", (x, y, z) {
>     auto foo = 1;
>     return foo + 2;
>   })
>
>
> Currently I am calling it like:
>
>   auto some_func = (x, y, z) {
>     auto foo = 1;
>     return foo + 2;
>   };
>
>   my_func!some_func("name", "description", "otherthing");
>
> Which is fine, it's just that from a readability perspective it 
> doesn't really allow for writing the function inline and you 
> need to declare it separately.
>
> Not a huge deal, just learning and thought I would ask =)
>
> Thank you!

Also with delegates (lazy), you get the type checks however you 
must have to declare parameters on call site, which can be PITA 
in the future when doing refactoring will be necessary.

Better plan ahead as the number of changes will explode when you 
make quite a number of these and decide to change params/returns.

```
   import std.stdio;

   void my_func(T, XS)(string a, string b, string c, lazy T 
function(XS)[] t...)
   {
     // call function, just the first one, can call all of them as 
well
     t[0](a);

     // can get the result too, mind the future refactoring needs 
tho
     // T res = t[0]();
   }

   void main()
   {
     my_func("name", "description", "otherthing", (string x) {
       writeln(x);
       return x;
     });

     // no function, compile error
     // my_func("name", "description", "otherthing");
   }
```