Thread overview | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|
|
April 06, 2017 Function names and lambdas | ||||
---|---|---|---|---|
| ||||
Attachments:
| 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
|
April 06, 2017 Re: Function names and lambdas | ||||
---|---|---|---|---|
| ||||
Posted in reply to 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.
|
April 06, 2017 Re: Function names and lambdas | ||||
---|---|---|---|---|
| ||||
Posted in reply to Russel Winder | 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
|
April 07, 2017 Re: Function names and lambdas | ||||
---|---|---|---|---|
| ||||
Posted in reply to Adam D. Ruppe Attachments:
| 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 |
April 07, 2017 Re: Function names and lambdas | ||||
---|---|---|---|---|
| ||||
Posted in reply to Ali Çehreli Attachments:
| 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 |
April 07, 2017 Re: Function names and lambdas | ||||
---|---|---|---|---|
| ||||
Posted in reply to Ali Çehreli | 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.
|
April 07, 2017 Re: Function names and lambdas | ||||
---|---|---|---|---|
| ||||
Posted in reply to Yuxuan Shui | 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 |
April 08, 2017 Re: Function names and lambdas | ||||
---|---|---|---|---|
| ||||
Posted in reply to Ali Çehreli | 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 |
Copyright © 1999-2021 by the D Language Foundation