www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - opDispatch forwarding and ifti

reply John Colvin <john.loughran.colvin gmail.com> writes:
Has anyone ever found a way to actually implement forwarding 
properly with opDispatch, such that it works for both general 
templates and also functions called using ifti (implicit function 
template instantiation)?

I've spent a day on it trying to improve std.typecons.Proxy to 
support this and it seems impossible.

The problem is to support this:

template X()
{
     alias X = int;
}

struct S0
{
     template A(T ...)
     {
         alias A = X;
     }

     template foo(T ...)
     {
         void foo(K)(K t) {}
     }
}

struct S1
{
     private S0 _s0;
     import std.typecons : Proxy;
     mixin Proxy!_s0;
}

unittest
{
     S1 s1;

     alias B0 = s1._s0.A!();
     static assert(is(B0!() == int));
     s1._s0.foo(3);

     alias B1 = s1.A!();
     static assert(is(B1!() == int));
     s1.foo(3);
}
Feb 27
next sibling parent reply Stefan Koch <uplink.coder googlemail.com> writes:
On Monday, 27 February 2017 at 12:14:10 UTC, John Colvin wrote:
 Has anyone ever found a way to actually implement forwarding 
 properly with opDispatch, such that it works for both general 
 templates and also functions called using ifti (implicit 
 function template instantiation)?
What is your actual usecase ? You are aware that your trying to mix an runtime and a compile-time feature, yes ? If it can be done then you will have to use CTFE and aliasSeqOf.
Feb 27
parent reply John Colvin <john.loughran.colvin gmail.com> writes:
On Monday, 27 February 2017 at 12:22:02 UTC, Stefan Koch wrote:
 On Monday, 27 February 2017 at 12:14:10 UTC, John Colvin wrote:
 Has anyone ever found a way to actually implement forwarding 
 properly with opDispatch, such that it works for both general 
 templates and also functions called using ifti (implicit 
 function template instantiation)?
What is your actual usecase ?
I'm trying to make std.typecons.Proxy support more things correctly (e.g. template members, members that are aliases of types). I thought that was clear from the rest of my post.
 You are aware that your trying to mix an runtime and a 
 compile-time feature, yes ?
Not quite sure what you mean there. What is a runtime feature here?
 If it can be done then you will have to use CTFE and aliasSeqOf.
The problem isn't with generating code (unless there's some very involved exhaustive solution I haven't thought of). How would you imagine I would use CTFE or aliasSeqOf to help here?
Feb 27
parent reply Stefan Koch <uplink.coder googlemail.com> writes:
On Monday, 27 February 2017 at 13:17:21 UTC, John Colvin wrote:
 On Monday, 27 February 2017 at 12:22:02 UTC, Stefan Koch wrote:
 On Monday, 27 February 2017 at 12:14:10 UTC, John Colvin wrote:
 Has anyone ever found a way to actually implement forwarding 
 properly with opDispatch, such that it works for both general 
 templates and also functions called using ifti (implicit 
 function template instantiation)?
What is your actual usecase ?
I'm trying to make std.typecons.Proxy support more things correctly (e.g. template members, members that are aliases of types). I thought that was clear from the rest of my post.
 You are aware that your trying to mix an runtime and a 
 compile-time feature, yes ?
Not quite sure what you mean there. What is a runtime feature here?
 If it can be done then you will have to use CTFE and 
 aliasSeqOf.
The problem isn't with generating code (unless there's some very involved exhaustive solution I haven't thought of). How would you imagine I would use CTFE or aliasSeqOf to help here?
op-dispatch is a runtime feature. It takes a string which is avilable at compile-time and passes it as a runtime parameter. This runtime parameter can be used at ctfe if opDispatch is called at ctfe. Then aliasSeqOf transforms it into a string-literal which can be used by templates.
Feb 27
parent reply Adam D. Ruppe <destructionator gmail.com> writes:
On Monday, 27 February 2017 at 14:27:21 UTC, Stefan Koch wrote:
 op-dispatch is a runtime feature.
 It takes a string which is avilable at compile-time and passes 
 it as a runtime parameter.
Completely false. It runs opDispatch!("the_string") which is totally compile time.
Feb 27
parent Stefan Koch <uplink.coder googlemail.com> writes:
On Monday, 27 February 2017 at 14:34:05 UTC, Adam D. Ruppe wrote:
 On Monday, 27 February 2017 at 14:27:21 UTC, Stefan Koch wrote:
 op-dispatch is a runtime feature.
 It takes a string which is avilable at compile-time and passes 
 it as a runtime parameter.
Completely false. It runs opDispatch!("the_string") which is totally compile time.
Oh damn. Just lost my Street Cred :)
Feb 27
prev sibling parent Timon Gehr <timon.gehr gmx.ch> writes:
On 27.02.2017 13:14, John Colvin wrote:
 Has anyone ever found a way to actually implement forwarding properly
 with opDispatch, such that it works for both general templates and also
 functions called using ifti (implicit function template instantiation)?

 I've spent a day on it trying to improve std.typecons.Proxy to support
 this and it seems impossible.
One reason why your test case doesn't work is probably this compiler bug: struct S1{ template opDispatch(string op){ template opDispatch(T...){ static int x; } } } unittest{ S1 s1,s2; alias B1 = s1.A!().x; // error s1.A!().x=2; // ok } opDispatch seems to not be resolved when aliasing a symbol.
Feb 27