I do not understand why error(incompatible operand types) occurred in my c++ code

Question

I wrote a code to analyize javascript code lexeme with c++. Below is the corresponding function. For reference, Kind is a enum class that contains kinds of lex, and definition of a function toKind is below of the function analyzeLexeme.

auto analyzeLexeme(std::wstring & source_code) -> std::vector<Token> {
    using std::__1::wregex;
    using std::regex_search;
    using std::vector;
    using std::wsmatch;
    using std::wstring;
    using std::string;
    using std::tuple;
    using std::map;

    wsmatch matched;
    Kind    result_kind;

    map<string, bool> context  = { { "in_tmplt", false }, };
    auto              result   = vector<Token>();
    auto              reSearch = [&source_code, &matched] (const wregex & re) {
        return regex_search(source_code, matched, re);
    };

    source_code += L'\0';

    for (; source_code[0]; source_code = matched.suffix()) {
        if (reSearch(kReWhiteSpace)) continue;

        result.push_back({(
                reSearch(kReNumLiteral)                             ? [] { return Kind::NumberLiteral; }                       :
                reSearch(kReStrLiteral)                             ? [] { return Kind::StringLiteral; }                       :
                reSearch(kReTmpltHdLiteral) && !context["in_tmplt"] ?
                    [&] {
                        context["in_tmplt"] = true;
                        return Kind::TemplateHeadLiteral;
                    }                                                                                                          :
                reSearch(kReTmpltTlLiteral) && context["in_tmplt"]  ?
                    [&] {
                        context["in_tmplt"] = false;
                        return Kind::TemplateTailLiteral;
                    }                                                                                                          :
                reSearch(kReTmpltMdLiteral) && context["in_tmplt"]   ? [] { return Kind::TemplateMiddleLiteral; }              :
                reSearch(kReTmpltLiteral)                            ? [] { return Kind::TemplateLiteral; }                    :
                reSearch(kReIdentifierKyword)                        ? [&] { return toKind(matched.str(), Kind::Identifier); } :
                reSearch(kReOperatorBracket)                         ? [&] { return toKind(matched.str()); }                   :
                [] { return Kind::Unknown; }
            )(),
            matched.str(),
        });

        if (result.back().kind == Kind::Unknown) {
            std::wcerr << L"[ERR] : Unknown Token : " << source_code.substr(0, 40) << std::endl;
            // fwprintf(stderr, L"[ERR] : Unknown Token : %s", source_code.substr(0, 40).c_str());
            exit(1);
        }
    }

    return result;
}

// str_to_kind is a map(string to kind).
auto toKind(std::wstring str, Kind default_kind) -> Kind {
    return str_to_kind.count(str) ? str_to_kind.at(str) : default_kind;
}

Error is occurred here(reSearch(kReOperatorBracket) ? [&] { return toKind(matched.str()); }). And reason is error: incompatible operand types ('(lambda at ~/projects/lexer.cc:69:72)' and '(lambda at ~/projects/lexer.cc:70:17)').

I do not understand it because return type of toKind is Kind, so lambda function([&] { return toKind(matched.str())) must return Kind value, and lambda function([] { return Kind::Unknown; }) also has no choice but to return a value of type Kind.

At first I thought g++ couldn't interpret my code (in python, sometimes the interpreter can't interpret it if I write down the line I shouldn't write down). However, after many attempts, I found that it was not the main cause either.

Also, if the code was compiled, I would run gdb to debug it, but I couldn't do this either because it was a problem with the compilation process.

Answer 1

Since you use lambdas as operands in a ternary operation, you'll need to wrap those lambdas inside a std::function.

As you can see, all lambdas have their own distinct type that is not std::function. If you want to have an expression that return one type or another, you need some kind of type erasure.

Consider this code:

std::any test = rand() > 10 ? 42 : "a";

Even though you're constructing a std::any, both sides of the operands of the ternary are not the same type and are not convertible between each other.

This code works though:

std::any test = rand() > 10 ? std::any{42} : std::any{"a"};

However, you seems to call the function on the spot, in line in the expression. Considering that, you can also remove all single-statement lambdas, and call the multi statements inside the ternary.

Here's how it would look like if you call them on the spot:

result.push_back({
  (
    reSearch(kReNumLiteral)
      ? Kind::NumberLiteral
      : reSearch(kReStrLiteral)
        ? Kind::StringLiteral
        : reSearch(kReTmpltHdLiteral) && !context["in_tmplt"]
          ? [&] {
            context["in_tmplt"] = true;
            return Kind::TemplateHeadLiteral;
          }() // here!
          : reSearch(kReTmpltTlLiteral) && context["in_tmplt"]
            ? [&] {
              context["in_tmplt"] = false;
              return Kind::TemplateTailLiteral;
            }() // here again, lambda called.
            : reSearch(kReTmpltMdLiteral) && context["in_tmplt"]
              ? Kind::TemplateMiddleLiteral
              : reSearch(kReTmpltLiteral)
                ? Kind::TemplateLiteral;
                : reSearch(kReIdentifierKyword)
                  ? toKind(matched.str(), Kind::Identifier)
                  : reSearch(kReOperatorBracket)
                    ? toKind(matched.str())
                    : Kind::Unknown
  ),
  matched.str(),
});

Here's how it look like if you wrap them all in a type erasure wrapper like std::function:

result.push_back({
  (
    reSearch(kReNumLiteral)
      ? std::function{[]{ return Kind::NumberLiteral; }}
      : reSearch(kReStrLiteral)
        ? std::function{[]{ return Kind::StringLiteral; }}
        : reSearch(kReTmpltHdLiteral) && !context["in_tmplt"]
          ? std::function{[&] {
            context["in_tmplt"] = true;
            return Kind::TemplateHeadLiteral;
          }}
          : reSearch(kReTmpltTlLiteral) && context["in_tmplt"]
            ? std::function{[&] {
              context["in_tmplt"] = false;
              return Kind::TemplateTailLiteral;
            }}
            : reSearch(kReTmpltMdLiteral) && context["in_tmplt"]
              ? std::function{[]{ return Kind::TemplateMiddleLiteral; }}
              : reSearch(kReTmpltLiteral)
                ? std::function{[]{ return Kind::TemplateLiteral; }}
                : reSearch(kReIdentifierKyword)
                  ? std::function{[]{ return toKind(matched.str(), Kind::Identifier); }}
                  : reSearch(kReOperatorBracket)
                    ? std::function{[]{ return toKind(matched.str()); }}
                    : std::function{[]{ return Kind::Unknown; }}
  )(), // call the std::function that wraps a lambda
  matched.str(),
});