It's quite common to see maps or sets that make use of a string->object
association, usually as <std::string, T>. However, this can result in
inefficient code when performing lookups or indexing, as something like:
std::map<std::string, T> some_map;
...
auto iter = some_map.find("Name");
...
will result in a std::string instance being constructed around "Name",
which is less than ideal.
With a heterogenous comparator, however (such as std::less<>), like:
std::map<std::string, T, std::less<>>
we allow the container to do automatic type deduction and comparisons.
This allows types comparable to the key type to be used in find calls,
etc, without actually needing to construct the key type around the other
type.
The main way to enable containers to perform such behavior is by
defining a type named is_transparent within the comparator type.
By using the std::string_view constructor for std::string, we can avoid
the char* constructor, which would require a strlen call in order to
determine the string size. This also allows it to work with
non-null-terminated strings.
We can make use of the result of a find() call to avoid performing two
redundant lookups into the command map and also use std::move to avoid
performing potentially reallocating copies.
We can use the result of the first lookup to avoid doing another
redundant lookup to perform the erasure.
While we're at it, we can use std::string's std::string_view constructor
in order to avoid an unnecessary strlen() call.
Allows avoiding a redundant initial element. We can also remove the
const from the std::function rvalue to allow a std::move to take effect.
We can also use the std::string_view constructor for std::string to
avoid an unnecessary strlen() call.
These are used within a file-scope lookup table in urde. Without this,
technically those constructors are runtime static constructors.
This allows the compiler to initialize them at compile-time.
