diff --git a/CMakeLists.txt b/CMakeLists.txt
index cb17761..02a07f6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -191,6 +191,8 @@ if(SLED_BUILD_TESTS)
                 src/sled/debugging/symbolize_test.cc NO_MAIN)
   sled_add_test(NAME sled_sigslot_test SRCS src/sled/sigslot_test.cc)
   sled_add_test(NAME sled_rpc_test SRCS src/sled/network/rpc_test.cc)
+  sled_add_test(NAME sled_string_view_test SRCS
+                src/sled/nonstd/string_view_test.cc)
 endif(SLED_BUILD_TESTS)
 
 if(SLED_BUILD_FUZZ)
diff --git a/src/sled/nonstd/string_view.h b/src/sled/nonstd/string_view.h
new file mode 100644
index 0000000..f7c3df6
--- /dev/null
+++ b/src/sled/nonstd/string_view.h
@@ -0,0 +1,1713 @@
+// Copyright 2017-2020 by Martin Moene
+//
+// string-view lite, a C++17-like string_view for C++98 and later.
+// For more information see https://github.com/martinmoene/string-view-lite
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef NONSTD_SV_LITE_H_INCLUDED
+#define NONSTD_SV_LITE_H_INCLUDED
+#pragma once
+
+#define string_view_lite_MAJOR 1
+#define string_view_lite_MINOR 7
+#define string_view_lite_PATCH 0
+
+#define string_view_lite_VERSION                                                                                       \
+    nssv_STRINGIFY(string_view_lite_MAJOR) "." nssv_STRINGIFY(string_view_lite_MINOR) "." nssv_STRINGIFY(              \
+        string_view_lite_PATCH)
+
+#define nssv_STRINGIFY(x) nssv_STRINGIFY_(x)
+#define nssv_STRINGIFY_(x) #x
+
+// string-view lite configuration:
+
+#define nssv_STRING_VIEW_DEFAULT 0
+#define nssv_STRING_VIEW_NONSTD 1
+#define nssv_STRING_VIEW_STD 2
+
+// tweak header support:
+
+#ifdef __has_include
+#if __has_include(<nonstd/string_view.tweak.hpp>)
+#include <nonstd/string_view.tweak.hpp>
+#endif
+#define nssv_HAVE_TWEAK_HEADER 1
+#else
+#define nssv_HAVE_TWEAK_HEADER 0
+//# pragma message("string_view.hpp: Note: Tweak header not supported.")
+#endif
+
+// string_view selection and configuration:
+
+#if !defined(nssv_CONFIG_SELECT_STRING_VIEW)
+#define nssv_CONFIG_SELECT_STRING_VIEW (nssv_HAVE_STD_STRING_VIEW ? nssv_STRING_VIEW_STD : nssv_STRING_VIEW_NONSTD)
+#endif
+
+#ifndef nssv_CONFIG_STD_SV_OPERATOR
+#define nssv_CONFIG_STD_SV_OPERATOR 0
+#endif
+
+#ifndef nssv_CONFIG_USR_SV_OPERATOR
+#define nssv_CONFIG_USR_SV_OPERATOR 1
+#endif
+
+#ifdef nssv_CONFIG_CONVERSION_STD_STRING
+#define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS nssv_CONFIG_CONVERSION_STD_STRING
+#define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS nssv_CONFIG_CONVERSION_STD_STRING
+#endif
+
+#ifndef nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS
+#define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS 1
+#endif
+
+#ifndef nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS
+#define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS 1
+#endif
+
+#ifndef nssv_CONFIG_NO_STREAM_INSERTION
+#define nssv_CONFIG_NO_STREAM_INSERTION 0
+#endif
+
+#ifndef nssv_CONFIG_CONSTEXPR11_STD_SEARCH
+#define nssv_CONFIG_CONSTEXPR11_STD_SEARCH 1
+#endif
+
+// Control presence of exception handling (try and auto discover):
+
+#ifndef nssv_CONFIG_NO_EXCEPTIONS
+#if defined(_MSC_VER)
+#include <cstddef>// for _HAS_EXCEPTIONS
+#endif
+#if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS)
+#define nssv_CONFIG_NO_EXCEPTIONS 0
+#else
+#define nssv_CONFIG_NO_EXCEPTIONS 1
+#endif
+#endif
+
+// C++ language version detection (C++23 is speculative):
+// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
+
+#ifndef nssv_CPLUSPLUS
+#if defined(_MSVC_LANG) && !defined(__clang__)
+#define nssv_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG)
+#else
+#define nssv_CPLUSPLUS __cplusplus
+#endif
+#endif
+
+#define nssv_CPP98_OR_GREATER (nssv_CPLUSPLUS >= 199711L)
+#define nssv_CPP11_OR_GREATER (nssv_CPLUSPLUS >= 201103L)
+#define nssv_CPP11_OR_GREATER_ (nssv_CPLUSPLUS >= 201103L)
+#define nssv_CPP14_OR_GREATER (nssv_CPLUSPLUS >= 201402L)
+#define nssv_CPP17_OR_GREATER (nssv_CPLUSPLUS >= 201703L)
+#define nssv_CPP20_OR_GREATER (nssv_CPLUSPLUS >= 202002L)
+#define nssv_CPP23_OR_GREATER (nssv_CPLUSPLUS >= 202300L)
+
+// use C++17 std::string_view if available and requested:
+
+#if nssv_CPP17_OR_GREATER && defined(__has_include)
+#if __has_include(<string_view> )
+#define nssv_HAVE_STD_STRING_VIEW 1
+#else
+#define nssv_HAVE_STD_STRING_VIEW 0
+#endif
+#else
+#define nssv_HAVE_STD_STRING_VIEW 0
+#endif
+
+#define nssv_USES_STD_STRING_VIEW                                                                                      \
+    ((nssv_CONFIG_SELECT_STRING_VIEW == nssv_STRING_VIEW_STD)                                                          \
+     || ((nssv_CONFIG_SELECT_STRING_VIEW == nssv_STRING_VIEW_DEFAULT) && nssv_HAVE_STD_STRING_VIEW))
+
+#define nssv_HAVE_STARTS_WITH (nssv_CPP20_OR_GREATER || !nssv_USES_STD_STRING_VIEW)
+#define nssv_HAVE_ENDS_WITH nssv_HAVE_STARTS_WITH
+
+//
+// Use C++17 std::string_view:
+//
+
+#if nssv_USES_STD_STRING_VIEW
+
+#include <string_view>
+
+// Extensions for std::string:
+
+#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS
+
+namespace nonstd {
+
+template<class CharT, class Traits, class Allocator = std::allocator<CharT>>
+std::basic_string<CharT, Traits, Allocator>
+to_string(std::basic_string_view<CharT, Traits> v, Allocator const &a = Allocator())
+{
+    return std::basic_string<CharT, Traits, Allocator>(v.begin(), v.end(), a);
+}
+
+template<class CharT, class Traits, class Allocator>
+std::basic_string_view<CharT, Traits>
+to_string_view(std::basic_string<CharT, Traits, Allocator> const &s)
+{
+    return std::basic_string_view<CharT, Traits>(s.data(), s.size());
+}
+
+// Literal operators sv and _sv:
+
+#if nssv_CONFIG_STD_SV_OPERATOR
+
+using namespace std::literals::string_view_literals;
+
+#endif
+
+#if nssv_CONFIG_USR_SV_OPERATOR
+
+inline namespace literals {
+inline namespace string_view_literals {
+
+constexpr std::string_view
+operator"" _sv(const char *str, size_t len) noexcept// (1)
+{
+    return std::string_view{str, len};
+}
+
+constexpr std::u16string_view
+operator"" _sv(const char16_t *str, size_t len) noexcept// (2)
+{
+    return std::u16string_view{str, len};
+}
+
+constexpr std::u32string_view
+operator"" _sv(const char32_t *str, size_t len) noexcept// (3)
+{
+    return std::u32string_view{str, len};
+}
+
+constexpr std::wstring_view
+operator"" _sv(const wchar_t *str, size_t len) noexcept// (4)
+{
+    return std::wstring_view{str, len};
+}
+
+}// namespace string_view_literals
+}// namespace literals
+
+#endif// nssv_CONFIG_USR_SV_OPERATOR
+
+}// namespace nonstd
+
+#endif// nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS
+
+namespace nonstd {
+
+using std::basic_string_view;
+using std::string_view;
+using std::u16string_view;
+using std::u32string_view;
+using std::wstring_view;
+
+// literal "sv" and "_sv", see above
+
+using std::operator==;
+using std::operator!=;
+using std::operator<;
+using std::operator<=;
+using std::operator>;
+using std::operator>=;
+
+using std::operator<<;
+
+}// namespace nonstd
+
+#else// nssv_HAVE_STD_STRING_VIEW
+
+//
+// Before C++17: use string_view lite:
+//
+
+// Compiler versions:
+//
+// MSVC++  6.0  _MSC_VER == 1200  nssv_COMPILER_MSVC_VERSION ==  60  (Visual Studio 6.0)
+// MSVC++  7.0  _MSC_VER == 1300  nssv_COMPILER_MSVC_VERSION ==  70  (Visual Studio .NET 2002)
+// MSVC++  7.1  _MSC_VER == 1310  nssv_COMPILER_MSVC_VERSION ==  71  (Visual Studio .NET 2003)
+// MSVC++  8.0  _MSC_VER == 1400  nssv_COMPILER_MSVC_VERSION ==  80  (Visual Studio 2005)
+// MSVC++  9.0  _MSC_VER == 1500  nssv_COMPILER_MSVC_VERSION ==  90  (Visual Studio 2008)
+// MSVC++ 10.0  _MSC_VER == 1600  nssv_COMPILER_MSVC_VERSION == 100  (Visual Studio 2010)
+// MSVC++ 11.0  _MSC_VER == 1700  nssv_COMPILER_MSVC_VERSION == 110  (Visual Studio 2012)
+// MSVC++ 12.0  _MSC_VER == 1800  nssv_COMPILER_MSVC_VERSION == 120  (Visual Studio 2013)
+// MSVC++ 14.0  _MSC_VER == 1900  nssv_COMPILER_MSVC_VERSION == 140  (Visual Studio 2015)
+// MSVC++ 14.1  _MSC_VER >= 1910  nssv_COMPILER_MSVC_VERSION == 141  (Visual Studio 2017)
+// MSVC++ 14.2  _MSC_VER >= 1920  nssv_COMPILER_MSVC_VERSION == 142  (Visual Studio 2019)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define nssv_COMPILER_MSVC_VER (_MSC_VER)
+#define nssv_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * (5 + (_MSC_VER < 1900)))
+#else
+#define nssv_COMPILER_MSVC_VER 0
+#define nssv_COMPILER_MSVC_VERSION 0
+#endif
+
+#define nssv_COMPILER_VERSION(major, minor, patch) (10 * (10 * (major) + (minor)) + (patch))
+
+#if defined(__apple_build_version__)
+#define nssv_COMPILER_APPLECLANG_VERSION nssv_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
+#define nssv_COMPILER_CLANG_VERSION 0
+#elif defined(__clang__)
+#define nssv_COMPILER_APPLECLANG_VERSION 0
+#define nssv_COMPILER_CLANG_VERSION nssv_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
+#else
+#define nssv_COMPILER_APPLECLANG_VERSION 0
+#define nssv_COMPILER_CLANG_VERSION 0
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__)
+#define nssv_COMPILER_GNUC_VERSION nssv_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#else
+#define nssv_COMPILER_GNUC_VERSION 0
+#endif
+
+// half-open range [lo..hi):
+#define nssv_BETWEEN(v, lo, hi) ((lo) <= (v) && (v) < (hi))
+
+// Presence of language and library features:
+
+#ifdef _HAS_CPP0X
+#define nssv_HAS_CPP0X _HAS_CPP0X
+#else
+#define nssv_HAS_CPP0X 0
+#endif
+
+// Unless defined otherwise below, consider VC14 as C++11 for string-view-lite:
+
+#if nssv_COMPILER_MSVC_VER >= 1900
+#undef nssv_CPP11_OR_GREATER
+#define nssv_CPP11_OR_GREATER 1
+#endif
+
+#define nssv_CPP11_90 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1500)
+#define nssv_CPP11_100 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1600)
+#define nssv_CPP11_110 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1700)
+#define nssv_CPP11_120 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1800)
+#define nssv_CPP11_140 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1900)
+#define nssv_CPP11_141 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1910)
+
+#define nssv_CPP14_000 (nssv_CPP14_OR_GREATER)
+#define nssv_CPP17_000 (nssv_CPP17_OR_GREATER)
+
+// Presence of C++11 language features:
+
+#define nssv_HAVE_CONSTEXPR_11 nssv_CPP11_140
+#define nssv_HAVE_EXPLICIT_CONVERSION nssv_CPP11_140
+#define nssv_HAVE_INLINE_NAMESPACE nssv_CPP11_140
+#define nssv_HAVE_IS_DEFAULT nssv_CPP11_140
+#define nssv_HAVE_IS_DELETE nssv_CPP11_140
+#define nssv_HAVE_NOEXCEPT nssv_CPP11_140
+#define nssv_HAVE_NULLPTR nssv_CPP11_100
+#define nssv_HAVE_REF_QUALIFIER nssv_CPP11_140
+#define nssv_HAVE_UNICODE_LITERALS nssv_CPP11_140
+#define nssv_HAVE_USER_DEFINED_LITERALS nssv_CPP11_140
+#define nssv_HAVE_WCHAR16_T nssv_CPP11_100
+#define nssv_HAVE_WCHAR32_T nssv_CPP11_100
+
+#if !((nssv_CPP11_OR_GREATER && nssv_COMPILER_CLANG_VERSION) || nssv_BETWEEN(nssv_COMPILER_CLANG_VERSION, 300, 400))
+#define nssv_HAVE_STD_DEFINED_LITERALS nssv_CPP11_140
+#else
+#define nssv_HAVE_STD_DEFINED_LITERALS 0
+#endif
+
+// Presence of C++14 language features:
+
+#define nssv_HAVE_CONSTEXPR_14 nssv_CPP14_000
+
+// Presence of C++17 language features:
+
+#define nssv_HAVE_NODISCARD nssv_CPP17_000
+
+// Presence of C++ library features:
+
+#define nssv_HAVE_STD_HASH nssv_CPP11_120
+
+// Presence of compiler intrinsics:
+
+// Providing char-type specializations for compare() and length() that
+// use compiler intrinsics can improve compile- and run-time performance.
+//
+// The challenge is in using the right combinations of builtin availability
+// and its constexpr-ness.
+//
+// | compiler | __builtin_memcmp (constexpr) | memcmp  (constexpr) |
+// |----------|------------------------------|---------------------|
+// | clang    | 4.0              (>= 4.0   ) | any     (?        ) |
+// | clang-a  | 9.0              (>= 9.0   ) | any     (?        ) |
+// | gcc      | any              (constexpr) | any     (?        ) |
+// | msvc     | >= 14.2 C++17    (>= 14.2  ) | any     (?        ) |
+
+#define nssv_HAVE_BUILTIN_VER                                                                                          \
+    ((nssv_CPP17_000 && nssv_COMPILER_MSVC_VERSION >= 142) || nssv_COMPILER_GNUC_VERSION > 0                           \
+     || nssv_COMPILER_CLANG_VERSION >= 400 || nssv_COMPILER_APPLECLANG_VERSION >= 900)
+#define nssv_HAVE_BUILTIN_CE (nssv_HAVE_BUILTIN_VER)
+
+#define nssv_HAVE_BUILTIN_MEMCMP ((nssv_HAVE_CONSTEXPR_14 && nssv_HAVE_BUILTIN_CE) || !nssv_HAVE_CONSTEXPR_14)
+#define nssv_HAVE_BUILTIN_STRLEN ((nssv_HAVE_CONSTEXPR_11 && nssv_HAVE_BUILTIN_CE) || !nssv_HAVE_CONSTEXPR_11)
+
+#ifdef __has_builtin
+#define nssv_HAVE_BUILTIN(x) __has_builtin(x)
+#else
+#define nssv_HAVE_BUILTIN(x) 0
+#endif
+
+#if nssv_HAVE_BUILTIN(__builtin_memcmp) || nssv_HAVE_BUILTIN_VER
+#define nssv_BUILTIN_MEMCMP __builtin_memcmp
+#else
+#define nssv_BUILTIN_MEMCMP memcmp
+#endif
+
+#if nssv_HAVE_BUILTIN(__builtin_strlen) || nssv_HAVE_BUILTIN_VER
+#define nssv_BUILTIN_STRLEN __builtin_strlen
+#else
+#define nssv_BUILTIN_STRLEN strlen
+#endif
+
+// C++ feature usage:
+
+#if nssv_HAVE_CONSTEXPR_11
+#define nssv_constexpr constexpr
+#else
+#define nssv_constexpr /*constexpr*/
+#endif
+
+#if nssv_HAVE_CONSTEXPR_14
+#define nssv_constexpr14 constexpr
+#else
+#define nssv_constexpr14 /*constexpr*/
+#endif
+
+#if nssv_HAVE_EXPLICIT_CONVERSION
+#define nssv_explicit explicit
+#else
+#define nssv_explicit /*explicit*/
+#endif
+
+#if nssv_HAVE_INLINE_NAMESPACE
+#define nssv_inline_ns inline
+#else
+#define nssv_inline_ns /*inline*/
+#endif
+
+#if nssv_HAVE_NOEXCEPT
+#define nssv_noexcept noexcept
+#else
+#define nssv_noexcept /*noexcept*/
+#endif
+
+//#if nssv_HAVE_REF_QUALIFIER
+//# define nssv_ref_qual  &
+//# define nssv_refref_qual  &&
+//#else
+//# define nssv_ref_qual  /*&*/
+//# define nssv_refref_qual  /*&&*/
+//#endif
+
+#if nssv_HAVE_NULLPTR
+#define nssv_nullptr nullptr
+#else
+#define nssv_nullptr NULL
+#endif
+
+#if nssv_HAVE_NODISCARD
+#define nssv_nodiscard [[nodiscard]]
+#else
+#define nssv_nodiscard /*[[nodiscard]]*/
+#endif
+
+// Additional includes:
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <limits>
+#include <string>// std::char_traits<>
+
+#if !nssv_CONFIG_NO_STREAM_INSERTION
+#include <ostream>
+#endif
+
+#if !nssv_CONFIG_NO_EXCEPTIONS
+#include <stdexcept>
+#endif
+
+#if nssv_CPP11_OR_GREATER
+#include <type_traits>
+#endif
+
+// Clang, GNUC, MSVC warning suppression macros:
+
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wreserved-user-defined-literal"
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wuser-defined-literals"
+#elif nssv_COMPILER_GNUC_VERSION >= 480
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+#endif// __clang__
+
+#if nssv_COMPILER_MSVC_VERSION >= 140
+#define nssv_SUPPRESS_MSGSL_WARNING(expr) [[gsl::suppress(expr)]]
+#define nssv_SUPPRESS_MSVC_WARNING(code, descr) __pragma(warning(suppress : code))
+#define nssv_DISABLE_MSVC_WARNINGS(codes) __pragma(warning(push)) __pragma(warning(disable : codes))
+#else
+#define nssv_SUPPRESS_MSGSL_WARNING(expr)
+#define nssv_SUPPRESS_MSVC_WARNING(code, descr)
+#define nssv_DISABLE_MSVC_WARNINGS(codes)
+#endif
+
+#if defined(__clang__)
+#define nssv_RESTORE_WARNINGS() _Pragma("clang diagnostic pop")
+#elif nssv_COMPILER_GNUC_VERSION >= 480
+#define nssv_RESTORE_WARNINGS() _Pragma("GCC diagnostic pop")
+#elif nssv_COMPILER_MSVC_VERSION >= 140
+#define nssv_RESTORE_WARNINGS() __pragma(warning(pop))
+#else
+#define nssv_RESTORE_WARNINGS()
+#endif
+
+// Suppress the following MSVC (GSL) warnings:
+// - C4455, non-gsl   : 'operator ""sv': literal suffix identifiers that do not
+//                      start with an underscore are reserved
+// - C26472, gsl::t.1 : don't use a static_cast for arithmetic conversions;
+//                      use brace initialization, gsl::narrow_cast or gsl::narow
+// - C26481: gsl::b.1 : don't use pointer arithmetic. Use span instead
+
+nssv_DISABLE_MSVC_WARNINGS(4455 26481 26472)
+    //nssv_DISABLE_CLANG_WARNINGS( "-Wuser-defined-literals" )
+    //nssv_DISABLE_GNUC_WARNINGS( -Wliteral-suffix )
+
+    namespace nonstd
+{
+    namespace sv_lite {
+
+    //
+    // basic_string_view declaration:
+    //
+
+    template<class CharT, class Traits = std::char_traits<CharT>>
+    class basic_string_view;
+
+    namespace detail {
+
+    // support constexpr comparison in C++14;
+    // for C++17 and later, use provided traits:
+
+    template<typename CharT>
+    inline nssv_constexpr14 int compare(CharT const *s1, CharT const *s2, std::size_t count)
+    {
+        while (count-- != 0) {
+            if (*s1 < *s2) return -1;
+            if (*s1 > *s2) return +1;
+            ++s1;
+            ++s2;
+        }
+        return 0;
+    }
+
+#if nssv_HAVE_BUILTIN_MEMCMP
+
+    // specialization of compare() for char, see also generic compare() above:
+
+    inline nssv_constexpr14 int compare(char const *s1, char const *s2, std::size_t count)
+    {
+        return nssv_BUILTIN_MEMCMP(s1, s2, count);
+    }
+
+#endif
+
+#if nssv_HAVE_BUILTIN_STRLEN
+
+    // specialization of length() for char, see also generic length() further below:
+
+    inline nssv_constexpr std::size_t length(char const *s) { return nssv_BUILTIN_STRLEN(s); }
+
+#endif
+
+#if defined(__OPTIMIZE__)
+
+    // gcc, clang provide __OPTIMIZE__
+    // Expect tail call optimization to make length() non-recursive:
+
+    template<typename CharT>
+    inline nssv_constexpr std::size_t length(CharT *s, std::size_t result = 0)
+    {
+        return *s == '\0' ? result : length(s + 1, result + 1);
+    }
+
+#else// OPTIMIZE
+
+    // non-recursive:
+
+    template<typename CharT>
+    inline nssv_constexpr14 std::size_t length(CharT *s)
+    {
+        std::size_t result = 0;
+        while (*s++ != '\0') { ++result; }
+        return result;
+    }
+
+#endif// OPTIMIZE
+
+#if nssv_CPP11_OR_GREATER && !nssv_CPP17_OR_GREATER
+#if defined(__OPTIMIZE__)
+
+    // gcc, clang provide __OPTIMIZE__
+    // Expect tail call optimization to make search() non-recursive:
+
+    template<class CharT, class Traits = std::char_traits<CharT>>
+    constexpr const CharT *search(basic_string_view<CharT, Traits> haystack, basic_string_view<CharT, Traits> needle)
+    {
+        return haystack.starts_with(needle) ? haystack.begin()
+               : haystack.empty()           ? haystack.end()
+                                            : search(haystack.substr(1), needle);
+    }
+
+#else// OPTIMIZE
+
+    // non-recursive:
+
+#if nssv_CONFIG_CONSTEXPR11_STD_SEARCH
+
+    template<class CharT, class Traits = std::char_traits<CharT>>
+    constexpr const CharT *search(basic_string_view<CharT, Traits> haystack, basic_string_view<CharT, Traits> needle)
+    {
+        return std::search(haystack.begin(), haystack.end(), needle.begin(), needle.end());
+    }
+
+#else // nssv_CONFIG_CONSTEXPR11_STD_SEARCH
+
+    template<class CharT, class Traits = std::char_traits<CharT>>
+    nssv_constexpr14 const CharT *
+    search(basic_string_view<CharT, Traits> haystack, basic_string_view<CharT, Traits> needle)
+    {
+        while (needle.size() <= haystack.size()) {
+            if (haystack.starts_with(needle)) { return haystack.cbegin(); }
+            haystack = basic_string_view<CharT, Traits>{haystack.begin() + 1, haystack.size() - 1U};
+        }
+        return haystack.cend();
+    }
+#endif// nssv_CONFIG_CONSTEXPR11_STD_SEARCH
+
+#endif// OPTIMIZE
+#endif// nssv_CPP11_OR_GREATER && ! nssv_CPP17_OR_GREATER
+
+    }// namespace detail
+
+    //
+    // basic_string_view:
+    //
+
+    template<class CharT, class Traits /* = std::char_traits<CharT> */
+             >
+    class basic_string_view {
+    public:
+        // Member types:
+
+        typedef Traits traits_type;
+        typedef CharT value_type;
+
+        typedef CharT *pointer;
+        typedef CharT const *const_pointer;
+        typedef CharT &reference;
+        typedef CharT const &const_reference;
+
+        typedef const_pointer iterator;
+        typedef const_pointer const_iterator;
+        typedef std::reverse_iterator<const_iterator> reverse_iterator;
+        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+        typedef std::size_t size_type;
+        typedef std::ptrdiff_t difference_type;
+
+        // 24.4.2.1 Construction and assignment:
+
+        nssv_constexpr basic_string_view() nssv_noexcept : data_(nssv_nullptr), size_(0) {}
+
+#if nssv_CPP11_OR_GREATER
+        nssv_constexpr basic_string_view(basic_string_view const &other) nssv_noexcept = default;
+#else
+        nssv_constexpr basic_string_view(basic_string_view const &other) nssv_noexcept
+            : data_(other.data_),
+              size_(other.size_)
+        {}
+#endif
+
+        nssv_constexpr basic_string_view(CharT const *s, size_type count) nssv_noexcept// non-standard noexcept
+            : data_(s),
+              size_(count)
+        {}
+
+        nssv_constexpr basic_string_view(CharT const *s) nssv_noexcept// non-standard noexcept
+            : data_(s)
+#if nssv_CPP17_OR_GREATER
+            ,
+              size_(Traits::length(s))
+#elif nssv_CPP11_OR_GREATER
+            ,
+              size_(detail::length(s))
+#else
+            ,
+              size_(Traits::length(s))
+#endif
+        {}
+
+#if nssv_HAVE_NULLPTR
+#if nssv_HAVE_IS_DELETE
+        nssv_constexpr basic_string_view(std::nullptr_t) nssv_noexcept = delete;
+#else
+    private:
+        nssv_constexpr basic_string_view(std::nullptr_t) nssv_noexcept;
+
+    public:
+#endif
+#endif
+
+        // Assignment:
+
+#if nssv_CPP11_OR_GREATER
+        nssv_constexpr14 basic_string_view &operator=(basic_string_view const &other) nssv_noexcept = default;
+#else
+        nssv_constexpr14 basic_string_view &operator=(basic_string_view const &other) nssv_noexcept
+        {
+            data_ = other.data_;
+            size_ = other.size_;
+            return *this;
+        }
+#endif
+
+        // 24.4.2.2 Iterator support:
+
+        nssv_constexpr const_iterator begin() const nssv_noexcept { return data_; }
+
+        nssv_constexpr const_iterator end() const nssv_noexcept { return data_ + size_; }
+
+        nssv_constexpr const_iterator cbegin() const nssv_noexcept { return begin(); }
+
+        nssv_constexpr const_iterator cend() const nssv_noexcept { return end(); }
+
+        nssv_constexpr const_reverse_iterator rbegin() const nssv_noexcept { return const_reverse_iterator(end()); }
+
+        nssv_constexpr const_reverse_iterator rend() const nssv_noexcept { return const_reverse_iterator(begin()); }
+
+        nssv_constexpr const_reverse_iterator crbegin() const nssv_noexcept { return rbegin(); }
+
+        nssv_constexpr const_reverse_iterator crend() const nssv_noexcept { return rend(); }
+
+        // 24.4.2.3 Capacity:
+
+        nssv_constexpr size_type size() const nssv_noexcept { return size_; }
+
+        nssv_constexpr size_type length() const nssv_noexcept { return size_; }
+
+        nssv_constexpr size_type max_size() const nssv_noexcept { return (std::numeric_limits<size_type>::max)(); }
+
+        // since C++20
+        nssv_nodiscard nssv_constexpr bool empty() const nssv_noexcept { return 0 == size_; }
+
+        // 24.4.2.4 Element access:
+
+        nssv_constexpr const_reference operator[](size_type pos) const { return data_at(pos); }
+
+        nssv_constexpr14 const_reference at(size_type pos) const
+        {
+#if nssv_CONFIG_NO_EXCEPTIONS
+            assert(pos < size());
+#else
+            if (pos >= size()) { throw std::out_of_range("nonstd::string_view::at()"); }
+#endif
+            return data_at(pos);
+        }
+
+        nssv_constexpr const_reference front() const { return data_at(0); }
+
+        nssv_constexpr const_reference back() const { return data_at(size() - 1); }
+
+        nssv_constexpr const_pointer data() const nssv_noexcept { return data_; }
+
+        // 24.4.2.5 Modifiers:
+
+        nssv_constexpr14 void remove_prefix(size_type n)
+        {
+            assert(n <= size());
+            data_ += n;
+            size_ -= n;
+        }
+
+        nssv_constexpr14 void remove_suffix(size_type n)
+        {
+            assert(n <= size());
+            size_ -= n;
+        }
+
+        nssv_constexpr14 void swap(basic_string_view &other) nssv_noexcept
+        {
+            const basic_string_view tmp(other);
+            other = *this;
+            *this = tmp;
+        }
+
+        // 24.4.2.6 String operations:
+
+        size_type copy(CharT *dest, size_type n, size_type pos = 0) const
+        {
+#if nssv_CONFIG_NO_EXCEPTIONS
+            assert(pos <= size());
+#else
+            if (pos > size()) { throw std::out_of_range("nonstd::string_view::copy()"); }
+#endif
+            const size_type rlen = (std::min)(n, size() - pos);
+
+            (void) Traits::copy(dest, data() + pos, rlen);
+
+            return rlen;
+        }
+
+        nssv_constexpr14 basic_string_view substr(size_type pos = 0, size_type n = npos) const
+        {
+#if nssv_CONFIG_NO_EXCEPTIONS
+            assert(pos <= size());
+#else
+            if (pos > size()) { throw std::out_of_range("nonstd::string_view::substr()"); }
+#endif
+            return basic_string_view(data() + pos, (std::min)(n, size() - pos));
+        }
+
+        // compare(), 6x:
+
+        nssv_constexpr14 int compare(basic_string_view other) const nssv_noexcept// (1)
+        {
+#if nssv_CPP17_OR_GREATER
+            if (const int result = Traits::compare(data(), other.data(), (std::min)(size(), other.size())))
+#else
+            if (const int result = detail::compare(data(), other.data(), (std::min)(size(), other.size())))
+#endif
+            {
+                return result;
+            }
+
+            return size() == other.size() ? 0 : size() < other.size() ? -1 : 1;
+        }
+
+        nssv_constexpr int compare(size_type pos1, size_type n1, basic_string_view other) const// (2)
+        {
+            return substr(pos1, n1).compare(other);
+        }
+
+        nssv_constexpr int
+        compare(size_type pos1, size_type n1, basic_string_view other, size_type pos2, size_type n2) const// (3)
+        {
+            return substr(pos1, n1).compare(other.substr(pos2, n2));
+        }
+
+        nssv_constexpr int compare(CharT const *s) const// (4)
+        {
+            return compare(basic_string_view(s));
+        }
+
+        nssv_constexpr int compare(size_type pos1, size_type n1, CharT const *s) const// (5)
+        {
+            return substr(pos1, n1).compare(basic_string_view(s));
+        }
+
+        nssv_constexpr int compare(size_type pos1, size_type n1, CharT const *s, size_type n2) const// (6)
+        {
+            return substr(pos1, n1).compare(basic_string_view(s, n2));
+        }
+
+        // 24.4.2.7 Searching:
+
+        // starts_with(), 3x, since C++20:
+
+        nssv_constexpr bool starts_with(basic_string_view v) const nssv_noexcept// (1)
+        {
+            return size() >= v.size() && compare(0, v.size(), v) == 0;
+        }
+
+        nssv_constexpr bool starts_with(CharT c) const nssv_noexcept// (2)
+        {
+            return starts_with(basic_string_view(&c, 1));
+        }
+
+        nssv_constexpr bool starts_with(CharT const *s) const// (3)
+        {
+            return starts_with(basic_string_view(s));
+        }
+
+        // ends_with(), 3x, since C++20:
+
+        nssv_constexpr bool ends_with(basic_string_view v) const nssv_noexcept// (1)
+        {
+            return size() >= v.size() && compare(size() - v.size(), npos, v) == 0;
+        }
+
+        nssv_constexpr bool ends_with(CharT c) const nssv_noexcept// (2)
+        {
+            return ends_with(basic_string_view(&c, 1));
+        }
+
+        nssv_constexpr bool ends_with(CharT const *s) const// (3)
+        {
+            return ends_with(basic_string_view(s));
+        }
+
+        // find(), 4x:
+
+        nssv_constexpr14 size_type find(basic_string_view v, size_type pos = 0) const nssv_noexcept// (1)
+        {
+            return assert(v.size() == 0 || v.data() != nssv_nullptr),
+                   pos >= size() ? npos
+                                 : to_pos(
+#if nssv_CPP11_OR_GREATER && !nssv_CPP17_OR_GREATER
+                                     detail::search(substr(pos), v)
+#else
+                                     std::search(cbegin() + pos, cend(), v.cbegin(), v.cend(), Traits::eq)
+#endif
+                                 );
+        }
+
+        nssv_constexpr size_type find(CharT c, size_type pos = 0) const nssv_noexcept// (2)
+        {
+            return find(basic_string_view(&c, 1), pos);
+        }
+
+        nssv_constexpr size_type find(CharT const *s, size_type pos, size_type n) const// (3)
+        {
+            return find(basic_string_view(s, n), pos);
+        }
+
+        nssv_constexpr size_type find(CharT const *s, size_type pos = 0) const// (4)
+        {
+            return find(basic_string_view(s), pos);
+        }
+
+        // rfind(), 4x:
+
+        nssv_constexpr14 size_type rfind(basic_string_view v, size_type pos = npos) const nssv_noexcept// (1)
+        {
+            if (size() < v.size()) { return npos; }
+
+            if (v.empty()) { return (std::min)(size(), pos); }
+
+            const_iterator last   = cbegin() + (std::min)(size() - v.size(), pos) + v.size();
+            const_iterator result = std::find_end(cbegin(), last, v.cbegin(), v.cend(), Traits::eq);
+
+            return result != last ? size_type(result - cbegin()) : npos;
+        }
+
+        nssv_constexpr14 size_type rfind(CharT c, size_type pos = npos) const nssv_noexcept// (2)
+        {
+            return rfind(basic_string_view(&c, 1), pos);
+        }
+
+        nssv_constexpr14 size_type rfind(CharT const *s, size_type pos, size_type n) const// (3)
+        {
+            return rfind(basic_string_view(s, n), pos);
+        }
+
+        nssv_constexpr14 size_type rfind(CharT const *s, size_type pos = npos) const// (4)
+        {
+            return rfind(basic_string_view(s), pos);
+        }
+
+        // find_first_of(), 4x:
+
+        nssv_constexpr size_type find_first_of(basic_string_view v, size_type pos = 0) const nssv_noexcept// (1)
+        {
+            return pos >= size() ? npos
+                                 : to_pos(std::find_first_of(cbegin() + pos, cend(), v.cbegin(), v.cend(), Traits::eq));
+        }
+
+        nssv_constexpr size_type find_first_of(CharT c, size_type pos = 0) const nssv_noexcept// (2)
+        {
+            return find_first_of(basic_string_view(&c, 1), pos);
+        }
+
+        nssv_constexpr size_type find_first_of(CharT const *s, size_type pos, size_type n) const// (3)
+        {
+            return find_first_of(basic_string_view(s, n), pos);
+        }
+
+        nssv_constexpr size_type find_first_of(CharT const *s, size_type pos = 0) const// (4)
+        {
+            return find_first_of(basic_string_view(s), pos);
+        }
+
+        // find_last_of(), 4x:
+
+        nssv_constexpr size_type find_last_of(basic_string_view v, size_type pos = npos) const nssv_noexcept// (1)
+        {
+            return empty() ? npos
+                   : pos >= size()
+                       ? find_last_of(v, size() - 1)
+                       : to_pos(std::find_first_of(const_reverse_iterator(cbegin() + pos + 1),
+                                                   crend(),
+                                                   v.cbegin(),
+                                                   v.cend(),
+                                                   Traits::eq));
+        }
+
+        nssv_constexpr size_type find_last_of(CharT c, size_type pos = npos) const nssv_noexcept// (2)
+        {
+            return find_last_of(basic_string_view(&c, 1), pos);
+        }
+
+        nssv_constexpr size_type find_last_of(CharT const *s, size_type pos, size_type count) const// (3)
+        {
+            return find_last_of(basic_string_view(s, count), pos);
+        }
+
+        nssv_constexpr size_type find_last_of(CharT const *s, size_type pos = npos) const// (4)
+        {
+            return find_last_of(basic_string_view(s), pos);
+        }
+
+        // find_first_not_of(), 4x:
+
+        nssv_constexpr size_type find_first_not_of(basic_string_view v, size_type pos = 0) const nssv_noexcept// (1)
+        {
+            return pos >= size() ? npos : to_pos(std::find_if(cbegin() + pos, cend(), not_in_view(v)));
+        }
+
+        nssv_constexpr size_type find_first_not_of(CharT c, size_type pos = 0) const nssv_noexcept// (2)
+        {
+            return find_first_not_of(basic_string_view(&c, 1), pos);
+        }
+
+        nssv_constexpr size_type find_first_not_of(CharT const *s, size_type pos, size_type count) const// (3)
+        {
+            return find_first_not_of(basic_string_view(s, count), pos);
+        }
+
+        nssv_constexpr size_type find_first_not_of(CharT const *s, size_type pos = 0) const// (4)
+        {
+            return find_first_not_of(basic_string_view(s), pos);
+        }
+
+        // find_last_not_of(), 4x:
+
+        nssv_constexpr size_type find_last_not_of(basic_string_view v, size_type pos = npos) const nssv_noexcept// (1)
+        {
+            return empty() ? npos
+                   : pos >= size()
+                       ? find_last_not_of(v, size() - 1)
+                       : to_pos(std::find_if(const_reverse_iterator(cbegin() + pos + 1), crend(), not_in_view(v)));
+        }
+
+        nssv_constexpr size_type find_last_not_of(CharT c, size_type pos = npos) const nssv_noexcept// (2)
+        {
+            return find_last_not_of(basic_string_view(&c, 1), pos);
+        }
+
+        nssv_constexpr size_type find_last_not_of(CharT const *s, size_type pos, size_type count) const// (3)
+        {
+            return find_last_not_of(basic_string_view(s, count), pos);
+        }
+
+        nssv_constexpr size_type find_last_not_of(CharT const *s, size_type pos = npos) const// (4)
+        {
+            return find_last_not_of(basic_string_view(s), pos);
+        }
+
+        // Constants:
+
+#if nssv_CPP17_OR_GREATER
+        static nssv_constexpr size_type npos = size_type(-1);
+#elif nssv_CPP11_OR_GREATER
+        enum : size_type { npos = size_type(-1) };
+#else
+        enum { npos = size_type(-1) };
+#endif
+
+    private:
+        struct not_in_view {
+            const basic_string_view v;
+
+            nssv_constexpr explicit not_in_view(basic_string_view v_) : v(v_) {}
+
+            nssv_constexpr bool operator()(CharT c) const { return npos == v.find_first_of(c); }
+        };
+
+        nssv_constexpr size_type to_pos(const_iterator it) const
+        {
+            return it == cend() ? npos : size_type(it - cbegin());
+        }
+
+        nssv_constexpr size_type to_pos(const_reverse_iterator it) const
+        {
+            return it == crend() ? npos : size_type(crend() - it - 1);
+        }
+
+        nssv_constexpr const_reference data_at(size_type pos) const
+        {
+#if nssv_BETWEEN(nssv_COMPILER_GNUC_VERSION, 1, 500)
+            return data_[pos];
+#else
+            return assert(pos < size()), data_[pos];
+#endif
+        }
+
+    private:
+        const_pointer data_;
+        size_type size_;
+
+    public:
+#if nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS
+
+        template<class Allocator>
+        basic_string_view(std::basic_string<CharT, Traits, Allocator> const &s) nssv_noexcept
+            : data_(s.data()),
+              size_(s.size())
+        {}
+
+#if nssv_HAVE_EXPLICIT_CONVERSION
+
+        template<class Allocator>
+        explicit operator std::basic_string<CharT, Traits, Allocator>() const
+        {
+            return to_string(Allocator());
+        }
+
+#endif// nssv_HAVE_EXPLICIT_CONVERSION
+
+#if nssv_CPP11_OR_GREATER
+
+        template<class Allocator = std::allocator<CharT>>
+        std::basic_string<CharT, Traits, Allocator> to_string(Allocator const &a = Allocator()) const
+        {
+            return std::basic_string<CharT, Traits, Allocator>(begin(), end(), a);
+        }
+
+#else
+
+        std::basic_string<CharT, Traits> to_string() const { return std::basic_string<CharT, Traits>(begin(), end()); }
+
+        template<class Allocator>
+        std::basic_string<CharT, Traits, Allocator> to_string(Allocator const &a) const
+        {
+            return std::basic_string<CharT, Traits, Allocator>(begin(), end(), a);
+        }
+
+#endif// nssv_CPP11_OR_GREATER
+
+#endif// nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS
+    };
+
+    //
+    // Non-member functions:
+    //
+
+    // 24.4.3 Non-member comparison functions:
+    // lexicographically compare two string views (function template):
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator==(basic_string_view<CharT, Traits> lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.size() == rhs.size() && lhs.compare(rhs) == 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator!=(basic_string_view<CharT, Traits> lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator<(basic_string_view<CharT, Traits> lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) < 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator<=(basic_string_view<CharT, Traits> lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) <= 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator>(basic_string_view<CharT, Traits> lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) > 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator>=(basic_string_view<CharT, Traits> lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) >= 0;
+    }
+
+    // Let S be basic_string_view<CharT, Traits>, and sv be an instance of S.
+    // Implementations shall provide sufficient additional overloads marked
+    // constexpr and noexcept so that an object t with an implicit conversion
+    // to S can be compared according to Table 67.
+
+#if !nssv_CPP11_OR_GREATER || nssv_BETWEEN(nssv_COMPILER_MSVC_VERSION, 100, 141)
+
+    // accommodate for older compilers:
+
+    // ==
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool operator==(basic_string_view<CharT, Traits> lhs, CharT const *rhs) nssv_noexcept
+    {
+        return lhs.size() == detail::length(rhs) && lhs.compare(rhs) == 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool operator==(CharT const *lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return detail::length(lhs) == rhs.size() && rhs.compare(lhs) == 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator==(basic_string_view<CharT, Traits> lhs, std::basic_string<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.size() == rhs.size() && lhs.compare(rhs) == 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator==(std::basic_string<CharT, Traits> rhs, basic_string_view<CharT, Traits> lhs) nssv_noexcept
+    {
+        return lhs.size() == rhs.size() && lhs.compare(rhs) == 0;
+    }
+
+    // !=
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool operator!=(basic_string_view<CharT, Traits> lhs, CharT const *rhs) nssv_noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool operator!=(CharT const *lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator!=(basic_string_view<CharT, Traits> lhs, std::basic_string<CharT, Traits> rhs) nssv_noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator!=(std::basic_string<CharT, Traits> rhs, basic_string_view<CharT, Traits> lhs) nssv_noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    // <
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool operator<(basic_string_view<CharT, Traits> lhs, CharT const *rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) < 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool operator<(CharT const *lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return rhs.compare(lhs) > 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator<(basic_string_view<CharT, Traits> lhs, std::basic_string<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) < 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator<(std::basic_string<CharT, Traits> rhs, basic_string_view<CharT, Traits> lhs) nssv_noexcept
+    {
+        return rhs.compare(lhs) > 0;
+    }
+
+    // <=
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool operator<=(basic_string_view<CharT, Traits> lhs, CharT const *rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) <= 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool operator<=(CharT const *lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return rhs.compare(lhs) >= 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator<=(basic_string_view<CharT, Traits> lhs, std::basic_string<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) <= 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator<=(std::basic_string<CharT, Traits> rhs, basic_string_view<CharT, Traits> lhs) nssv_noexcept
+    {
+        return rhs.compare(lhs) >= 0;
+    }
+
+    // >
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool operator>(basic_string_view<CharT, Traits> lhs, CharT const *rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) > 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool operator>(CharT const *lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return rhs.compare(lhs) < 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator>(basic_string_view<CharT, Traits> lhs, std::basic_string<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) > 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator>(std::basic_string<CharT, Traits> rhs, basic_string_view<CharT, Traits> lhs) nssv_noexcept
+    {
+        return rhs.compare(lhs) < 0;
+    }
+
+    // >=
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool operator>=(basic_string_view<CharT, Traits> lhs, CharT const *rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) >= 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool operator>=(CharT const *lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return rhs.compare(lhs) <= 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator>=(basic_string_view<CharT, Traits> lhs, std::basic_string<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) >= 0;
+    }
+
+    template<class CharT, class Traits>
+    nssv_constexpr bool
+    operator>=(std::basic_string<CharT, Traits> rhs, basic_string_view<CharT, Traits> lhs) nssv_noexcept
+    {
+        return rhs.compare(lhs) <= 0;
+    }
+
+#else// newer compilers:
+
+#define nssv_BASIC_STRING_VIEW_I(T, U) typename std::decay<basic_string_view<T, U>>::type
+
+#if defined(_MSC_VER)// issue 40
+#define nssv_MSVC_ORDER(x) , int = x
+#else
+#define nssv_MSVC_ORDER(x) /*, int=x*/
+#endif
+
+    // ==
+
+    template<class CharT, class Traits nssv_MSVC_ORDER(1)>
+    nssv_constexpr bool
+    operator==(basic_string_view<CharT, Traits> lhs, nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept
+    {
+        return lhs.size() == rhs.size() && lhs.compare(rhs) == 0;
+    }
+
+    template<class CharT, class Traits nssv_MSVC_ORDER(2)>
+    nssv_constexpr bool
+    operator==(nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.size() == rhs.size() && lhs.compare(rhs) == 0;
+    }
+
+    // !=
+
+    template<class CharT, class Traits nssv_MSVC_ORDER(1)>
+    nssv_constexpr bool
+    operator!=(basic_string_view<CharT, Traits> lhs, nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    template<class CharT, class Traits nssv_MSVC_ORDER(2)>
+    nssv_constexpr bool
+    operator!=(nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    // <
+
+    template<class CharT, class Traits nssv_MSVC_ORDER(1)>
+    nssv_constexpr bool
+    operator<(basic_string_view<CharT, Traits> lhs, nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) < 0;
+    }
+
+    template<class CharT, class Traits nssv_MSVC_ORDER(2)>
+    nssv_constexpr bool
+    operator<(nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) < 0;
+    }
+
+    // <=
+
+    template<class CharT, class Traits nssv_MSVC_ORDER(1)>
+    nssv_constexpr bool
+    operator<=(basic_string_view<CharT, Traits> lhs, nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) <= 0;
+    }
+
+    template<class CharT, class Traits nssv_MSVC_ORDER(2)>
+    nssv_constexpr bool
+    operator<=(nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) <= 0;
+    }
+
+    // >
+
+    template<class CharT, class Traits nssv_MSVC_ORDER(1)>
+    nssv_constexpr bool
+    operator>(basic_string_view<CharT, Traits> lhs, nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) > 0;
+    }
+
+    template<class CharT, class Traits nssv_MSVC_ORDER(2)>
+    nssv_constexpr bool
+    operator>(nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) > 0;
+    }
+
+    // >=
+
+    template<class CharT, class Traits nssv_MSVC_ORDER(1)>
+    nssv_constexpr bool
+    operator>=(basic_string_view<CharT, Traits> lhs, nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) >= 0;
+    }
+
+    template<class CharT, class Traits nssv_MSVC_ORDER(2)>
+    nssv_constexpr bool
+    operator>=(nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept
+    {
+        return lhs.compare(rhs) >= 0;
+    }
+
+#undef nssv_MSVC_ORDER
+#undef nssv_BASIC_STRING_VIEW_I
+
+#endif// compiler-dependent approach to comparisons
+
+    // 24.4.4 Inserters and extractors:
+
+#if !nssv_CONFIG_NO_STREAM_INSERTION
+
+    namespace detail {
+
+    template<class Stream>
+    void write_padding(Stream &os, std::streamsize n)
+    {
+        for (std::streamsize i = 0; i < n; ++i) os.rdbuf()->sputc(os.fill());
+    }
+
+    template<class Stream, class View>
+    Stream &write_to_stream(Stream &os, View const &sv)
+    {
+        typename Stream::sentry sentry(os);
+
+        if (!sentry) return os;
+
+        const std::streamsize length = static_cast<std::streamsize>(sv.length());
+
+        // Whether, and how, to pad:
+        const bool pad      = (length < os.width());
+        const bool left_pad = pad && (os.flags() & std::ios_base::adjustfield) == std::ios_base::right;
+
+        if (left_pad) write_padding(os, os.width() - length);
+
+        // Write span characters:
+        os.rdbuf()->sputn(sv.begin(), length);
+
+        if (pad && !left_pad) write_padding(os, os.width() - length);
+
+        // Reset output stream width:
+        os.width(0);
+
+        return os;
+    }
+
+    }// namespace detail
+
+    template<class CharT, class Traits>
+    std::basic_ostream<CharT, Traits> &
+    operator<<(std::basic_ostream<CharT, Traits> &os, basic_string_view<CharT, Traits> sv)
+    {
+        return detail::write_to_stream(os, sv);
+    }
+
+#endif// nssv_CONFIG_NO_STREAM_INSERTION
+
+    // Several typedefs for common character types are provided:
+
+    typedef basic_string_view<char> string_view;
+    typedef basic_string_view<wchar_t> wstring_view;
+#if nssv_HAVE_WCHAR16_T
+    typedef basic_string_view<char16_t> u16string_view;
+    typedef basic_string_view<char32_t> u32string_view;
+#endif
+
+    }// namespace sv_lite
+}// namespace nonstd::sv_lite
+
+//
+// 24.4.6 Suffix for basic_string_view literals:
+//
+
+#if nssv_HAVE_USER_DEFINED_LITERALS
+
+namespace nonstd {
+nssv_inline_ns namespace literals
+{
+    nssv_inline_ns namespace string_view_literals
+    {
+
+#if nssv_CONFIG_STD_SV_OPERATOR && nssv_HAVE_STD_DEFINED_LITERALS
+
+        nssv_constexpr nonstd::sv_lite::string_view operator"" sv(const char *str, size_t len) nssv_noexcept// (1)
+        {
+            return nonstd::sv_lite::string_view{str, len};
+        }
+
+        nssv_constexpr nonstd::sv_lite::u16string_view operator"" sv(const char16_t *str, size_t len)
+            nssv_noexcept// (2)
+        {
+            return nonstd::sv_lite::u16string_view{str, len};
+        }
+
+        nssv_constexpr nonstd::sv_lite::u32string_view operator"" sv(const char32_t *str, size_t len)
+            nssv_noexcept// (3)
+        {
+            return nonstd::sv_lite::u32string_view{str, len};
+        }
+
+        nssv_constexpr nonstd::sv_lite::wstring_view operator"" sv(const wchar_t *str, size_t len) nssv_noexcept// (4)
+        {
+            return nonstd::sv_lite::wstring_view{str, len};
+        }
+
+#endif// nssv_CONFIG_STD_SV_OPERATOR && nssv_HAVE_STD_DEFINED_LITERALS
+
+#if nssv_CONFIG_USR_SV_OPERATOR
+
+        nssv_constexpr nonstd::sv_lite::string_view operator"" _sv(const char *str, size_t len) nssv_noexcept// (1)
+        {
+            return nonstd::sv_lite::string_view{str, len};
+        }
+
+        nssv_constexpr nonstd::sv_lite::u16string_view operator"" _sv(const char16_t *str, size_t len)
+            nssv_noexcept// (2)
+        {
+            return nonstd::sv_lite::u16string_view{str, len};
+        }
+
+        nssv_constexpr nonstd::sv_lite::u32string_view operator"" _sv(const char32_t *str, size_t len)
+            nssv_noexcept// (3)
+        {
+            return nonstd::sv_lite::u32string_view{str, len};
+        }
+
+        nssv_constexpr nonstd::sv_lite::wstring_view operator"" _sv(const wchar_t *str, size_t len) nssv_noexcept// (4)
+        {
+            return nonstd::sv_lite::wstring_view{str, len};
+        }
+
+#endif// nssv_CONFIG_USR_SV_OPERATOR
+    }
+}
+}// namespace nonstd
+
+#endif
+
+//
+// Extensions for std::string:
+//
+
+#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS
+
+namespace nonstd {
+namespace sv_lite {
+
+// Exclude MSVC 14 (19.00): it yields ambiguous to_string():
+
+#if nssv_CPP11_OR_GREATER && nssv_COMPILER_MSVC_VERSION != 140
+
+template<class CharT, class Traits, class Allocator = std::allocator<CharT>>
+std::basic_string<CharT, Traits, Allocator>
+to_string(basic_string_view<CharT, Traits> v, Allocator const &a = Allocator())
+{
+    return std::basic_string<CharT, Traits, Allocator>(v.begin(), v.end(), a);
+}
+
+#else
+
+template<class CharT, class Traits>
+std::basic_string<CharT, Traits>
+to_string(basic_string_view<CharT, Traits> v)
+{
+    return std::basic_string<CharT, Traits>(v.begin(), v.end());
+}
+
+template<class CharT, class Traits, class Allocator>
+std::basic_string<CharT, Traits, Allocator>
+to_string(basic_string_view<CharT, Traits> v, Allocator const &a)
+{
+    return std::basic_string<CharT, Traits, Allocator>(v.begin(), v.end(), a);
+}
+
+#endif// nssv_CPP11_OR_GREATER
+
+template<class CharT, class Traits, class Allocator>
+basic_string_view<CharT, Traits>
+to_string_view(std::basic_string<CharT, Traits, Allocator> const &s)
+{
+    return basic_string_view<CharT, Traits>(s.data(), s.size());
+}
+
+}// namespace sv_lite
+}// namespace nonstd
+
+#endif// nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS
+
+//
+// make types and algorithms available in namespace nonstd:
+//
+
+namespace nonstd {
+
+using sv_lite::basic_string_view;
+using sv_lite::string_view;
+using sv_lite::wstring_view;
+
+#if nssv_HAVE_WCHAR16_T
+using sv_lite::u16string_view;
+#endif
+#if nssv_HAVE_WCHAR32_T
+using sv_lite::u32string_view;
+#endif
+
+// literal "sv"
+
+using sv_lite::operator==;
+using sv_lite::operator!=;
+using sv_lite::operator<;
+using sv_lite::operator<=;
+using sv_lite::operator>;
+using sv_lite::operator>=;
+
+#if !nssv_CONFIG_NO_STREAM_INSERTION
+using sv_lite::operator<<;
+#endif
+
+#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS
+using sv_lite::to_string;
+using sv_lite::to_string_view;
+#endif
+
+}// namespace nonstd
+
+// 24.4.5 Hash support (C++11):
+
+// Note: The hash value of a string view object is equal to the hash value of
+// the corresponding string object.
+
+#if nssv_HAVE_STD_HASH
+
+#include <functional>
+
+namespace std {
+
+template<>
+struct hash<nonstd::string_view> {
+public:
+    std::size_t operator()(nonstd::string_view v) const nssv_noexcept
+    {
+        return std::hash<std::string>()(std::string(v.data(), v.size()));
+    }
+};
+
+template<>
+struct hash<nonstd::wstring_view> {
+public:
+    std::size_t operator()(nonstd::wstring_view v) const nssv_noexcept
+    {
+        return std::hash<std::wstring>()(std::wstring(v.data(), v.size()));
+    }
+};
+
+template<>
+struct hash<nonstd::u16string_view> {
+public:
+    std::size_t operator()(nonstd::u16string_view v) const nssv_noexcept
+    {
+        return std::hash<std::u16string>()(std::u16string(v.data(), v.size()));
+    }
+};
+
+template<>
+struct hash<nonstd::u32string_view> {
+public:
+    std::size_t operator()(nonstd::u32string_view v) const nssv_noexcept
+    {
+        return std::hash<std::u32string>()(std::u32string(v.data(), v.size()));
+    }
+};
+
+}// namespace std
+
+#endif// nssv_HAVE_STD_HASH
+
+namespace sled {
+using namespace nonstd;
+}
+nssv_RESTORE_WARNINGS()
+
+#endif// nssv_HAVE_STD_STRING_VIEW
+#endif// NONSTD_SV_LITE_H_INCLUDED
diff --git a/src/sled/nonstd/string_view_test.cc b/src/sled/nonstd/string_view_test.cc
new file mode 100644
index 0000000..3ae4567
--- /dev/null
+++ b/src/sled/nonstd/string_view_test.cc
@@ -0,0 +1,59 @@
+#include <sled/nonstd/string_view.h>
+
+using namespace sled;
+using size_type = size_t;
+
+TEST_SUITE("string_view")
+{
+    TEST_CASE("string_view: Allows to default construct an empty string_view")
+    {
+        string_view sv;
+
+        // use parenthesis with data() to prevent lest from using sv.data() as C-string:
+
+        CHECK(sv.size() == size_type(0));
+        CHECK((sv.data() == nssv_nullptr));
+    }
+
+    TEST_CASE("string_view: Allows to construct from pointer and size")
+    {
+        string_view sv("hello world", 5);
+
+        CHECK(sv.size() == size_type(5));
+        CHECK(*(sv.data() + 0) == 'h');
+        CHECK(*(sv.data() + 4) == 'o');
+    }
+
+    TEST_CASE("string_view: Allows to construct from C-string")
+    {
+        string_view sv("hello world");
+
+        CHECK(sv.size() == size_type(11));
+        CHECK(*(sv.data() + 0) == 'h');
+        CHECK(*(sv.data() + 10) == 'd');
+    }
+
+    TEST_CASE("string_view: Allows to copy-construct from empty string_view")
+    {
+        string_view sv1;
+
+        string_view sv2(sv1);
+
+        // use parenthesis with data() to prevent lest from using sv.data() as C-string:
+
+        CHECK(sv2.size() == size_type(0));
+        CHECK((sv2.data() == nssv_nullptr));
+    }
+
+    TEST_CASE("string_view: Allows to copy-construct from non-empty string_view")
+    {
+        string_view sv1("hello world", 5);
+
+        string_view sv2(sv1);
+
+        CHECK(sv2.size() == sv1.size());
+        CHECK((sv2.data() == sv1.data()));
+        CHECK(*(sv2.data() + 0) == 'h');
+        CHECK(*(sv2.data() + 4) == 'o');
+    }
+}
diff --git a/src/sled/sled.h b/src/sled/sled.h
index de4fb8c..31b301f 100644
--- a/src/sled/sled.h
+++ b/src/sled/sled.h
@@ -3,9 +3,10 @@
 #define SLED_SLED_H
 
 // thrid_party
-#include "async/async.h"
 #include "inja.hpp"
 #include "rx.h"
+#include "sled/async/async.h"
+#include "sled/nonstd/string_view.h"
 #include "toml.hpp"
 
 // experimental
@@ -22,7 +23,7 @@
 // #include "sled/futures/promise.h"
 
 // lang
-#include "lang/attributes.h"
+#include "sled/lang/attributes.h"
 
 // log
 #include "sled/log/log.h"