static_assert failed: 'choice requires a branch condition'

[totalgee]

Hi there, is there some way one can create a std::variant given some contained type, using lexy::construct? Maybe using something like: lexy::construct<type, variantType>...

With lexy::new_, you can specify the underlying type and the pointer type, I'd like to do something similar, but using variants rather than inheritance and unique_ptr.

I have something like this (not complete code, but should give you the idea), inspired by https://github.com/foonathan/lexy/blob/main/examples/shell.cpp:

struct CmdA {
};
struct CmdB {
};

using Command = std::variant<CmdA, CmdB>;
// define `identifier` and `argument` (as per https://github.com/foonathan/lexy/blob/main/examples/shell.cpp)

struct cmd_A {
    static constexpr auto whitespace = dsl::ascii::space;
    static constexpr auto rule = dsl::keyword<"A">(identifier) + dsl::p<argument> + dsl::eof;
    static constexpr auto value = lexy::construct<CmdA>;
};

struct cmd_B {
    static constexpr auto whitespace = dsl::ascii::space;
    static constexpr auto rule = dsl::keyword<"B">(identifier) + dsl::p<argument> + dsl::eof;
    static constexpr auto value = lexy::construct<CmdB>;
};

struct AnyCommand {
    struct unknown_command {
        static constexpr auto name = "unknown command";
    };

    static constexpr auto rule = [] {
        auto unknown = dsl::error<unknown_command>(identifier);
        auto commands = dsl::p<cmd_A> | dsl::p<cmd_B> | unknown;
        return commands;
    }();
    static constexpr auto value = lexy::forward<Command>;
};

I get errors when I try to test this at compile time:

static_assert([] {
    constexpr auto result = lexy::parse<AnyCommand>(lexy::zstring_input("A something"), lexy::noop);
    return result.is_success();
}());

  C:\Users\...\out\build\x64-debug\vcpkg_installed\x64-windows\include\lexy\dsl\choice.hpp(137): error C2338: static_assert failed: 'choice requires a branch condition'
  C:\Users\...\out\build\x64-debug\vcpkg_installed\x64-windows\include\lexy/dsl/choice.hpp(137): note: the template instantiation context (the oldest one first) is
  C:\Users\...\src\Parser.cpp(119): note: see reference to function template instantiation 'auto lexyd::operator |<lexyd::_prd<`anonymous-namespace'::cmd_A>,lexyd::_prd<`anonymous-namespace'::cmd_B>>(R,S)' being compiled
          with
          [
              R=lexyd::_prd<`anonymous-namespace'::cmd_A>,
              S=lexyd::_prd<`anonymous-namespace'::cmd_B>
          ]

Any suggestions?

[totalgee]

BTW, the "line 119" is this one:

        auto commands = dsl::p<cmd_A> | dsl::p<cmd_B> | unknown;

[totalgee]

Hmm, I think this is not really a problem with using variant -- that part seems to work. I think it's rather something I'm not understanding about the | operator...

[foonathan]

As you realized, the issue is with choice. A choice requires a branch rule, but a plain sequence with + is not a branch. You need to specify which part of the sequence is being used as the condition with >>. The condition is the part that is being checked to determine whether the branch should of the choice should be taken, and then is potentially backtracked if it does not match. You probably want to use the keyword as condition:

struct cmd_A {
    static constexpr auto rule = dsl::keyword<"A">(identifier) >> dsl::p<argument> + dsl::eof;
    static constexpr auto value = lexy::construct<CmdA>;
};

struct cmd_B {
    static constexpr auto rule = dsl::keyword<"B">(identifier) >> dsl::p<argument> + dsl::eof;
    static constexpr auto value = lexy::construct<CmdB>;
};

For more information: https://lexy.foonathan.net/learn/branching/

Edit: removed bogus whitespace rule.

[totalgee]

Thanks for the quick answer! However, it's still giving me the same error, even with the >> (branch rule) instead of + (not branch)...

Here is the complete code for the example, maybe it's something to do with the identifier or argument, which are slightly simplified from the shell example (although I've tried many other combinations of things, with no luck):

namespace test {

    namespace dsl = lexy::dsl;

    struct CmdA {
        std::string_view str;
    };
    struct CmdB {
        std::string_view str;
    };
    using Command = std::variant<CmdA, CmdB>;

    static constexpr auto identifier = dsl::identifier(dsl::ascii::alpha, dsl::ascii::alpha_digit_underscore);
    struct argument {
        struct invalid {
            static constexpr auto name = "invalid argument character";
        };
        static constexpr auto rule = dsl::identifier(dsl::ascii::word);
        static constexpr auto value = lexy::as_string<std::string_view>;
    };

    struct cmd_A {
        static constexpr auto whitespace = dsl::ascii::space;
        static constexpr auto rule = dsl::keyword<"A">(identifier) >> dsl::p<argument> +dsl::eof;
        static constexpr auto value = lexy::construct<CmdA>;
    };

    struct cmd_B {
        static constexpr auto whitespace = dsl::ascii::space;
        static constexpr auto rule = dsl::keyword<"B">(identifier) >> dsl::p<argument> +dsl::eof;
        static constexpr auto value = lexy::construct<CmdB>;
    };

    struct AnyCommand {
        struct unknown_command {
            static constexpr auto name = "unknown command";
        };

        static constexpr auto rule = [] {
            auto unknown = dsl::error<unknown_command>(identifier);
            auto commands = dsl::p<cmd_A> | dsl::p<cmd_B> | unknown;
            return commands;
            }();
        static constexpr auto value = lexy::forward<Command>;
    };

} // namespace test

Compile errors:

C:\Users\...\out\build\x64-debug\vcpkg_installed\x64-windows\include\lexy\dsl\choice.hpp(137): error C2338: static_assert failed: 'choice requires a branch condition'
  C:\Users\...\out\build\x64-debug\vcpkg_installed\x64-windows\include\lexy/dsl/choice.hpp(137): note: the template instantiation context (the oldest one first) is
  C:\Users\...\src\Parser.cpp(50): note: see reference to function template instantiation 'auto lexyd::operator |<lexyd::_prd<test::cmd_A>,lexyd::_prd<test::cmd_B>>(R,S)' being compiled
          with
          [
              R=lexyd::_prd<test::cmd_A>,
              S=lexyd::_prd<test::cmd_B>
          ]

Where line 50 is:

    auto commands = dsl::p<cmd_A> | dsl::p<cmd_B> | unknown;

[totalgee]

I don't know why this is not true, based on what you (and the docs) say about the branch combinator, it should be...?

The following assert fails:

    static_assert(lexy::is_branch_rule([cmd_A::rule](dsl::keyword<"A">(identifier) >> dsl::p<argument> + dsl::eof)));

I suspect maybe it's because my identifier also isn't a branch rule...?

[totalgee]

Aha! It seems to be the whitespace in the cmd_A and cmd_B structs that causes the problem. If I get rid of it, things work...

    struct cmd_A {
        //static constexpr auto whitespace = dsl::ascii::space;
        static constexpr auto rule = dsl::keyword<"A">(identifier) >> dsl::ascii::space >> dsl::p<argument> + dsl::eof;
        static constexpr auto value = lexy::construct<CmdA>;
    };

    struct cmd_B {
        //static constexpr auto whitespace = dsl::ascii::space;
        static constexpr auto rule = dsl::keyword<"B">(identifier) >> dsl::ascii::space >> dsl::p<argument> + dsl::eof;
        static constexpr auto value = lexy::construct<CmdB>;
    };

[foonathan]

Yes, if you add whitespace to a production, lexy will skip whitespace before parsing the dsl::p making it no longer a branch rule. Note that you only need whitespace in a production if the whitespace rule changes, otherwise it's inherited from the parent. If it's inherited, it doesn't need to be skipped before parsing, as it was presumably already skipped after the previous token.

More details here: https://lexy.foonathan.net/reference/dsl/whitespace/#whitespace-auto

[totalgee]

Thanks again, that makes sense (bit by bit...lexy is still pretty new to me!).