Returning a constant on a match

[DiKetarogg]

I'm trying to make a rule that matches \w\+\s*: or \w\+
I cannot use whitespace field as it makes a nonbranch rule
(I want to later use that rule in a dsl::list)

So instead, I thought to make a has_colon rule which if matched,
outputs true and if not, doesn't output anything
(as I couldn't figure how to make a rule output false if it is a nonmatch).

For that to work, has_colon also has to consume any whitespace characters,
so I opted to use identifier to eat those. Whitespace and colon characters
are not expected to be part of the resulting string.

namespace dsl = lexy::dsl;

struct unit {
	unit(const std::string& word, bool has_colon = false);
};

struct word {
	struct str {
		static constexpr
		auto rule = identifier(dsl::ascii::word);
		static constexpr
		auto value = ::lexy::as_string<std::string>;
	};
	static constexpr
	auto rule = dsl::p<str>;
	static constexpr
	auto value = ::lexy::forward<std::string>;
};

struct unit_rule {
	struct has_colon {
		static constexpr
		auto rule = (identifier(dsl::ascii::space) >> dsl::lit_c<':'>)
			| dsl::lit_c<':'>;
		static constexpr
		auto value = ::lexy::constant(true);
	};
	static constexpr
	auto rule = dsl::p<word> >> opt(dsl::p<has_colon>);
	static constexpr
	auto value = ::lexy::construct<unit>;
};

void test() {
	auto input = lexy::read_file<lexy::utf8_encoding>("");
	//error here: In template: static assertion failed due to requirement
	//'_detail::error<unit_rule::has_colon, lexy::lexeme<lexy::_br8>>':
	//missing value callback overload for production
	auto result = lexy::parse<unit_rule>(input.buffer()
		, lexy_ext::report_error.path(""));
}

The question is how to actually produce a boolean value true/false (or no value on non match is also fine) depending on whether there is a colon after a word or not.

Currently, the code above has 2 issues:

• error on case \w\+\s\+
• value is not extracted because (my guess) has_colon does not generate a bool value

Even though a bool value is preferred, I'm fine with a string containing a colon instead, provided there are no whitespaces in between.

Note, that I cannot use operator+ as it makes a nonbranch rule (unless there is a way to avoid making a nonbranch rule, then it's fine).

[foonathan]

The compilation error here is because opt(dsl::p<has_colon>) returns true or lexy::nullopt, but there is no way to construct unit from lexy::nullopt.

The whitespace issue is because after you skip whitespace, you expect a colon, and don't have a way to parse whitespace without a colon. I don't understand why you can't use automatic whitespace skipping. Is whitespace only relevant in some parts of your grammars and not in others? Because otherwise, it's enough to add a whitespace member to the root production and have it propagate through. That way, you don't have to worry about it at all.