Attribute inference for auto functions?

[Peter Alexander]

On Wednesday, 17 April 2013 at 07:58:42 UTC, deadalnix wrote:
> auto is about type inference. Attribute is part of the function 
> type as much as it return type, and so it is expected that auto 
> applied to a function infer its attributes and its return type.

I disagree. Attributes are completely separate from return value, 
and I do not think it is "expected" that auto should infer 
attributes.


> The problem you are talking about is very real, but much 
> broader than this auto thing. The problem is that you have no 
> control on what the storage classes bind on.
>
> Examples :
> extern(C) void function() foo; // does extern binds to foo, 
> foo's type or both ?
> pure function() function() bar; // is bar a pure function ? is 
> bar() pure ? Noth ? How to choose ?

Yes, that is a problem, but not related to this change.


> Back to the subject, if auto bind to the function it must 
> infers attributes, if it binds to the return type, it mustn't. 
> And right now, storage class bind to the function.

I think you are confusing separate things here.

First, 'auto' is a storage class that means 'no other storage 
class'. It does NOT mean type inference. You do not need to use 
'auto' to get type inference. You cannot use 'auto' in 
conjunction with other storage classes to get type inference.

auto foo(); // type inference
const foo(); // type inference
auto const foo(); // illegal, two storage classes

As you can see, auto is neither sufficient, nor required for type 
inference. The storage class you use has absolutely nothing to do 
with type inference. Type inference happens if and only if you do 
not specify a return type. Storage class and type inference are 
100% orthogonal.

With that matter cleared up, your argument no longer holds water. 
It doesn't matter what 'auto' binds to because 'auto' has nothing 
to do with return type inference, and shouldn't affect attribute 
inference either.

The name of this thread is quite misleading. The proposal also 
has nothing to do with auto. The proposal is to infer attributes 
when the return type is inferred. I think it's worth being clear 
on that otherwise people will confuse storage classes with 
type/attribute inference.