Templatized delegates

[Christian Köstlin]

On 2022-05-31 23:15, Andrey Zherikov wrote:
> I have tightly coupled code which I'd like to decouple but I'm a bit stuck.
> For simplicity, I reduced the amount of code to something simple to 
> understand. So I have a struct `S` that has templated member function 
> that does something. On the other side I have delegate holder `R` - this 
> delegate takes `S` object as an argument and calls that function. My 
> goal is to remove dependency from `R` to `S`.
> 
> Here is code example:
> 
> ```d
> import std.stdio: writeln;
> 
> struct S
> {
>      // function that should be called from delegate
>      void doSomething(T)(T value) { value.writeln; }
> }
> 
> alias DG = void delegate (ref S s);
> 
> auto createDG(T)(T value)
> {
>      return delegate (ref S s) { s.doSomething(value); };
> }
> 
> struct R
> {
>      DG dg;
> 
>      this(int value)
>      {
>          dg = createDG(value);
>      }
> }
> 
> void main()
> {
>      auto r = R(5);
> 
>      S s;
>      r.dg(s);
> }
> ```
> 
> An obvious way is to add a type template parameter to `R`, `DG` and 
> `createDG` but I would like to avoid this. Is there another way to do so?
> 
> I think ideal solution would be having templatized delegate `void 
> delegate (S)(ref S s)` and then call `r.dg!S(s)` but it's not available: 
> `alias DG = void delegate (S) (ref S s)` gives unclear `Error: function 
> declaration without return type. (Note that constructors are always 
> named 'this')` message.Would it help to not create the delegate in R's constructor, but feed 
the delegate into it (and create the delegate outside). This would also 
resemble your description (R is a delegate holder) more.