return type and templates

[Timon Gehr]

On 11/22/2013 01:29 PM, Jonathan M Davis wrote:
> On Friday, November 22, 2013 11:50:57 Andrea Fontana wrote:
>> I just mean:
>>
>> int t = s.value;  // Means  int t = s.value!int;
>>
>> If there's a problem with template instantiatio is the same we
>> have now.
>> Now I have to write:
>>
>> int t = s.value!int;
>>
>> so if there's a problem with !int, it's just like now.
>>
>> It's just a syntactic sugar, no new feature... Am I wrong?
>
> Again, how is the compiler supposed to have any clue that you want to
> instantiate value with int in the case of
>
> int t = s.value;
>
> The left-hand side of the expression has no impact on the type of the right-
> hand side,

If you mean the type of the variable declaration, then yes it does.

int delegate(int) dg1 = x=>x;
float delegate(float) dg2 = x=>x;

static assert(!is(typeof(x=>x)));

> and you have not given the compiler any information as to what
> template argument should be given to value.

Well, technically, in this case there is only one choice.

> s.value(3) only works because
> you've given value a function argument from which the corresponding template
> argument can be inforred. With s.value, you've given no indication whatsoever
> as to what value should be instantiated with.
>
> If you want a default template argument, then give it one. e.g.
>
> @property auto value(T = int)() if (is(T == int)) { return _intValue; }
>
> But I don't know how you expect the compiler to have any clue what type value
> should be instantiated with when you haven't given it any template arguments
> and there are no function arguments to infer the template arguments from -
> especially when this what the compiler really sees
>
> template value(T)
>      if(is(T == int))
> {
>      @property auto value() { return _intValue; }
> }
>
> and it doesn't even look at the template constraint, let alone the contents of
> the template, until you attempt to instantiate the template. And it's not
> going to be able to try and instantiate the template without having any
> template arguments.
> ...

The request would be reasonable if 'value' was declared as follows though:

@property T value(T)() if (is(T == int)) { return _intValue; }

i.e. the fact that the template argument equals the type of the 
resulting call can be read off directly from the signature. This is in 
the same ballpark as the existing IFTI features.