diff --git a/include/boost/parser/detail/printing.hpp b/include/boost/parser/detail/printing.hpp
index c3ab256d..42ccfcb4 100644
--- a/include/boost/parser/detail/printing.hpp
+++ b/include/boost/parser/detail/printing.hpp
@@ -5,12 +5,12 @@
 #include <boost/parser/detail/detection.hpp>
 
 #include <boost/hana.hpp>
-#include <boost/optional.hpp>
 #include <boost/text/utf8.hpp>
 #include <boost/text/utility.hpp>
 
 #include <iomanip>
 #include <iostream>
+#include <optional>
 #include <sstream>
 #include <string>
 #include <variant>
@@ -572,7 +572,7 @@ namespace boost { namespace parser { namespace detail {
     inline void print(std::ostream & os, std::variant<T...> const & attr);
 
     template<typename T>
-    inline void print(std::ostream & os, optional<T> const & attr);
+    inline void print(std::ostream & os, std::optional<T> const & attr);
 
     template<typename Attribute>
     inline void print(std::ostream & os, Attribute const & attr);
@@ -598,7 +598,7 @@ namespace boost { namespace parser { namespace detail {
     }
 
     template<typename T>
-    inline void print(std::ostream & os, optional<T> const & attr)
+    inline void print(std::ostream & os, std::optional<T> const & attr)
     {
         if (!attr)
             os << "<<empty>>";
diff --git a/include/boost/parser/parser.hpp b/include/boost/parser/parser.hpp
index c9fb5f66..79e94d4e 100644
--- a/include/boost/parser/parser.hpp
+++ b/include/boost/parser/parser.hpp
@@ -69,7 +69,7 @@ namespace boost { namespace parser {
             }
 
             // Convertible to optional.
-            operator none_t() const noexcept { return none; }
+            operator std::nullopt_t() const noexcept { return std::nullopt; }
 
             // Also acts as a dummy predicate.
             template<typename Context>
@@ -507,7 +507,7 @@ namespace boost { namespace parser {
         struct is_optional : std::false_type
         {};
         template<typename T>
-        struct is_optional<optional<T>> : std::true_type
+        struct is_optional<std::optional<T>> : std::true_type
         {};
 
         template<typename T>
@@ -544,7 +544,7 @@ namespace boost { namespace parser {
         struct hana_tuple_to_or_type<
             hana::pair<hana::tuple<T...>, std::true_type>>
         {
-            using type = optional<std::variant<T...>>;
+            using type = std::optional<std::variant<T...>>;
         };
 
         template<typename... T>
@@ -557,7 +557,7 @@ namespace boost { namespace parser {
         template<typename T>
         struct hana_tuple_to_or_type<hana::pair<hana::tuple<T>, std::true_type>>
         {
-            using type = optional<T>;
+            using type = std::optional<T>;
         };
 
         template<typename T>
@@ -569,9 +569,9 @@ namespace boost { namespace parser {
 
         template<typename T>
         struct hana_tuple_to_or_type<
-            hana::pair<hana::tuple<optional<T>>, std::true_type>>
+            hana::pair<hana::tuple<std::optional<T>>, std::true_type>>
         {
-            using type = optional<T>;
+            using type = std::optional<T>;
         };
 
         template<>
@@ -619,13 +619,13 @@ namespace boost { namespace parser {
         template<typename T>
         struct optional_of_impl
         {
-            using type = optional<T>;
+            using type = std::optional<T>;
         };
 
         template<typename T>
-        struct optional_of_impl<optional<T>>
+        struct optional_of_impl<std::optional<T>>
         {
-            using type = optional<T>;
+            using type = std::optional<T>;
         };
 
         template<>
@@ -643,7 +643,7 @@ namespace boost { namespace parser {
             using type = T;
         };
         template<typename T>
-        struct unwrapped_optional<optional<T>>
+        struct unwrapped_optional<std::optional<T>>
         {
             using type = T;
         };
@@ -876,9 +876,9 @@ namespace boost { namespace parser {
         enum : int64_t { unbounded = -1 };
 
         template<typename T>
-        optional<T> make_parse_result(T & x, bool success)
+        std::optional<T> make_parse_result(T & x, bool success)
         {
-            optional<T> retval;
+            std::optional<T> retval;
             if (success)
                 retval = x;
             return retval;
@@ -1031,21 +1031,21 @@ namespace boost { namespace parser {
         }
 
         template<typename Container>
-        constexpr void move_back(Container & c, optional<Container> & x)
+        constexpr void move_back(Container & c, std::optional<Container> & x)
         {
             if (x)
                 c.insert(c.end(), x->begin(), x->end());
         }
 
         template<typename Container, typename T>
-        constexpr void move_back(Container & c, optional<T> & x)
+        constexpr void move_back(Container & c, std::optional<T> & x)
         {
             if (x)
                 c.insert(c.end(), std::move(*x));
         }
 
         template<typename Container, typename T>
-        constexpr void move_back(Container & c, optional<T> && x)
+        constexpr void move_back(Container & c, std::optional<T> && x)
         {
             if (x)
                 c.insert(c.end(), std::move(*x));
@@ -1096,7 +1096,7 @@ namespace boost { namespace parser {
                 SkipParser const & skip,
                 flags flags,
                 bool & success,
-                optional<std::variant<T...>> & retval)
+                std::optional<std::variant<T...>> & retval)
             {
                 Attr attr = parser.call(
                     use_cbs, first, last, context, skip, flags, success);
@@ -1106,7 +1106,7 @@ namespace boost { namespace parser {
         };
 
         template<typename... T>
-        struct apply_opt_var_parser_impl<optional<std::variant<T...>>>
+        struct apply_opt_var_parser_impl<std::optional<std::variant<T...>>>
         {
             template<
                 typename Parser,
@@ -1124,7 +1124,7 @@ namespace boost { namespace parser {
                 SkipParser const & skip,
                 flags flags,
                 bool & success,
-                optional<std::variant<U...>> & retval)
+                std::optional<std::variant<U...>> & retval)
             {
                 parser.call(
                     use_cbs,
@@ -1157,7 +1157,7 @@ namespace boost { namespace parser {
                 SkipParser const & skip,
                 flags flags,
                 bool & success,
-                optional<std::variant<T...>> & retval)
+                std::optional<std::variant<T...>> & retval)
             {
                 parser.call(
                     use_cbs, first, last, context, skip, flags, success);
@@ -1182,7 +1182,7 @@ namespace boost { namespace parser {
             SkipParser const & skip,
             flags flags,
             bool & success,
-            optional<std::variant<T...>> & retval)
+            std::optional<std::variant<T...>> & retval)
         {
             using attr_t = decltype(parser.call(
                 use_cbs, first, last, context, skip, flags, success));
@@ -1198,8 +1198,9 @@ namespace boost { namespace parser {
                 success,
                 retval);
 #else
-            if constexpr (std::
-                              is_same<attr_t, optional<std::variant<T...>>>{}) {
+            if constexpr (std::is_same<
+                              attr_t,
+                              std::optional<std::variant<T...>>>{}) {
                 parser.call(
                     use_cbs,
                     first,
@@ -1261,7 +1262,7 @@ namespace boost { namespace parser {
             SkipParser const & skip,
             flags flags,
             bool & success,
-            optional<T> & retval)
+            std::optional<T> & retval)
         {
             auto attr = parser.call(
                 use_cbs, first, last, context, skip, flags, success);
diff --git a/include/boost/yaml/json.hpp b/include/boost/yaml/json.hpp
index 92209f7d..bc5cf3c4 100644
--- a/include/boost/yaml/json.hpp
+++ b/include/boost/yaml/json.hpp
@@ -4,10 +4,10 @@
 #include <boost/yaml/json_fwd.hpp>
 #include <boost/yaml/detail/json.hpp>
 
-#include <boost/optional.hpp>
 #include <boost/utility/string_view.hpp>
 
 #include <memory>
+#include <optional>
 
 
 namespace boost { namespace json {
@@ -228,7 +228,7 @@ namespace boost { namespace json {
 
     using diagnostic_function = std::function<void(std::string const &)>;
 
-    optional<value> parse(
+    std::optional<value> parse(
         string_view str,
         diagnostic_function errors_callback = diagnostic_function(),
         int max_recursion = 512);
diff --git a/include/boost/yaml/yaml.hpp b/include/boost/yaml/yaml.hpp
index d429a5a9..24e954ce 100644
--- a/include/boost/yaml/yaml.hpp
+++ b/include/boost/yaml/yaml.hpp
@@ -4,9 +4,10 @@
 #include <boost/yaml/yaml_fwd.hpp>
 #include <boost/yaml/detail/yaml.hpp>
 
-#include <boost/optional.hpp>
 #include <boost/utility/string_view.hpp>
 
+#include <optional>
+
 
 namespace boost { namespace yaml {
 
@@ -310,7 +311,7 @@ namespace boost { namespace yaml {
 
     using diagnostic_function = std::function<void(std::string const &)>;
 
-    optional<std::vector<value>> parse(
+    std::optional<std::vector<value>> parse(
         string_view str,
         diagnostic_function errors_callback = diagnostic_function(),
         int max_recursion = 512);
diff --git a/src/json.cpp b/src/json.cpp
index 2b45fd71..b96b0bb3 100644
--- a/src/json.cpp
+++ b/src/json.cpp
@@ -172,7 +172,7 @@ namespace boost { namespace json {
 
     // TODO: This needs to change; it cannot parse a rope; there should also
     // be interfaces that accept CPIters and CPRanges.
-    optional<value> parse(
+    std::optional<value> parse(
         string_view str, diagnostic_function errors_callback, int max_recursion)
     {
         auto const range = text::make_to_utf32_range(str);
@@ -193,7 +193,7 @@ namespace boost { namespace json {
             bool const success = bp::skip_parse(first, last, parser, ws, val);
             if (!success || first != last)
                 return {};
-            return optional<value>(std::move(val));
+            return std::optional<value>(std::move(val));
         } catch (yaml::excessive_nesting<iter_t> const & e) {
             if (errors_callback) {
                 std::string const message = "error: Exceeded maximum number (" +
diff --git a/src/yaml.cpp b/src/yaml.cpp
index 8d2b6fb9..04b1fbeb 100644
--- a/src/yaml.cpp
+++ b/src/yaml.cpp
@@ -2348,12 +2348,12 @@ namespace boost { namespace yaml {
 
     // TODO: This needs to change; it cannot parse a rope; there should also
     // be interfaces that accept CPIters and CPRanges.
-    optional<std::vector<value>> parse(
+    std::optional<std::vector<value>> parse(
         string_view const & str,
         diagnostic_function errors_callback,
         int max_recursion)
     {
-        optional<std::vector<value>> retval;
+        std::optional<std::vector<value>> retval;
 
         auto const range = text::make_to_utf32_range(str);
         using iter_t = decltype(range.begin());
diff --git a/test/compile_or_attribute.cpp b/test/compile_or_attribute.cpp
index 4c54b904..a42f10ff 100644
--- a/test/compile_or_attribute.cpp
+++ b/test/compile_or_attribute.cpp
@@ -11,7 +11,6 @@
 
 using namespace boost::parser;
 using boost::is_same;
-using boost::optional;
 using boost::hana::tuple;
 
 void compile_or_attribute()
@@ -24,79 +23,86 @@ void compile_or_attribute()
     {
         constexpr auto parser = int_ | eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<optional<int>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::optional<int>>>));
     }
     {
         constexpr auto parser = eps | int_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<optional<int>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::optional<int>>>));
     }
 
     // scalar | scalar
     {
         constexpr auto parser = char_ | char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<char>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<char>>));
     }
     {
         constexpr auto parser = eps | char_ | char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<optional<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::optional<char>>>));
     }
     {
         constexpr auto parser = char_ | eps | char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<optional<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::optional<char>>>));
     }
     {
         constexpr auto parser = char_ | char_ | eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<optional<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::optional<char>>>));
     }
     {
         constexpr auto parser = int_ | char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::variant<int, char>>>));
+        BOOST_MPL_ASSERT(
+            (is_same<attr_t, std::optional<std::variant<int, char>>>));
     }
     {
         constexpr auto parser = eps | int_ | char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<optional<std::variant<int, char>>>>));
+            (is_same<
+                attr_t,
+                std::optional<std::optional<std::variant<int, char>>>>));
     }
     {
         constexpr auto parser = int_ | eps | char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<optional<std::variant<int, char>>>>));
+            (is_same<
+                attr_t,
+                std::optional<std::optional<std::variant<int, char>>>>));
     }
     {
         constexpr auto parser = int_ | char_ | eps;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<optional<std::variant<int, char>>>>));
+            (is_same<
+                attr_t,
+                std::optional<std::optional<std::variant<int, char>>>>));
     }
 
     // -scalar | -scalar
     {
         constexpr auto parser = -char_ | -char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<optional<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::optional<char>>>));
     }
     {
         constexpr auto parser = eps | -char_ | -char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<optional<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::optional<char>>>));
     }
     {
         constexpr auto parser = -char_ | eps | -char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<optional<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::optional<char>>>));
     }
     {
         constexpr auto parser = -char_ | -char_ | eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<optional<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::optional<char>>>));
     }
     {
         constexpr auto parser = -int_ | -char_;
@@ -104,7 +110,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<std::variant<optional<int>, optional<char>>>>));
+                std::optional<
+                    std::variant<std::optional<int>, std::optional<char>>>>));
     }
     {
         constexpr auto parser = eps | -int_ | -char_;
@@ -112,8 +119,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<
-                    optional<std::variant<optional<int>, optional<char>>>>>));
+                std::optional<std::optional<
+                    std::variant<std::optional<int>, std::optional<char>>>>>));
     }
     {
         constexpr auto parser = -int_ | eps | -char_;
@@ -121,8 +128,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<
-                    optional<std::variant<optional<int>, optional<char>>>>>));
+                std::optional<std::optional<
+                    std::variant<std::optional<int>, std::optional<char>>>>>));
     }
     {
         constexpr auto parser = -int_ | -char_ | eps;
@@ -130,53 +137,56 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<
-                    optional<std::variant<optional<int>, optional<char>>>>>));
+                std::optional<std::optional<
+                    std::variant<std::optional<int>, std::optional<char>>>>>));
     }
 
     // seq<T> | seq<T>
     {
         constexpr auto parser = *char_ | *char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = eps | *char_ | *char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<optional<std::vector<char>>>>));
+            (is_same<attr_t, std::optional<std::optional<std::vector<char>>>>));
     }
     {
         constexpr auto parser = *char_ | eps | *char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<optional<std::vector<char>>>>));
+            (is_same<attr_t, std::optional<std::optional<std::vector<char>>>>));
     }
     {
         constexpr auto parser = *char_ | *char_ | eps;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<optional<std::vector<char>>>>));
+            (is_same<attr_t, std::optional<std::optional<std::vector<char>>>>));
     }
     {
         constexpr auto parser = *string("str") | *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = eps | *string("str") | *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<optional<std::string>>>));
+        BOOST_MPL_ASSERT(
+            (is_same<attr_t, std::optional<std::optional<std::string>>>));
     }
     {
         constexpr auto parser = *string("str") | eps | *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<optional<std::string>>>));
+        BOOST_MPL_ASSERT(
+            (is_same<attr_t, std::optional<std::optional<std::string>>>));
     }
     {
         constexpr auto parser = *string("str") | *string("str") | eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<optional<std::string>>>));
+        BOOST_MPL_ASSERT(
+            (is_same<attr_t, std::optional<std::optional<std::string>>>));
     }
 
     // seq<T> | seq<U>
@@ -186,34 +196,31 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<std::variant<std::vector<char>, std::string>>>));
+                std::optional<std::variant<std::vector<char>, std::string>>>));
     }
     {
         constexpr auto parser = eps | *char_ | *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT(
-            (is_same<
-                attr_t,
-                optional<
-                    optional<std::variant<std::vector<char>, std::string>>>>));
+        BOOST_MPL_ASSERT((is_same<
+                          attr_t,
+                          std::optional<std::optional<
+                              std::variant<std::vector<char>, std::string>>>>));
     }
     {
         constexpr auto parser = *char_ | eps | *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT(
-            (is_same<
-                attr_t,
-                optional<
-                    optional<std::variant<std::vector<char>, std::string>>>>));
+        BOOST_MPL_ASSERT((is_same<
+                          attr_t,
+                          std::optional<std::optional<
+                              std::variant<std::vector<char>, std::string>>>>));
     }
     {
         constexpr auto parser = *char_ | *string("str") | eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT(
-            (is_same<
-                attr_t,
-                optional<
-                    optional<std::variant<std::vector<char>, std::string>>>>));
+        BOOST_MPL_ASSERT((is_same<
+                          attr_t,
+                          std::optional<std::optional<
+                              std::variant<std::vector<char>, std::string>>>>));
     }
 
     // seq<T> | T
@@ -221,7 +228,9 @@ void compile_or_attribute()
         constexpr auto parser = *char_ | char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<std::variant<std::vector<char>, char>>>));
+            (is_same<
+                attr_t,
+                std::optional<std::variant<std::vector<char>, char>>>));
     }
     {
         constexpr auto parser = eps | *char_ | char_;
@@ -229,7 +238,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<std::variant<std::vector<char>, char>>>>));
+                std::optional<
+                    std::optional<std::variant<std::vector<char>, char>>>>));
     }
     {
         constexpr auto parser = *char_ | eps | char_;
@@ -237,7 +247,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<std::variant<std::vector<char>, char>>>>));
+                std::optional<
+                    std::optional<std::variant<std::vector<char>, char>>>>));
     }
     {
         constexpr auto parser = *char_ | char_ | eps;
@@ -245,13 +256,14 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<std::variant<std::vector<char>, char>>>>));
+                std::optional<
+                    std::optional<std::variant<std::vector<char>, char>>>>));
     }
     {
         constexpr auto parser = *string("str") | char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<std::variant<std::string, char>>>));
+            (is_same<attr_t, std::optional<std::variant<std::string, char>>>));
     }
     {
         constexpr auto parser = eps | *string("str") | char_;
@@ -259,7 +271,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<std::variant<std::string, char>>>>));
+                std::optional<
+                    std::optional<std::variant<std::string, char>>>>));
     }
     {
         constexpr auto parser = *string("str") | eps | char_;
@@ -267,7 +280,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<std::variant<std::string, char>>>>));
+                std::optional<
+                    std::optional<std::variant<std::string, char>>>>));
     }
     {
         constexpr auto parser = *string("str") | char_ | eps;
@@ -275,7 +289,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<std::variant<std::string, char>>>>));
+                std::optional<
+                    std::optional<std::variant<std::string, char>>>>));
     }
 
     // T | seq<T>
@@ -283,7 +298,9 @@ void compile_or_attribute()
         constexpr auto parser = char_ | *char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<std::variant<char, std::vector<char>>>>));
+            (is_same<
+                attr_t,
+                std::optional<std::variant<char, std::vector<char>>>>));
     }
     {
         constexpr auto parser = eps | char_ | *char_;
@@ -291,7 +308,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<std::variant<char, std::vector<char>>>>>));
+                std::optional<
+                    std::optional<std::variant<char, std::vector<char>>>>>));
     }
     {
         constexpr auto parser = char_ | eps | *char_;
@@ -299,7 +317,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<std::variant<char, std::vector<char>>>>>));
+                std::optional<
+                    std::optional<std::variant<char, std::vector<char>>>>>));
     }
     {
         constexpr auto parser = char_ | *char_ | eps;
@@ -307,13 +326,14 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<std::variant<char, std::vector<char>>>>>));
+                std::optional<
+                    std::optional<std::variant<char, std::vector<char>>>>>));
     }
     {
         constexpr auto parser = char_ | *string("str");
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<std::variant<char, std::string>>>));
+            (is_same<attr_t, std::optional<std::variant<char, std::string>>>));
     }
     {
         constexpr auto parser = eps | char_ | *string("str");
@@ -321,7 +341,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<std::variant<char, std::string>>>>));
+                std::optional<
+                    std::optional<std::variant<char, std::string>>>>));
     }
     {
         constexpr auto parser = char_ | eps | *string("str");
@@ -329,7 +350,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<std::variant<char, std::string>>>>));
+                std::optional<
+                    std::optional<std::variant<char, std::string>>>>));
     }
     {
         constexpr auto parser = char_ | *string("str") | eps;
@@ -337,17 +359,19 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<std::variant<char, std::string>>>>));
+                std::optional<
+                    std::optional<std::variant<char, std::string>>>>));
     }
 
-    // seq<T> | optional<T>
+    // seq<T> | std::optional<T>
     {
         constexpr auto parser = *char_ | -char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<std::variant<std::vector<char>, optional<char>>>>));
+                std::optional<
+                    std::variant<std::vector<char>, std::optional<char>>>>));
     }
     {
         constexpr auto parser = eps | *char_ | -char_;
@@ -355,8 +379,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<
-                    std::variant<std::vector<char>, optional<char>>>>>));
+                std::optional<std::optional<
+                    std::variant<std::vector<char>, std::optional<char>>>>>));
     }
     {
         constexpr auto parser = *char_ | eps | -char_;
@@ -364,8 +388,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<
-                    std::variant<std::vector<char>, optional<char>>>>>));
+                std::optional<std::optional<
+                    std::variant<std::vector<char>, std::optional<char>>>>>));
     }
     {
         constexpr auto parser = *char_ | -char_ | eps;
@@ -373,8 +397,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<
-                    std::variant<std::vector<char>, optional<char>>>>>));
+                std::optional<std::optional<
+                    std::variant<std::vector<char>, std::optional<char>>>>>));
     }
     {
         constexpr auto parser = *string("str") | -char_;
@@ -382,7 +406,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<std::variant<std::string, optional<char>>>>));
+                std::optional<
+                    std::variant<std::string, std::optional<char>>>>));
     }
     {
         constexpr auto parser = eps | *string("str") | -char_;
@@ -390,8 +415,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<
-                    optional<std::variant<std::string, optional<char>>>>>));
+                std::optional<std::optional<
+                    std::variant<std::string, std::optional<char>>>>>));
     }
     {
         constexpr auto parser = *string("str") | eps | -char_;
@@ -399,8 +424,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<
-                    optional<std::variant<std::string, optional<char>>>>>));
+                std::optional<std::optional<
+                    std::variant<std::string, std::optional<char>>>>>));
     }
     {
         constexpr auto parser = *string("str") | -char_ | eps;
@@ -408,18 +433,19 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<
-                    optional<std::variant<std::string, optional<char>>>>>));
+                std::optional<std::optional<
+                    std::variant<std::string, std::optional<char>>>>>));
     }
 
-    // optional<T> | seq<T>
+    // std::optional<T> | seq<T>
     {
         constexpr auto parser = -char_ | *char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<std::variant<optional<char>, std::vector<char>>>>));
+                std::optional<
+                    std::variant<std::optional<char>, std::vector<char>>>>));
     }
     {
         constexpr auto parser = eps | -char_ | *char_;
@@ -427,8 +453,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<
-                    std::variant<optional<char>, std::vector<char>>>>>));
+                std::optional<std::optional<
+                    std::variant<std::optional<char>, std::vector<char>>>>>));
     }
     {
         constexpr auto parser = -char_ | eps | *char_;
@@ -436,8 +462,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<
-                    std::variant<optional<char>, std::vector<char>>>>>));
+                std::optional<std::optional<
+                    std::variant<std::optional<char>, std::vector<char>>>>>));
     }
     {
         constexpr auto parser = -char_ | *char_ | eps;
@@ -445,8 +471,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<optional<
-                    std::variant<optional<char>, std::vector<char>>>>>));
+                std::optional<std::optional<
+                    std::variant<std::optional<char>, std::vector<char>>>>>));
     }
     {
         constexpr auto parser = -char_ | *string("str");
@@ -454,7 +480,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<std::variant<optional<char>, std::string>>>));
+                std::optional<
+                    std::variant<std::optional<char>, std::string>>>));
     }
     {
         constexpr auto parser = eps | -char_ | *string("str");
@@ -462,8 +489,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<
-                    optional<std::variant<optional<char>, std::string>>>>));
+                std::optional<std::optional<
+                    std::variant<std::optional<char>, std::string>>>>));
     }
     {
         constexpr auto parser = -char_ | eps | *string("str");
@@ -471,8 +498,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<
-                    optional<std::variant<optional<char>, std::string>>>>));
+                std::optional<std::optional<
+                    std::variant<std::optional<char>, std::string>>>>));
     }
     {
         constexpr auto parser = -char_ | *string("str") | eps;
@@ -480,8 +507,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<
-                    optional<std::variant<optional<char>, std::string>>>>));
+                std::optional<std::optional<
+                    std::variant<std::optional<char>, std::string>>>>));
     }
 
     // or grouping
@@ -491,17 +518,17 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<
-                    optional<std::variant<optional<char>, std::string>>>>));
+                std::optional<std::optional<
+                    std::variant<std::optional<char>, std::string>>>>));
     }
     {
         constexpr auto parser = -char_ | (*string("str") | eps);
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT(
-            (is_same<
-                attr_t,
-                optional<
-                    std::variant<optional<char>, optional<std::string>>>>));
+        BOOST_MPL_ASSERT((is_same<
+                          attr_t,
+                          std::optional<std::variant<
+                              std::optional<char>,
+                              std::optional<std::string>>>>));
     }
     {
         constexpr auto parser = eps | (-char_ | *string("str") | eps);
@@ -509,8 +536,8 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<
-                    optional<std::variant<optional<char>, std::string>>>>));
+                std::optional<std::optional<
+                    std::variant<std::optional<char>, std::string>>>>));
     }
     {
         constexpr auto parser = eps | (-char_ | *string("str") | eps) | eps;
@@ -518,7 +545,7 @@ void compile_or_attribute()
         BOOST_MPL_ASSERT(
             (is_same<
                 attr_t,
-                optional<
-                    optional<std::variant<optional<char>, std::string>>>>));
+                std::optional<std::optional<
+                    std::variant<std::optional<char>, std::string>>>>));
     }
 }
diff --git a/test/compile_seq_attribute.cpp b/test/compile_seq_attribute.cpp
index 6142d826..348bdff7 100644
--- a/test/compile_seq_attribute.cpp
+++ b/test/compile_seq_attribute.cpp
@@ -11,8 +11,6 @@
 
 using namespace boost::parser;
 using boost::is_same;
-using boost::optional;
-using boost::variant;
 using boost::hana::tuple;
 
 void compile_seq_attribute()
@@ -25,54 +23,54 @@ void compile_seq_attribute()
     {
         constexpr auto parser = int_ >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<int>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<int>>));
     }
     {
         constexpr auto parser = eps >> int_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<int>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<int>>));
     }
 
     // scalar >> scalar
     {
         constexpr auto parser = char_ >> char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = eps >> char_ >> char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = char_ >> eps >> char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = char_ >> char_ >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = int_ >> char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<tuple<int, char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<tuple<int, char>>>));
     }
     {
         constexpr auto parser = eps >> int_ >> char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<tuple<int, char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<tuple<int, char>>>));
     }
     {
         constexpr auto parser = int_ >> eps >> char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<tuple<int, char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<tuple<int, char>>>));
     }
     {
         constexpr auto parser = int_ >> char_ >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<tuple<int, char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<tuple<int, char>>>));
     }
 
     // -scalar >> -scalar
@@ -80,91 +78,103 @@ void compile_seq_attribute()
         constexpr auto parser = -char_ >> -char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<std::vector<optional<char>>>>));
+            (is_same<attr_t, std::optional<std::vector<std::optional<char>>>>));
     }
     {
         constexpr auto parser = eps >> -char_ >> -char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<std::vector<optional<char>>>>));
+            (is_same<attr_t, std::optional<std::vector<std::optional<char>>>>));
     }
     {
         constexpr auto parser = -char_ >> eps >> -char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<std::vector<optional<char>>>>));
+            (is_same<attr_t, std::optional<std::vector<std::optional<char>>>>));
     }
     {
         constexpr auto parser = -char_ >> -char_ >> eps;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<std::vector<optional<char>>>>));
+            (is_same<attr_t, std::optional<std::vector<std::optional<char>>>>));
     }
     {
         constexpr auto parser = -int_ >> -char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<tuple<optional<int>, optional<char>>>>));
+            (is_same<
+                attr_t,
+                std::optional<
+                    tuple<std::optional<int>, std::optional<char>>>>));
     }
     {
         constexpr auto parser = eps >> -int_ >> -char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<tuple<optional<int>, optional<char>>>>));
+            (is_same<
+                attr_t,
+                std::optional<
+                    tuple<std::optional<int>, std::optional<char>>>>));
     }
     {
         constexpr auto parser = -int_ >> eps >> -char_;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<tuple<optional<int>, optional<char>>>>));
+            (is_same<
+                attr_t,
+                std::optional<
+                    tuple<std::optional<int>, std::optional<char>>>>));
     }
     {
         constexpr auto parser = -int_ >> -char_ >> eps;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<tuple<optional<int>, optional<char>>>>));
+            (is_same<
+                attr_t,
+                std::optional<
+                    tuple<std::optional<int>, std::optional<char>>>>));
     }
 
     // seq<T> >> seq<T>
     {
         constexpr auto parser = *char_ >> *char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = eps >> *char_ >> *char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = *char_ >> eps >> *char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = *char_ >> *char_ >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = *string("str") >> *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = eps >> *string("str") >> *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = *string("str") >> eps >> *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = *string("str") >> *string("str") >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
 
     // seq<T> >> seq<U>
@@ -172,214 +182,222 @@ void compile_seq_attribute()
         constexpr auto parser = *char_ >> *string("str");
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<tuple<std::vector<char>, std::string>>>));
+            (is_same<
+                attr_t,
+                std::optional<tuple<std::vector<char>, std::string>>>));
     }
     {
         constexpr auto parser = eps >> *char_ >> *string("str");
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<tuple<std::vector<char>, std::string>>>));
+            (is_same<
+                attr_t,
+                std::optional<tuple<std::vector<char>, std::string>>>));
     }
     {
         constexpr auto parser = *char_ >> eps >> *string("str");
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<tuple<std::vector<char>, std::string>>>));
+            (is_same<
+                attr_t,
+                std::optional<tuple<std::vector<char>, std::string>>>));
     }
     {
         constexpr auto parser = *char_ >> *string("str") >> eps;
         using attr_t = decltype(parse(first, last, parser));
         BOOST_MPL_ASSERT(
-            (is_same<attr_t, optional<tuple<std::vector<char>, std::string>>>));
+            (is_same<
+                attr_t,
+                std::optional<tuple<std::vector<char>, std::string>>>));
     }
 
     // seq<T> >> T
     {
         constexpr auto parser = *char_ >> char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = eps >> *char_ >> char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = *char_ >> eps >> char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = *char_ >> char_ >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = *string("str") >> char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = eps >> *string("str") >> char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = *string("str") >> eps >> char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = *string("str") >> char_ >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
 
     // T >> seq<T>
     {
         constexpr auto parser = char_ >> *char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = eps >> char_ >> *char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = char_ >> eps >> *char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = char_ >> *char_ >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = char_ >> *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = eps >> char_ >> *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = char_ >> eps >> *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = char_ >> *string("str") >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
 
-    // seq<T> >> optional<T>
+    // seq<T> >> std::optional<T>
     {
         constexpr auto parser = *char_ >> -char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = eps >> *char_ >> -char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = *char_ >> eps >> -char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = *char_ >> -char_ >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = *string("str") >> -char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = eps >> *string("str") >> -char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = *string("str") >> eps >> -char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = *string("str") >> -char_ >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
 
-    // optional<T> >> seq<T>
+    // std::optional<T> >> seq<T>
     {
         constexpr auto parser = -char_ >> *char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = eps >> -char_ >> *char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = -char_ >> eps >> *char_;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = -char_ >> *char_ >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::vector<char>>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::vector<char>>>));
     }
     {
         constexpr auto parser = -char_ >> *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = eps >> -char_ >> *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = -char_ >> eps >> *string("str");
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = -char_ >> *string("str") >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
 
     // seq grouping
     {
         constexpr auto parser = (-char_ >> *string("str")) >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = -char_ >> (*string("str") >> eps);
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = eps >> (-char_ >> *string("str") >> eps);
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
     {
         constexpr auto parser = eps >> (-char_ >> *string("str") >> eps) >> eps;
         using attr_t = decltype(parse(first, last, parser));
-        BOOST_MPL_ASSERT((is_same<attr_t, optional<std::string>>));
+        BOOST_MPL_ASSERT((is_same<attr_t, std::optional<std::string>>));
     }
 }
diff --git a/test/json_parser.cpp b/test/json_parser.cpp
index 5b4677db..21de8a0a 100644
--- a/test/json_parser.cpp
+++ b/test/json_parser.cpp
@@ -8,7 +8,7 @@ int main()
         if (str.empty())
             break;
 
-        boost::optional<boost::json::value> value;
+        std::optional<boost::json::value> value;
         if ((value = boost::json::parse(
                  str, [](std::string const & msg) { std::cout << msg; }))) {
             std::cout << "Parsed value:\n";
diff --git a/test/parse_json_test.cpp b/test/parse_json_test.cpp
index 81533f2b..47936893 100644
--- a/test/parse_json_test.cpp
+++ b/test/parse_json_test.cpp
@@ -36,7 +36,7 @@ TEST(parse, test_parse_yaml)
         errors.push_back(error);
     };
 
-    boost::optional<boost::json::value> result =
+    std::optional<boost::json::value> result =
         boost::json::parse(str, report_error);
 
     for (auto const & error : errors) {
diff --git a/test/parser.cpp b/test/parser.cpp
index cf209dbd..7996c78c 100644
--- a/test/parser.cpp
+++ b/test/parser.cpp
@@ -124,15 +124,15 @@ TEST(parser, basic)
     }
     {
         std::string str = "a";
-        boost::optional<char> c;
+        std::optional<char> c;
         EXPECT_TRUE(parse(str, parser_5, c));
         EXPECT_EQ(c, 'a');
     }
     {
         std::string str = "z";
-        boost::optional<char> c;
+        std::optional<char> c;
         EXPECT_TRUE(parse(str, parser_5, c));
-        EXPECT_EQ(c, boost::none);
+        EXPECT_EQ(c, std::nullopt);
     }
 }
 
@@ -526,7 +526,7 @@ TEST(parser, star_as_string_or_vector)
             EXPECT_EQ(chars, "");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(chars);
                 EXPECT_EQ(*chars, "");
             }
@@ -538,7 +538,7 @@ TEST(parser, star_as_string_or_vector)
             EXPECT_EQ(chars, "");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(chars);
                 EXPECT_EQ(*chars, "");
             }
@@ -550,7 +550,7 @@ TEST(parser, star_as_string_or_vector)
             EXPECT_EQ(chars, "zs");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(chars);
                 EXPECT_EQ(*chars, "zs");
             }
@@ -562,7 +562,7 @@ TEST(parser, star_as_string_or_vector)
             EXPECT_EQ(chars, "zszs");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(chars);
                 EXPECT_EQ(*chars, "zszs");
             }
@@ -679,7 +679,7 @@ TEST(parser, repeat)
             EXPECT_EQ(chars, "");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(!chars);
             }
         }
@@ -690,7 +690,7 @@ TEST(parser, repeat)
             EXPECT_EQ(chars, "");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(!chars);
             }
         }
@@ -701,7 +701,7 @@ TEST(parser, repeat)
             EXPECT_EQ(chars, "");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(!chars);
             }
         }
@@ -712,7 +712,7 @@ TEST(parser, repeat)
             EXPECT_EQ(chars, "zszs");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(chars);
                 EXPECT_EQ(*chars, "zszs");
             }
@@ -752,25 +752,25 @@ TEST(parser, raw)
         }
         {
             std::string str = "";
-            boost::optional<range_t> result = parse(str, parser);
+            std::optional<range_t> result = parse(str, parser);
             EXPECT_TRUE(result);
             EXPECT_EQ(*result, range_t(&*str.begin(), &*str.begin()));
         }
         {
             std::string str = "z";
-            boost::optional<range_t> result = parse(str, parser);
+            std::optional<range_t> result = parse(str, parser);
             EXPECT_TRUE(result);
             EXPECT_EQ(*result, range_t(&*str.begin(), &*str.begin()));
         }
         {
             std::string str = "zs";
-            boost::optional<range_t> result = parse(str, parser);
+            std::optional<range_t> result = parse(str, parser);
             EXPECT_TRUE(result);
             EXPECT_EQ(*result, range_t(&*str.begin(), &*str.end()));
         }
         {
             std::string str = "zszs";
-            boost::optional<range_t> result = parse(str, parser);
+            std::optional<range_t> result = parse(str, parser);
             EXPECT_TRUE(result);
             EXPECT_EQ(*result, range_t(&*str.begin(), &*str.end()));
         }
@@ -789,7 +789,7 @@ TEST(parser, delimited)
             EXPECT_EQ(chars, "");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(!chars);
             }
         }
@@ -800,7 +800,7 @@ TEST(parser, delimited)
             EXPECT_EQ(chars, "");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(!chars);
             }
         }
@@ -811,7 +811,7 @@ TEST(parser, delimited)
             EXPECT_EQ(chars, "");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(!chars);
             }
         }
@@ -822,7 +822,7 @@ TEST(parser, delimited)
             EXPECT_EQ(chars, "");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(!chars);
             }
         }
@@ -833,7 +833,7 @@ TEST(parser, delimited)
             EXPECT_EQ(chars, "yay");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(chars);
                 EXPECT_EQ(*chars, "yay");
             }
@@ -845,7 +845,7 @@ TEST(parser, delimited)
             EXPECT_EQ(chars, "yay");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(chars);
                 EXPECT_EQ(*chars, "yay");
             }
@@ -857,7 +857,7 @@ TEST(parser, delimited)
             EXPECT_EQ(chars, "yay");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(chars);
                 EXPECT_EQ(*chars, "yay");
             }
@@ -869,7 +869,7 @@ TEST(parser, delimited)
             EXPECT_EQ(chars, "yayyayyay");
 
             {
-                boost::optional<std::string> const chars = parse(str, parser);
+                std::optional<std::string> const chars = parse(str, parser);
                 EXPECT_TRUE(chars);
                 EXPECT_EQ(*chars, "yayyayyay");
             }
@@ -887,7 +887,7 @@ TEST(parser, delimited)
 
         {
             std::string str = "";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(!chars);
         }
@@ -899,7 +899,7 @@ TEST(parser, delimited)
         }
         {
             std::string str = "z";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(!chars);
         }
@@ -911,7 +911,7 @@ TEST(parser, delimited)
         }
         {
             std::string str = ",";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(!chars);
         }
@@ -923,7 +923,7 @@ TEST(parser, delimited)
         }
         {
             std::string str = " ,yay";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(!chars);
         }
@@ -935,7 +935,7 @@ TEST(parser, delimited)
         }
         {
             std::string str = ", yay";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(!chars);
         }
@@ -947,7 +947,7 @@ TEST(parser, delimited)
         }
         {
             std::string str = ",yay ";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(!chars);
         }
@@ -960,7 +960,7 @@ TEST(parser, delimited)
         }
         {
             std::string str = " , yay ";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(!chars);
         }
@@ -972,7 +972,7 @@ TEST(parser, delimited)
         }
         {
             std::string str = "yay";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yay");
@@ -985,7 +985,7 @@ TEST(parser, delimited)
         }
         {
             std::string str = "yayyay";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yay");
@@ -998,7 +998,7 @@ TEST(parser, delimited)
         }
         {
             std::string str = "yay,";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yay");
@@ -1011,7 +1011,7 @@ TEST(parser, delimited)
         }
         {
             std::string str = "yay,yay,yay";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yayyayyay");
@@ -1024,7 +1024,7 @@ TEST(parser, delimited)
         }
         {
             std::string str = " yay,yay,yay";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yayyayyay");
@@ -1038,7 +1038,7 @@ TEST(parser, delimited)
 
         {
             std::string str = "yay ,yay,yay";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yayyayyay");
@@ -1051,7 +1051,7 @@ TEST(parser, delimited)
         }
         {
             std::string str = "yay, yay,yay";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yayyayyay");
@@ -1065,7 +1065,7 @@ TEST(parser, delimited)
 
         {
             std::string str = "yay,yay ,yay";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yayyayyay");
@@ -1079,7 +1079,7 @@ TEST(parser, delimited)
 
         {
             std::string str = "yay,yay, yay";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yayyayyay");
@@ -1093,7 +1093,7 @@ TEST(parser, delimited)
 
         {
             std::string str = "yay,yay,yay ";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yayyayyay");
@@ -1107,7 +1107,7 @@ TEST(parser, delimited)
 
         {
             std::string str = " yay , yay , yay ";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yayyayyay");
@@ -1121,7 +1121,7 @@ TEST(parser, delimited)
 
         {
             std::string str = "yay, yay, yay";
-            boost::optional<std::string> const chars =
+            std::optional<std::string> const chars =
                 skip_parse(str, parser, char_(' '));
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yayyayyay");
@@ -1142,7 +1142,7 @@ TEST(parser, lexeme)
 
             {
                 std::string str = "yay, yay, yay";
-                boost::optional<std::string> const chars =
+                std::optional<std::string> const chars =
                     skip_parse(str, parser, char_(' '));
                 EXPECT_TRUE(chars);
                 EXPECT_EQ(*chars, "yay");
@@ -1156,7 +1156,7 @@ TEST(parser, lexeme)
 
             {
                 std::string str = " yay, yay, yay";
-                boost::optional<std::string> const chars =
+                std::optional<std::string> const chars =
                     skip_parse(str, parser, char_(' '));
                 EXPECT_TRUE(chars);
                 EXPECT_EQ(*chars, "yay");
@@ -1175,7 +1175,7 @@ TEST(parser, lexeme)
 
             {
                 std::string str = "yay, yay, yay";
-                boost::optional<std::string> const chars =
+                std::optional<std::string> const chars =
                     skip_parse(str, parser, char_(' '));
                 EXPECT_TRUE(chars);
                 EXPECT_EQ(*chars, "yayyayyay");
@@ -1189,7 +1189,7 @@ TEST(parser, lexeme)
 
             {
                 std::string str = " yay, yay, yay";
-                boost::optional<std::string> const chars =
+                std::optional<std::string> const chars =
                     skip_parse(str, parser, char_(' '));
                 EXPECT_TRUE(chars);
                 EXPECT_EQ(*chars, "yayyayyay");
@@ -1211,7 +1211,7 @@ TEST(parser, skip)
         }
         {
             std::string str = "yay, yay, yay";
-            boost::optional<std::string> const chars = parse(str, parser);
+            std::optional<std::string> const chars = parse(str, parser);
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yayyayyay");
         }
@@ -1223,7 +1223,7 @@ TEST(parser, skip)
         }
         {
             std::string str = " yay, yay, yay";
-            boost::optional<std::string> const chars = parse(str, parser);
+            std::optional<std::string> const chars = parse(str, parser);
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "yayyayyay");
         }
@@ -1244,7 +1244,7 @@ TEST(parser, combined_seq_and_or)
 
         {
             std::string str = "abc";
-            boost::optional<std::vector<char>> const chars = parse(str, parser);
+            std::optional<std::vector<char>> const chars = parse(str, parser);
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, std::vector<char>({'a', 'b', 'c'}));
         }
@@ -1269,7 +1269,7 @@ TEST(parser, combined_seq_and_or)
 
         {
             std::string str = "abc";
-            boost::optional<std::string> const chars = parse(str, parser);
+            std::optional<std::string> const chars = parse(str, parser);
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "abc");
         }
@@ -1343,7 +1343,7 @@ TEST(parser, combined_seq_and_or)
 
         {
             std::string str = "abc";
-            boost::optional<std::string> const chars = parse(str, parser);
+            std::optional<std::string> const chars = parse(str, parser);
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "abc");
         }
@@ -1395,7 +1395,7 @@ TEST(parser, combined_seq_and_or)
 
         {
             std::string str = "abc";
-            boost::optional<std::string> const chars = parse(str, parser);
+            std::optional<std::string> const chars = parse(str, parser);
             EXPECT_TRUE(chars);
             EXPECT_EQ(*chars, "abc");
         }