There is, and I plan to write about that 🙂 In the meantime, maybe you’ll be interested in having a look at Boost.Parameter, that does it and much more, but at the cost of impacting the function prototype.

Ok so passing the semantics of a default consructed-optional through the strong type construction. Thanks for sharing this idea, sehe.

(In fact, using optional in the interface presents issues (you can’t ever pass temporary values by const reference because the optional doesn’t afford references — with good reason, but still). I’d probably avoid optional here.)

namespace mylibrary {
    // expose "Niebler" functors for callers
    using tagging::tag;
    inline constexpr auto firstname = tag;
    inline constexpr auto lastname  = tag;

    using opt_str = std::optional;
    using tagging::tagged;

    void findEmployees(tagged firstname, tagged lastname) {
        auto sep = [first=true]() mutable { return first? (first = false, "") : ", "; };

        std::cout << "findEmployees(";
        if (firstname) std::cout << sep() << "firstname:" << std::quoted(*firstname);
        if (lastname)  std::cout << sep() << "lastname:" << std::quoted(*lastname);
        std::cout << ")n";
    }

    template 
        void genericQuery(tagged firstname, tagged lastname) {
            std::cout << "genericQuery(" << firstname << ", " << lastname << ")n";
        }
}

See a full PoC: http://coliru.stacked-crooked.com/a/0a8b618f7670cda7

Perhaps something like this:

enum class QueryType
{
FirstName,
LastName
};

struct QueryData
{
QueryType type;
std::string data;
};

std::vector findEmployees(std::vector queryData);

At call site:

findEmployees({ { QueryType::FirstName,”John” } });
findEmployees({ { QueryType::FirstName,”John” },
{ QueryType::LastName,”Doe” } });
findEmployees({ { QueryType::LastName,”Doe” },
{ QueryType::FirstName,”John” } });

It is ugly with all the braces, but …

findEmployee (firstname=”John”,lastname=”Doe”)

or

findEmployee (lastname=”Doe” , firstname=”John”)

do you know a solution?