I am used to a function name being a reference to the function body, cf. lots of other languages. However D rejects:

	iterative

as a thing can put in an array, it requires:

	(n) => iterative(n)

Presumably this introduces inefficiency at run time? I.e. the extra level of indirection is not compiled away?

-- 
Russel. ============================================================================= Dr Russel Winder      t: +44 20 7585 2200   voip: sip:russel.winder@ekiga.net 41 Buckmaster Road    m: +44 7770 465 077   xmpp: russel@winder.org.uk London SW11 1EN, UK   w: www.russel.org.uk  skype: russel_winder

On Thursday, 6 April 2017 at 18:37:51 UTC, Russel Winder wrote:
> I am used to a function name being a reference to the function body, cf. lots of other languages. However D rejects:
>
> 	iterative

Try

&iterative



The compiler would probably optimize out a trivial thing anyway, but &foo should work too in most cases.

On 04/06/2017 11:37 AM, Russel Winder via Digitalmars-d-learn wrote:
> I am used to a function name being a reference to the function body,
> cf. lots of other languages. However D rejects:
>
> 	iterative
>
> as a thing can put in an array, it requires:
>
> 	(n) => iterative(n)
>
> Presumably this introduces inefficiency at run time? I.e. the extra
> level of indirection is not compiled away?
>

I think it's just a design choice. C implicitly converts the name of the function to a pointer to that function. D requires the explicit & operator:

alias Func = int function(int);

int foo(int i) {
    return i;
}

void main() {
    Func[] funcs = [ &foo ];
}

Close to what you mentioned, name of the function can be used as an alias template parameter:

void bar(alias func)() {
    func(42);
}

int foo(int i) {
    return i;
}

void main() {
    bar!foo();
}

Ali

On Thu, 2017-04-06 at 18:45 +0000, Adam D. Ruppe via Digitalmars-d- learn wrote:
> On Thursday, 6 April 2017 at 18:37:51 UTC, Russel Winder wrote:
> > I am used to a function name being a reference to the function body, cf. lots of other languages. However D rejects:
> > 
> > 	iterative
> 
> Try
> 
> &iterative
> 
> 
> 
> The compiler would probably optimize out a trivial thing anyway, but &foo should work too in most cases.

No don't I look like a real idiot. Of course I should have known that. :-)

It works exactly as required.

-- 
Russel. ============================================================================= Dr Russel Winder      t: +44 20 7585 2200   voip: sip:russel.winder@ekiga.net 41 Buckmaster Road    m: +44 7770 465 077   xmpp: russel@winder.org.uk London SW11 1EN, UK   w: www.russel.org.uk  skype: russel_winder

On Thu, 2017-04-06 at 11:45 -0700, Ali Çehreli via Digitalmars-d-learn wrote:
> 
[…]
> I think it's just a design choice. C implicitly converts the name of
> the
> function to a pointer to that function. D requires the explicit &
> operator:

One of the dangers of being a bit like and a replacement for another language is that often people carry ideas over incorrectly, as I have here.

> alias Func = int function(int);
> 
> int foo(int i) {
>      return i;
> }
> 
> void main() {
>      Func[] funcs = [ &foo ];
> }

I just did:

immutable funcs = [tuple(&foo, "foo")];

as I don't need the name of the type, but I do need a string form of the name of the function.

> Close to what you mentioned, name of the function can be used as an alias template parameter:
> 
> void bar(alias func)() {
>      func(42);
> }
> 
> int foo(int i) {
>      return i;
> }
> 
> void main() {
>      bar!foo();
> }

Good to know but for situation here the &foo was what was needed.

-- 
Russel. ============================================================================= Dr Russel Winder      t: +44 20 7585 2200   voip: sip:russel.winder@ekiga.net 41 Buckmaster Road    m: +44 7770 465 077   xmpp: russel@winder.org.uk London SW11 1EN, UK   w: www.russel.org.uk  skype: russel_winder

On Thursday, 6 April 2017 at 18:45:26 UTC, Ali Çehreli wrote:
> On 04/06/2017 11:37 AM, Russel Winder via Digitalmars-d-learn wrote:
>>[...]
>
> I think it's just a design choice. C implicitly converts the name of the function to a pointer to that function. D requires the explicit & operator:
>
> alias Func = int function(int);
>
> int foo(int i) {
>     return i;
> }
>
> void main() {
>     Func[] funcs = [ &foo ];
> }
>
> Close to what you mentioned, name of the function can be used as an alias template parameter:
>
> void bar(alias func)() {
>     func(42);
> }
>
> int foo(int i) {
>     return i;
> }
>
> void main() {
>     bar!foo();
> }
>
> Ali

Main reason is probably UFCS.

On 04/07/2017 11:19 AM, Yuxuan Shui wrote:
> On Thursday, 6 April 2017 at 18:45:26 UTC, Ali Çehreli wrote:
>> On 04/06/2017 11:37 AM, Russel Winder via Digitalmars-d-learn wrote:
>>> [...]
>>
>> I think it's just a design choice. C implicitly converts the name of
>> the function to a pointer to that function. D requires the explicit &
>> operator:
>>
>> alias Func = int function(int);
>>
>> int foo(int i) {
>>     return i;
>> }
>>
>> void main() {
>>     Func[] funcs = [ &foo ];
>> }
>>
>> Close to what you mentioned, name of the function can be used as an
>> alias template parameter:
>>
>> void bar(alias func)() {
>>     func(42);
>> }
>>
>> int foo(int i) {
>>     return i;
>> }
>>
>> void main() {
>>     bar!foo();
>> }
>>
>> Ali
>
> Main reason is probably UFCS.

Main reason for D not supporting the name-to-pointer mapping? I don't think so because as far as I know this has been the case since very early on but UFCS came very much later.

Ali

On 2017-04-07 23:05, Ali Çehreli wrote:

> Main reason for D not supporting the name-to-pointer mapping? I don't
> think so because as far as I know this has been the case since very
> early on but UFCS came very much later.

More likely due to properties, i.e. calling functions without parentheses. It's more difficult to know if the function should be called or if the address of the function should be taken.

-- 
/Jacob Carlborg