www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Self function

reply bearophile <bearophileHUGS lycos.com> writes:
Sometimes I rename recursive functions, or I duplicate and modify them, and
they stop working because inside them there's one or more copy of their old
name, so for example they recurse to their old name.
So inside a function I'd like to have a standard name to call the function
itself, useful for recursivity.
(If you have two or more recursive functions that call each other this idea
can't be used, but I think such situations are uncommon enough to not deserve
help from the language).

I have just discussed this in the Python newsgroup too:
http://groups.google.com/group/comp.lang.python/browse_thread/thread/d265da85d4b70eaf#

I use more recursivity in D than in Python, because Python has troubles with it.

In future in D2 you may use:

int ANUGLYNAME(int n) {
    if (n <= 1)
        return 1;
    else
        mixin(__FUNCTION__ ~ "(n - 1) * n");
}

But you can't use __FUNCTION__ into a delegate/function pointer/lambda because
the name isn't available, and it's a bit ugly syntax anyway...

This looks a bit better:

int ANUGLYNAME(int n) {
    if (n <= 1)
        return 1;
    else
        __self(n - 1) * n;
}

Other syntaxes are possible.

__self is a way to denote the pointer/delegate of the function currently being
run, so I think the compiler is always able to that, for delegate/ function
pointers/ lambdas/ methods/ virtual methods/ opCalls too.

Bye,
bearophile
May 04 2009
next sibling parent Frank Benoit <keinfarbton googlemail.com> writes:
bearophile schrieb:
 Sometimes I rename recursive functions, or I duplicate and modify them, and
they stop working because inside them there's one or more copy of their old
name, so for example they recurse to their old name.
 So inside a function I'd like to have a standard name to call the function
itself, useful for recursivity.
 (If you have two or more recursive functions that call each other this idea
can't be used, but I think such situations are uncommon enough to not deserve
help from the language).
 
 I have just discussed this in the Python newsgroup too:
 http://groups.google.com/group/comp.lang.python/browse_thread/thread/d265da85d4b70eaf#
 
 I use more recursivity in D than in Python, because Python has troubles with
it.
 
 In future in D2 you may use:
 
 int ANUGLYNAME(int n) {
     if (n <= 1)
         return 1;
     else
         mixin(__FUNCTION__ ~ "(n - 1) * n");
 }
 
 But you can't use __FUNCTION__ into a delegate/function pointer/lambda because
the name isn't available, and it's a bit ugly syntax anyway...
 
 This looks a bit better:
 
 int ANUGLYNAME(int n) {
     if (n <= 1)
         return 1;
     else
         __self(n - 1) * n;
 }
 
 Other syntaxes are possible.
 
 __self is a way to denote the pointer/delegate of the function currently being
run, so I think the compiler is always able to that, for delegate/ function
pointers/ lambdas/ methods/ virtual methods/ opCalls too.
 
 Bye,
 bearophile

how about scope.function // the surrounding function scope.method // the surrounding method scope.class // the surrounding class scope.class.outer // the outer class of the surrounding class The current functions name, was requested so often: scope.function.name ?
May 04 2009
prev sibling next sibling parent reply "Denis Koroskin" <2korden gmail.com> writes:
On Mon, 04 May 2009 23:52:56 +0400, bearophile <bearophileHUGS lycos.com> wrote:

 Sometimes I rename recursive functions, or I duplicate and modify them,  
 and they stop working because inside them there's one or more copy of  
 their old name, so for example they recurse to their old name.
 So inside a function I'd like to have a standard name to call the  
 function itself, useful for recursivity.
 (If you have two or more recursive functions that call each other this  
 idea can't be used, but I think such situations are uncommon enough to  
 not deserve help from the language).

 I have just discussed this in the Python newsgroup too:
 http://groups.google.com/group/comp.lang.python/browse_thread/thread/d265da85d4b70eaf#

 I use more recursivity in D than in Python, because Python has troubles  
 with it.

 In future in D2 you may use:

 int ANUGLYNAME(int n) {
     if (n <= 1)
         return 1;
     else
         mixin(__FUNCTION__ ~ "(n - 1) * n");
 }

 But you can't use __FUNCTION__ into a delegate/function pointer/lambda  
 because the name isn't available, and it's a bit ugly syntax anyway...

 This looks a bit better:

 int ANUGLYNAME(int n) {
     if (n <= 1)
         return 1;
     else
         __self(n - 1) * n;
 }

 Other syntaxes are possible.

 __self is a way to denote the pointer/delegate of the function currently  
 being run, so I think the compiler is always able to that, for delegate/  
 function pointers/ lambdas/ methods/ virtual methods/ opCalls too.

 Bye,
 bearophile

It was proposed awhile ago: http://www.digitalmars.com/d/archives/digitalmars/D/FUNCTION_84985.html Andrei's respond: "I think instead of __FUNCTION__ we'll define a much more comprehensive static reflection facility." "You will have it as a human readable identifier too. The problem with __FUNCTION__, __CLASS__ etc. is that the list of ad-hoc names (what happened to __STRUCT__, __MODULE__ et al?) can go forever." "D2 will have reflection. (Walter doesn't know yet. He thinks D3 will have reflection.) It will be compile-time reflection because only run-time reflection only is missing the point." "This is a long discussion, but in brief any runtime reflection engine needs some sort of compile-time metadata infrastructure. Some languages don't make that accessible within the language itself. Runtime reflection has been explored extensively, its possibilities and limitations are pretty well understood, I hardly smothered a yawn reading all you wrote. Compile-time reflection is much less understood and hides many more exciting possibilities. With the advances in compiler technology implemented by Walter, we have a chance to tackle reflection in a systematic manner."
May 04 2009
next sibling parent bearophile <bearophileHUGS lycos.com> writes:
Denis Koroskin:
 It was proposed awhile ago:
http://www.digitalmars.com/d/archives/digitalmars/D/FUNCTION_84985.html

I am not asking for a static __function__ name, because you can't use it inside lambdas or function pointers/delegates. The __func I am talking about is a pointer/delegate, and I don't know if you can use a static solution once you start juggling function pointers around. Bye, bearophile
May 04 2009
prev sibling parent "Denis Koroskin" <2korden gmail.com> writes:
On Tue, 05 May 2009 02:30:49 +0400, bearophile <bearophileHUGS lycos.com> wrote:

 Denis Koroskin:
 It was proposed awhile ago:  
 http://www.digitalmars.com/d/archives/digitalmars/D/FUNCTION_84985.html

I am not asking for a static __function__ name, because you can't use it inside lambdas or function pointers/delegates. The __func I am talking about is a pointer/delegate, and I don't know if you can use a static solution once you start juggling function pointers around. Bye, bearophile

If you read carefully, you'll see that there's more than just __FUNCTION__. For example, I suggested to use some literal to denote current function, fthis/self/whatever. Others suggested scope.function/scope.class/etc. Andrei agreed that there should be a compile-time reflection that would allow function to call itself in some generic way.
May 04 2009
prev sibling parent reply Georg Wrede <georg.wrede iki.fi> writes:
bearophile wrote:
 Sometimes I rename recursive functions, or I duplicate and modify

of their old name, so for example they recurse to their old name.
 So inside a function I'd like to have a standard name to call the

 (If you have two or more recursive functions that call each other
 this

not deserve help from the language).
 
 I have just discussed this in the Python newsgroup too:
 http://groups.google.com/group/comp.lang.python/browse_thread/thread/d265da85d4b70eaf#
 
 I use more recursivity in D than in Python, because Python has troubles with
it.
 
 In future in D2 you may use:
 
 int ANUGLYNAME(int n) {
     if (n <= 1)
         return 1;
     else
         mixin(__FUNCTION__ ~ "(n - 1) * n");
 }
 
 But you can't use __FUNCTION__ into a delegate/function
 pointer/lambdabecause the name isn't available, and it's a bit ugly
 syntax anyway...
 
 This looks a bit better:
 
 int ANUGLYNAME(int n) {
     if (n <= 1)
         return 1;
     else
         __self(n - 1) * n;
 }
 
 Other syntaxes are possible.
 
 __self is a way to denote the pointer/delegate of the function
 currently being run, so I think the compiler is always able to that, for
 delegate/ function pointers/ lambdas/ methods/ virtual methods/ opCalls too.

Since you need this at compile time, then you don't need a pointer. A name would be enough. If, as Denis pointed out, Andrei is going to provide that, and if it turns out to have a long name (like scope.function.name), then I hope it will be implemented so that you can alias that into something shorter, like "thisf" or "me".
May 04 2009
parent reply BCS <ao pathlink.com> writes:
Reply to Georg,

 bearophile wrote:
 
 Sometimes I rename recursive functions, or I duplicate and modify
 

copy of their old name, so for example they recurse to their old name.
 So inside a function I'd like to have a standard name to call the
 

 (If you have two or more recursive functions that call each other
 this
 

not deserve help from the language).
 I have just discussed this in the Python newsgroup too:
 http://groups.google.com/group/comp.lang.python/browse_thread/thread/
 d265da85d4b70eaf#
 
 I use more recursivity in D than in Python, because Python has
 troubles with it.
 
 In future in D2 you may use:
 
 int ANUGLYNAME(int n) {
 if (n <= 1)
 return 1;
 else
 mixin(__FUNCTION__ ~ "(n - 1) * n");
 }
 But you can't use __FUNCTION__ into a delegate/function
 pointer/lambdabecause the name isn't available, and it's a bit ugly
 syntax anyway...
 
 This looks a bit better:
 
 int ANUGLYNAME(int n) {
 if (n <= 1)
 return 1;
 else
 __self(n - 1) * n;
 }
 Other syntaxes are possible.
 
 __self is a way to denote the pointer/delegate of the function
 currently being run, so I think the compiler is always able to that,
 for
 delegate/ function pointers/ lambdas/ methods/ virtual methods/
 opCalls too.

name would be enough. If, as Denis pointed out, Andrei is going to provide that, and if it turns out to have a long name (like scope.function.name), then I hope it will be implemented so that you can alias that into something shorter, like "thisf" or "me".

void main() { int i = 0; auto dg = (int j) { i++; return j <= 1 ? 1 : self(j-1) + self(j-2); // self can't be a name as the function dosn't have a name // and it can't be a compile time const at the context is not known. }; dg(5); }
May 04 2009
parent Georg Wrede <georg.wrede iki.fi> writes:
BCS wrote:
 Reply to Georg,
 
 bearophile wrote:

 Sometimes I rename recursive functions, or I duplicate and modify

copy of their old name, so for example they recurse to their old name.
 So inside a function I'd like to have a standard name to call the

 (If you have two or more recursive functions that call each other
 this

not deserve help from the language).
 I have just discussed this in the Python newsgroup too:
 http://groups.google.com/group/comp.lang.python/browse_thread/thread/
 d265da85d4b70eaf#

 I use more recursivity in D than in Python, because Python has
 troubles with it.

 In future in D2 you may use:

 int ANUGLYNAME(int n) {
 if (n <= 1)
 return 1;
 else
 mixin(__FUNCTION__ ~ "(n - 1) * n");
 }
 But you can't use __FUNCTION__ into a delegate/function
 pointer/lambdabecause the name isn't available, and it's a bit ugly
 syntax anyway...

 This looks a bit better:

 int ANUGLYNAME(int n) {
 if (n <= 1)
 return 1;
 else
 __self(n - 1) * n;
 }
 Other syntaxes are possible.

 __self is a way to denote the pointer/delegate of the function
 currently being run, so I think the compiler is always able to that,
 for
 delegate/ function pointers/ lambdas/ methods/ virtual methods/
 opCalls too.

name would be enough. If, as Denis pointed out, Andrei is going to provide that, and if it turns out to have a long name (like scope.function.name), then I hope it will be implemented so that you can alias that into something shorter, like "thisf" or "me".

void main() { int i = 0; auto dg = (int j) { i++; return j <= 1 ? 1 : self(j-1) + self(j-2); // self can't be a name as the function dosn't have a name // and it can't be a compile time const at the context is not known. }; dg(5); }

Oh boy, I missed half of the post. (Note to self: remember use two eyes for reading. Especially at the wee hours.)
May 04 2009