www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - How would you do this in D?

reply Jose Armando Garcia <jsancio gmail.com> writes:
Hey guys,

I am trying to create a function that return true or executes
"something" the n-th time it is called from a specific call site. How
would you do that in D? In C we can do that with the help of
pre-processor macros. E.g.:

---
#include <assert.h>

#define EVERY(N, ACTION) { static int counter = 0; if(++counter > (N))
counter -= (N); if(counter == 1) (ACTION); }

int main()
{
   int i = 0;
   int j = 0;
   while(i < 10)
   {
      EVERY(10, ++j);
      EVERY(2, ++i);
   }
   assert(j == 2);
   assert(i == 10);
}
---

In D, I hacked the following implementation. I don't like this
implementation for a log of reason... Am I missing some D feature? Can
someone do better?

---
int[string] map;

bool every(string file = __FILE__, int line = __LINE__)(int time)
{
   // assume file ~ "+" ~ to!string(line) is unique
   // assumption could be removed by using a struct
   string key = file ~ "+" ~ to!string(line);

   map[key] += 1;
   if(map[key] > time) map[key] -= time;

   return map[key] == 1;
}

unittest
{
   auto i = 0;
   auto j = 0;
   while(i < 10)
   {
      if(every(10)) ++j;
      if(every(2)) ++i;
   }
   assert(j == 2);
   assert(i == 10);
}

void main() {}
---

Thanks!
-Jose
May 10 2011
next sibling parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
On 5/10/11 7:32 PM, Jose Armando Garcia wrote:
 Hey guys,

 I am trying to create a function that return true or executes
 "something" the n-th time it is called from a specific call site. How
 would you do that in D? In C we can do that with the help of
 pre-processor macros. E.g.:

 ---
 #include<assert.h>

 #define EVERY(N, ACTION) { static int counter = 0; if(++counter>  (N))
 counter -= (N); if(counter == 1) (ACTION); }

 int main()
 {
     int i = 0;
     int j = 0;
     while(i<  10)
     {
        EVERY(10, ++j);
        EVERY(2, ++i);
     }
     assert(j == 2);
     assert(i == 10);
 }
 ---

 In D, I hacked the following implementation. I don't like this
 implementation for a log of reason... Am I missing some D feature? Can
 someone do better?

Just use a static variable inside a function parameterized by __FILE__ and __LINE__. Indeed the drawback is that two every() calls in one line will share that static. I consider it a small matter. If it becomes a bear we may as well add __COLUMN__ or something similar. Note that the macro version has other, arguably larger, drawbacks - e.g. it can't be used as an expression, evaluates the limit multiple times. pollutes the global namespace etc. Andrei
May 10 2011
next sibling parent Don <nospam nospam.com> writes:
Jens Mueller wrote:
 Jonathan M Davis wrote:
 On 2011-05-10 18:06, Jose Armando Garcia wrote:
 Thanks. I should have read
 http://www.digitalmars.com/d/2.0/template.html more carefully.

 "Multiple instantiations of a TemplateDeclaration with the same
 TemplateArgumentList, before implicit conversions, all will refer to
 the same instantiation."

 The default values which are evaluated at the call site are part of
 the TemplateArgumentList.

declared. I believe that C++ has the opposite behavior, so it's not uncommon that people miss that. It's _very_ useful though - particularly when dealing with __FILE__ and __LINE__.

I did some little testing (see attached file). The bar() example shows that default arguments are evaluated at call site (even in C++). If it was only evaluated when declared it would always return 1. But __LINE__ does not work as in D. I believe that is due to __LINE__ being a macro in C whereas in D it is evaluated at instantiation time (i.e. it is not text replacement). So it seems that instantiation of default arguments is the same in D and C++. The difference is that __LINE__ and __FILE__ are different things in C++ and D. In C++ there is no such thing as evaluating __LINE__. Or let's say they are constant expressions (due to textual replacement) where in D they are evaluated differently depending on the context. Does this make sense?

__LINE__ and __FILE__ are magical when used as default arguments in D, for exactly this use case, since it is *extremely* useful. In every other case they behave as in C++. (IIRC the magic is not even implemented for default arguments of __LINE__ + 0, only for __LINE__).
May 11 2011
prev sibling parent reply Alexander <aldem+dmars nk7.net> writes:
On 11.05.2011 02:52, Andrei Alexandrescu wrote:

 Note that the macro version has other, arguably larger, drawbacks - e.g. it
can't be used as an expression, evaluates the limit multiple times. pollutes
the global namespace etc.

BTW, I don't get it - why *scoped* variable is going to *global* namespace when declared "static"? This, IMHO, defeats the value and purpose of scoping... /Alexander
May 11 2011
parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
On 05/11/2011 12:07 PM, Alexander wrote:
 On 11.05.2011 02:52, Andrei Alexandrescu wrote:

 Note that the macro version has other, arguably larger, drawbacks - e.g. it
can't be used as an expression, evaluates the limit multiple times. pollutes
the global namespace etc.

BTW, I don't get it - why *scoped* variable is going to *global* namespace when declared "static"? This, IMHO, defeats the value and purpose of scoping... /Alexander

The macro name itself is polluting the global namespace. Andrei
May 11 2011
parent Alexander <aldem+dmars nk7.net> writes:
On 11.05.2011 20:07, Andrei Alexandrescu wrote:

 The macro name itself is polluting the global namespace.

OK, this I understand. But I cannot have something like: { static int i = 0; } { static int i = 1; } This produces linker warning: io.o:(.tdata.+0x0): multiple definition of `void io.main(immutable(char)[][]).int i' Sure, this defined in function scope, not globally, but anyway... /Alexander
May 11 2011
prev sibling next sibling parent reply Daniel Gibson <metalcaedes gmail.com> writes:
Am 11.05.2011 02:32, schrieb Jose Armando Garcia:
 Hey guys,
 
 I am trying to create a function that return true or executes
 "something" the n-th time it is called from a specific call site. How
 would you do that in D? In C we can do that with the help of
 pre-processor macros. E.g.:
 
 ---
 #include <assert.h>
 
 #define EVERY(N, ACTION) { static int counter = 0; if(++counter > (N))
 counter -= (N); if(counter == 1) (ACTION); }
 
 int main()
 {
    int i = 0;
    int j = 0;
    while(i < 10)
    {
       EVERY(10, ++j);
       EVERY(2, ++i);
    }
    assert(j == 2);
    assert(i == 10);
 }
 ---
 
 In D, I hacked the following implementation. I don't like this
 implementation for a log of reason... Am I missing some D feature? Can
 someone do better?
 
 ---
 int[string] map;
 
 bool every(string file = __FILE__, int line = __LINE__)(int time)
 {
    // assume file ~ "+" ~ to!string(line) is unique
    // assumption could be removed by using a struct
    string key = file ~ "+" ~ to!string(line);
 
    map[key] += 1;
    if(map[key] > time) map[key] -= time;
 
    return map[key] == 1;
 }
 
 unittest
 {
    auto i = 0;
    auto j = 0;
    while(i < 10)
    {
       if(every(10)) ++j;
       if(every(2)) ++i;
    }
    assert(j == 2);
    assert(i == 10);
 }
 
 void main() {}
 ---
 
 Thanks!
 -Jose

1. For ACTION you could use a delegate/lambda 2. Using a map is an ugly hack IMHO. IMHO it's not necessary, because the code generated by the template will be unique if __FILE__ and __LINE__ are unique (as you assume), so you could use a static int like in C. However, it's probably smarter and more clean to have struct (or maybe class) containing the counter, the delegate and the threshold (10 for every 10 etc) and a method incrementing the counter and invoking the delegate. The code isn't as short as the C version, but the implementation is more clean IMHO: http://pastebin.com/XVSnALbq There may be a more clever template-trick, however. Cheers, - Daniel
May 10 2011
parent Daniel Gibson <metalcaedes gmail.com> writes:
Am 11.05.2011 02:56, schrieb Daniel Gibson:
 
 There may be a more clever template-trick, however.

What about: void EVERY(int threshold, alias action, string file = __FILE__, int line = __LINE__)() { static int cnt; ++cnt; if(cnt==threshold) { action(); cnt=0; } } void main() { int i,j; while(i<10) { EVERY!(10, {++j;} )(); EVERY!(2, {++i;} ); // last () was optional } assert(j==2); assert(i==10); } :-)
May 10 2011
prev sibling next sibling parent Jose Armando Garcia <jsancio gmail.com> writes:
Thanks. I should have read
http://www.digitalmars.com/d/2.0/template.html more carefully.

"Multiple instantiations of a TemplateDeclaration with the same
TemplateArgumentList, before implicit conversions, all will refer to
the same instantiation."

The default values which are evaluated at the call site are part of
the TemplateArgumentList.

On Tue, May 10, 2011 at 9:52 PM, Andrei Alexandrescu
<SeeWebsiteForEmail erdani.org> wrote:
 On 5/10/11 7:32 PM, Jose Armando Garcia wrote:
 Hey guys,

 I am trying to create a function that return true or executes
 "something" the n-th time it is called from a specific call site. How
 would you do that in D? In C we can do that with the help of
 pre-processor macros. E.g.:

 ---
 #include<assert.h>

 #define EVERY(N, ACTION) { static int counter =3D 0; if(++counter> =A0(N=


 counter -=3D (N); if(counter =3D=3D 1) (ACTION); }

 int main()
 {
 =A0 =A0int i =3D 0;
 =A0 =A0int j =3D 0;
 =A0 =A0while(i< =A010)
 =A0 =A0{
 =A0 =A0 =A0 EVERY(10, ++j);
 =A0 =A0 =A0 EVERY(2, ++i);
 =A0 =A0}
 =A0 =A0assert(j =3D=3D 2);
 =A0 =A0assert(i =3D=3D 10);
 }
 ---

 In D, I hacked the following implementation. I don't like this
 implementation for a log of reason... Am I missing some D feature? Can
 someone do better?

[snip] Just use a static variable inside a function parameterized by __FILE__ an=

 __LINE__. Indeed the drawback is that two every() calls in one line will
 share that static. I consider it a small matter. If it becomes a bear we =

 as well add __COLUMN__ or something similar.

 Note that the macro version has other, arguably larger, drawbacks - e.g. =

 can't be used as an expression, evaluates the limit multiple times. pollu=

 the global namespace etc.


 Andrei

May 10 2011
prev sibling next sibling parent Jonathan M Davis <jmdavisProg gmx.com> writes:
On 2011-05-10 18:06, Jose Armando Garcia wrote:
 Thanks. I should have read
 http://www.digitalmars.com/d/2.0/template.html more carefully.
 
 "Multiple instantiations of a TemplateDeclaration with the same
 TemplateArgumentList, before implicit conversions, all will refer to
 the same instantiation."
 
 The default values which are evaluated at the call site are part of
 the TemplateArgumentList.

Yes, default arguments are evaluated at the call site, not where the code is declared. I believe that C++ has the opposite behavior, so it's not uncommon that people miss that. It's _very_ useful though - particularly when dealing with __FILE__ and __LINE__. - Jonathan M Davis
May 10 2011
prev sibling next sibling parent Jens Mueller <jens.k.mueller gmx.de> writes:
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline

Jonathan M Davis wrote:
 On 2011-05-10 18:06, Jose Armando Garcia wrote:
 Thanks. I should have read
 http://www.digitalmars.com/d/2.0/template.html more carefully.
 
 "Multiple instantiations of a TemplateDeclaration with the same
 TemplateArgumentList, before implicit conversions, all will refer to
 the same instantiation."
 
 The default values which are evaluated at the call site are part of
 the TemplateArgumentList.

Yes, default arguments are evaluated at the call site, not where the code is declared. I believe that C++ has the opposite behavior, so it's not uncommon that people miss that. It's _very_ useful though - particularly when dealing with __FILE__ and __LINE__.

I did some little testing (see attached file). The bar() example shows that default arguments are evaluated at call site (even in C++). If it was only evaluated when declared it would always return 1. But __LINE__ does not work as in D. I believe that is due to __LINE__ being a macro in C whereas in D it is evaluated at instantiation time (i.e. it is not text replacement). So it seems that instantiation of default arguments is the same in D and C++. The difference is that __LINE__ and __FILE__ are different things in C++ and D. In C++ there is no such thing as evaluating __LINE__. Or let's say they are constant expressions (due to textual replacement) where in D they are evaluated differently depending on the context. Does this make sense? Jens
May 11 2011
prev sibling next sibling parent so <so so.so> writes:
 Just use a static variable inside a function parameterized by __FILE__  
 and __LINE__. Indeed the drawback is that two every() calls in one line  
 will share that static. I consider it a small matter. If it becomes a  
 bear we may as well add __COLUMN__ or something similar.

__COLUMN__ would be a very nice addition. Not an everyday usage but there was this unorthodox approach on UI coding, immediate mode, which i quite like. The problem was the id generation. There were solutions, but either not enough or too verbose. With default template args and __F,L,C__ we would have a pretty good solution for this particular problem and similar issues. I don't know, maybe there are already some neat solutions to this in D.
May 11 2011
prev sibling parent Jonathan M Davis <jmdavisProg gmx.com> writes:
On 2011-05-11 03:59, Don wrote:
 Jens Mueller wrote:
 Jonathan M Davis wrote:
 On 2011-05-10 18:06, Jose Armando Garcia wrote:
 Thanks. I should have read
 http://www.digitalmars.com/d/2.0/template.html more carefully.
 
 "Multiple instantiations of a TemplateDeclaration with the same
 TemplateArgumentList, before implicit conversions, all will refer to
 the same instantiation."
 
 The default values which are evaluated at the call site are part of
 the TemplateArgumentList.

Yes, default arguments are evaluated at the call site, not where the code is declared. I believe that C++ has the opposite behavior, so it's not uncommon that people miss that. It's _very_ useful though - particularly when dealing with __FILE__ and __LINE__.

I did some little testing (see attached file). The bar() example shows that default arguments are evaluated at call site (even in C++). If it was only evaluated when declared it would always return 1. But __LINE__ does not work as in D. I believe that is due to __LINE__ being a macro in C whereas in D it is evaluated at instantiation time (i.e. it is not text replacement). So it seems that instantiation of default arguments is the same in D and C++. The difference is that __LINE__ and __FILE__ are different things in C++ and D. In C++ there is no such thing as evaluating __LINE__. Or let's say they are constant expressions (due to textual replacement) where in D they are evaluated differently depending on the context. Does this make sense?

__LINE__ and __FILE__ are magical when used as default arguments in D, for exactly this use case, since it is *extremely* useful. In every other case they behave as in C++. (IIRC the magic is not even implemented for default arguments of __LINE__ + 0, only for __LINE__).

Hmm. Good to know. Well regardless of why and how it works with __FILE__ and __LINE__, it's definitely fantastic that they do. It is indeed _extremely_ useful. - Jonathan M Davis
May 11 2011