[boost] code naming conventions

6 Mar 2016

      I've written a lot of code in the boost/standard library style.
I've become increasingly annoyed at naming my variables when coding in 
this style.

Looking to the standard library implementations for guidance isn't much 
help as they often use conventions like local variables are named with a 
leading double underscore and member variables are named with a leading 
underscore and capital letter. I.E. things I'm not allowed to do as I'm 
not a standard library implementer.

Good names are generally taken by types leading to distress when trying 
to name objects and functions.

Here's a concrete example:

// type takes the most natural name
enum class format {
     rgba,
     rgb,
     float // enum value wants reserved name
};

class image {
public:
     // getter wants the same name
     format format() const noexcept
     { return this->format; }

     // setter wants the same name
     void format( format format ) noexcept
     // parameter wants the same name
     { this->format = format; }
private:
     // member variable wants the same name
     format format;
};

format bits_to_format( int bits )
{
     // local variable wants the same name
     format format = format::rgba;
     if ( bits == 24 ) {
         format = format::rgb;
     }
     return format;
}

// unrestricted template parameter does *not* want the same name
template< typename Format >
std::ostream& print_format( std::ostream&, Format format );

// Concept template parameter *does* want the same name
template< Format Format >
std::ostream& print_format( std::ostream&, Format format );

What I end up doing right now is something like:

// type takes the most natural name
enum class format {
     rgba,
     rgb,
     float_ // add trailing underscore to reserved name
};

class image {
public:
     // prefix getter with get_
     format get_format() const noexcept
     { return _format; }
     // prefix setter with get_
     void set_format( format format_ ) noexcept
     // trailing underscore on parameter
     { _format = format_; }
private:
     // leading underscore on member
     format _format;
};

format bits_to_format( int bits )
{
     // cutesy abbreviation for local variable
     format fmt = format::rgba;
     if ( bits == 24 ) {
         fmt = format::rgb;
     }
     return fmt;
}

template< typename Format >
std::ostream& print_format( std::ostream&, Format format_ );

// cutesy abbreviation for constrained template type
template< Format Fmt >
std::ostream& print_format( std::ostream&, Fmt format_ );

Having to come up with cutesy abbreviations for every local variable 
that are still meaningful is especially distracting.
Surely enough code has been written that this has been solved.

I looked through several boost library implementations but didn't see 
anything that stuck out as a clear convention.

Adobe's ASL library seems to append _t postfix to type names and _m 
postfix to member variables.
They also use very terse names for template parameter type names as well 
as parameter names and local variables. Like in:

template <typename I, // I models ForwardIterator
           typename N, // N models IntegralType
           typename T, // T == result_type(P)
           typename C, // C models StrictWeakOrdering(T, T)
           typename P>
// P models UnaryFunction(value_type(I)) -> T
I lower_bound_n_(I f, N n, const T& x, C c, P p) {
     while (n != 0) {
         N h = n >> 1;
         I m = boost::next(f, h);

         if (c(p(*m), x)) {
             f = boost::next(m);
             n -= h + N(1);
         } else {
             n = h;
         }
     }
     return f;
}

What's your preferred convention?
If possible please answer by modifying the initial concrete example and 
providing annotations.

[boost] code naming conventions

Michael Marcin