www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - local variable naming convention

reply "Boyd" <gaboonviper gmx.net> writes:
I'm in the process of adapting my library to the D standard 
naming convention.

The problem is that I used to separate member variables and local 
variables through capitalization.

X would be a member variable.
x would be a local variable.

this allowed me, among other things, to create constructors such 
as:

this(int x, int y)
{
    X = x;
    Y = y;
}

So now my question is, how do you distinguish between member and 
local vars in such cases?

Cheers,
Boyd
Dec 20 2013
next sibling parent reply "kdmult" <kdmult ya.ru> writes:
On Friday, 20 December 2013 at 09:15:26 UTC, Boyd wrote:

 this(int x, int y)
 {
    X = x;
    Y = y;
 }

 So now my question is, how do you distinguish between member 
 and local vars in such cases?


this(int x, int y)
{
    this.x = x;
    this.y = y;
}
Dec 20 2013
parent reply "bearophile" <bearophileHUGS lycos.com> writes:
kdmult:


 this(int x, int y)
 {
    this.x = x;
    this.y = y;
 }


In D I prefer:

this(int x_, int y_) {
     this.x = x_;
     this.y = y_;
}

Bye,
bearophile
Dec 20 2013
next sibling parent "Boyd" <gaboonviper gmx.net> writes:
On Friday, 20 December 2013 at 09:30:08 UTC, bearophile wrote:

 kdmult:


 this(int x, int y)
 {
   this.x = x;
   this.y = y;
 }


 In D I prefer:

 this(int x_, int y_) {
     this.x = x_;
     this.y = y_;
 }

 Bye,
 bearophile


I concur. And I should probably get used to using 'this' a lot as 
well.

Maybe it would be a good idea to add this kind of information to 
the official coding style guide.
Dec 20 2013
prev sibling next sibling parent reply Jonathan M Davis <jmdavisProg gmx.com> writes:
On Friday, December 20, 2013 10:30:06 bearophile wrote:

 kdmult:

 this(int x, int y)
 {
 
    this.x = x;
    this.y = y;
 
 }


 
 In D I prefer:
 
 this(int x_, int y_) {
      this.x = x_;
      this.y = y_;
 }


Whereas I put the underscore before (e.g. _x), and some folks like to do m_x 
(though I haven't seen many people do that in D - more in C++). It doesn't 
really matter. But the typical naming conventions have types being 
PascalCased, and everything else being camelCased, so naming any variables 
with PascalCasing (or simply making them all uppercase) is definitely not the 
typical thing to do in D.

http://dlang.org/dstyle.html

- Jonathan M Davis
Dec 20 2013
parent reply "Jeremy DeHaan" <dehaan.jeremiah gmail.com> writes:
On Friday, 20 December 2013 at 10:06:36 UTC, Jonathan M Davis 
wrote:

 Whereas I put the underscore before (e.g. _x), and some folks 
 like to do m_x
 (though I haven't seen many people do that in D - more in C++).



I tend to use the m_x naming convention, though I limit it to 
private member variables. Otherwise I stick to camelCase.

If it is a parameter that is just going to be assigned to a 
member variable and they would otherwise have the same name, I 
usually add a prefix to parameter name to differentiate the two. 
In constructors it is usually "the" and in setters it is usually 
"new." Something like:

this(string theTitle)
{
      title = theTitle;
}

void setTitle(string newTitle)
{
      title = newTitle;
}
Dec 20 2013
parent reply "Boyd" <gaboonviper gmx.net> writes:
On Friday, 20 December 2013 at 10:29:26 UTC, Jeremy DeHaan wrote:

 On Friday, 20 December 2013 at 10:06:36 UTC, Jonathan M Davis 
 wrote:

 Whereas I put the underscore before (e.g. _x), and some folks 
 like to do m_x
 (though I haven't seen many people do that in D - more in C++).



 I tend to use the m_x naming convention, though I limit it to 
 private member variables. Otherwise I stick to camelCase.

 If it is a parameter that is just going to be assigned to a 
 member variable and they would otherwise have the same name, I 
 usually add a prefix to parameter name to differentiate the 
 two. In constructors it is usually "the" and in setters it is 
 usually "new." Something like:

 this(string theTitle)
 {
      title = theTitle;
 }

 void setTitle(string newTitle)
 {
      title = newTitle;
 }


I've never seen the use of "the" before. I must say I like the 
sound of it better than using 'title_'. I'm not a big fan of 
arbitrary signs, even though I use '_title' if there is already 
setter called 'title'

For setter parameters I tend to use 'value', though now that 
might compromise certain cases where 'value' is already a member. 
I do occasionally use 'new' as well, so I'll probably start using 
that.

What does m_ stand for anyway?
Dec 20 2013
parent Jacob Carlborg <doob me.com> writes:
On 2013-12-20 12:16, Boyd wrote:


 What does m_ stand for anyway?


"member" I would guess.

-- 
/Jacob Carlborg
Dec 20 2013
prev sibling parent "Gary Willoughby" <dev nomad.so> writes:
On Friday, 20 December 2013 at 09:30:08 UTC, bearophile wrote:

 kdmult:


 this(int x, int y)
 {
   this.x = x;
   this.y = y;
 }


 In D I prefer:

 this(int x_, int y_) {
     this.x = x_;
     this.y = y_;
 }

 Bye,
 bearophile


I tend to use the opposite for private/protected member variables 
as per the d style guidelines located here: 
http://dlang.org/dstyle.html.

"Unless listed otherwise below, names should be camelCased (this 
includes all variables). So, names formed by joining multiple 
words have each word other than the first word capitalized. Also, 
names do not begin with an underscore ‘_’ unless they are 
private."

Example:

this(int x, int y)
{
     this._x = x;
     this._y = y;
}
Dec 20 2013
prev sibling parent Jacob Carlborg <doob me.com> writes:
On 2013-12-20 10:15, Boyd wrote:

 I'm in the process of adapting my library to the D standard naming
 convention.

 The problem is that I used to separate member variables and local
 variables through capitalization.

 X would be a member variable.
 x would be a local variable.

 this allowed me, among other things, to create constructors such as:

 this(int x, int y)
 {
     X = x;
     Y = y;
 }

 So now my question is, how do you distinguish between member and local
 vars in such cases?


This is how I would do it:

class Point
{
     private int x_;
     private int y_;

     this (int x, int y)
     {
         x_ = x;
         y_ = y;
     }

     int x ()
     {
         return x_;
     }

     int y ()
     {
         return y_;
     }

     int x (int x)
     {
         return x_ = x;
     }

     int y (int y)
     {
         return y_ = y;
     }
}

If I don't have a conflict with methods I just drop the underscore and 
use "this." in the constructor:

struct Point
{
     int x;
     int y;

     this (int x, int y)
     {
         this.x = x;
         this.y = y;
     }
}

-- 
/Jacob Carlborg
Dec 20 2013