Thread overview | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|
|
December 06, 2012 opDispatch to template members | ||||
---|---|---|---|---|
| ||||
Greetings, Given the following code: struct Inner { void fun1() {} void fun2( string toto ) {} string fun3() { return "tata"; } string fun4( string tutu ) { return "this is going too far"; } void fun5( string ohOh )() {} } struct Outer { private Inner _inner; auto opDispatch( string method, T... )( T args ) { return mixin( "_inner." ~ method )( args ); } } void main( string[] args ) { Outer outer; outer.fun1(); outer.fun2( "some string" ); auto zeString = outer.fun3(); auto zeOtherString = outer.fun4( zeString ); outer.fun5!"popo"(); //No compilo amigo } Is it possible/desirable to ever get opDispatch to delegate to a template member function? Thanks |
December 06, 2012 Re: opDispatch to template members | ||||
---|---|---|---|---|
| ||||
Posted in reply to Phil Lavoie | I mean automatically dispatch to template members, not doing it in a case by case fashion (using template if clauses for example). Thanks |
December 06, 2012 Re: opDispatch to template members | ||||
---|---|---|---|---|
| ||||
Posted in reply to Phil Lavoie | On Thursday, 6 December 2012 at 21:49:21 UTC, Phil Lavoie wrote:
> I mean automatically dispatch to template members, not doing it in a case by case fashion (using template if clauses for example).
>
> Thanks
This is a known issue of the current design of opDispatch.
|
December 06, 2012 Re: opDispatch to template members | ||||
---|---|---|---|---|
| ||||
Posted in reply to deadalnix | Got it! Thanks |
December 07, 2012 Re: opDispatch to template members | ||||
---|---|---|---|---|
| ||||
Posted in reply to deadalnix Attachments:
| Note that, std.typecons.Proxy implements such template member function
forwarding by opDispatch nesting.
If curious, you can look its implementation.
Kenji Hara
2012/12/7 deadalnix <deadalnix@gmail.com>
> On Thursday, 6 December 2012 at 21:49:21 UTC, Phil Lavoie wrote:
>
>> I mean automatically dispatch to template members, not doing it in a case by case fashion (using template if clauses for example).
>>
>> Thanks
>>
>
> This is a known issue of the current design of opDispatch.
>
|
December 07, 2012 Re: opDispatch to template members | ||||
---|---|---|---|---|
| ||||
Posted in reply to Phil Lavoie | On 2012-12-06 22:49, Phil Lavoie wrote: > I mean automatically dispatch to template members, not doing it in a > case by case fashion (using template if clauses for example). > > Thanks As Kenji said, doing something like this: struct Outer { private Inner _inner; template opDispatch( string method ) { auto opDispatch (T... ) (T args) return mixin( "_inner." ~ method )( args ); } } } -- /Jacob Carlborg |
December 07, 2012 Re: opDispatch to template members | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jacob Carlborg | Hi,
Indeed as he suggested. I tried to reply that I was looking at the code yesterday and that it was what I was looking for, but my post did not get through for some reasons.
Thanks!
On Friday, 7 December 2012 at 07:57:09 UTC, Jacob Carlborg wrote:
> On 2012-12-06 22:49, Phil Lavoie wrote:
>> I mean automatically dispatch to template members, not doing it in a
>> case by case fashion (using template if clauses for example).
>>
>> Thanks
>
> As Kenji said, doing something like this:
>
> struct Outer {
> private Inner _inner;
>
> template opDispatch( string method ) {
> auto opDispatch (T... ) (T args)
> return mixin( "_inner." ~ method )( args );
> }
> }
> }
|
December 07, 2012 Re: opDispatch to template members | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jacob Carlborg | Hi,
Yes indeed Kenji pointed me in the right direction. I tried posting that I looked at the code he suggested and found what I was looking for, but I had some issue posting :(.
Thanks
On Friday, 7 December 2012 at 07:57:09 UTC, Jacob Carlborg wrote:
> On 2012-12-06 22:49, Phil Lavoie wrote:
>> I mean automatically dispatch to template members, not doing it in a
>> case by case fashion (using template if clauses for example).
>>
>> Thanks
>
> As Kenji said, doing something like this:
>
> struct Outer {
> private Inner _inner;
>
> template opDispatch( string method ) {
> auto opDispatch (T... ) (T args)
> return mixin( "_inner." ~ method )( args );
> }
> }
> }
|
December 09, 2012 Re: opDispatch to template members | ||||
---|---|---|---|---|
| ||||
Posted in reply to deadalnix | On Thursday, 6 December 2012 at 23:01:19 UTC, deadalnix wrote: > On Thursday, 6 December 2012 at 21:49:21 UTC, Phil Lavoie wrote: >> I mean automatically dispatch to template members, not doing it in a case by case fashion (using template if clauses for example). >> >> Thanks > > This is a known issue of the current design of opDispatch. It seems like there should be a way to separate template function calls to opDispatch and keep opDispatch's own template half separate. Hmmm... Some type of separator. It would likely have to allow a beginning tuple, as well as call opDispatch that would recognize it as such. In theory... auto opDispatch(T..., string method, V...)(V args) Assuming it would be allowed, T represents the template portion of a call. Since the ... makes it illegal to be first (in normal cases) it may allow a special rule in order to understand it's a passable tuple for templates only, and allowed for only the first and last arguments. Or would T[] be better? Then calling such an opDispatch may be... { static assert (!T.length) { return mixin("._inner." ~ method)(args); } else { return mixin("._inner." ~ method)!(T)(args); } } The rewrite of such a function call would be.. auto zeOtherString = outer.fun4( zeString ); outer.fun5!"popo"(); //No compilo amigo would become (I think?) //depending on how they do it... auto zeOtherString = outer.opDispatch("fun4")(zeString); auto zeOtherString = outer.opDispatch([], "fun4")(zeString); auto zeOtherString = outer.opDispatch(void[0], "fun4")(zeString); outer.opDispatch(["popo"], "fun5")(); Having the passable tuple after the method may be confusing, but might equally work... auto opDispatch(string method, T t, V...)(V args) (or is it 'T[] t'?) Allowing a blank (for t) wouldn't probably be allowed, so two opDispatches might have to be made, but that might be minor. Depends on what makes sense and how walter/andrei decide to handle if (if at all). If it still requires a separating type, you could always use void... auto opDispatch(T[], void, string method, V...)(V args) outer.opDispatch(["popo"], void, "fun5")(); or?? auto opDispatch(string method, T[], void, V...)(V args) //void and non-void attempted? Or always insert void silently? outer.opDispatch("fun5", ["popo"])(); outer.opDispatch("fun5", ["popo"], void)(); |
December 10, 2012 Re: opDispatch to template members | ||||
---|---|---|---|---|
| ||||
Posted in reply to Era Scarecrow | On Sunday, 9 December 2012 at 03:33:07 UTC, Era Scarecrow wrote:
> On Thursday, 6 December 2012 at 23:01:19 UTC, deadalnix wrote:
>> On Thursday, 6 December 2012 at 21:49:21 UTC, Phil Lavoie wrote:
>>> I mean automatically dispatch to template members, not doing it in a case by case fashion (using template if clauses for example).
>>>
>>> Thanks
>>
>> This is a known issue of the current design of opDispatch.
>
> It seems like there should be a way to separate template function calls to opDispatch and keep opDispatch's own template half separate. Hmmm... Some type of separator.
>
It seems that using opDispatch within opDispatch as shown before in the thread solve the problem. This technique should be advertised.
|
Copyright © 1999-2021 by the D Language Foundation