Type wrapping blockers

[Steven Schveighoffer]

On Tue, 05 Oct 2010 08:50:04 -0400, Steven Schveighoffer  
<schveiguy at yahoo.com> wrote:

> One of the good goals of D I think is to be able to automatically  
> encapsulate a type, and all its attributes/functions, in order to  
> slightly alter the functionality.  I think this is probably a pattern,  
> but I don't know what it is (Interceptor?).
>
> One of the best methods to wrap a type is to use opDispatch.  But there  
> are some problems that block this.  It might be good to get a bug report  
> that gathers these together.  I have one that I just ran into -- IFTI  
> and literals.  Basically, if you have a function:
>
> void foo(short x);
>
> you can call foo(1) no problem.
>
> But if you *wrap* the type that contains foo, you cannot use opDispatch  
> to implement foo(1), because IFTI treats 1 as an int.  So what you get  
> is an instantiation of opDispatch like this:
>
> opDispatch!("foo", int)(1)  Which then cannot call foo, because you  
> cannot cast int to short.
>
> Does anyone have any other blockers that prevent type wrapping?  Does  
> anyone have any ideas on how to fix the above issue?

Found another one, really old bug: 1748

Basically, if you have

class C(T)
{
}

and you try to get (C!int).stringof you get just "C".  This makes  
specifying wrapped arguments that are class templates impossible for  
mixins.

I'm giving up my workaround to try and implement the "Nifty chaining", it  
appears it's just not possible with the compiler bugs today :(

-Steve