diff --git a/mapbox/recursive_wrapper.hpp b/mapbox/recursive_wrapper.hpp
index af569ef..c90a88c 100644
--- a/mapbox/recursive_wrapper.hpp
+++ b/mapbox/recursive_wrapper.hpp
@@ -20,7 +20,8 @@
 namespace util
 {
 
-template <typename T> class recursive_wrapper
+template <typename T>
+class recursive_wrapper
 {
 
     T* p_;
diff --git a/mapbox/variant.hpp b/mapbox/variant.hpp
index 2019fc5..14fe75c 100644
--- a/mapbox/variant.hpp
+++ b/mapbox/variant.hpp
@@ -78,7 +78,8 @@
 
 }; // class bad_variant_access
 
-template <typename R = void> struct MAPBOX_VARIANT_DEPRECATED static_visitor
+template <typename R = void>
+struct MAPBOX_VARIANT_DEPRECATED static_visitor
 {
     using result_type = R;
 
@@ -96,7 +97,8 @@
 
 static constexpr std::size_t invalid_value = std::size_t(-1);
 
-template <typename T, typename... Types> struct direct_type;
+template <typename T, typename... Types>
+struct direct_type;
 
 template <typename T, typename First, typename... Types>
 struct direct_type<T, First, Types...>
@@ -106,7 +108,8 @@
                                              : direct_type<T, Types...>::index;
 };
 
-template <typename T> struct direct_type<T>
+template <typename T>
+struct direct_type<T>
 {
     static constexpr std::size_t index = invalid_value;
 };
@@ -117,11 +120,13 @@
 
 #else
 
-template <typename...> struct disjunction : std::false_type
+template <typename...>
+struct disjunction : std::false_type
 {
 };
 
-template <typename B1> struct disjunction<B1> : B1
+template <typename B1>
+struct disjunction<B1> : B1
 {
 };
 
@@ -138,7 +143,8 @@
 
 #endif
 
-template <typename T, typename... Types> struct convertible_type;
+template <typename T, typename... Types>
+struct convertible_type;
 
 template <typename T, typename First, typename... Types>
 struct convertible_type<T, First, Types...>
@@ -151,12 +157,14 @@
             : convertible_type<T, Types...>::index;
 };
 
-template <typename T> struct convertible_type<T>
+template <typename T>
+struct convertible_type<T>
 {
     static constexpr std::size_t index = invalid_value;
 };
 
-template <typename T, typename... Types> struct value_traits
+template <typename T, typename... Types>
+struct value_traits
 {
     using value_type = typename std::remove_const<
         typename std::remove_reference<T>::type>::type;
@@ -173,7 +181,8 @@
         typename std::tuple_element<tindex, std::tuple<void, Types...>>::type;
 };
 
-template <typename T, typename R = void> struct enable_if_type
+template <typename T, typename R = void>
+struct enable_if_type
 {
     using type = R;
 };
@@ -204,9 +213,11 @@
     using type = typename F::result_type;
 };
 
-template <std::size_t arg1, std::size_t... others> struct static_max;
+template <std::size_t arg1, std::size_t... others>
+struct static_max;
 
-template <std::size_t arg> struct static_max<arg>
+template <std::size_t arg>
+struct static_max<arg>
 {
     static const std::size_t value = arg;
 };
@@ -219,9 +230,11 @@
                                          : static_max<arg2, others...>::value;
 };
 
-template <typename... Types> struct variant_helper;
+template <typename... Types>
+struct variant_helper;
 
-template <typename T, typename... Types> struct variant_helper<T, Types...>
+template <typename T, typename... Types>
+struct variant_helper<T, Types...>
 {
     VARIANT_INLINE static void destroy(const std::size_t type_index, void* data)
     {
@@ -264,7 +277,8 @@
     }
 };
 
-template <> struct variant_helper<>
+template <>
+struct variant_helper<>
 {
     VARIANT_INLINE static void destroy(const std::size_t, void*)
     {
@@ -277,7 +291,8 @@
     }
 };
 
-template <typename T> struct unwrapper
+template <typename T>
+struct unwrapper
 {
     static T const& apply_const(T const& obj)
     {
@@ -289,7 +304,8 @@
     }
 };
 
-template <typename T> struct unwrapper<recursive_wrapper<T>>
+template <typename T>
+struct unwrapper<recursive_wrapper<T>>
 {
     static auto apply_const(recursive_wrapper<T> const& obj) ->
         typename recursive_wrapper<T>::type const&
@@ -303,7 +319,8 @@
     }
 };
 
-template <typename T> struct unwrapper<std::reference_wrapper<T>>
+template <typename T>
+struct unwrapper<std::reference_wrapper<T>>
 {
     static auto apply_const(std::reference_wrapper<T> const& obj) ->
         typename std::reference_wrapper<T>::type const&
@@ -549,7 +566,8 @@
 // comparator functors
 struct equal_comp
 {
-    template <typename T> bool operator()(T const& lhs, T const& rhs) const
+    template <typename T>
+    bool operator()(T const& lhs, T const& rhs) const
     {
         return lhs == rhs;
     }
@@ -557,13 +575,15 @@
 
 struct less_comp
 {
-    template <typename T> bool operator()(T const& lhs, T const& rhs) const
+    template <typename T>
+    bool operator()(T const& lhs, T const& rhs) const
     {
         return lhs < rhs;
     }
 };
 
-template <typename Variant, typename Comp> class comparer
+template <typename Variant, typename Comp>
+class comparer
 {
   public:
     explicit comparer(Variant const& lhs) noexcept : lhs_(lhs)
@@ -571,7 +591,8 @@
     }
     comparer& operator=(comparer const&) = delete;
     // visitor
-    template <typename T> bool operator()(T const& rhs_content) const
+    template <typename T>
+    bool operator()(T const& rhs_content) const
     {
         T const& lhs_content = lhs_.template get_unchecked<T>();
         return Comp()(lhs_content, rhs_content);
@@ -587,7 +608,8 @@
 {
 };
 
-template <typename... Types> class variant
+template <typename... Types>
+class variant
 {
     static_assert(sizeof...(Types) > 0,
                   "Template parameter type list of variant can not be empty");
@@ -1067,7 +1089,8 @@
 }
 #endif
 
-template <typename ResultType, typename T> ResultType& get_unchecked(T& var)
+template <typename ResultType, typename T>
+ResultType& get_unchecked(T& var)
 {
     return var.template get_unchecked<ResultType>();
 }