select optimization: avoid backtracking on mutually exclusive branches

When we match against characters that belong to no other select branch we can avoid backtracking by a significant amount.
Note: HeadOptions could be a fairly large sequence, here we use calculate_first() to evaluate the initial condition for a mutually exclusive branch*

Author: Andersama

include/ctre/atoms_characters.hpp

@@ -24,21 +24,21 @@ template <auto V> struct character {
 };
 
 template <typename... Content> struct negative_set {
-	template <typename CharT> CTRE_FORCE_INLINE static constexpr bool match_char(CharT value) noexcept {
+	template <typename CharT> CTRE_FORCE_INLINE static constexpr bool match_char([[maybe_unused]] CharT value) noexcept {
 		return !(Content::match_char(value) || ... || false);
 	}
 };
 
 template <typename... Content> struct set {
-	template <typename CharT> CTRE_FORCE_INLINE static constexpr bool match_char(CharT value) noexcept {
+	template <typename CharT> CTRE_FORCE_INLINE static constexpr bool match_char([[maybe_unused]] CharT value) noexcept {
 		return (Content::match_char(value) || ... || false);
 	}
 };
 
 template <auto... Cs> struct enumeration : set<character<Cs>...> { };
 
 template <typename... Content> struct negate {
-	template <typename CharT> CTRE_FORCE_INLINE static constexpr bool match_char(CharT value) noexcept {
+	template <typename CharT> CTRE_FORCE_INLINE static constexpr bool match_char([[maybe_unused]] CharT value) noexcept {
 		return !(Content::match_char(value) || ... || false);
 	}
 };

include/ctre/evaluation.hpp

@@ -136,11 +136,32 @@ constexpr CTRE_FORCE_INLINE R evaluate(const Iterator begin, Iterator current, c
 // matching select in patterns
 template <typename R, typename Iterator, typename EndIterator, typename HeadOptions, typename... TailOptions, typename... Tail> 
 constexpr CTRE_FORCE_INLINE R evaluate(const Iterator begin, Iterator current, const EndIterator end, const flags & f, R captures, ctll::list<select<HeadOptions, TailOptions...>, Tail...>) noexcept {
-	if (auto r = evaluate(begin, current, end, f, captures, ctll::list<HeadOptions, Tail...>())) {
-		return r;
+#ifndef CTRE_DISABLE_GREEDY_OPT
+	if constexpr (sizeof...(TailOptions) > 0 && !collides(calculate_first(sequence<HeadOptions, Tail...>{}), calculate_first(sequence<select<TailOptions...>, Tail...>{}))) {
+		using set_type = decltype(transform_into_set(calculate_first(sequence<HeadOptions, Tail...>{})));
+		if constexpr (::std::is_same_v<set<>, set_type>) {
+			if (auto r = evaluate(begin, current, end, f, captures, ctll::list<HeadOptions, Tail...>())) {
+				return r;
+			} else {
+				return evaluate(begin, current, end, f, captures, ctll::list<select<TailOptions...>, Tail...>());
+			}
+		} else {
+			if (auto r = evaluate(begin, current, end, f, captures, ctll::list<set_type, end_cycle_mark>{})) {
+				return evaluate(begin, current, end, f, captures, ctll::list<HeadOptions, Tail...>{});
+			} else {
+				return evaluate(begin, current, end, f, captures, ctll::list<select<TailOptions...>, Tail...>());
+			}
+		}
 	} else {
-		return evaluate(begin, current, end, f, captures, ctll::list<select<TailOptions...>, Tail...>());
+#endif
+		if (auto r = evaluate(begin, current, end, f, captures, ctll::list<HeadOptions, Tail...>())) {
+			return r;
+		} else {
+			return evaluate(begin, current, end, f, captures, ctll::list<select<TailOptions...>, Tail...>());
+		}
+#ifndef CTRE_DISABLE_GREEDY_OPT
 	}
+#endif
 }
 
 template <typename R, typename Iterator, typename EndIterator, typename... Tail> 

include/ctre/first.hpp

@@ -368,6 +368,21 @@ template <typename CB> constexpr void negative_helper(ctre::negative_set<>, CB &
 	}
 }
 
+template <typename... Content>
+constexpr auto transform_into_set(ctll::list<Content...>) {
+	return ctre::set<decltype(transform_into_set(Content{}))...>{};
+}
+
+template <typename T>
+constexpr auto transform_into_set(T) {
+	return T{};
+}
+
+template<>
+constexpr auto transform_into_set(can_be_anything) {
+	return ctre::char_range<std::numeric_limits<int64_t>::min(), std::numeric_limits<int64_t>::max()>{};
+}
+
 // simple fixed set
 // TODO: this needs some optimizations
 template <size_t Capacity> class point_set {
@@ -469,6 +484,9 @@ template <size_t Capacity> class point_set {
 	constexpr bool check(can_be_anything) {
 		return used > 0;
 	}
+	constexpr bool check(empty) {
+		return used == 0;
+	}
 	template <typename... Content> constexpr bool check(ctre::negative_set<Content...> nset) {
 		bool collision = false;
 		negative_helper(nset, [&](int64_t low, int64_t high){
@@ -497,6 +515,9 @@ template <size_t Capacity> class point_set {
 	constexpr void populate(can_be_anything) {
 		insert(std::numeric_limits<int64_t>::min(), std::numeric_limits<int64_t>::max());
 	}
+	constexpr void populate(empty) {
+		//do nothing
+	}
 	template <typename... Content> constexpr void populate(ctre::negative_set<Content...> nset) {
 		negative_helper(nset, [&](int64_t low, int64_t high){
 			this->insert(low, high);