diff --git a/include/msgpack/v1/adaptor/cpp17/variant.hpp b/include/msgpack/v1/adaptor/cpp17/variant.hpp
index 6614fc1b..2ddb6b6e 100644
--- a/include/msgpack/v1/adaptor/cpp17/variant.hpp
+++ b/include/msgpack/v1/adaptor/cpp17/variant.hpp
@@ -32,11 +32,13 @@ template <
     typename T,
     typename... Ts,
     std::size_t current_index,
-    std::size_t... indices>
+    std::size_t... indices
+>
 Variant construct_variant(
     std::size_t index,
     msgpack::object& object,
-    std::index_sequence<current_index, indices...>) {
+    std::index_sequence<current_index, indices...>
+) {
     if constexpr(sizeof...(Ts) == 0) {
         return object.as<T>();
     }
@@ -45,9 +47,10 @@ Variant construct_variant(
             return object.as<T>();
         }
         return construct_variant<Variant, Ts...>(
-                   index,
-                   object,
-                   std::index_sequence<indices...>());
+            index,
+            object,
+            std::index_sequence<indices...>()
+        );
     }
 }
 
@@ -70,16 +73,16 @@ template <typename... Ts>
 struct as<std::variant<Ts...>, typename std::enable_if<(msgpack::has_as<Ts>::value && ...)>::type> {
     std::variant<Ts...> operator()(msgpack::object const& o) const {
         if (  o.type != msgpack::type::ARRAY
-            || o.via.array.size != 2
-            || o.via.array.ptr[0].type != msgpack::type::POSITIVE_INTEGER
-            || o.via.array.ptr[0].via.u64 >= sizeof...(Ts)) {
+           || o.via.array.size != 2
+           || o.via.array.ptr[0].type != msgpack::type::POSITIVE_INTEGER
+           || o.via.array.ptr[0].via.u64 >= sizeof...(Ts)) {
             throw msgpack::type_error{};
         }
 
         return detail::construct_variant<std::variant<Ts...>, Ts...>(
-          o.via.array.ptr[0].as<std::size_t>(),
-          o.via.array.ptr[1],
-          std::make_index_sequence<sizeof...(Ts)>()
+            o.via.array.ptr[0].as<std::size_t>(),
+            o.via.array.ptr[1],
+            std::make_index_sequence<sizeof...(Ts)>()
         );
     }
 };
@@ -88,16 +91,16 @@ template<typename... Ts>
 struct convert<std::variant<Ts...>> {
     msgpack::object const& operator()(msgpack::object const& o, std::variant<Ts...>& v) const {
         if (  o.type != msgpack::type::ARRAY
-            || o.via.array.size != 2
-            || o.via.array.ptr[0].type != msgpack::type::POSITIVE_INTEGER
-            || o.via.array.ptr[0].via.u64 >= sizeof...(Ts)) {
+           || o.via.array.size != 2
+           || o.via.array.ptr[0].type != msgpack::type::POSITIVE_INTEGER
+           || o.via.array.ptr[0].via.u64 >= sizeof...(Ts)) {
             throw msgpack::type_error{};
         }
 
         v =  detail::construct_variant<std::variant<Ts...>, Ts...>(
-          o.via.array.ptr[0].as<std::size_t>(),
-          o.via.array.ptr[1],
-          std::make_index_sequence<sizeof...(Ts)>()
+            o.via.array.ptr[0].as<std::size_t>(),
+            o.via.array.ptr[1],
+            std::make_index_sequence<sizeof...(Ts)>()
         );
         return o;
     }
@@ -106,7 +109,10 @@ struct convert<std::variant<Ts...>> {
 template <typename... Ts>
 struct pack<std::variant<Ts...>>{
     template<typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, std::variant<Ts...> const& v) const {
+    msgpack::packer<Stream>& operator()(
+        msgpack::packer<Stream>& o,
+        std::variant<Ts...> const& v
+    ) const {
         o.pack_array(2);
         o.pack_uint64(v.index());
         std::visit([&o](auto const& value){o.pack(value);}, v);
@@ -117,10 +123,17 @@ struct pack<std::variant<Ts...>>{
 
 template<typename... Ts>
 struct object_with_zone<std::variant<Ts...>> {
-    void operator()(msgpack::object::with_zone& o, std::variant<Ts...> const& v) const {
-        msgpack::object *p = static_cast<msgpack::object *>(
-                                 o.zone.allocate_align(sizeof(msgpack::object) * 2,
-                                 MSGPACK_ZONE_ALIGNOF(msgpack::object)));
+    void operator()(
+        msgpack::object::with_zone& o,
+        std::variant<Ts...> const& v
+    ) const {
+        msgpack::object *p =
+            static_cast<msgpack::object *>(
+                o.zone.allocate_align(
+                    sizeof(msgpack::object) * 2,
+                    MSGPACK_ZONE_ALIGNOF(msgpack::object)
+                )
+            );
 
         o.type = msgpack::type::ARRAY;
         o.via.array.size = 2;
diff --git a/test/msgpack_cpp17.cpp b/test/msgpack_cpp17.cpp
index 30a76770..b20c04cc 100644
--- a/test/msgpack_cpp17.cpp
+++ b/test/msgpack_cpp17.cpp
@@ -464,24 +464,25 @@ BOOST_AUTO_TEST_CASE(carray_byte_object_with_zone)
 #if defined(MSGPACK_USE_STD_VARIANT_ADAPTOR)
 
 BOOST_AUTO_TEST_CASE(variant_pack_unpack_as) {
-  std::stringstream ss;
-  std::variant<bool, int, float, double> val1{1.0};
-  msgpack::pack(ss, val1);
-  std::string const& str = ss.str();
-  msgpack::object_handle oh =
-      msgpack::unpack(str.data(), str.size());
-  std::variant<bool, int, float, double> val2 = oh.get().as<std::variant<bool, int, float, double> >();
-  BOOST_CHECK(val1 == val2);
-  BOOST_CHECK_THROW((oh.get().as<std::variant<bool>>()), msgpack::type_error);
+    std::stringstream ss;
+    std::variant<bool, int, float, double> val1{1.0};
+    msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
+    msgpack::object_handle oh =
+        msgpack::unpack(str.data(), str.size());
+    std::variant<bool, int, float, double> val2 =
+        oh.get().as<std::variant<bool, int, float, double> >();
+    BOOST_CHECK(val1 == val2);
+    BOOST_CHECK_THROW((oh.get().as<std::variant<bool>>()), msgpack::type_error);
 }
 
 BOOST_AUTO_TEST_CASE(variant_with_zone) {
-  msgpack::zone z;
-  std::variant<bool, int, float, double> val1{1.0};
-  msgpack::object obj(val1, z);
-  std::variant<bool, int, float, double> val2 = obj.as<std::variant<bool, int, float, double>>();
-  BOOST_CHECK(val1 == val2);
-  BOOST_CHECK_THROW((obj.as<std::variant<bool>>()), msgpack::type_error);
+    msgpack::zone z;
+    std::variant<bool, int, float, double> val1{1.0};
+    msgpack::object obj(val1, z);
+    std::variant<bool, int, float, double> val2 = obj.as<std::variant<bool, int, float, double>>();
+    BOOST_CHECK(val1 == val2);
+    BOOST_CHECK_THROW((obj.as<std::variant<bool>>()), msgpack::type_error);
 }
 
 #endif // defined(MSGPACK_USE_STD_VARIANT_ADAPTOR)