View mode: basic / threaded / horizontal-split · Log in · Help
November 08, 2010
calling functions without parentheses
Hello,

It seems that if function has no parameters, it's possible to omit the
parentheses when calling it:

   string sayHello() {
     return "hello";
   }

   void main() {
     writeln(sayHello); // same as writeln(sayHello());
   }

Is this an actual defined (and documented) behaviour that I can expect
to keep working in the future, or just some random unintended side
effect which might disappear in a next version?


adam.
November 08, 2010
Re: calling functions without parentheses
On Mon, 08 Nov 2010 14:48:20 -0500, Adam Cigánek <adam.ciganek@gmail.com>  
wrote:

> Hello,
>
> It seems that if function has no parameters, it's possible to omit the
> parentheses when calling it:
>
>     string sayHello() {
>       return "hello";
>     }
>
>     void main() {
>       writeln(sayHello); // same as writeln(sayHello());
>     }
>
> Is this an actual defined (and documented) behaviour that I can expect
> to keep working in the future, or just some random unintended side
> effect which might disappear in a next version?

It is documented behavior in D1 and originally in D2.  D2 will eventually  
require you to mark function calls omitting parentheses with @property.   
This is valid D2 today, but the @property part is not required to call the  
function:

@property string sayHello() {
    return "hello";
}

D1 will remain the same, i.e. it will not require @property.

-Steve
November 08, 2010
Re: calling functions without parentheses
Ok, thanks. I knew about @property, but not that it works even without
it. Actually, is @property even needed? I think that the ability to
call functions without parentheses could be useful for non-property
like function as well:

   widget.hide;

instead of:

   widget.hide();

The empty parentheses are just noise anyway. Unless it would conflict
with something else. But the only thing that comes to my mind is if
one wants to get the function itself, not call it. But that's what the
& operator is for anyway:

   button.onClick = &widget.hide;

a.

2010/11/8 Steven Schveighoffer <schveiguy@yahoo.com>:
> On Mon, 08 Nov 2010 14:48:20 -0500, Adam Cigánek <adam.ciganek@gmail.com>
> wrote:
>
>> Hello,
>>
>> It seems that if function has no parameters, it's possible to omit the
>> parentheses when calling it:
>>
>>    string sayHello() {
>>      return "hello";
>>    }
>>
>>    void main() {
>>      writeln(sayHello); // same as writeln(sayHello());
>>    }
>>
>> Is this an actual defined (and documented) behaviour that I can expect
>> to keep working in the future, or just some random unintended side
>> effect which might disappear in a next version?
>
> It is documented behavior in D1 and originally in D2.  D2 will eventually
> require you to mark function calls omitting parentheses with @property.
>  This is valid D2 today, but the @property part is not required to call the
> function:
>
> @property string sayHello() {
>    return "hello";
> }
>
> D1 will remain the same, i.e. it will not require @property.
>
> -Steve
>
November 08, 2010
Re: calling functions without parentheses
On Mon, 08 Nov 2010 15:29:15 -0500, Adam Cigánek <adam.ciganek@gmail.com>  
wrote:

> Ok, thanks. I knew about @property, but not that it works even without
> it. Actually, is @property even needed? I think that the ability to
> call functions without parentheses could be useful for non-property
> like function as well:
>
>     widget.hide;
>
> instead of:
>
>     widget.hide();

The point is that parentheses imply a function, where lack-of implies  
property.  For example:

if(x.read)

Could mean, read something from x, see if it's valid, or check if x has  
been read.

With forcing omitting parentheses or using them, the author of x is able  
to keep code that uses his object consistent.  The only alternative to  
this is to make the function/property a compound word like 'isRead' or  
'readValue', and we are back to Java.

For functions that return no value, it's pretty obvious that those are  
functions and not properties.  I have proposed that it might be possible  
to allow omitting parentheses on parameter-less functions that return  
void, but I have no idea if that will be implemented.

> The empty parentheses are just noise anyway. Unless it would conflict
> with something else. But the only thing that comes to my mind is if
> one wants to get the function itself, not call it. But that's what the
> & operator is for anyway:
>
>     button.onClick = &widget.hide;

When the compiler is changed to require omission of parentheses for  
properties, you will not be able to get the address of the function via  
the & operator.  This is a limitation of the requirement.  Otherwise, if  
the property returns an lvalue, how do you know what the user wants, an  
address to the lvalue or the function address?

I've proposed to work around this using __traits syntax:

auto dg = __traits(getDelegate, x.read);

Haven't got any feedback on that idea.  It could also make getting  
delegates to specific overloads much more friendly.

-Steve
Top | Discussion index | About this forum | D home