added -pedantic -Wall -Wextra

Hana Dusíková · Hana Dusíková · commit 5d0f97a9b586 · 2018-10-25T13:15:31.000+02:00
diff --git a/Makefile b/Makefile
@@ -6,7 +6,7 @@ TARGETS := result.cpp test.cpp $(wildcard tests/benchmark-exec/*.cpp)
 
 DESATOMAT := /www/root/desatomat/console/desatomat.php
 
-CXXFLAGS := -std=c++17 -Iinclude -O3 -Wno-gnu-string-literal-operator-template 
+CXXFLAGS := -std=c++17 -Iinclude -O3 -Wno-gnu-string-literal-operator-template  -pedantic -Wall -Wextra 
 #-Xclang -fconcepts-ts
 LDFLAGS := -lpcre2-8
 
diff --git a/include/ctll/actions.hpp b/include/ctll/actions.hpp
@@ -20,6 +20,7 @@ namespace ctll {
 	template <typename Actions> struct augment_actions<false, Actions>: public Actions {
 		using Actions::apply;
 		// will fail if unknown action is called
+		constexpr static auto apply(...) = delete;
 	};
 }
 
diff --git a/include/ctll/fixed_string.hpp b/include/ctll/fixed_string.hpp
@@ -37,7 +37,7 @@ template <typename CharT, size_t N> class basic_fixed_string {
 template <typename CharT> class basic_fixed_string<CharT, 0> {
 public: 
 	using char_type = CharT;
-	constexpr basic_fixed_string(const CharT(&)[0]) noexcept { }
+	constexpr basic_fixed_string(const CharT *) noexcept { }
 	constexpr size_t size() const noexcept {
 		return 0;
 	}
diff --git a/include/ctll/grammars.hpp b/include/ctll/grammars.hpp
@@ -35,11 +35,11 @@ struct pop_input {
 };
 
 // additional overloads for type list
-template <typename... Ts> constexpr auto push_front(pop_input, list<Ts...>) -> list<Ts...> { return {}; };
+template <typename... Ts> constexpr auto push_front(pop_input, list<Ts...>) -> list<Ts...> { return {}; }
 
-template <typename... Ts> constexpr auto push_front(epsilon, list<Ts...>) -> list<Ts...> { return {}; };
+template <typename... Ts> constexpr auto push_front(epsilon, list<Ts...>) -> list<Ts...> { return {}; }
 
-template <typename... As, typename... Bs> constexpr auto push_front(list<As...>, list<Bs...>) -> list<As..., Bs...> { return {}; };
+template <typename... As, typename... Bs> constexpr auto push_front(list<As...>, list<Bs...>) -> list<As..., Bs...> { return {}; }
 
 template <typename T, typename... As> constexpr auto pop_front_and_push_front(T item, list<As...> l) {
 	return push_front(item, pop_front(l));
diff --git a/include/ctll/list.hpp b/include/ctll/list.hpp
@@ -16,20 +16,20 @@ template <typename... Ts> constexpr auto size(list<Ts...>) noexcept { return siz
 
 	
 // check if the list is empty
-template <typename... Ts> constexpr bool empty(list<Ts...>) noexcept { return false; };
-constexpr bool empty(empty_list) { return true; };
+template <typename... Ts> constexpr bool empty(list<Ts...>) noexcept { return false; }
+constexpr bool empty(empty_list) { return true; }
 
 
 // concat two lists together left to right
-template <typename... As, typename... Bs> constexpr auto concat(list<As...>, list<Bs...>) noexcept -> list<As..., Bs...> { return {}; };
+template <typename... As, typename... Bs> constexpr auto concat(list<As...>, list<Bs...>) noexcept -> list<As..., Bs...> { return {}; }
 
 
 // push something to the front of a list
-template <typename T, typename... As> constexpr auto push_front(T, list<As...>) noexcept -> list<T, As...> { return {}; };
+template <typename T, typename... As> constexpr auto push_front(T, list<As...>) noexcept -> list<T, As...> { return {}; }
 
 
 // pop element from the front of a list
-template <typename T, typename... As> constexpr auto pop_front(list<T, As...>) noexcept -> list<As...> { return {}; };
+template <typename T, typename... As> constexpr auto pop_front(list<T, As...>) noexcept -> list<As...> { return {}; }
 constexpr auto pop_front(empty_list) -> empty_list;
 
 // pop element from the front of a list and return new typelist too
@@ -39,13 +39,13 @@ template <typename Front, typename List> struct list_pop_pair {
 	constexpr list_pop_pair() = default;
 };
 
-template <typename Head, typename... As, typename T = _nothing> constexpr auto pop_and_get_front(list<Head, As...>, T = T()) noexcept -> list_pop_pair<Head, list<As...>> { return {}; };
-template <typename T = _nothing> constexpr auto pop_and_get_front(empty_list, T = T()) noexcept -> list_pop_pair<T, empty_list> { return {}; };
+template <typename Head, typename... As, typename T = _nothing> constexpr auto pop_and_get_front(list<Head, As...>, T = T()) noexcept -> list_pop_pair<Head, list<As...>> { return {}; }
+template <typename T = _nothing> constexpr auto pop_and_get_front(empty_list, T = T()) noexcept -> list_pop_pair<T, empty_list> { return {}; }
 
 
 // return front of the list
-template <typename Head, typename... As, typename T = _nothing> constexpr auto front(list<Head, As...>, T = T()) noexcept -> Head { return {}; };
-template <typename T = _nothing> constexpr auto front(empty_list, T = T()) noexcept -> T { return {}; };
+template <typename Head, typename... As, typename T = _nothing> constexpr auto front(list<Head, As...>, T = T()) noexcept -> Head { return {}; }
+template <typename T = _nothing> constexpr auto front(empty_list, T = T()) noexcept -> T { return {}; }
 
 
 }
diff --git a/include/ctll/parser.hpp b/include/ctll/parser.hpp
@@ -58,7 +58,7 @@ template <typename Grammar, basic_fixed_string input, typename ActionSelector =
 	}
 	// if rule is pop_input => move to next character
 	template <size_t Pos, typename Terminal, typename Stack, typename Subject>
-	static constexpr auto move(ctll::pop_input, Terminal, Stack stack, Subject subject) noexcept {
+	static constexpr auto move(ctll::pop_input, Terminal, Stack, Subject) noexcept {
 		return seed<Pos+1, Stack, Subject, decision::undecided>();
 	}
 	// if rule is string => push it to the front of stack
@@ -74,21 +74,21 @@ template <typename Grammar, basic_fixed_string input, typename ActionSelector =
 	// if rule is string with current character at the beginning (term<V>) => move to next character 
 	// and push string without the character (quick LL(1))
 	template <size_t Pos, auto V, typename... Content, typename Stack, typename Subject>
-	static constexpr auto move(ctll::list<term<V>, Content...> string, term<V>, Stack stack, Subject subject) noexcept {
+	static constexpr auto move(ctll::list<term<V>, Content...>, term<V>, Stack stack, Subject) noexcept {
 		return seed<Pos+1, decltype(push_front(list<Content...>(), stack)), Subject, decision::undecided>();
 	}
 	// if rule is string with any character at the beginning (compatible with current term<T>) => move to next character 
 	// and push string without the character (quick LL(1))
 	template <size_t Pos, auto V, typename... Content, auto T, typename Stack, typename Subject>
-	static constexpr auto move(ctll::list<anything, Content...> string, term<T>, Stack stack, Subject subject) noexcept {
+	static constexpr auto move(ctll::list<anything, Content...>, term<T>, Stack stack, Subject) noexcept {
 		return seed<Pos+1, decltype(push_front(list<Content...>(), stack)), Subject, decision::undecided>();
 	}
 	// decide if we need to take action or move
 	template <size_t Pos, typename Stack, typename Subject> static constexpr auto decide(Stack previous_stack, Subject previous_subject) noexcept {
 		// each call means we pop something from stack
 		auto top_symbol = decltype(ctll::front(previous_stack, empty_stack_symbol()))();
-		auto stack = decltype(ctll::pop_front(previous_stack))();
-		//auto [top_symbol, stack] = pop_and_get_front(previous_stack, empty_stack_symbol());
+		// gcc pedantic warning
+		[[maybe_unused]] auto stack = decltype(ctll::pop_front(previous_stack))();
 		
 		// in case top_symbol is action type (apply it on previous subject and get new one)
 		if constexpr (std::is_base_of_v<ctll::action, decltype(top_symbol)>) {
@@ -132,7 +132,7 @@ template <typename Grammar, basic_fixed_string input, typename ActionSelector =
 	};
 	
 	// trampolines with folded expression
-	template <typename Subject, size_t... Pos> static constexpr auto trampoline_decide(Subject default_subject, std::index_sequence<Pos...>) noexcept {
+	template <typename Subject, size_t... Pos> static constexpr auto trampoline_decide(Subject, std::index_sequence<Pos...>) noexcept {
 		// parse everything for first char and than for next and next ...
 		// Pos+1 is needed as we want to finish calculation with epsilons on stack
 		return (seed<0, decltype(grammar.start_stack), Subject, decision::undecided>::parse() + ... + placeholder<Pos+1>());
@@ -143,9 +143,9 @@ template <typename Grammar, basic_fixed_string input, typename ActionSelector =
 		return trampoline_decide(subject, std::make_index_sequence<input.size()>());
 	}
 	
-	template <typename Subject = empty_subject> using output = decltype(trampoline_decide(Subject()));
+	template <typename Subject = empty_subject> using output = decltype(trampoline_decide<Subject>());
 	static inline constexpr bool correct = trampoline_decide(empty_subject());
-	template <typename Subject = empty_subject> static inline constexpr bool correct_with = trampoline_decide(Subject());
+	template <typename Subject = empty_subject> static inline constexpr bool correct_with = trampoline_decide<Subject>();
 };
 
 } // end of ctll namespace
diff --git a/include/ctre/actions/backreference.inc.hpp b/include/ctre/actions/backreference.inc.hpp
@@ -17,7 +17,7 @@ template <auto V, size_t Id, typename... Ts, size_t Counter> static constexpr au
 }
 
 // relative backreference
-template <auto V, size_t Id, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_relative_back_reference, ctll::term<V>, pcre_context<ctll::list<number<Id>, Ts...>, pcre_parameters<Counter>> subject) {	
+template <auto V, size_t Id, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_relative_back_reference, ctll::term<V>, [[maybe_unused]] pcre_context<ctll::list<number<Id>, Ts...>, pcre_parameters<Counter>> subject) {	
 	// if we are looking outside of existing list of Ids ... reject input during parsing
 	if constexpr (Counter < Id) {
 		return ctll::reject{};
diff --git a/include/ctre/actions/capture.inc.hpp b/include/ctre/actions/capture.inc.hpp
@@ -2,11 +2,11 @@
 #define CTRE__ACTIONS__CAPTURE__HPP
 
 // capture
-template <auto V, typename A, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture, ctll::term<V>, pcre_context<ctll::list<A, Ts...>, pcre_parameters<Counter>> subject) {
+template <auto V, typename A, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture, ctll::term<V>, pcre_context<ctll::list<A, Ts...>, pcre_parameters<Counter>>) {
 	return pcre_context{ctll::push_front(capture<Counter+1, A>(), ctll::list<Ts...>()), pcre_parameters<Counter+1>()};
 }
 // capture (sequence)
-template <auto V, typename... Content, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture, ctll::term<V>, pcre_context<ctll::list<sequence<Content...>, Ts...>, pcre_parameters<Counter>> subject) {
+template <auto V, typename... Content, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture, ctll::term<V>, pcre_context<ctll::list<sequence<Content...>, Ts...>, pcre_parameters<Counter>>) {
 	return pcre_context{ctll::push_front(capture<Counter+1, Content...>(), ctll::list<Ts...>()), pcre_parameters<Counter+1>()};
 }
 // push_name
@@ -18,11 +18,11 @@ template <auto... Str, auto V, typename... Ts, typename Parameters> static const
 	return pcre_context{ctll::push_front(id<Str..., V>(), ctll::list<Ts...>()), subject.parameters};
 }
 // capture with name
-template <auto... Str, auto V, typename A, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture_with_name, ctll::term<V>, pcre_context<ctll::list<A, id<Str...>, Ts...>, pcre_parameters<Counter>> subject) {
+template <auto... Str, auto V, typename A, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture_with_name, ctll::term<V>, pcre_context<ctll::list<A, id<Str...>, Ts...>, pcre_parameters<Counter>>) {
 	return pcre_context{ctll::push_front(capture_with_name<Counter+1, id<Str...>, A>(), ctll::list<Ts...>()), pcre_parameters<Counter+1>()};
 }
 // capture with name (sequence)
-template <auto... Str, auto V, typename... Content, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture_with_name, ctll::term<V>, pcre_context<ctll::list<sequence<Content...>, id<Str...>, Ts...>, pcre_parameters<Counter>> subject) {
+template <auto... Str, auto V, typename... Content, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture_with_name, ctll::term<V>, pcre_context<ctll::list<sequence<Content...>, id<Str...>, Ts...>, pcre_parameters<Counter>>) {
 	return pcre_context{ctll::push_front(capture_with_name<Counter+1, id<Str...>, Content...>(), ctll::list<Ts...>()), pcre_parameters<Counter+1>()};
 }
 
diff --git a/include/ctre/actions/set.inc.hpp b/include/ctre/actions/set.inc.hpp
@@ -3,7 +3,7 @@
 
 // UTILITY
 // add into set if not exists
-template <template <typename...> typename SetType, typename T, typename... As, bool Exists = (std::is_same_v<T, As> || ... || false)> static constexpr auto push_back_into_set(T, SetType<As...>) -> ctll::conditional<Exists, SetType<As...>, SetType<As...,T>> { return {}; };
+template <template <typename...> typename SetType, typename T, typename... As, bool Exists = (std::is_same_v<T, As> || ... || false)> static constexpr auto push_back_into_set(T, SetType<As...>) -> ctll::conditional<Exists, SetType<As...>, SetType<As...,T>> { return {}; }
 
 //template <template <typename...> typename SetType, typename A, typename BHead, typename... Bs> struct set_merge_helper {
 //	using step = decltype(push_back_into_set<SetType>(BHead(), A()));
diff --git a/include/ctre/atoms_characters.hpp b/include/ctre/atoms_characters.hpp
@@ -24,7 +24,7 @@ template <auto V> struct character {
 };
 
 struct any {
-	template <typename CharT> CTRE_FORCE_INLINE static constexpr bool match_char(CharT value) noexcept { return true; }
+	template <typename CharT> CTRE_FORCE_INLINE static constexpr bool match_char(CharT) noexcept { return true; }
 };
 
 template <typename... Content> struct negative_set {
diff --git a/include/ctre/evaluation.hpp b/include/ctre/evaluation.hpp
@@ -35,7 +35,7 @@ constexpr inline auto search_re(const Iterator begin, const EndIterator end, Pat
 
 // if we found "accept" object on stack => ACCEPT
 template <typename R, typename Iterator, typename EndIterator> 
-constexpr CTRE_FORCE_INLINE R evaluate(const Iterator begin, Iterator current, const EndIterator end, R captures, ctll::list<accept>) noexcept {
+constexpr CTRE_FORCE_INLINE R evaluate(const Iterator, Iterator, const EndIterator, R captures, ctll::list<accept>) noexcept {
 	return captures.matched();
 }
 
@@ -53,7 +53,7 @@ constexpr CTRE_FORCE_INLINE R evaluate(const Iterator begin, Iterator current, c
 
 // mark end of cycle
 template <typename R, typename Iterator, typename EndIterator, typename... Tail> 
-constexpr CTRE_FORCE_INLINE R evaluate(const Iterator begin, Iterator current, const EndIterator end, R captures, ctll::list<end_cycle_mark>) noexcept {
+constexpr CTRE_FORCE_INLINE R evaluate(const Iterator, Iterator current, const EndIterator, R captures, ctll::list<end_cycle_mark>) noexcept {
 	return captures.set_end_mark(current).matched();
 }
 
@@ -108,7 +108,7 @@ constexpr CTRE_FORCE_INLINE R evaluate(const Iterator begin, Iterator current, c
 }
 
 template <typename R, typename Iterator, typename EndIterator, typename... Tail> 
-constexpr CTRE_FORCE_INLINE R evaluate(const Iterator begin, Iterator current, const EndIterator end, R captures, ctll::list<select<>, Tail...>) noexcept {
+constexpr CTRE_FORCE_INLINE R evaluate(const Iterator, Iterator, const EndIterator, R, ctll::list<select<>, Tail...>) noexcept {
 	// no previous option was matched => REJECT
 	return not_matched;
 }
diff --git a/include/ctre/find_captures.hpp b/include/ctre/find_captures.hpp
@@ -103,12 +103,12 @@ template <size_t A, size_t B, typename... Content, typename... Tail, typename Ou
 
 
 
-template <size_t Id, typename... Content, typename... Tail, typename... Output> constexpr auto find_captures(ctll::list<capture<Id,Content...>, Tail...>, ctll::list<Output...> output) noexcept {
+template <size_t Id, typename... Content, typename... Tail, typename... Output> constexpr auto find_captures(ctll::list<capture<Id,Content...>, Tail...>, ctll::list<Output...>) noexcept {
 	return find_captures(ctll::list<Content..., Tail...>(), ctll::list<Output..., captured_content<Id>>());
 }
 
 
-template <size_t Id, typename Name, typename... Content, typename... Tail, typename... Output> constexpr auto find_captures(ctll::list<capture_with_name<Id,Name,Content...>, Tail...>, ctll::list<Output...> output) noexcept {
+template <size_t Id, typename Name, typename... Content, typename... Tail, typename... Output> constexpr auto find_captures(ctll::list<capture_with_name<Id,Name,Content...>, Tail...>, ctll::list<Output...>) noexcept {
 	return find_captures(ctll::list<Content..., Tail...>(), ctll::list<Output..., captured_content<Id, Name>>());
 }
 
diff --git a/include/ctre/pcre_actions.hpp b/include/ctre/pcre_actions.hpp
@@ -43,6 +43,6 @@ struct pcre_actions {
 };
 
 
-};
+}
 
 #endif
diff --git a/include/ctre/return_type.hpp b/include/ctre/return_type.hpp
@@ -200,9 +200,10 @@ template <typename Iterator, typename... Captures> regex_results(Iterator, ctll:
 // support for structured bindings
 
 namespace std {
-	template <typename... Captures> struct tuple_size<ctre::regex_results<Captures...>> : std::integral_constant<size_t, ctre::regex_results<Captures...>::size()> { };
+	template <typename... Captures> class tuple_size<ctre::regex_results<Captures...>> : public std::integral_constant<size_t, ctre::regex_results<Captures...>::size()> { };
 	
-	template <size_t N, typename... Captures> struct tuple_element<N, ctre::regex_results<Captures...>> {
+	template <size_t N, typename... Captures> class tuple_element<N, ctre::regex_results<Captures...>> {
+	public:
 		using type = decltype(
 			std::declval<const ctre::regex_results<Captures...> &>().template get<N>()
 		);
diff --git a/tests/benchmark-exec/baseline.cpp b/tests/benchmark-exec/baseline.cpp
@@ -12,7 +12,7 @@ extern "C" {
 
 }
 
-int main (int argc, char ** argv)
+int main ()
 {
 	return 0;
 }
diff --git a/tests/msvc.cpp b/tests/msvc.cpp
@@ -9,3 +9,9 @@ static inline constexpr auto pattern2 = ctll::basic_fixed_string{""};
 
 static_assert(ctre::re<pattern1>().match("123456789"sv));
 static_assert(ctre::re<pattern2>().match(""sv));
+
+template <auto & ptn> constexpr bool re() {
+	return ctll::parser<ctre::pcre, ptn, ctre::pcre_actions>::template correct_with<ctre::pcre_context<>>;
+}
+
+static_assert(re<pattern2>());

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ namespace ctll {`
`20`	`20`	`template <typename Actions> struct augment_actions<false, Actions>: public Actions {`
`21`	`21`	`using Actions::apply;`
`22`	`22`	`// will fail if unknown action is called`
	`23`	`+ constexpr static auto apply(...) = delete;`
`23`	`24`	`};`
`24`	`25`	`}`
`25`	`26`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ template <typename CharT, size_t N> class basic_fixed_string {`
`37`	`37`	`template <typename CharT> class basic_fixed_string<CharT, 0> {`
`38`	`38`	`public:`
`39`	`39`	`using char_type = CharT;`
`40`		`- constexpr basic_fixed_string(const CharT(&)[0]) noexcept { }`
	`40`	`+ constexpr basic_fixed_string(const CharT *) noexcept { }`
`41`	`41`	`constexpr size_t size() const noexcept {`
`42`	`42`	`return 0;`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ template <auto V, size_t Id, typename... Ts, size_t Counter> static constexpr au`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`// relative backreference`
`20`		`-template <auto V, size_t Id, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_relative_back_reference, ctll::term<V>, pcre_context<ctll::list<number<Id>, Ts...>, pcre_parameters<Counter>> subject) {`
	`20`	`+template <auto V, size_t Id, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_relative_back_reference, ctll::term<V>, [[maybe_unused]] pcre_context<ctll::list<number<Id>, Ts...>, pcre_parameters<Counter>> subject) {`
`21`	`21`	`// if we are looking outside of existing list of Ids ... reject input during parsing`
`22`	`22`	`if constexpr (Counter < Id) {`
`23`	`23`	`return ctll::reject{};`
Original file line number	Diff line number	Diff line change
`@@ -2,11 +2,11 @@`
`2`	`2`	`#define CTRE__ACTIONS__CAPTURE__HPP`
`3`	`3`
`4`	`4`	`// capture`
`5`		`-template <auto V, typename A, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture, ctll::term<V>, pcre_context<ctll::list<A, Ts...>, pcre_parameters<Counter>> subject) {`
	`5`	`+template <auto V, typename A, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture, ctll::term<V>, pcre_context<ctll::list<A, Ts...>, pcre_parameters<Counter>>) {`
`6`	`6`	`return pcre_context{ctll::push_front(capture<Counter+1, A>(), ctll::list<Ts...>()), pcre_parameters<Counter+1>()};`
`7`	`7`	`}`
`8`	`8`	`// capture (sequence)`
`9`		`-template <auto V, typename... Content, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture, ctll::term<V>, pcre_context<ctll::list<sequence<Content...>, Ts...>, pcre_parameters<Counter>> subject) {`
	`9`	`+template <auto V, typename... Content, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture, ctll::term<V>, pcre_context<ctll::list<sequence<Content...>, Ts...>, pcre_parameters<Counter>>) {`
`10`	`10`	`return pcre_context{ctll::push_front(capture<Counter+1, Content...>(), ctll::list<Ts...>()), pcre_parameters<Counter+1>()};`
`11`	`11`	`}`
`12`	`12`	`// push_name`
`@@ -18,11 +18,11 @@ template <auto... Str, auto V, typename... Ts, typename Parameters> static const`
`18`	`18`	`return pcre_context{ctll::push_front(id<Str..., V>(), ctll::list<Ts...>()), subject.parameters};`
`19`	`19`	`}`
`20`	`20`	`// capture with name`
`21`		`-template <auto... Str, auto V, typename A, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture_with_name, ctll::term<V>, pcre_context<ctll::list<A, id<Str...>, Ts...>, pcre_parameters<Counter>> subject) {`
	`21`	`+template <auto... Str, auto V, typename A, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture_with_name, ctll::term<V>, pcre_context<ctll::list<A, id<Str...>, Ts...>, pcre_parameters<Counter>>) {`
`22`	`22`	`return pcre_context{ctll::push_front(capture_with_name<Counter+1, id<Str...>, A>(), ctll::list<Ts...>()), pcre_parameters<Counter+1>()};`
`23`	`23`	`}`
`24`	`24`	`// capture with name (sequence)`
`25`		`-template <auto... Str, auto V, typename... Content, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture_with_name, ctll::term<V>, pcre_context<ctll::list<sequence<Content...>, id<Str...>, Ts...>, pcre_parameters<Counter>> subject) {`
	`25`	`+template <auto... Str, auto V, typename... Content, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_capture_with_name, ctll::term<V>, pcre_context<ctll::list<sequence<Content...>, id<Str...>, Ts...>, pcre_parameters<Counter>>) {`
`26`	`26`	`return pcre_context{ctll::push_front(capture_with_name<Counter+1, id<Str...>, Content...>(), ctll::list<Ts...>()), pcre_parameters<Counter+1>()};`
`27`	`27`	`}`
`28`	`28`