Docs: Spell C++ lambdas like functions, not variables

[dexonsmith]

Summary

I argue we should spell C++ lambdas (and other function-like variables) like functions, not like variables.

• Use verbs, not nouns.
• Use lowerCamelCase.

Thoughts?

[dexonsmith]

I've started an RFC on llvm-dev to discuss whether we should make this change:
http://lists.llvm.org/pipermail/llvm-dev/2018-July/124466.html

[lattner]

Patch LGTM, I'd suggest including an example like `auto updateResult = [&](){...`

[dblaikie]

Only lambdas, and not other functors (like std::function, etc)?

So we could end up with code like:

MyFunctor = myLambda;

Though I suppose that's OK - and it's only in the local scope of a function
& not like any interesting object-like operations (such as assignment) can
be done with the lambda as the subject anyway, so it does look a lot like a
function... (except you can't assign it to a function pointer - but at
least the lambda should be nearby in the code so that's not too confusing)

[dexonsmith]

In D48991#1156565, @dblaikie wrote:

Only lambdas, and not other functors (like std::function, etc)?

So we could end up with code like:

MyFunctor = myLambda;

Though I suppose that's OK - and it's only in the local scope of a function
& not like any interesting object-like operations (such as assignment) can
be done with the lambda as the subject anyway, so it does look a lot like a
function... (except you can't assign it to a function pointer - but at
least the lambda should be nearby in the code so that's not too confusing)

I was just about to commit this (with an example), then I saw your comment which I had missed. The idea would actually be:

myFunctor = myLambda;

Essentially, objects primarily used as callable things would be spelled like functions.

Would you rather carve out lambdas specifically?

[dexonsmith]

Abandoning this in light of the recent discussions.

llvm/docs/CodingStandards.rst

 * **Variable names** should be nouns (as they represent state).  The name should
   be camel case, and start with an upper case letter (e.g. ``Leader`` or
   ``Boats``).
   
 * **Function names** should be verb phrases (as they represent actions), and
   command-like function should be imperative.  The name should be camel case,
   and start with a lower case letter (e.g. ``openFile()`` or ``isFoo()``).
 
+* **Function-like objects**, such as C++ lambdas and function pointers, should
+  be written like function names.
+
 * **Enum declarations** (e.g. ``enum Foo {...}``) are types, so they should
   follow the naming conventions for types.  A common use for enums is as a
   discriminator for a union, or an indicator of a subclass.  When an enum is
   used for something like this, it should have a ``Kind`` suffix
   (e.g. ``ValueKind``).
   
 * **Enumerators** (e.g. ``enum { Foo, Bar }``) and **public member variables**
   should start with an upper-case letter, just like types.  Unless the