Search code examples
c++lambdaconditional-operatorlexer

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


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.


Solution

  • 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(),
    });