Apply the same sort of change as the previous two commits, but to all the

parsers not already modified.  Generalize with_parser_mods().  Remove
omit_parser, since it is now moot.

See #160.

include/boost/parser/detail/printing.hpp

@@ -52,110 +52,125 @@ namespace boost { namespace parser { namespace detail {
         typename Parser,
         typename DelimiterParser,
         typename MinType,
-        typename MaxType>
-    void print_parser(
+        typename MaxType,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        repeat_parser<Parser, DelimiterParser, MinType, MaxType> const & parser,
+        repeat_parser<
+            Parser,
+            DelimiterParser,
+            MinType,
+            MaxType,
+            ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Parser>
-    void print_parser(
+    template<typename Context, typename Parser, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        opt_parser<Parser> const & parser,
+        opt_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename ParserTuple>
-    void print_parser(
+    template<typename Context, typename ParserTuple, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        or_parser<ParserTuple> const & parser,
+        or_parser<ParserTuple, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename ParserTuple>
-    void print_parser(
+    template<typename Context, typename ParserTuple, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        perm_parser<ParserTuple> const & parser,
+        perm_parser<ParserTuple, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
     template<
         typename Context,
         typename ParserTuple,
         typename BacktrackingTuple,
-        typename CombiningGroups>
-    void print_parser(
+        typename CombiningGroups,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        seq_parser<ParserTuple, BacktrackingTuple, CombiningGroups> const &
-            parser,
+        seq_parser<
+            ParserTuple,
+            BacktrackingTuple,
+            CombiningGroups,
+            ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Parser, typename Action>
-    void print_parser(
+    template<
+        typename Context,
+        typename Parser,
+        typename Action,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        action_parser<Parser, Action> const & parser,
+        action_parser<Parser, Action, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Parser, typename F>
-    void print_parser(
+    template<typename Context, typename Parser, typename F, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        transform_parser<Parser, F> const & parser,
+        transform_parser<Parser, F, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Parser>
-    void print_parser(
+    template<typename Context, typename Parser, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        omit_parser<Parser> const & parser,
+        raw_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
-
-    template<typename Context, typename Parser>
-    void print_parser(
-        Context const & context,
-        raw_parser<Parser> const & parser,
-        std::ostream & os,
-        int components = 0);
+        int components);
 
 #if defined(BOOST_PARSER_DOXYGEN) || BOOST_PARSER_USE_CONCEPTS
-    template<typename Context, typename Parser>
-    void print_parser(
+    template<typename Context, typename Parser, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        string_view_parser<Parser> const & parser,
+        string_view_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 #endif
 
-    template<typename Context, typename Parser>
-    void print_parser(
+    template<typename Context, typename Parser, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        lexeme_parser<Parser> const & parser,
+        lexeme_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Parser>
-    void print_parser(
+    template<typename Context, typename Parser, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        no_case_parser<Parser> const & parser,
+        no_case_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Parser, typename SkipParser>
-    void print_parser(
+    template<
+        typename Context,
+        typename Parser,
+        typename SkipParser,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        skip_parser<Parser, SkipParser> const & parser,
+        skip_parser<Parser, SkipParser, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Parser, bool FailOnMatch>
-    void print_parser(
+    template<
+        typename Context,
+        typename Parser,
+        bool FailOnMatch,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        expect_parser<Parser, FailOnMatch> const & parser,
+        expect_parser<Parser, FailOnMatch, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
     template<
         typename Context,
@@ -163,137 +178,147 @@ namespace boost { namespace parser { namespace detail {
         typename Parser,
         typename Attribute,
         typename LocalState,
-        typename ParamsTuple>
-    void print_parser(
+        typename ParamsTuple,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
         rule_parser<
             UseCallbacks,
             Parser,
             Attribute,
             LocalState,
-            ParamsTuple> const & parser,
+            ParamsTuple,
+            ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename T>
-    void print_parser(
+    template<typename Context, typename T, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        symbol_parser<T> const & parser,
+        symbol_parser<T, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Predicate>
-    void print_parser(
+    template<typename Context, typename Predicate, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        eps_parser<Predicate> const & parser,
+        eps_parser<Predicate, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        eps_parser<nope> const & parser,
+        eps_parser<nope, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        eoi_parser const & parser,
+        eoi_parser<ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Atribute>
-    void print_parser(
+    template<typename Context, typename Atribute, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        attr_parser<Atribute> const & parser,
+        attr_parser<Atribute, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
     template<
         typename Context,
         typename Expected,
         typename AttributeType,
         typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
         char_parser<Expected, AttributeType, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        digit_parser const & parser,
+        digit_parser<ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        char_subrange_parser<hex_digit_subranges> const & parser,
+        char_subrange_parser<hex_digit_subranges, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        char_subrange_parser<control_subranges> const & parser,
+        char_subrange_parser<control_subranges, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        char_set_parser<punct_chars> const & parser,
+        char_set_parser<punct_chars, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        char_set_parser<lower_case_chars> const & parser,
+        char_set_parser<lower_case_chars, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        char_set_parser<upper_case_chars> const & parser,
+        char_set_parser<upper_case_chars, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
     template<
         typename Context,
         typename StrIter,
         typename StrSentinel,
         typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
         string_parser<StrIter, StrSentinel, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Quotes, typename Escapes>
-    void print_parser(
+    template<
+        typename Context,
+        typename Quotes,
+        typename Escapes,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        quoted_string_parser<Quotes, Escapes> const & parser,
+        quoted_string_parser<Quotes, Escapes, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, bool NewlinesOnly, bool NoNewlines>
-    void print_parser(
+    template<
+        typename Context,
+        bool NewlinesOnly,
+        bool NoNewlines,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        ws_parser<NewlinesOnly, NoNewlines> const & parser,
+        ws_parser<NewlinesOnly, NoNewlines, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        bool_parser const & parser,
+        bool_parser<ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
     template<
         typename Context,
@@ -301,12 +326,19 @@ namespace boost { namespace parser { namespace detail {
         int Radix,
         int MinDigits,
         int MaxDigits,
-        typename Expected>
-    void print_parser(
+        typename Expected,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        uint_parser<T, Radix, MinDigits, MaxDigits, Expected> const & parser,
+        uint_parser<
+            T,
+            Radix,
+            MinDigits,
+            MaxDigits,
+            Expected,
+            ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
     template<
         typename Context,
@@ -314,38 +346,51 @@ namespace boost { namespace parser { namespace detail {
         int Radix,
         int MinDigits,
         int MaxDigits,
-        typename Expected>
-    void print_parser(
+        typename Expected,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        int_parser<T, Radix, MinDigits, MaxDigits, Expected> const & parser,
+        int_parser<T, Radix, MinDigits, MaxDigits, Expected, ParserMods> const &
+            parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename T>
-    void print_parser(
+    template<typename Context, typename T, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        float_parser<T> const & parser,
+        float_parser<T, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        float_parser<float> const & parser,
+        float_parser<float, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        float_parser<double> const & parser,
+        float_parser<double, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename SwitchValue, typename OrParser>
+    template<
+        typename Context,
+        typename SwitchValue,
+        typename OrParser,
+        typename ParserMods>
+    void print_parser_impl(
+        Context const & context,
+        switch_parser<SwitchValue, OrParser, ParserMods> const & parser,
+        std::ostream & os,
+        int components);
+
+    template<typename Context, typename Parser>
     void print_parser(
         Context const & context,
-        switch_parser<SwitchValue, OrParser> const & parser,
+        Parser const & parser,
         std::ostream & os,
         int components = 0);
 

include/boost/parser/detail/printing_impl.hpp

@@ -43,36 +43,44 @@ namespace boost { namespace parser { namespace detail {
         typename Parser,
         typename DelimiterParser,
         typename MinType,
-        typename MaxType>
+        typename MaxType,
+        typename ParserMods>
     struct n_aray_parser<
-        repeat_parser<Parser, DelimiterParser, MinType, MaxType>>
+        repeat_parser<Parser, DelimiterParser, MinType, MaxType, ParserMods>>
         : std::true_type
     {};
 
-    template<typename Parser, typename MinType, typename MaxType>
-    struct n_aray_parser<repeat_parser<Parser, detail::nope, MinType, MaxType>>
+    template<
+        typename Parser,
+        typename MinType,
+        typename MaxType,
+        typename ParserMods>
+    struct n_aray_parser<
+        repeat_parser<Parser, detail::nope, MinType, MaxType, ParserMods>>
         : std::false_type
     {};
 
-    template<typename Parser, typename DelimiterParser>
-    struct n_aray_parser<delimited_seq_parser<Parser, DelimiterParser>>
+    template<typename Parser, typename DelimiterParser, typename ParserMods>
+    struct n_aray_parser<
+        delimited_seq_parser<Parser, DelimiterParser, ParserMods>>
         : std::true_type
     {};
 
-    template<typename ParserTuple>
-    struct n_aray_parser<or_parser<ParserTuple>> : std::true_type
+    template<typename ParserTuple, typename ParserMods>
+    struct n_aray_parser<or_parser<ParserTuple, ParserMods>> : std::true_type
     {};
 
-    template<typename ParserTuple>
-    struct n_aray_parser<perm_parser<ParserTuple>> : std::true_type
+    template<typename ParserTuple, typename ParserMods>
+    struct n_aray_parser<perm_parser<ParserTuple, ParserMods>> : std::true_type
     {};
 
     template<
         typename ParserTuple,
         typename BacktrackingTuple,
-        typename CombiningGroups>
+        typename CombiningGroups,
+        typename ParserMods>
     struct n_aray_parser<
-        seq_parser<ParserTuple, BacktrackingTuple, CombiningGroups>>
+        seq_parser<ParserTuple, BacktrackingTuple, CombiningGroups, ParserMods>>
         : std::true_type
     {};
 
@@ -101,10 +109,16 @@ namespace boost { namespace parser { namespace detail {
         typename Parser,
         typename DelimiterParser,
         typename MinType,
-        typename MaxType>
-    void print_parser(
+        typename MaxType,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        repeat_parser<Parser, DelimiterParser, MinType, MaxType> const & parser,
+        repeat_parser<
+            Parser,
+            DelimiterParser,
+            MinType,
+            MaxType,
+            ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -116,7 +130,7 @@ namespace boost { namespace parser { namespace detail {
                 os << "*";
                 if (n_ary_child)
                     os << "(";
-                detail::print_parser(
+                detail::print_parser_impl(
                     context, parser.parser_, os, components + 1);
                 if (n_ary_child)
                     os << ")";
@@ -124,7 +138,7 @@ namespace boost { namespace parser { namespace detail {
                 os << "+";
                 if (n_ary_child)
                     os << "(";
-                detail::print_parser(
+                detail::print_parser_impl(
                     context, parser.parser_, os, components + 1);
                 if (n_ary_child)
                     os << ")";
@@ -141,22 +155,22 @@ namespace boost { namespace parser { namespace detail {
                         detail::print(os, max_);
                     os << ")[";
                 }
-                detail::print_parser(
+                detail::print_parser_impl(
                     context, parser.parser_, os, components + 1);
                 os << "]";
             }
         } else {
-            detail::print_parser(context, parser.parser_, os, components + 1);
+            detail::print_parser_impl(context, parser.parser_, os, components + 1);
             os << " % ";
-            detail::print_parser(
+            detail::print_parser_impl(
                 context, parser.delimiter_parser_, os, components + 2);
         }
     }
 
-    template<typename Context, typename Parser>
-    void print_parser(
+    template<typename Context, typename Parser, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        opt_parser<Parser> const & parser,
+        opt_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -164,7 +178,7 @@ namespace boost { namespace parser { namespace detail {
         constexpr bool n_ary_child = n_aray_parser_v<Parser>;
         if (n_ary_child)
             os << "(";
-        detail::print_parser(context, parser.parser_, os, components + 1);
+        detail::print_parser_impl(context, parser.parser_, os, components + 1);
         if (n_ary_child)
             os << ")";
     }
@@ -189,16 +203,16 @@ namespace boost { namespace parser { namespace detail {
             }
             if (i)
                 os << ws_or;
-            detail::print_parser(context, parser, os, components);
+            detail::print_parser_impl(context, parser, os, components);
             ++components;
             ++i;
         });
     }
 
-    template<typename Context, typename ParserTuple>
-    void print_parser(
+    template<typename Context, typename ParserTuple, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        or_parser<ParserTuple> const & parser,
+        or_parser<ParserTuple, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -206,10 +220,10 @@ namespace boost { namespace parser { namespace detail {
             context, parser, os, components, " | ...", " | ");
     }
 
-    template<typename Context, typename ParserTuple>
-    void print_parser(
+    template<typename Context, typename ParserTuple, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        perm_parser<ParserTuple> const & parser,
+        perm_parser<ParserTuple, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -221,11 +235,15 @@ namespace boost { namespace parser { namespace detail {
         typename Context,
         typename ParserTuple,
         typename BacktrackingTuple,
-        typename CombiningGroups>
-    void print_parser(
+        typename CombiningGroups,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        seq_parser<ParserTuple, BacktrackingTuple, CombiningGroups> const &
-            parser,
+        seq_parser<
+            ParserTuple,
+            BacktrackingTuple,
+            CombiningGroups,
+            ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -255,7 +273,7 @@ namespace boost { namespace parser { namespace detail {
                     os << (backtrack ? " >> " : " > ");
                 if (group != prev_group && group)
                     os << (group == -1 ? "separate[" : "merge[");
-                detail::print_parser(context, parser, os, components);
+                detail::print_parser_impl(context, parser, os, components);
                 ++components;
                 ++i;
                 prev_group = (int)group;
@@ -264,14 +282,18 @@ namespace boost { namespace parser { namespace detail {
             os << ']';
     }
 
-    template<typename Context, typename Parser, typename Action>
-    void print_parser(
+    template<
+        typename Context,
+        typename Parser,
+        typename Action,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        action_parser<Parser, Action> const & parser,
+        action_parser<Parser, Action, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
-        detail::print_parser(context, parser.parser_, os, components);
+        detail::print_parser_impl(context, parser.parser_, os, components);
         os << "[<<action>>]";
     }
 
@@ -287,14 +309,14 @@ namespace boost { namespace parser { namespace detail {
         if (++components == parser_component_limit)
             os << "...";
         else
-            detail::print_parser(context, parser, os, components + 1);
+            detail::print_parser_impl(context, parser, os, components + 1);
         os << "]";
     }
 
-    template<typename Context, typename Parser, typename F>
-    void print_parser(
+    template<typename Context, typename Parser, typename F, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        transform_parser<Parser, F> const & parser,
+        transform_parser<Parser, F, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -302,21 +324,10 @@ namespace boost { namespace parser { namespace detail {
             context, "transform(<<f>>)", parser.parser_, os, components);
     }
 
-    template<typename Context, typename Parser>
-    void print_parser(
+    template<typename Context, typename Parser, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        omit_parser<Parser> const & parser,
-        std::ostream & os,
-        int components)
-    {
-        detail::print_directive(
-            context, "omit", parser.parser_, os, components);
-    }
-
-    template<typename Context, typename Parser>
-    void print_parser(
-        Context const & context,
-        raw_parser<Parser> const & parser,
+        raw_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -324,10 +335,10 @@ namespace boost { namespace parser { namespace detail {
     }
 
 #if defined(BOOST_PARSER_DOXYGEN) || BOOST_PARSER_USE_CONCEPTS
-    template<typename Context, typename Parser>
-    void print_parser(
+    template<typename Context, typename Parser, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        string_view_parser<Parser> const & parser,
+        string_view_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -336,10 +347,10 @@ namespace boost { namespace parser { namespace detail {
     }
 #endif
 
-    template<typename Context, typename Parser>
-    void print_parser(
+    template<typename Context, typename Parser, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        lexeme_parser<Parser> const & parser,
+        lexeme_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -347,10 +358,10 @@ namespace boost { namespace parser { namespace detail {
             context, "lexeme", parser.parser_, os, components);
     }
 
-    template<typename Context, typename Parser>
-    void print_parser(
+    template<typename Context, typename Parser, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        no_case_parser<Parser> const & parser,
+        no_case_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -358,10 +369,14 @@ namespace boost { namespace parser { namespace detail {
             context, "no_case", parser.parser_, os, components);
     }
 
-    template<typename Context, typename Parser, typename SkipParser>
-    void print_parser(
+    template<
+        typename Context,
+        typename Parser,
+        typename SkipParser,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        skip_parser<Parser, SkipParser> const & parser,
+        skip_parser<Parser, SkipParser, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -370,7 +385,7 @@ namespace boost { namespace parser { namespace detail {
                 context, "skip", parser.parser_, os, components);
         } else {
             os << "skip(";
-            detail::print_parser(
+            detail::print_parser_impl(
                 context, parser.skip_parser_.parser_, os, components);
             os << ")";
             detail::print_directive(
@@ -378,10 +393,14 @@ namespace boost { namespace parser { namespace detail {
         }
     }
 
-    template<typename Context, typename Parser, bool FailOnMatch>
-    void print_parser(
+    template<
+        typename Context,
+        typename Parser,
+        bool FailOnMatch,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        expect_parser<Parser, FailOnMatch> const & parser,
+        expect_parser<Parser, FailOnMatch, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -392,7 +411,7 @@ namespace boost { namespace parser { namespace detail {
         constexpr bool n_ary_child = n_aray_parser_v<Parser>;
         if (n_ary_child)
             os << "(";
-        detail::print_parser(context, parser.parser_, os, components + 1);
+        detail::print_parser_impl(context, parser.parser_, os, components + 1);
         if (n_ary_child)
             os << ")";
     }
@@ -403,15 +422,17 @@ namespace boost { namespace parser { namespace detail {
         typename Parser,
         typename Attribute,
         typename LocalState,
-        typename ParamsTuple>
-    void print_parser(
+        typename ParamsTuple,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
         rule_parser<
             UseCallbacks,
             Parser,
             Attribute,
             LocalState,
-            ParamsTuple> const & parser,
+            ParamsTuple,
+            ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -428,10 +449,10 @@ namespace boost { namespace parser { namespace detail {
         }
     }
 
-    template<typename Context, typename T>
-    void print_parser(
+    template<typename Context, typename T, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        symbol_parser<T> const & parser,
+        symbol_parser<T, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -441,40 +462,40 @@ namespace boost { namespace parser { namespace detail {
             os << parser.diagnostic_text_;
     }
 
-    template<typename Context, typename Predicate>
-    void print_parser(
+    template<typename Context, typename Predicate, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        eps_parser<Predicate> const & parser,
+        eps_parser<Predicate, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "eps(<<pred>>)";
     }
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        eps_parser<nope> const & parser,
+        eps_parser<nope, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "eps";
     }
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        eoi_parser const & parser,
+        eoi_parser<ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "eoi";
     }
 
-    template<typename Context, typename Atribute>
-    void print_parser(
+    template<typename Context, typename Atribute, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        attr_parser<Atribute> const & parser,
+        attr_parser<Atribute, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -527,7 +548,7 @@ namespace boost { namespace parser { namespace detail {
     }
 
     template<typename Context, typename T>
-    struct char_print_parser_impl
+    struct char_print_parser_impl_impl
     {
         static void call(Context const & context, std::ostream & os, T expected)
         {
@@ -536,7 +557,7 @@ namespace boost { namespace parser { namespace detail {
     };
 
     template<typename Context, typename T, typename U>
-    struct char_print_parser_impl<Context, char_pair<T, U>>
+    struct char_print_parser_impl_impl<Context, char_pair<T, U>>
     {
         static void call(
             Context const & context,
@@ -550,7 +571,7 @@ namespace boost { namespace parser { namespace detail {
     };
 
     template<typename Context, typename Iter, typename Sentinel, bool B>
-    struct char_print_parser_impl<Context, char_range<Iter, Sentinel, B>>
+    struct char_print_parser_impl_impl<Context, char_range<Iter, Sentinel, B>>
     {
         static void call(
             Context const & context,
@@ -571,7 +592,7 @@ namespace boost { namespace parser { namespace detail {
         typename Expected,
         typename AttributeType,
         typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
         char_parser<Expected, AttributeType, ParserMods> const & parser,
         std::ostream & os,
@@ -579,9 +600,9 @@ namespace boost { namespace parser { namespace detail {
     {
         if constexpr (parser.mods_.omit_attr) {
             if constexpr (is_nope_v<Expected>) {
-                os << "omit[char_]";
+                os << "char_";
             } else {
-                char_print_parser_impl<Context, Expected>::call(
+                char_print_parser_impl_impl<Context, Expected>::call(
                     context, os, parser.expected_);
             }
         } else {
@@ -593,67 +614,67 @@ namespace boost { namespace parser { namespace detail {
                 os << "char_";
             if constexpr (!is_nope_v<Expected>) {
                 os << "(";
-                char_print_parser_impl<Context, Expected>::call(
+                char_print_parser_impl_impl<Context, Expected>::call(
                     context, os, parser.expected_);
                 os << ")";
             }
         }
     }
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        digit_parser const & parser,
+        digit_parser<ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "digit";
     }
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        char_subrange_parser<hex_digit_subranges> const & parser,
+        char_subrange_parser<hex_digit_subranges, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "hex_digit";
     }
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        char_subrange_parser<control_subranges> const & parser,
+        char_subrange_parser<control_subranges, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "control";
     }
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        char_set_parser<punct_chars> const & parser,
+        char_set_parser<punct_chars, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "punct";
     }
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        char_set_parser<lower_case_chars> const & parser,
+        char_set_parser<lower_case_chars, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "lower";
     }
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        char_set_parser<upper_case_chars> const & parser,
+        char_set_parser<upper_case_chars, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -665,7 +686,7 @@ namespace boost { namespace parser { namespace detail {
         typename StrIter,
         typename StrSentinel,
         typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
         string_parser<StrIter, StrSentinel, ParserMods> const & parser,
         std::ostream & os,
@@ -686,10 +707,14 @@ namespace boost { namespace parser { namespace detail {
         }
     }
 
-    template<typename Context, typename Quotes, typename Escapes>
-    void print_parser(
+    template<
+        typename Context,
+        typename Quotes,
+        typename Escapes,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        quoted_string_parser<Quotes, Escapes> const & parser,
+        quoted_string_parser<Quotes, Escapes, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -707,10 +732,14 @@ namespace boost { namespace parser { namespace detail {
         os << ')';
     }
 
-    template<typename Context, bool NewlinesOnly, bool NoNewlines>
-    void print_parser(
+    template<
+        typename Context,
+        bool NewlinesOnly,
+        bool NoNewlines,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        ws_parser<NewlinesOnly, NoNewlines> const & parser,
+        ws_parser<NewlinesOnly, NoNewlines, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -722,10 +751,10 @@ namespace boost { namespace parser { namespace detail {
             os << "ws";
     }
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        bool_parser const & parser,
+        bool_parser<ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -738,10 +767,17 @@ namespace boost { namespace parser { namespace detail {
         int Radix,
         int MinDigits,
         int MaxDigits,
-        typename Expected>
-    void print_parser(
+        typename Expected,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        uint_parser<T, Radix, MinDigits, MaxDigits, Expected> const & parser,
+        uint_parser<
+            T,
+            Radix,
+            MinDigits,
+            MaxDigits,
+            Expected,
+            ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -782,27 +818,29 @@ namespace boost { namespace parser { namespace detail {
         int Radix,
         int MinDigits,
         int MaxDigits,
-        typename Expected>
-    void print_parser(
+        typename Expected,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        int_parser<T, Radix, MinDigits, MaxDigits, Expected> const & parser,
+        int_parser<T, Radix, MinDigits, MaxDigits, Expected, ParserMods> const &
+            parser,
         std::ostream & os,
         int components)
     {
         if (Radix == 10 && MinDigits == 1 && MaxDigits == -1) {
-            if (std::is_same_v<T, short>) {
+            if constexpr (std::is_same_v<T, short>) {
                 os << "short_";
                 detail::print_expected(context, os, parser.expected_);
                 return;
-            } else if (std::is_same_v<T, int>) {
+            } else if constexpr (std::is_same_v<T, int>) {
                 os << "int_";
                 detail::print_expected(context, os, parser.expected_);
                 return;
-            } else if (std::is_same_v<T, long>) {
+            } else if constexpr (std::is_same_v<T, long>) {
                 os << "long_";
                 detail::print_expected(context, os, parser.expected_);
                 return;
-            } else if (std::is_same_v<T, long long>) {
+            } else if constexpr (std::is_same_v<T, long long>) {
                 os << "long_long";
                 detail::print_expected(context, os, parser.expected_);
                 return;
@@ -812,61 +850,31 @@ namespace boost { namespace parser { namespace detail {
            << MinDigits << ", " << MaxDigits << ">";
         detail::print_expected(context, os, parser.expected_);
     }
-
-    template<typename Context>
-    void print_parser(
+            
+    template<typename Context, typename T, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        int_parser<short> const & parser,
-        std::ostream & os,
-        int components)
-    {
-        os << "short_";
-    }
-
-    template<typename Context>
-    void print_parser(
-        Context const & context,
-        int_parser<long> const & parser,
-        std::ostream & os,
-        int components)
-    {
-        os << "long_";
-    }
-
-    template<typename Context>
-    void print_parser(
-        Context const & context,
-        int_parser<long long> const & parser,
-        std::ostream & os,
-        int components)
-    {
-        os << "long_long";
-    }
-
-    template<typename Context, typename T>
-    void print_parser(
-        Context const & context,
-        float_parser<T> const & parser,
+        float_parser<T, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "float<" << detail::type_name<T>() << ">";
     }
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        float_parser<float> const & parser,
+        float_parser<float, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "float_";
     }
 
-    template<typename Context>
-    void print_parser(
+    template<typename Context, typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        float_parser<double> const & parser,
+        float_parser<double, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -877,10 +885,11 @@ namespace boost { namespace parser { namespace detail {
         typename Context,
         typename ParserTuple,
         typename BacktrackingTuple,
-        typename CombiningGroups>
+        typename CombiningGroups,
+        typename ParserMods>
     void print_switch_matchers(
         Context const & context,
-        seq_parser<ParserTuple, BacktrackingTuple, CombiningGroups> const &
+        seq_parser<ParserTuple, BacktrackingTuple, CombiningGroups, ParserMods> const &
             parser,
         std::ostream & os,
         int components)
@@ -892,15 +901,15 @@ namespace boost { namespace parser { namespace detail {
             detail::resolve(
                 context, parser::get(parser.parsers_, 0_c).pred_.value_));
         os << ", ";
-        detail::print_parser(
+        detail::print_parser_impl(
             context, parser::get(parser.parsers_, 1_c), os, components);
         os << ")";
     }
 
-    template<typename Context, typename ParserTuple>
+    template<typename Context, typename ParserTuple, typename ParserMods>
     void print_switch_matchers(
         Context const & context,
-        or_parser<ParserTuple> const & parser,
+        or_parser<ParserTuple, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -919,10 +928,14 @@ namespace boost { namespace parser { namespace detail {
         });
     }
 
-    template<typename Context, typename SwitchValue, typename OrParser>
-    void print_parser(
+    template<
+        typename Context,
+        typename SwitchValue,
+        typename OrParser,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        switch_parser<SwitchValue, OrParser> const & parser,
+        switch_parser<SwitchValue, OrParser, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -933,6 +946,67 @@ namespace boost { namespace parser { namespace detail {
             context, parser.or_parser_, os, components);
     }
 
+    template<typename ParserMods>
+    struct scoped_print_parser_mods
+    {
+        template<typename Parser>
+        scoped_print_parser_mods(std::ostream & os, Parser const & parser) :
+            os_(os), mods_(parser.mods_)
+        {
+            if constexpr (ParserMods::omit_attr) {
+                skip_omit_ = skip_omit(parser);
+                if (!skip_omit_)
+                    os_ << "omit[";
+            }
+        }
+        ~scoped_print_parser_mods()
+        {
+            if constexpr (ParserMods::omit_attr) {
+                if (!skip_omit_)
+                    os_ << "]";
+            }
+        }
+
+        template<typename T>
+        static bool skip_omit(T const &)
+        {
+            return false;
+        }
+        template<
+            typename Expected,
+            typename AttributeType,
+            typename ParserMods2>
+        static bool
+        skip_omit(char_parser<Expected, AttributeType, ParserMods2> const &)
+        {
+            return !std::is_same_v<Expected, detail::nope>;
+        }
+        template<typename StrIter, typename StrSentinel, typename ParserMods2>
+        static bool
+        skip_omit(string_parser<StrIter, StrSentinel, ParserMods2> const &)
+        {
+            return true;
+        }
+
+        std::ostream & os_;
+        ParserMods const & mods_;
+        bool skip_omit_ = false;
+    };
+
+    // TODO: Document how 'omit[]' will reappear for subparsers sometimes, as
+    // in omt[*omit[char_]] (see test/tracing.cpp).
+    template<typename Context, typename Parser>
+    void print_parser(
+        Context const & context,
+        Parser const & parser,
+        std::ostream & os,
+        int components)
+    {
+        scoped_print_parser_mods<std::decay_t<decltype(parser.mods_)>> _(
+            os, parser);
+        detail::print_parser_impl(context, parser, os, components);
+    }
+
 }}}
 
 #endif

include/boost/parser/parser_fwd.hpp

@@ -165,20 +165,21 @@ namespace boost { namespace parser {
         typename Parser,
         typename DelimiterParser = detail::nope,
         typename MinType = int64_t,
-        typename MaxType = int64_t>
+        typename MaxType = int64_t,
+        typename ParserMods = parser_modifiers<>>
     struct repeat_parser;
 
     /** Repeats the application of another parser `p` of type `Parser`, `[0,
         Inf)` times.  The parse always succeeds.  The attribute produced is a
         sequence of the type of attribute produced by `Parser`. */
-    template<typename Parser>
+    template<typename Parser, typename ParserMods>
     struct zero_plus_parser;
 
     /** Repeats the application of another parser `p` of type `Parser`, `[1,
         Inf)` times.  The parse succeeds iff `p` succeeds at least once.  The
         attribute produced is a sequence of the type of attribute produced by
         `Parser`. */
-    template<typename Parser>
+    template<typename Parser, typename ParserMods>
     struct one_plus_parser;
 
     /** Repeats the application of another parser `p` of type `Parser`, `[1,
@@ -187,14 +188,14 @@ namespace boost { namespace parser {
         succeeds at least once, and `d` succeeds each time it is applied.  The
         attribute produced is a sequence of the type of attribute produced by
         `Parser`. */
-    template<typename Parser, typename DelimiterParser>
+    template<typename Parser, typename DelimiterParser, typename ParserMods>
     struct delimited_seq_parser;
 
     /** Repeats the application of another parser of type `Parser`, `[0, 1]`
         times.  The parse always succeeds.  The attribute produced is a
         `std::optional<T>`, where `T` is the type of attribute produced by
         `Parser`. */
-    template<typename Parser>
+    template<typename Parser, typename ParserMods>
     struct opt_parser;
 
     /** Applies each parser in `ParserTuple`, in order, stopping after the
@@ -202,7 +203,7 @@ namespace boost { namespace parser {
         one of the sub-parsers succeeds.  The attribute produced is a
         `std::variant` over the types of attribute produced by the parsers in
         `ParserTuple`. */
-    template<typename ParserTuple>
+    template<typename ParserTuple, typename ParserMods>
     struct or_parser;
 
     /** Applies each parsers in `ParserTuple`, an any order, stopping after
@@ -213,7 +214,7 @@ namespace boost { namespace parser {
         `ParserTuple`, not the order of the parsers' matches.  It is an error
         to specialize `perm_parser` with a `ParserTuple` template parameter
         that includes an `eps_parser`. */
-    template<typename ParserTuple>
+    template<typename ParserTuple, typename ParserMods>
     struct perm_parser;
 
     /** Applies each parser in `ParserTuple`, in order.  The parse succeeds
@@ -226,14 +227,15 @@ namespace boost { namespace parser {
     template<
         typename ParserTuple,
         typename BacktrackingTuple,
-        typename CombiningGroups>
+        typename CombiningGroups,
+        typename ParserMods>
     struct seq_parser;
 
     /** Applies the given parser `p` of type `Parser` and an invocable `a` of
         type `Action`.  `Action` shall model `semantic_action`, and `a` will
         only be invoked if `p` succeeds.  The parse succeeds iff `p` succeeds.
         Produces no attribute. */
-    template<typename Parser, typename Action>
+    template<typename Parser, typename Action, typename ParserMods>
     struct action_parser;
 
     /** Applies the given parser `p` of type `Parser`.  The attribute produced
@@ -241,21 +243,14 @@ namespace boost { namespace parser {
         only be invoked if `p` succeeds and sttributes are currently being
         generated.  The parse succeeds iff `p` succeeds.  The attribute
         produced is the the result of the call to `f`. */
-    template<typename Parser, typename F>
+    template<typename Parser, typename F, typename ParserMods>
     struct transform_parser;
 
-    /** Applies the given parser `p` of type `Parser`.  This parser produces
-        no attribute, and suppresses the production of any attributes that
-        would otherwise be produced by `p`.  The parse succeeds iff `p`
-        succeeds. */
-    template<typename Parser>
-    struct omit_parser;
-
     /** Applies the given parser `p` of type `Parser`; regardless of the
         attribute produced by `Parser`, this parser's attribute is equivalent
         to `_where(ctx)` within a semantic action on `p`.  The parse succeeds
         iff `p` succeeds. */
-    template<typename Parser>
+    template<typename Parser, typename ParserMods>
     struct raw_parser;
 
 #if defined(BOOST_PARSER_DOXYGEN) || BOOST_PARSER_USE_CONCEPTS
@@ -268,34 +263,37 @@ namespace boost { namespace parser {
         non-contiguous, code using `string_view_parser` is ill-formed.  The
         parse succeeds iff `p` succeeds.  This parser is only available in
         C++20 and later. */
-    template<typename Parser>
+    template<typename Parser, typename ParserMods>
     struct string_view_parser;
 #endif
 
     /** Applies the given parser `p` of type `Parser`, disabling the current
         skipper in use, if any.  The parse succeeds iff `p` succeeds.  The
         attribute produced is the type of attribute produced by `Parser`. */
-    template<typename Parser>
+    template<typename Parser, typename ParserMods>
     struct lexeme_parser;
 
     /** Applies the given parser `p` of type `Parser`, enabling
         case-insensitive matching, based on Unicode case folding.  The parse
         succeeds iff `p` succeeds.  The attribute produced is the type of
         attribute produced by `Parser`. */
-    template<typename Parser>
+    template<typename Parser, typename ParserMods>
     struct no_case_parser;
 
     /** Applies the given parser `p` of type `Parser`, using a parser of type
         `SkipParser` as the skipper.  The parse succeeds iff `p` succeeds.
         The attribute produced is the type of attribute produced by
         `Parser`. */
-    template<typename Parser, typename SkipParser = detail::nope>
+    template<
+        typename Parser,
+        typename SkipParser = detail::nope,
+        typename ParserMods = parser_modifiers<>>
     struct skip_parser;
 
     /** Applies the given parser `p` of type `Parser`, producing no attributes
         and consuming no input.  The parse succeeds iff `p`'s success is
         unequal to `FailOnMatch`. */
-    template<typename Parser, bool FailOnMatch>
+    template<typename Parser, bool FailOnMatch, typename ParserMods>
     struct expect_parser;
 
     /** Matches one of a set S of possible inputs, each of which is associated
@@ -304,7 +302,7 @@ namespace boost { namespace parser {
         from S dynamically, during parsing; any such changes are reverted at
         the end of parsing.  The parse succeeds iff an element of S is
         matched.  \see `symbols` */
-    template<typename T>
+    template<typename T, typename ParserMods>
     struct symbol_parser;
 
     /** Applies another parser `p`, associated with this parser via `TagType`.
@@ -323,22 +321,24 @@ namespace boost { namespace parser {
         typename TagType,
         typename Attribute,
         typename LocalState,
-        typename ParamsTuple>
+        typename ParamsTuple,
+        typename ParserMods>
     struct rule_parser;
 
     /** Matches anything, and consumes no input.  If `Predicate` is anything
         other than `detail::nope` (which it is by default), and `pred_(ctx)`
         evaluates to false, where `ctx` is the parser context, the parse
         fails. */
-    template<typename Predicate>
+    template<typename Predicate, typename ParserMods>
     struct eps_parser;
 
     /** Matches only the end of input.  Produces no attribute. */
+    template<typename ParserMods>
     struct eoi_parser;
 
     /** Matches anything, consumes no input, and produces an attribute of type
         `RESOLVE(Attribute)`. */
-    template<typename Attribute>
+    template<typename Attribute, typename ParserMods>
     struct attr_parser;
 
     /** A tag type that can be passed as the first parameter to `char_()` when
@@ -366,7 +366,7 @@ namespace boost { namespace parser {
         characters for matching Unicode character classes like punctuation or
         lower case.  Attribute type is the attribute type of the character
         being matched. */
-    template<typename Tag>
+    template<typename Tag, typename ParserMods>
     struct char_set_parser;
 
     /** Matches a single code point that falls into one of the subranges of
@@ -374,12 +374,13 @@ namespace boost { namespace parser {
         sets of characters for matching Unicode character classes like hex
         digits or control characters.  Attribute type is the attribute type of
         the character being matched. */
-    template<typename Tag>
+    template<typename Tag, typename ParserMods>
     struct char_subrange_parser;
 
     /** Matches a single decimal digit code point, using the Unicode character
         class Hex_Digit.  Attribute type is the attribute type of the
         character being matched. */
+    template<typename ParserMods>
     struct digit_parser;
 
     /** Matches a particular string, delimited by an iterator sentinel pair;
@@ -389,7 +390,10 @@ namespace boost { namespace parser {
 
     /** Matches a string delimited by quotation marks; produces a
         `std::string` attribute. */
-    template<typename Quotes = detail::nope, typename Escapes = detail::nope>
+    template<
+        typename Quotes = detail::nope,
+        typename Escapes = detail::nope,
+        typename ParserMods = parser_modifiers<>>
     struct quoted_string_parser;
 
     /** Matches an end-of-line (`NewlinesOnly == true`), whitespace
@@ -397,11 +401,12 @@ namespace boost { namespace parser {
         but not newline) code point, based on the Unicode definitions of each
         (also matches the two code points `"\r\n"`).  Produces no
         attribute. */
-    template<bool NewlinesOnly, bool NoNewlines>
+    template<bool NewlinesOnly, bool NoNewlines, typename ParserMods>
     struct ws_parser;
 
     /** Matches the strings "true" and "false", producing an attribute of
         `true` or `false`, respectively, and fails on any other input. */
+    template<typename ParserMods>
     struct bool_parser;
 
     /** Matches an unsigned number of radix `Radix`, of at least `MinDigits`
@@ -415,7 +420,8 @@ namespace boost { namespace parser {
         int Radix = 10,
         int MinDigits = 1,
         int MaxDigits = -1,
-        typename Expected = detail::nope>
+        typename Expected = detail::nope,
+        typename ParserMods = parser_modifiers<>>
     struct uint_parser;
 
     /** Matches a signed number of radix `Radix`, of at least `MinDigits` and
@@ -429,12 +435,13 @@ namespace boost { namespace parser {
         int Radix = 10,
         int MinDigits = 1,
         int MaxDigits = -1,
-        typename Expected = detail::nope>
+        typename Expected = detail::nope,
+        typename ParserMods = parser_modifiers<>>
     struct int_parser;
 
     /** Matches a floating point number, producing an attribute of type
         `T`. */
-    template<typename T>
+    template<typename T, typename ParserMods>
     struct float_parser;
 
     /** Applies at most one of the parsers in `OrParser`.  If `switch_value_`
@@ -442,7 +449,10 @@ namespace boost { namespace parser {
         first such parser is applied, and the success or failure and attribute
         of the parse are those of the applied parser.  Otherwise, the parse
         fails. */
-    template<typename SwitchValue, typename OrParser = detail::nope>
+    template<
+        typename SwitchValue,
+        typename OrParser = detail::nope,
+        typename ParserMods = parser_modifiers<>>
     struct switch_parser;
 
     /** A wrapper for parsers that provides the operations that must be

include/boost/parser/replace.hpp

@@ -451,7 +451,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     template<
         typename V,
@@ -469,7 +469,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     namespace detail {
         template<
@@ -571,7 +571,8 @@ namespace boost::parser {
                              Parser,
                              GlobalState,
                              ErrorHandler,
-                             parser_interface<eps_parser<detail::phony>>>
+                             parser_interface<
+                                 eps_parser<detail::phony, parser_modifiers<>>>>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
@@ -582,7 +583,8 @@ namespace boost::parser {
                 return (*this)(
                     (R &&)r,
                     parser,
-                    parser_interface<eps_parser<detail::phony>>{},
+                    parser_interface<
+                        eps_parser<detail::phony, parser_modifiers<>>>{},
                     (ReplacementR &&)replacement,
                     trace_mode);
             }
@@ -623,10 +625,11 @@ namespace boost::parser {
                     std::is_same_v<Trace, trace>) {
                     // (r, parser, replacement, trace) case
                     return impl(
-                        (R &&) r,
+                        (R &&)r,
                         parser,
-                        parser_interface<eps_parser<detail::phony>>{},
-                        (SkipParser &&) skip,
+                        parser_interface<
+                            eps_parser<detail::phony, parser_modifiers<>>>{},
+                        (SkipParser &&)skip,
                         replacement);
                 } else {
                     static_assert(

include/boost/parser/search.hpp

@@ -116,7 +116,9 @@ namespace boost::parser {
                 return BOOST_PARSER_SUBRANGE(first, first);
 
             auto const search_parser = omit[*(char_ - parser)] >> -raw[parser];
-            if constexpr (std::is_same_v<SkipParser, eps_parser<phony>>) {
+            if constexpr (std::is_same_v<
+                              SkipParser,
+                              eps_parser<phony, parser_modifiers<>>>) {
                 auto result = parser::prefix_parse(
                     first, last, search_parser, trace_mode);
                 if (*result)
@@ -255,9 +257,9 @@ namespace boost::parser {
         trace trace_mode = trace::off)
     {
         return parser::search(
-            (R &&) r,
+            (R &&)r,
             parser,
-            parser_interface<eps_parser<detail::phony>>{},
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>{},
             trace_mode);
     }
 
@@ -292,7 +294,7 @@ namespace boost::parser {
         return parser::search(
             BOOST_PARSER_SUBRANGE(first, last),
             parser,
-            parser_interface<eps_parser<detail::phony>>{},
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>{},
             trace_mode);
     }
 
@@ -483,7 +485,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     template<
         typename V,
@@ -496,7 +498,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     namespace detail {
         template<
@@ -569,7 +571,8 @@ namespace boost::parser {
                             Parser,
                             GlobalState,
                             ErrorHandler,
-                            parser_interface<eps_parser<detail::phony>>>
+                            parser_interface<
+                                eps_parser<detail::phony, parser_modifiers<>>>>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
@@ -579,7 +582,8 @@ namespace boost::parser {
                 return (*this)(
                     (R &&)r,
                     parser,
-                    parser_interface<eps_parser<detail::phony>>{},
+                    parser_interface<
+                        eps_parser<detail::phony, parser_modifiers<>>>{},
                     trace_mode);
             }
 
@@ -590,8 +594,8 @@ namespace boost::parser {
                 typename Parser,
                 typename GlobalState,
                 typename ErrorHandler,
-                typename SkipParser =
-                    parser_interface<eps_parser<detail::phony>>,
+                typename SkipParser = parser_interface<
+                    eps_parser<detail::phony, parser_modifiers<>>>,
                 typename Trace = trace,
                 typename Enable = std::enable_if_t<is_parsable_range_v<R>>>
             [[nodiscard]] constexpr auto operator()(
@@ -607,9 +611,10 @@ namespace boost::parser {
                     std::is_same_v<Trace, trace>) {
                     // (r, parser, trace) case
                     return impl(
-                        (R &&) r,
+                        (R &&)r,
                         parser,
-                        parser_interface<eps_parser<detail::phony>>{},
+                        parser_interface<
+                            eps_parser<detail::phony, parser_modifiers<>>>{},
                         skip);
                 } else if constexpr (
                     detail::is_parser_iface<SkipParser> &&

include/boost/parser/split.hpp

@@ -193,14 +193,13 @@ namespace boost::parser {
         typename Parser,
         typename GlobalState,
         typename ErrorHandler>
-    split_view(
-        V &&, parser_interface<Parser, GlobalState, ErrorHandler>, trace)
+    split_view(V &&, parser_interface<Parser, GlobalState, ErrorHandler>, trace)
         -> split_view<
             detail::text::detail::all_t<V>,
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     template<
         typename V,
@@ -213,7 +212,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     namespace detail {
         template<
@@ -286,7 +285,8 @@ namespace boost::parser {
                             Parser,
                             GlobalState,
                             ErrorHandler,
-                            parser_interface<eps_parser<detail::phony>>>
+                            parser_interface<
+                                eps_parser<detail::phony, parser_modifiers<>>>>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
@@ -296,7 +296,8 @@ namespace boost::parser {
                 return (*this)(
                     (R &&)r,
                     parser,
-                    parser_interface<eps_parser<detail::phony>>{},
+                    parser_interface<
+                        eps_parser<detail::phony, parser_modifiers<>>>{},
                     trace_mode);
             }
 
@@ -307,8 +308,8 @@ namespace boost::parser {
                 typename Parser,
                 typename GlobalState,
                 typename ErrorHandler,
-                typename SkipParser =
-                    parser_interface<eps_parser<detail::phony>>,
+                typename SkipParser = parser_interface<
+                    eps_parser<detail::phony, parser_modifiers<>>>,
                 typename Trace = trace,
                 typename Enable = std::enable_if_t<is_parsable_range_v<R>>>
             [[nodiscard]] constexpr auto operator()(
@@ -324,9 +325,10 @@ namespace boost::parser {
                     std::is_same_v<Trace, trace>) {
                     // (r, parser, trace) case
                     return impl(
-                        (R &&) r,
+                        (R &&)r,
                         parser,
-                        parser_interface<eps_parser<detail::phony>>{},
+                        parser_interface<
+                            eps_parser<detail::phony, parser_modifiers<>>>{},
                         skip);
                 } else if constexpr (
                     detail::is_parser_iface<SkipParser> &&

include/boost/parser/transform_replace.hpp

@@ -254,7 +254,9 @@ namespace boost::parser {
                     BOOST_PARSER_SUBRANGE(first, first), parse_result{});
             }
 
-            if constexpr (std::is_same_v<SkipParser, eps_parser<phony>>) {
+            if constexpr (std::is_same_v<
+                              SkipParser,
+                              eps_parser<phony, parser_modifiers<>>>) {
                 auto result = parser::prefix_parse(
                     first, last, search_parser, trace_mode);
                 if (*result) {
@@ -578,7 +580,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     template<
         typename V,
@@ -594,7 +596,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     namespace detail {
         template<
@@ -697,7 +699,8 @@ namespace boost::parser {
                              Parser,
                              GlobalState,
                              ErrorHandler,
-                             parser_interface<eps_parser<detail::phony>>>
+                             parser_interface<
+                                 eps_parser<detail::phony, parser_modifiers<>>>>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
@@ -708,7 +711,8 @@ namespace boost::parser {
                 return (*this)(
                     (R &&)r,
                     parser,
-                    parser_interface<eps_parser<detail::phony>>{},
+                    parser_interface<
+                        eps_parser<detail::phony, parser_modifiers<>>>{},
                     (F &&)f,
                     trace_mode);
             }
@@ -753,10 +757,11 @@ namespace boost::parser {
                     std::is_same_v<Trace, trace>) {
                     // (r, parser, f, trace) case
                     return impl(
-                        to_range<R>::call((R &&) r),
+                        to_range<R>::call((R &&)r),
                         parser,
-                        parser_interface<eps_parser<detail::phony>>{},
-                        (SkipParser &&) skip,
+                        parser_interface<
+                            eps_parser<detail::phony, parser_modifiers<>>>{},
+                        (SkipParser &&)skip,
                         f);
                 } else {
                     static_assert(

test/tracing.cpp

@@ -156,6 +156,8 @@ int main()
               << "----------------------------------------\n";
 
     PARSE(omit[char_]);
+    PARSE(omit[omit[char_]]);
+    PARSE(omit[*omit[char_]]);
 
     std::cout << "\n\n"
               << "----------------------------------------\n"