IFTI for constructors worth a DIP?

Steven Schveighoffer schveiguy at yahoo.com
Fri Mar 30 13:02:52 UTC 2018


On 3/30/18 2:25 AM, Dmitry Olshansky wrote:
> On Friday, 30 March 2018 at 06:21:27 UTC, Dmitry Olshansky wrote:
>> I think it should be mostly stright-forward and we can get rid of 
>> “instantiator” functions to do IFTI.
>>
>> The problem (I guess) is 2 type parameter lists, one of aggregate and 
>> the other of function:
>>
>> struct Foo(T)
>> if (isSomeSuch!T)
>> {
>>     this(U)(T a, U u) if (isSomethindElse!U) {...}
>>     this(R)(T x, R r) if (yetAnother!U){ ... }
>> }
> 
> More interesting case...
> struct Foo(T)
> {
>       alias K = T.K;
>       this(K k) { .... }
>       // same
> }
> 
> In general it might be impossible (if we throw in more static ifs on T’s 
> type) but well IFTI is not 100% solution anyway.
> 
>>
>> I believe in such a case compiler can as far as IFTI goes just 
>> consider a combined tuple of types.
>>
>> Thoughts?
> 
> 

The easy way to test these is to see what IFTI does now:

import std.traits;

template foo(T)
if (isIntegral!T)
{
     void foo(U)(T a, U u) if (isSomeString!U) {}
}

void main()
{
     foo(1, "hello");
}

onlineapp.d(11): Error: template onlineapp.foo cannot deduce function 
from argument types !()(int, string), candidates are:
onlineapp.d(3):        onlineapp.foo(T) if (isIntegral!T)

Your second case:

struct Foo(T)
{
      alias K = T.K;
      this(K k) { .... }
      // same
}

I can't see at all how this would work, as there may be infinite types 
for T that have an alias K that matches.


However, a simpler case:

template foo(T)
{
      alias K = T;
      void foo(K k) {}
}

void main()
{
     foo(1);
}

onlineapp.d(4): Error: undefined identifier K
onlineapp.d(10): Error: template onlineapp.foo cannot deduce function 
from argument types !()(int), candidates are:
onlineapp.d(1):        onlineapp.foo(T)(K k)

So it appears IFTI wouldn't be up to the task if there are aliases 
involved, or nested templates. But the simplest cases it does work with:

import std.traits;

template foo(T, U)
if (isIntegral!T && isSomeString!U)
{
     void foo(T a, U u) {}
}

void main()
{
     foo(1, "hello");
}

A class/struct ctor (where the constructor itself isn't a template) 
isn't any different, I can't see why it wouldn't work.

-Steve


More information about the Digitalmars-d mailing list