diff --git a/include/stdplus/raw.hpp b/include/stdplus/raw.hpp
index c572744..a5206c0 100644
--- a/include/stdplus/raw.hpp
+++ b/include/stdplus/raw.hpp
@@ -54,7 +54,7 @@
  *  @return True if they are the same, false otherwise
  */
 template <typename A, typename B>
-inline constexpr bool equal(const A& a, const B& b) noexcept
+constexpr bool equal(const A& a, const B& b) noexcept
 {
     static_assert(std::is_trivially_copyable_v<A>);
     static_assert(std::is_trivially_copyable_v<B>);
@@ -71,7 +71,7 @@
  */
 #define STDPLUS_COPY_FROM(func, comp)                                          \
     template <typename T, typename Container>                                  \
-    inline constexpr T func(const Container& c)                                \
+    constexpr T func(const Container& c)                                       \
     {                                                                          \
         static_assert(std::is_trivially_copyable_v<T>);                        \
         static_assert(detail::trivialContainer<Container>);                    \
@@ -109,7 +109,7 @@
     template <typename T, typename A = stdplus::raw::UnAligned,                \
               typename Container,                                              \
               typename Tp = detail::copyConst<T, detail::dataType<Container>>> \
-    inline constexpr Tp& func(Container&& c)                                   \
+    constexpr Tp& func(Container&& c)                                          \
     {                                                                          \
         static_assert(std::is_trivially_copyable_v<Tp>);                       \
         static_assert(detail::trivialContainer<Container>);                    \
@@ -134,7 +134,7 @@
  *  @return The copyable type with data populated
  */
 template <typename T, typename CharT>
-inline constexpr T extract(std::basic_string_view<CharT>& data)
+constexpr T extract(std::basic_string_view<CharT>& data)
 {
     T ret = copyFrom<T>(data);
     static_assert(sizeof(T) % sizeof(CharT) == 0);
@@ -143,7 +143,7 @@
 }
 template <typename T, typename IntT,
           typename = std::enable_if_t<std::is_trivially_copyable_v<IntT>>>
-inline constexpr T extract(std::span<IntT>& data)
+constexpr T extract(std::span<IntT>& data)
 {
     T ret = copyFrom<T>(data);
     static_assert(sizeof(T) % sizeof(IntT) == 0);
@@ -158,7 +158,7 @@
  *  @return A reference to the data
  */
 template <typename T, typename A = stdplus::raw::UnAligned, typename CharT>
-inline constexpr const T& extractRef(std::basic_string_view<CharT>& data)
+constexpr const T& extractRef(std::basic_string_view<CharT>& data)
 {
     const T& ret = refFrom<T, A>(data);
     static_assert(sizeof(T) % sizeof(CharT) == 0);
@@ -168,7 +168,7 @@
 template <typename T, typename A = stdplus::raw::UnAligned, typename IntT,
           typename = std::enable_if_t<std::is_trivially_copyable_v<IntT>>,
           typename Tp = detail::copyConst<T, IntT>>
-inline constexpr Tp& extractRef(std::span<IntT>& data)
+constexpr Tp& extractRef(std::span<IntT>& data)
 {
     Tp& ret = refFrom<Tp, A>(data);
     static_assert(sizeof(Tp) % sizeof(IntT) == 0);
@@ -183,8 +183,7 @@
  *  @return A view over the input with the given output integral type
  */
 template <typename CharT, typename T>
-inline constexpr std::enable_if_t<!detail::hasData<T>,
-                                  std::basic_string_view<CharT>>
+constexpr std::enable_if_t<!detail::hasData<T>, std::basic_string_view<CharT>>
     asView(const T& t) noexcept
 {
     static_assert(std::is_trivially_copyable_v<T>);
@@ -193,8 +192,8 @@
 }
 
 template <typename CharT, typename Container>
-inline constexpr std::enable_if_t<detail::hasData<Container>,
-                                  std::basic_string_view<CharT>>
+constexpr std::enable_if_t<detail::hasData<Container>,
+                           std::basic_string_view<CharT>>
     asView(const Container& c) noexcept
 {
     static_assert(detail::trivialContainer<Container>);
@@ -207,7 +206,7 @@
           typename = std::enable_if_t<std::is_trivially_copyable_v<IntT>>,
           typename = std::enable_if_t<!detail::hasData<T>>,
           typename IntTp = detail::copyConst<IntT, T>>
-inline constexpr std::span<IntTp> asSpan(T& t) noexcept
+constexpr std::span<IntTp> asSpan(T& t) noexcept
 {
     static_assert(std::is_trivially_copyable_v<T>);
     static_assert(sizeof(T) % sizeof(IntTp) == 0);
@@ -217,7 +216,7 @@
           typename = std::enable_if_t<std::is_trivially_copyable_v<IntT>>,
           typename = std::enable_if_t<detail::hasData<Container>>,
           typename IntTp = detail::copyConst<IntT, detail::dataType<Container>>>
-inline constexpr std::span<IntTp> asSpan(Container&& c) noexcept
+constexpr std::span<IntTp> asSpan(Container&& c) noexcept
 {
     static_assert(detail::trivialContainer<Container>);
     static_assert(sizeof(*std::data(c)) % sizeof(IntTp) == 0);
diff --git a/include/stdplus/zstring.hpp b/include/stdplus/zstring.hpp
index 2612b09..694eeaf 100644
--- a/include/stdplus/zstring.hpp
+++ b/include/stdplus/zstring.hpp
@@ -84,7 +84,7 @@
     using size_type = std::size_t;
 
     template <typename T, size_type N>
-    inline constexpr basic_zstring(T (&str)[N])
+    constexpr basic_zstring(T (&str)[N])
 #ifdef NDEBUG
         noexcept
 #endif
@@ -96,14 +96,14 @@
 #endif
     }
     template <typename T, std::enable_if_t<std::is_pointer_v<T>, bool> = true>
-    inline constexpr basic_zstring(T str) noexcept : data_(str)
+    constexpr basic_zstring(T str) noexcept : data_(str)
     {
     }
     template <typename T,
               std::enable_if_t<detail::same_string<std::remove_cvref_t<T>,
                                                    decay_t, Traits>::value,
                                bool> = true>
-    inline constexpr basic_zstring(T&& str)
+    constexpr basic_zstring(T&& str)
 #ifdef NDEBUG
         noexcept
 #endif
@@ -115,25 +115,24 @@
 #endif
     }
 
-    inline constexpr
-        operator basic_zstring<const CharT, Traits>() const noexcept
+    constexpr operator basic_zstring<const CharT, Traits>() const noexcept
     {
         return basic_zstring<const CharT, Traits>(data_);
     }
 
-    inline constexpr reference operator[](size_type pos) const noexcept
+    constexpr reference operator[](size_type pos) const noexcept
     {
         return data_[pos];
     }
-    inline constexpr reference front() const noexcept
+    constexpr reference front() const noexcept
     {
         return data_[0];
     }
-    inline constexpr pointer data() const noexcept
+    constexpr pointer data() const noexcept
     {
         return data_;
     }
-    inline constexpr const_pointer c_str() const noexcept
+    constexpr const_pointer c_str() const noexcept
     {
         return data_;
     }
@@ -142,11 +141,11 @@
         return data_ == nullptr || data_[0] == '\0';
     }
 
-    inline constexpr basic_zstring suffix(size_type size) const noexcept
+    constexpr basic_zstring suffix(size_type size) const noexcept
     {
         return data_ + size;
     }
-    inline constexpr basic_zstring<const CharT, Traits>
+    constexpr basic_zstring<const CharT, Traits>
         csuffix(size_type size) const noexcept
     {
         return data_ + size;
@@ -199,30 +198,29 @@
     }
 
     template <typename CharT1>
-    inline constexpr Traits::comparison_category
+    constexpr Traits::comparison_category
         operator<=>(basic_zstring<CharT1, Traits> rhs) const noexcept
     {
         return compare(rhs.data()) <=> 0;
     }
     template <typename T, std::enable_if_t<std::is_pointer_v<T>, bool> = true>
-    inline constexpr Traits::comparison_category
-        operator<=>(T rhs) const noexcept
+    constexpr Traits::comparison_category operator<=>(T rhs) const noexcept
     {
         return compare(rhs) <=> 0;
     }
     template <typename Allocator>
-    inline constexpr Traits::comparison_category operator<=>(
+    constexpr Traits::comparison_category operator<=>(
         const std::basic_string<decay_t, Traits, Allocator>& rhs) const noexcept
     {
         return compare(rhs.data(), rhs.size()) <=> 0;
     }
-    inline constexpr Traits::comparison_category
+    constexpr Traits::comparison_category
         operator<=>(std::basic_string_view<decay_t, Traits> rhs) const noexcept
     {
         return compare(rhs.data(), rhs.size()) <=> 0;
     }
 
-    inline constexpr bool operator==(const auto& rhs) const noexcept
+    constexpr bool operator==(const auto& rhs) const noexcept
     {
         return (*this <=> rhs) == 0;
     }
diff --git a/include/stdplus/zstring_view.hpp b/include/stdplus/zstring_view.hpp
index 2a8de3c..3ae13b3 100644
--- a/include/stdplus/zstring_view.hpp
+++ b/include/stdplus/zstring_view.hpp
@@ -21,7 +21,7 @@
 {
 
 template <typename CharT, typename Traits>
-inline constexpr auto
+constexpr auto
     unsafe_zstring_view(std::basic_string_view<CharT, Traits> sv) noexcept
 {
     using SV = basic_zstring_view<CharT, Traits>;
@@ -75,7 +75,7 @@
     static constexpr size_type npos = string_view_base::npos;
 
     template <typename T, size_type N>
-    inline constexpr basic_zstring_view(T (&str)[N])
+    constexpr basic_zstring_view(T (&str)[N])
 #ifdef NDEBUG
         noexcept :
         sv(str)
@@ -86,13 +86,13 @@
     {
     }
     template <typename T, std::enable_if_t<std::is_pointer_v<T>, bool> = true>
-    inline constexpr basic_zstring_view(T str) noexcept : sv(str)
+    constexpr basic_zstring_view(T str) noexcept : sv(str)
     {
     }
     template <typename T,
               std::enable_if_t<detail::same_string<T, CharT, Traits>::value,
                                bool> = true>
-    inline constexpr basic_zstring_view(const T& str)
+    constexpr basic_zstring_view(const T& str)
 #ifdef NDEBUG
         noexcept :
         sv(str)
@@ -107,132 +107,131 @@
         typename T,
         std::enable_if_t<std::is_same_v<value_type, std::remove_const_t<T>>,
                          bool> = true>
-    inline constexpr basic_zstring_view(basic_zstring<T, Traits> str) noexcept :
+    constexpr basic_zstring_view(basic_zstring<T, Traits> str) noexcept :
         sv(str.data())
     {
     }
 
-    inline constexpr operator string_view_base() const noexcept
+    constexpr operator string_view_base() const noexcept
     {
         return sv;
     }
 
-    inline constexpr operator zstring_base() const noexcept
+    constexpr operator zstring_base() const noexcept
     {
         return zstring_base(data());
     }
 
-    inline constexpr const_iterator begin() const noexcept
+    constexpr const_iterator begin() const noexcept
     {
         return sv.begin();
     }
-    inline constexpr const_iterator end() const noexcept
+    constexpr const_iterator end() const noexcept
     {
         return sv.end();
     }
-    inline constexpr const_reverse_iterator rbegin() const noexcept
+    constexpr const_reverse_iterator rbegin() const noexcept
     {
         return sv.rbegin();
     }
-    inline constexpr const_reverse_iterator rend() const noexcept
+    constexpr const_reverse_iterator rend() const noexcept
     {
         return sv.rend();
     }
 
-    inline constexpr const_reference operator[](size_type pos) const noexcept
+    constexpr const_reference operator[](size_type pos) const noexcept
     {
         return sv[pos];
     }
-    inline constexpr const_reference at(size_type pos) const
+    constexpr const_reference at(size_type pos) const
     {
         return sv.at(pos);
     }
-    inline constexpr const_reference front() const noexcept
+    constexpr const_reference front() const noexcept
     {
         return sv.front();
     }
-    inline constexpr const_reference back() const noexcept
+    constexpr const_reference back() const noexcept
     {
         return sv.back();
     }
-    inline constexpr const_pointer data() const noexcept
+    constexpr const_pointer data() const noexcept
     {
         return sv.data();
     }
 
-    inline constexpr size_type size() const noexcept
+    constexpr size_type size() const noexcept
     {
         return sv.size();
     }
-    inline constexpr size_type length() const noexcept
+    constexpr size_type length() const noexcept
     {
         return sv.length();
     }
-    inline constexpr size_type max_size() noexcept
+    constexpr size_type max_size() noexcept
     {
         return sv.max_size();
     }
-    [[nodiscard]] inline constexpr bool empty() const noexcept
+    [[nodiscard]] constexpr bool empty() const noexcept
     {
         return sv.empty();
     }
 
-    inline constexpr void swap(basic_zstring_view& v) noexcept
+    constexpr void swap(basic_zstring_view& v) noexcept
     {
         sv.swap(v.sv);
     }
 
-    inline constexpr size_type copy(pointer dest, size_type count,
-                                    size_type pos = 0) const
+    constexpr size_type copy(pointer dest, size_type count,
+                             size_type pos = 0) const
     {
         return sv.copy(dest, count, pos);
     }
-    inline constexpr string_view_base substr(size_type pos = 0,
-                                             size_type count = npos) const
+    constexpr string_view_base substr(size_type pos = 0,
+                                      size_type count = npos) const
     {
         return sv.substr(pos, count);
     }
 
-    inline constexpr int compare(string_view_base v) const noexcept
+    constexpr int compare(string_view_base v) const noexcept
     {
         return sv.compare(v);
     }
-    inline constexpr int compare(size_type pos1, size_type count1,
-                                 string_view_base v) const
+    constexpr int compare(size_type pos1, size_type count1,
+                          string_view_base v) const
     {
         return sv.compare(pos1, count1, v);
     }
-    inline constexpr int compare(size_type pos1, size_type count1,
-                                 string_view_base v, size_type pos2,
-                                 size_type count2) const
+    constexpr int compare(size_type pos1, size_type count1, string_view_base v,
+                          size_type pos2, size_type count2) const
     {
         return sv.compare(pos1, count1, v, pos2, count2);
     }
-    inline constexpr int compare(const_pointer s) const
+    constexpr int compare(const_pointer s) const
     {
         return sv.compare(s);
     }
-    inline constexpr int compare(size_type pos1, size_type count1,
-                                 const_pointer s) const
+    constexpr int compare(size_type pos1, size_type count1,
+                          const_pointer s) const
     {
         return sv.compare(pos1, count1, s);
     }
-    inline constexpr int compare(size_type pos1, size_type count1,
-                                 const_pointer s, size_type count2) const
+    constexpr int compare(size_type pos1, size_type count1, const_pointer s,
+                          size_type count2) const
     {
         return sv.compare(pos1, count1, s, count2);
     }
 
 #define zstring_view_has(func)                                                 \
-    inline constexpr bool func(string_view_base sv) const noexcept             \
+    constexpr bool func(string_view_base sv) const noexcept                    \
     {                                                                          \
         return sv.func(sv);                                                    \
     }                                                                          \
-    inline constexpr bool func(value_type c) const noexcept                    \
+    constexpr bool func(value_type c) const noexcept                           \
     {                                                                          \
         return sv.func(c);                                                     \
     }                                                                          \
-    inline constexpr bool func(const_pointer s) const                          \
+    constexpr bool func(const_pointer s) const                                 \
     {                                                                          \
         return sv.func(s);                                                     \
     }
@@ -241,23 +240,22 @@
 #undef zstring_view_has
 
 #define zstring_view_find(func, def)                                           \
-    inline constexpr size_type func(string_view_base v, size_type pos = def)   \
+    constexpr size_type func(string_view_base v, size_type pos = def)          \
         const noexcept                                                         \
     {                                                                          \
         return sv.func(v, pos);                                                \
     }                                                                          \
-    inline constexpr size_type func(value_type ch, size_type pos = def)        \
+    constexpr size_type func(value_type ch, size_type pos = def)               \
         const noexcept                                                         \
     {                                                                          \
         return sv.func(ch, pos);                                               \
     }                                                                          \
-    inline constexpr size_type func(const_pointer s, size_type pos,            \
-                                    size_type count) const                     \
+    constexpr size_type func(const_pointer s, size_type pos, size_type count)  \
+        const                                                                  \
     {                                                                          \
         return sv.func(s, pos, count);                                         \
     }                                                                          \
-    inline constexpr size_type func(const_pointer s, size_type pos = def)      \
-        const                                                                  \
+    constexpr size_type func(const_pointer s, size_type pos = def) const       \
     {                                                                          \
         return sv.func(s, pos);                                                \
     }
@@ -269,7 +267,7 @@
     zstring_view_find(find_last_not_of, npos);
 #undef zstring_view_find
 
-    inline constexpr const_pointer c_str() const noexcept
+    constexpr const_pointer c_str() const noexcept
     {
         return sv.data();
     }
@@ -299,8 +297,7 @@
     struct unsafe
     {
     };
-    inline constexpr basic_zstring_view(unsafe, string_view_base sv) noexcept :
-        sv(sv)
+    constexpr basic_zstring_view(unsafe, string_view_base sv) noexcept : sv(sv)
     {
     }
     friend auto detail::unsafe_zstring_view<CharT, Traits>(string_view_base sv);
@@ -317,7 +314,7 @@
 namespace zstring_view_literals
 {
 template <detail::compile_zstring_view Str>
-inline constexpr auto operator"" _zsv() noexcept
+constexpr auto operator"" _zsv() noexcept
 {
     static_assert(Str.valid, "stdplus::zstring_view");
     return Str.getzsv();