diff --git a/blocks/http/request.h b/blocks/http/request.h
index a83f82360..32fa9e9b2 100644
--- a/blocks/http/request.h
+++ b/blocks/http/request.h
@@ -97,7 +97,7 @@ struct Request final {
 
   // A shortcut to allow `[](Request r) { r("OK"); }` instead of `r.connection.SendHTTPResponse("OK")`.
   template <typename T, typename... TS>
-  std::enable_if_t<!std::is_base_of_v<IHasDoRespondViaHTTP, current::decay_t<T>>> operator()(T&& arg, TS&&... args) {
+  std::enable_if_t<!std::is_base_of<IHasDoRespondViaHTTP, current::decay_t<T>>::value> operator()(T&& arg, TS&&... args) {
     if (!unique_connection) {
       CURRENT_THROW(net::AttemptedToSendHTTPResponseMoreThanOnce());
     }
@@ -106,7 +106,7 @@ struct Request final {
 
   // Support `Response`, as well as custom objects with user-defined HTTP response handlers.
   template <class T>
-  std::enable_if_t<std::is_base_of_v<IHasDoRespondViaHTTP, current::decay_t<T>>> operator()(T&& response) {
+  std::enable_if_t<std::is_base_of<IHasDoRespondViaHTTP, current::decay_t<T>>::value> operator()(T&& response) {
     if (!unique_connection) {
       CURRENT_THROW(net::AttemptedToSendHTTPResponseMoreThanOnce());
     }
diff --git a/blocks/http/response.h b/blocks/http/response.h
index 6244a2fe7..3835255f6 100644
--- a/blocks/http/response.h
+++ b/blocks/http/response.h
@@ -85,7 +85,7 @@ struct Response final : IHasDoRespondViaHTTP {
   Response& operator=(const Response&) = default;
   Response& operator=(Response&&) = default;
 
-  template <typename ARG, typename... ARGS, class = std::enable_if_t<!std::is_same_v<Response, current::decay_t<ARG>>>>
+  template <typename ARG, typename... ARGS, class = std::enable_if_t<!std::is_same<Response, current::decay_t<ARG>>::value>>
   Response(ARG&& arg, ARGS&&... args) : initialized(true) {
     Construct(std::forward<ARG>(arg), std::forward<ARGS>(args)...);
   }
diff --git a/blocks/ss/persister.h b/blocks/ss/persister.h
index 4eb4a69c6..c6e6a7b9e 100644
--- a/blocks/ss/persister.h
+++ b/blocks/ss/persister.h
@@ -153,12 +153,12 @@ class EntryPersister : public GenericEntryPersister<ENTRY>, public IMPL {
 // For `static_assert`-s.
 template <typename T>
 struct IsPersister {
-  static constexpr bool value = std::is_base_of_v<GenericPersister, T>;
+  static constexpr bool value = std::is_base_of<GenericPersister, T>::value;
 };
 
 template <typename T, typename E>
 struct IsEntryPersister {
-  static constexpr bool value = std::is_base_of_v<GenericEntryPersister<E>, T>;
+  static constexpr bool value = std::is_base_of<GenericEntryPersister<E>, T>::value;
 };
 
 }  // namespace ss
diff --git a/blocks/ss/pubsub.h b/blocks/ss/pubsub.h
index da250a47e..c6a14fc78 100644
--- a/blocks/ss/pubsub.h
+++ b/blocks/ss/pubsub.h
@@ -107,17 +107,17 @@ class StreamPublisher : public GenericStreamPublisher<ENTRY>, public EntryPublis
 // TODO(dkorolev): `Variant` stream types, and publishing those?
 template <typename T>
 struct IsPublisher {
-  static constexpr bool value = std::is_base_of_v<GenericPublisher, current::decay_t<T>>;
+  static constexpr bool value = std::is_base_of<GenericPublisher, current::decay_t<T>>::value;
 };
 
 template <typename T, typename E>
 struct IsEntryPublisher {
-  static constexpr bool value = std::is_base_of_v<GenericEntryPublisher<current::decay_t<E>>, current::decay_t<T>>;
+  static constexpr bool value = std::is_base_of<GenericEntryPublisher<current::decay_t<E>>, current::decay_t<T>>::value;
 };
 
 template <typename T, typename E>
 struct IsStreamPublisher {
-  static constexpr bool value = std::is_base_of_v<GenericStreamPublisher<current::decay_t<E>>, current::decay_t<T>>;
+  static constexpr bool value = std::is_base_of<GenericStreamPublisher<current::decay_t<E>>, current::decay_t<T>>::value;
 };
 
 enum class EntryResponse { Done = 0, More = 1 };
@@ -162,17 +162,17 @@ class StreamSubscriber : public GenericStreamSubscriber<ENTRY>, public EntrySubs
 // For `static_assert`-s. Must `decay_t<>` for template xvalue references support.
 template <typename T>
 struct IsSubscriber {
-  static constexpr bool value = std::is_base_of_v<GenericSubscriber, current::decay_t<T>>;
+  static constexpr bool value = std::is_base_of<GenericSubscriber, current::decay_t<T>>::value;
 };
 
 template <typename T, typename E>
 struct IsEntrySubscriber {
-  static constexpr bool value = std::is_base_of_v<GenericEntrySubscriber<current::decay_t<E>>, current::decay_t<T>>;
+  static constexpr bool value = std::is_base_of<GenericEntrySubscriber<current::decay_t<E>>, current::decay_t<T>>::value;
 };
 
 template <typename T, typename E>
 struct IsStreamSubscriber {
-  static constexpr bool value = std::is_base_of_v<GenericStreamSubscriber<current::decay_t<E>>, current::decay_t<T>>;
+  static constexpr bool value = std::is_base_of<GenericStreamSubscriber<current::decay_t<E>>, current::decay_t<T>>::value;
 };
 
 namespace impl {
diff --git a/blocks/ss/types.h b/blocks/ss/types.h
index 413b92666..9d663112b 100644
--- a/blocks/ss/types.h
+++ b/blocks/ss/types.h
@@ -37,7 +37,7 @@ template <typename ENTRY, typename STREAM_ENTRY>
 #ifndef CURRENT_FOR_CPP14
 inline
 #endif  // CURRENT_FOR_CPP14
-    constexpr bool can_publish_v = std::is_constructible_v<STREAM_ENTRY, ENTRY>;
+    constexpr bool can_publish_v = std::is_constructible<STREAM_ENTRY, ENTRY>::value;
 
 }  // namespace ss
 }  // namespace current
diff --git a/blocks/xterm/progress.h b/blocks/xterm/progress.h
index 6b2d75f22..509016d46 100644
--- a/blocks/xterm/progress.h
+++ b/blocks/xterm/progress.h
@@ -101,7 +101,7 @@ class ProgressLine final {
     }
 
     // The `std::enable_if_t` is necessary, as well as `current::decay`, because of `vt100::Color`. -- D.K.
-    template <typename T, class = std::enable_if_t<!std::is_base_of_v<vt100::E, current::decay_t<T>>>>
+    template <typename T, class = std::enable_if_t<!std::is_base_of<vt100::E, current::decay_t<T>>::value>>
     Status& operator<<(T&& whatever) {
       oss_text << whatever;
       oss_text_with_no_vt100_escape_sequences << whatever;
diff --git a/bricks/dflags/dflags.h b/bricks/dflags/dflags.h
index d92eada4e..7495ad7b2 100644
--- a/bricks/dflags/dflags.h
+++ b/bricks/dflags/dflags.h
@@ -273,7 +273,7 @@ class FlagRegisterer : public FlagRegistererBase {
     }
   }
 
-  bool IsBooleanFlag() const override { return std::is_same_v<FLAG_TYPE, bool>; }
+  bool IsBooleanFlag() const override { return std::is_same<FLAG_TYPE, bool>::value; }
 
   std::string TypeAsString() const override { return type_; }
 
diff --git a/bricks/dflags/test.cc b/bricks/dflags/test.cc
index 1c7e7bcbd..7f8d88930 100644
--- a/bricks/dflags/test.cc
+++ b/bricks/dflags/test.cc
@@ -35,13 +35,16 @@ SOFTWARE.
 #include <string>
 #include <sstream>
 
+template <typename A, typename B>
+constexpr bool is_same_v = std::is_same<A, B>::value;
+
 TEST(DFlags, DefinesAFlag) {
   ::dflags::FlagsManager::DefaultRegisterer local_registerer;
   auto local_registerer_scope = ::dflags::FlagsManager::ScopedSingletonInjector(local_registerer);
   DEFINE_int8(foo, 42, "");
   DEFINE_uint8(bar, 42, "");
-  static_assert(std::is_same_v<decltype(FLAGS_foo), int8_t>, "");
-  static_assert(std::is_same_v<decltype(FLAGS_bar), uint8_t>, "");
+  static_assert(is_same_v<decltype(FLAGS_foo), int8_t>, "");
+  static_assert(is_same_v<decltype(FLAGS_bar), uint8_t>, "");
   EXPECT_EQ(42, FLAGS_foo);
   EXPECT_EQ(42, FLAGS_bar);
   FLAGS_foo = -1;
@@ -56,7 +59,7 @@ TEST(DFlags, ParsesAFlagUsingSingleDash) {
   ::dflags::FlagsManager::DefaultRegisterer local_registerer;
   auto local_registerer_scope = ::dflags::FlagsManager::ScopedSingletonInjector(local_registerer);
   DEFINE_int16(foo, 1, "");
-  static_assert(std::is_same_v<decltype(FLAGS_foo), int16_t>, "");
+  static_assert(is_same_v<decltype(FLAGS_foo), int16_t>, "");
   EXPECT_EQ(1, FLAGS_foo);
   int argc = 3;
   char p1[] = "./ParsesAFlagUsingSingleDash";
@@ -74,7 +77,7 @@ TEST(DFlags, ParsesAFlagUsingDoubleDash) {
   ::dflags::FlagsManager::DefaultRegisterer local_registerer;
   auto local_registerer_scope = ::dflags::FlagsManager::ScopedSingletonInjector(local_registerer);
   DEFINE_uint16(bar, 1, "");
-  static_assert(std::is_same_v<decltype(FLAGS_bar), uint16_t>, "");
+  static_assert(is_same_v<decltype(FLAGS_bar), uint16_t>, "");
   EXPECT_EQ(1, FLAGS_bar);
   int argc = 3;
   char p1[] = "./ParsesAFlagUsingDoubleDash";
@@ -92,7 +95,7 @@ TEST(DFlags, ParsesAFlagUsingSingleDashEquals) {
   ::dflags::FlagsManager::DefaultRegisterer local_registerer;
   auto local_registerer_scope = ::dflags::FlagsManager::ScopedSingletonInjector(local_registerer);
   DEFINE_int32(baz, 1, "");
-  static_assert(std::is_same_v<decltype(FLAGS_baz), int32_t>, "");
+  static_assert(is_same_v<decltype(FLAGS_baz), int32_t>, "");
   EXPECT_EQ(1, FLAGS_baz);
   int argc = 2;
   char p1[] = "./ParsesAFlagUsingSingleDashEquals";
@@ -109,7 +112,7 @@ TEST(DFlags, ParsesAFlagUsingDoubleDashEquals) {
   ::dflags::FlagsManager::DefaultRegisterer local_registerer;
   auto local_registerer_scope = ::dflags::FlagsManager::ScopedSingletonInjector(local_registerer);
   DEFINE_uint32(meh, 1, "");
-  static_assert(std::is_same_v<decltype(FLAGS_meh), uint32_t>, "");
+  static_assert(is_same_v<decltype(FLAGS_meh), uint32_t>, "");
   EXPECT_EQ(1u, FLAGS_meh);
   int argc = 2;
   char p1[] = "./ParsesAFlagUsingDoubleDashEquals";
@@ -142,12 +145,12 @@ TEST(DFlags, ParsesMultipleFlags) {
   DEFINE_int64(flag_int64, 0, "");
   DEFINE_uint64(flag_uint64, 0u, "");
   DEFINE_size_t(flag_size_t, 0u, "");
-  static_assert(std::is_same_v<decltype(FLAGS_flag_string), std::string>, "");
-  static_assert(std::is_same_v<decltype(FLAGS_flag_bool1), bool>, "");
-  static_assert(std::is_same_v<decltype(FLAGS_flag_bool2), bool>, "");
-  static_assert(std::is_same_v<decltype(FLAGS_flag_int64), int64_t>, "");
-  static_assert(std::is_same_v<decltype(FLAGS_flag_uint64), uint64_t>, "");
-  static_assert(std::is_same_v<decltype(FLAGS_flag_size_t), size_t>, "");
+  static_assert(is_same_v<decltype(FLAGS_flag_string), std::string>, "");
+  static_assert(is_same_v<decltype(FLAGS_flag_bool1), bool>, "");
+  static_assert(is_same_v<decltype(FLAGS_flag_bool2), bool>, "");
+  static_assert(is_same_v<decltype(FLAGS_flag_int64), int64_t>, "");
+  static_assert(is_same_v<decltype(FLAGS_flag_uint64), uint64_t>, "");
+  static_assert(is_same_v<decltype(FLAGS_flag_size_t), size_t>, "");
   EXPECT_EQ("", FLAGS_flag_string);
   EXPECT_FALSE(FLAGS_flag_bool1);
   EXPECT_TRUE(FLAGS_flag_bool2);
@@ -182,7 +185,7 @@ TEST(DFlags, ParsesEmptyString) {
   ::dflags::FlagsManager::DefaultRegisterer local_registerer;
   auto local_registerer_scope = ::dflags::FlagsManager::ScopedSingletonInjector(local_registerer);
   DEFINE_string(empty_string, "not yet", "");
-  static_assert(std::is_same_v<decltype(FLAGS_empty_string), std::string>, "");
+  static_assert(is_same_v<decltype(FLAGS_empty_string), std::string>, "");
   EXPECT_EQ("not yet", FLAGS_empty_string);
   int argc = 3;
   char p1[] = "./ParsesEmptyString";
@@ -198,7 +201,7 @@ TEST(DFlags, ParsesEmptyStringUsingEquals) {
   ::dflags::FlagsManager::DefaultRegisterer local_registerer;
   auto local_registerer_scope = ::dflags::FlagsManager::ScopedSingletonInjector(local_registerer);
   DEFINE_string(empty_string, "not yet", "");
-  static_assert(std::is_same_v<decltype(FLAGS_empty_string), std::string>, "");
+  static_assert(is_same_v<decltype(FLAGS_empty_string), std::string>, "");
   EXPECT_EQ("not yet", FLAGS_empty_string);
   int argc = 2;
   char p1[] = "./ParsesEmptyStringUsingEquals";
diff --git a/bricks/distributed/test.cc b/bricks/distributed/test.cc
index 69b3d9064..9bc68427c 100644
--- a/bricks/distributed/test.cc
+++ b/bricks/distributed/test.cc
@@ -30,27 +30,26 @@ SOFTWARE.
 using namespace std::chrono_literals;
 
 TEST(VectorClock, SmokeTest) {
-  auto v = VectorClock();
+  auto v = VectorClock<>();
   v.Step();
 
   auto data = DiscreteClocks(1);
   EXPECT_FALSE(v.AdvanceTo(data)) << "Merge from future should return false.";
   EXPECT_EQ(v.State().size(), static_cast<size_t>(1));
 
-  auto v2 = VectorClock(data, 0);
+  auto v2 = VectorClock<>(data, 0);
   EXPECT_TRUE(v2.AdvanceTo(data)) << "Test lte t==t'.";
 }
 
 TEST(VectorClock, ToString) {
   DiscreteClocks c1 = {1, 2};
-  auto v = VectorClock(c1, 0);
+  auto v = VectorClock<>(c1, 0);
   EXPECT_EQ(v.ToString(), "VCLOCK ID=0: [1, 2]");
 }
 
 TEST(VectorClock, Merge) {
-  auto base_time = current::time::Now();
   DiscreteClocks c1 = {1, 2};
-  auto v = VectorClock(c1, 0);
+  auto v = VectorClock<>(c1, 0);
 
   // Merge correct update
   DiscreteClocks c2 = {2, 3};
@@ -65,14 +64,14 @@ TEST(VectorClock, Merge) {
   EXPECT_EQ(v.State()[1], cur_state[1]);
 
   // Merge partially equals using lte validation
-  v = VectorClock(c1, 0);
+  v = VectorClock<>(c1, 0);
   c2 = {1, 3};
   EXPECT_TRUE(v.AdvanceTo(c2)) << "0 is equals, 1 is greater - ok to merge.";
   cur_state = v.State();
   EXPECT_GT(cur_state[0], c2[0]) << "Local time should be updated after merge.";
   EXPECT_EQ(c2[1], cur_state[1]) << "Merged time should be equal c2[1].";
 
-  v = VectorClock(c1, 0);
+  v = VectorClock<>(c1, 0);
   cur_state = v.State();
   c2 = DiscreteClocks({1, 0});
   EXPECT_FALSE(v.AdvanceTo(c2)) << "Merge partially incorrect.";
@@ -96,7 +95,6 @@ TEST(VectorClock, ContinuousTime) {
 }
 
 TEST(VectorClock, StrictMerge) {
-  auto base_time = current::time::Now();
   DiscreteClocks c1 = {1, 2};
   auto v = VectorClock<DiscreteClocks, StrictMergeStrategy>(c1, 0);
 
diff --git a/bricks/net/http/impl/server.h b/bricks/net/http/impl/server.h
index 142fb77ac..4e8f5c66a 100644
--- a/bricks/net/http/impl/server.h
+++ b/bricks/net/http/impl/server.h
@@ -820,9 +820,9 @@ class GenericHTTPServerConnection final : public HTTPResponder {
 
       // Only support STL containers of chars and bytes, this does not yet cover std::string.
       template <typename T>
-      inline std::enable_if_t<std::is_same_v<typename T::value_type, char> ||
-                              std::is_same_v<typename T::value_type, uint8_t> ||
-                              std::is_same_v<typename T::value_type, int8_t>>
+      inline std::enable_if_t<std::is_same<typename T::value_type, char>::value ||
+                              std::is_same<typename T::value_type, uint8_t>::value ||
+                              std::is_same<typename T::value_type, int8_t>::value>
       Send(T&& data, ChunkFlush flush) {
         SendImpl(std::forward<T>(data), flush);
       }
diff --git a/bricks/net/tcp/impl/posix.h b/bricks/net/tcp/impl/posix.h
index 96e7bc974..025d2829f 100644
--- a/bricks/net/tcp/impl/posix.h
+++ b/bricks/net/tcp/impl/posix.h
@@ -390,7 +390,7 @@ class ReserveLocalPortImpl final {
     uint16_t port,
     NagleAlgorithm nagle_algorithm_policy = kDefaultNagleAlgorithmPolicy,
     MaxServerQueuedConnectionsValue max_connections = kMaxServerQueuedConnections) {
-  auto hold_port_or_throw = current::net::SocketHandle(current::net::SocketHandle::BindAndListen(),
+  current::net::SocketHandle hold_port_or_throw(current::net::SocketHandle::BindAndListen(),
                                                 current::net::BarePort(port),
                                                 nagle_algorithm_policy,
                                                 max_connections);
diff --git a/bricks/strings/join.h b/bricks/strings/join.h
index 5d72ba304..19bf9e57d 100644
--- a/bricks/strings/join.h
+++ b/bricks/strings/join.h
@@ -64,10 +64,16 @@ namespace sfinae {
 template <typename T, typename = void>
 struct is_container : std::false_type {};
 
+// NOTE(dkorolev): To avoid `std::void_t` in C++14.
+template <typename... TS>
+struct make_void {
+  typedef void type;
+};
+
 template <typename T>
 struct is_container<
     T,
-    std::void_t<decltype(std::declval<T>().begin()), decltype(std::declval<T>().end()), typename T::value_type>>
+    typename make_void<decltype(std::declval<T>().begin()), decltype(std::declval<T>().end()), typename T::value_type>::type>
     : std::true_type {};
 
 #ifndef CURRENT_FOR_CPP14
@@ -75,7 +81,7 @@ struct is_container<
 template <typename T>
 constexpr bool is_container_of_strings() {
   if constexpr (is_container<T>::value) {
-    return std::is_same_v<typename T::value_type, std::string>;
+    return std::is_same<typename T::value_type, std::string>::value;
   }
   return false;
 }
@@ -92,7 +98,7 @@ struct is_container_of_strings_impl final {
 
 template <typename T>
 struct is_container_of_strings_impl<true, T> final {
-  constexpr static bool value = std::is_same_v<typename T::value_type, std::string>;
+  constexpr static bool value = std::is_same<typename T::value_type, std::string>::value;
 };
 
 template <typename T>
diff --git a/bricks/strings/split.h b/bricks/strings/split.h
index 67f6df131..22b57132d 100644
--- a/bricks/strings/split.h
+++ b/bricks/strings/split.h
@@ -129,7 +129,7 @@ struct DefaultSeparator<ByLines> {
 }  // namespace impl
 
 template <typename SEPARATOR, typename PROCESSOR>
-inline std::enable_if_t<!std::is_same_v<PROCESSOR, EmptyFields>, size_t> Split(
+inline std::enable_if_t<!std::is_same<PROCESSOR, EmptyFields>::value, size_t> Split(
     const std::string& s,
     SEPARATOR&& separator,
     PROCESSOR&& processor,
@@ -186,7 +186,7 @@ inline size_t Split(char* s,
 
 // `Split(std::string&, ...)` maps to `Split(char*, size_t, ...)`.
 template <typename SEPARATOR, typename PROCESSOR>
-inline std::enable_if_t<!std::is_same_v<PROCESSOR, EmptyFields>, size_t> Split(
+inline std::enable_if_t<!std::is_same<PROCESSOR, EmptyFields>::value, size_t> Split(
     std::string& string,
     SEPARATOR&& separator,
     PROCESSOR&& processor,
@@ -214,7 +214,7 @@ inline size_t Split(char* string,
 }
 
 template <typename SEPARATOR, typename PROCESSOR>
-inline std::enable_if_t<!std::is_same_v<PROCESSOR, EmptyFields>, size_t> Split(
+inline std::enable_if_t<!std::is_same<PROCESSOR, EmptyFields>::value, size_t> Split(
     const char* string,
     SEPARATOR&& separator,
     PROCESSOR&& processor,
@@ -228,7 +228,7 @@ inline std::enable_if_t<!std::is_same_v<PROCESSOR, EmptyFields>, size_t> Split(
 // Special case for `Chunk`: Treat even the `const` Chunk-s as mutable.
 // We assume the users of `Chunk` a) expect performance, and b) know what they are doing.
 template <typename SEPARATOR, typename PROCESSOR>
-inline std::enable_if_t<!std::is_same_v<PROCESSOR, EmptyFields>, size_t> Split(
+inline std::enable_if_t<!std::is_same<PROCESSOR, EmptyFields>::value, size_t> Split(
     const Chunk& chunk,
     SEPARATOR&& separator,
     PROCESSOR&& processor,
@@ -251,7 +251,7 @@ inline size_t Split(STRING&& s, PROCESSOR&& processor, EmptyFields empty_fields_
 
 // The version returning an `std::vector<Chunk>`, which is somewhat performant.
 template <typename SEPARATOR>
-inline std::enable_if_t<impl::IsValidSeparator<SEPARATOR>::value && !std::is_same_v<SEPARATOR, EmptyFields>,
+inline std::enable_if_t<impl::IsValidSeparator<SEPARATOR>::value && !std::is_same<SEPARATOR, EmptyFields>::value,
                         std::vector<Chunk>>
 SplitIntoChunks(Chunk chunk,
                 SEPARATOR&& separator = impl::DefaultSeparator<SEPARATOR>::value(),
@@ -266,7 +266,7 @@ SplitIntoChunks(Chunk chunk,
 }
 
 template <typename SEPARATOR>
-inline std::enable_if_t<impl::IsValidSeparator<SEPARATOR>::value && !std::is_same_v<SEPARATOR, EmptyFields>,
+inline std::enable_if_t<impl::IsValidSeparator<SEPARATOR>::value && !std::is_same<SEPARATOR, EmptyFields>::value,
                         std::vector<Chunk>>
 SplitIntoChunks(char* s,
                 SEPARATOR&& separator = impl::DefaultSeparator<SEPARATOR>::value(),
@@ -275,7 +275,7 @@ SplitIntoChunks(char* s,
 }
 
 template <typename SEPARATOR>
-inline std::enable_if_t<impl::IsValidSeparator<SEPARATOR>::value && !std::is_same_v<SEPARATOR, EmptyFields>,
+inline std::enable_if_t<impl::IsValidSeparator<SEPARATOR>::value && !std::is_same<SEPARATOR, EmptyFields>::value,
                         std::vector<Chunk>>
 SplitIntoChunks(const std::string& s,
                 SEPARATOR&& separator = impl::DefaultSeparator<SEPARATOR>::value(),
@@ -285,7 +285,7 @@ SplitIntoChunks(const std::string& s,
 
 // The versions returning an `std::vector<std::string>`, for those not caring about performance.
 template <typename SEPARATOR, typename STRING>
-inline std::enable_if_t<impl::IsValidSeparator<SEPARATOR>::value && !std::is_same_v<SEPARATOR, EmptyFields>,
+inline std::enable_if_t<impl::IsValidSeparator<SEPARATOR>::value && !std::is_same<SEPARATOR, EmptyFields>::value,
                         std::vector<std::string>>
 Split(STRING&& s,
       SEPARATOR&& separator = impl::DefaultSeparator<SEPARATOR>::value(),
diff --git a/bricks/strings/util.h b/bricks/strings/util.h
index 38bd585df..0cd42d56c 100644
--- a/bricks/strings/util.h
+++ b/bricks/strings/util.h
@@ -69,7 +69,7 @@ constexpr auto HasMemberFromString(int) -> decltype(std::declval<T>().FromString
 // Default implepentation for arithmetic types calling `std::to_string`.
 template <typename DECAYED_T, bool HAS_MEMBER_TO_STRING, bool IS_ENUM>
 struct ToStringImpl {
-  template <bool B = std::is_arithmetic_v<DECAYED_T>>
+  template <bool B = std::is_arithmetic<DECAYED_T>::value>
   static std::enable_if_t<B, std::string> DoIt(DECAYED_T value) {
     return std::to_string(value);
   }
@@ -148,7 +148,7 @@ struct ToStringImpl<strings::Chunk, false, false> {
 template <typename T>
 inline std::string ToString(T&& something) {
   using decayed_t = current::decay_t<T>;
-  return ToStringImpl<decayed_t, sfinae::HasMemberToString<decayed_t>(0), std::is_enum_v<decayed_t>>::DoIt(
+  return ToStringImpl<decayed_t, sfinae::HasMemberToString<decayed_t>(0), std::is_enum<decayed_t>::value>::DoIt(
       std::forward<T>(something));
 }
 
@@ -257,7 +257,7 @@ inline const std::string& FromString(INPUT&& input, std::string& output) {
 
 template <typename OUTPUT, typename INPUT = std::string>
 inline const OUTPUT& FromString(INPUT&& input, OUTPUT& output) {
-  return FromStringImpl<INPUT, OUTPUT, sfinae::HasMemberFromString<OUTPUT>(0), std::is_enum_v<OUTPUT>>::Go(
+  return FromStringImpl<INPUT, OUTPUT, sfinae::HasMemberFromString<OUTPUT>(0), std::is_enum<OUTPUT>::value>::Go(
       std::forward<INPUT>(input), output);
 }
 
diff --git a/bricks/sync/locks.h b/bricks/sync/locks.h
index de7a41492..84f49a22f 100644
--- a/bricks/sync/locks.h
+++ b/bricks/sync/locks.h
@@ -43,8 +43,8 @@ struct NoOpLock {
 template <MutexLockStatus MLS, class MUTEX = std::mutex>
 using SmartMutexLockGuard = std::conditional_t<MLS == MutexLockStatus::NeedToLock, std::lock_guard<MUTEX>, NoOpLock>;
 
-static_assert(std::is_same_v<std::lock_guard<std::mutex>, SmartMutexLockGuard<MutexLockStatus::NeedToLock>>, "");
-static_assert(std::is_same_v<NoOpLock, SmartMutexLockGuard<MutexLockStatus::AlreadyLocked>>, "");
+static_assert(std::is_same<std::lock_guard<std::mutex>, SmartMutexLockGuard<MutexLockStatus::NeedToLock>>::value, "");
+static_assert(std::is_same<NoOpLock, SmartMutexLockGuard<MutexLockStatus::AlreadyLocked>>::value, "");
 
 }  // namespace locks
 }  // namespace current
diff --git a/bricks/sync/owned_borrowed.h b/bricks/sync/owned_borrowed.h
index 0c5efe09a..72a5f85ac 100644
--- a/bricks/sync/owned_borrowed.h
+++ b/bricks/sync/owned_borrowed.h
@@ -317,7 +317,7 @@ struct ConstructOwned {};
 template <typename T>
 class Owned final : private impl::UniqueInstanceContainer<T>, public WeakBorrowed<T> {
  private:
-  static_assert(std::is_same_v<T, decay_t<T>>, "`Owned<>` requires a clean type.");
+  static_assert(std::is_same<T, decay_t<T>>::value, "`Owned<>` requires a clean type.");
 
   using impl_t = impl::UniqueInstanceContainer<T>;
   using base_t = WeakBorrowed<T>;
@@ -365,7 +365,7 @@ class Owned final : private impl::UniqueInstanceContainer<T>, public WeakBorrowe
 template <typename T>
 class BorrowedWithCallback final : public WeakBorrowed<T> {
  private:
-  static_assert(std::is_same_v<T, decay_t<T>>, "`BorrowedWithCallback<>` requires a clean type.");
+  static_assert(std::is_same<T, decay_t<T>>::value, "`BorrowedWithCallback<>` requires a clean type.");
 
   using base_t = WeakBorrowed<T>;
 
@@ -394,7 +394,7 @@ class BorrowedWithCallback final : public WeakBorrowed<T> {
 template <typename T>
 class Borrowed final : public WeakBorrowed<T> {
  private:
-  static_assert(std::is_same_v<T, decay_t<T>>, "`Borrowed<>` requires a clean type.");
+  static_assert(std::is_same<T, decay_t<T>>::value, "`Borrowed<>` requires a clean type.");
 
   using base_t = WeakBorrowed<T>;
 
@@ -433,7 +433,7 @@ inline void BorrowedOfGuaranteedLifetimeInvariantErrorCallback() {
 template <typename T>
 class BorrowedOfGuaranteedLifetime final : public WeakBorrowed<T> {
  private:
-  static_assert(std::is_same_v<T, decay_t<T>>, "`BorrowedOfGuaranteedLifetime<>` requires a clean type.");
+  static_assert(std::is_same<T, decay_t<T>>::value, "`BorrowedOfGuaranteedLifetime<>` requires a clean type.");
 
   using base_t = WeakBorrowed<T>;
 
diff --git a/bricks/sync/waitable_atomic.h b/bricks/sync/waitable_atomic.h
index 3ec060bc4..25fc38708 100644
--- a/bricks/sync/waitable_atomic.h
+++ b/bricks/sync/waitable_atomic.h
@@ -187,9 +187,9 @@ class WaitableAtomic {
     {
       // Only lock the subscribers, no need to lock the data.
       // Friendly reminder that the subscribers are expected to return quickly.
-      std::lock_guard lock(subscribers_mutex_);
-      for (const auto& [_, f] : subscribers_) {
-        f();
+      std::lock_guard<std::mutex> lock(subscribers_mutex_);
+      for (const auto& unused_and_f : subscribers_) {
+        unused_and_f.second();
       }
     }
   }
@@ -208,13 +208,11 @@ class WaitableAtomic {
     return true;
   }
 
-#ifndef CURRENT_FOR_CPP14
-
   // NOTE(dkorolev): Deliberately not bothering with C++14 for this two-lambdas `Wait()`.
   // TODO(dkorolev): The `.Wait()` above always returning `true` could use some TLC.
 
   template <typename F>
-  std::invoke_result_t<F, data_t&> DoWait(std::function<bool(const data_t&)> wait_predicate, F&& retval_predicate) {
+  typename std::result_of<F(data_t&)>::type DoWait(std::function<bool(const data_t&)> wait_predicate, F&& retval_predicate) {
     std::unique_lock<std::mutex> lock(data_mutex_);
     if (!wait_predicate(data_)) {
       const data_t& data = data_;
@@ -225,21 +223,19 @@ class WaitableAtomic {
     }
   }
 
-  template <typename F, class = std::enable_if_t<std::is_same_v<std::invoke_result_t<F, data_t&>, void>>>
+  template <typename F, class = std::enable_if_t<std::is_same<typename std::result_of<F(data_t&)>::type, void>::value>>
   void Wait(std::function<bool(const data_t&)> wait_predicate, F&& retval_predicate) {
     DoWait(wait_predicate, std::forward<F>(retval_predicate));
     Notify();
   }
 
-  template <typename F, class = std::enable_if_t<!std::is_same_v<std::invoke_result_t<F, data_t&>, void>>>
-  std::invoke_result_t<F, data_t&> Wait(std::function<bool(const data_t&)> wait_predicate, F&& retval_predicate) {
-    std::invoke_result_t<F, data_t&> retval = DoWait(wait_predicate, std::forward<F>(retval_predicate));
+  template <typename F, class = std::enable_if_t<!std::is_same<typename std::result_of<F(data_t&)>::type, void>::value>>
+  typename std::result_of<F(data_t&)>::type Wait(std::function<bool(const data_t&)> wait_predicate, F&& retval_predicate) {
+    typename std::result_of<F(data_t&)>::type retval = DoWait(wait_predicate, std::forward<F>(retval_predicate));
     Notify();
     return retval;
   }
 
-#endif  // CURRENT_FOR_CPP14
-
   template <typename T>
   bool WaitFor(std::function<bool(const data_t&)> predicate, T duration) const {
     std::unique_lock<std::mutex> lock(data_mutex_);
@@ -260,14 +256,10 @@ class WaitableAtomic {
     return true;
   }
 
-#ifndef CURRENT_FOR_CPP14
-
-  // NOTE(dkorolev): Deliberately not bothering with C++14 for these three- and four-argument `WaitFor()`-s.
-
   template <typename T, typename F>
-  std::invoke_result_t<F, data_t&> WaitFor(std::function<bool(const data_t&)> predicate,
-                                           F&& retval_predicate,
-                                           T duration) {
+  typename std::result_of<F(data_t&)>::type WaitFor(std::function<bool(const data_t&)> predicate,
+                                                    F&& retval_predicate,
+                                                    T duration) {
     std::unique_lock<std::mutex> lock(data_mutex_);
     if (!predicate(data_)) {
       const data_t& data = data_;
@@ -277,7 +269,7 @@ class WaitableAtomic {
         // The three-argument `WaitFor()` assumes the default constructor for the return type indicates that
         // the wait should continue. Use the four-argument `WaitFor()` to provide a custom retval initializer.
         // The custom retval predicate can also mutate the waited upon object as it sees fit.
-        return std::invoke_result_t<F, data_t&>();
+        return typename std::result_of<F(data_t&)>::type();
       }
     } else {
       return retval_predicate(data_);
@@ -285,10 +277,10 @@ class WaitableAtomic {
   }
 
   template <typename T, typename F, typename G>
-  std::invoke_result_t<F, data_t&> WaitFor(std::function<bool(const data_t&)> predicate,
-                                           F&& retval_predicate,
-                                           G&& wait_unsuccessul_predicate,
-                                           T duration) {
+  typename std::result_of<F(data_t&)>::type WaitFor(std::function<bool(const data_t&)> predicate,
+                                                    F&& retval_predicate,
+                                                    G&& wait_unsuccessul_predicate,
+                                                    T duration) {
     std::unique_lock<std::mutex> lock(data_mutex_);
     if (!predicate(data_)) {
       const data_t& data = data_;
@@ -302,9 +294,6 @@ class WaitableAtomic {
     }
   }
 
-
-#endif  // CURRENT_FOR_CPP14
-
 #ifndef CURRENT_FOR_CPP14
 
   template <typename F, typename... ARGS>
@@ -365,7 +354,7 @@ class WaitableAtomic {
     WaitableAtomicSubscriberRemoverImpl& operator=(WaitableAtomicSubscriberRemoverImpl const&) = delete;
     WaitableAtomicSubscriberRemoverImpl(WaitableAtomic& self, size_t id) : self_(self), id_(id) {}    void Remove() override {
       // Okay to only lock the subscribers map, but not the data.
-      std::lock_guard lock(self_.subscribers_mutex_);
+      std::lock_guard<std::mutex> lock(self_.subscribers_mutex_);
       self_.subscribers_.erase(id_);
     }
   };
@@ -376,8 +365,8 @@ class WaitableAtomic {
     // The order is this way because subscribers are assumed to be locked for a shorter period of time.
     // The assumption is that the clients will not perform slow operations and/or lock anything while notified,
     // but at most schedule some tasks to be executed in their respective threads, thus releasing this lock quickly.
-    std::lock_guard lock_data(data_mutex_);
-    std::lock_guard lock_subscribers(subscribers_mutex_);
+    std::lock_guard<std::mutex> lock_data(data_mutex_);
+    std::lock_guard<std::mutex> lock_subscribers(subscribers_mutex_);
     const size_t id = subscriber_next_id_;
     ++subscriber_next_id_;
     subscribers_[id] = f;
diff --git a/bricks/template/pod.h b/bricks/template/pod.h
index 7b4b5dbd2..38cb58175 100644
--- a/bricks/template/pod.h
+++ b/bricks/template/pod.h
@@ -35,8 +35,8 @@ namespace current {
 template <typename T>
 using copy_free = std::conditional_t<std::is_pod<T>::value, T, const T&>;
 
-static_assert(std::is_same_v<int, copy_free<int>>, "");
-static_assert(std::is_same_v<const std::string&, copy_free<std::string>>, "");
+static_assert(std::is_same<int, copy_free<int>>::value, "");
+static_assert(std::is_same<const std::string&, copy_free<std::string>>::value, "");
 
 }  // namespace current
 
diff --git a/bricks/template/test.cc b/bricks/template/test.cc
index dc8ff7f3f..fccc43bde 100644
--- a/bricks/template/test.cc
+++ b/bricks/template/test.cc
@@ -28,6 +28,9 @@ SOFTWARE.
 #include "is_unique_ptr.h"
 #include "variadic_indexes.h"
 
+template <typename A, typename B>
+constexpr bool is_same_v = std::is_same<A, B>::value;
+
 // The internal test uses `std::tuple<>`, and not a single `TypeList`.
 // The one that goes into the documentation uses `TypeList<>`, and not a single `std::tuple<>`.
 
@@ -140,10 +143,10 @@ TEST(TemplateMetaprogrammingInternalTest, VariadicIndexes) {
   using current::variadic_indexes::generate_indexes;
   using current::variadic_indexes::indexes;
 
-  static_assert(std::is_same_v<indexes<>, generate_indexes<0>>, "");
-  static_assert(std::is_same_v<indexes<0>, generate_indexes<1>>, "");
-  static_assert(std::is_same_v<indexes<0, 1>, generate_indexes<2>>, "");
-  static_assert(std::is_same_v<indexes<0, 1, 2>, generate_indexes<3>>, "");
+  static_assert(is_same_v<indexes<>, generate_indexes<0>>, "");
+  static_assert(is_same_v<indexes<0>, generate_indexes<1>>, "");
+  static_assert(is_same_v<indexes<0, 1>, generate_indexes<2>>, "");
+  static_assert(is_same_v<indexes<0, 1, 2>, generate_indexes<3>>, "");
 }
 
 TEST(TemplateMetaprogrammingInternalTest, OddIndexes) {
@@ -153,12 +156,12 @@ TEST(TemplateMetaprogrammingInternalTest, OddIndexes) {
   struct C {};
   struct D {};
   struct E {};
-  static_assert(std::is_same_v<TypeList<>, EvensOnly<TypeList<>>>, "");
-  static_assert(std::is_same_v<TypeList<A>, EvensOnly<TypeList<A>>>, "");
-  static_assert(std::is_same_v<TypeList<A>, EvensOnly<TypeList<A, B>>>, "");
-  static_assert(std::is_same_v<TypeList<A, C>, EvensOnly<TypeList<A, B, C>>>, "");
-  static_assert(std::is_same_v<TypeList<A, C>, EvensOnly<TypeList<A, B, C, D>>>, "");
-  static_assert(std::is_same_v<TypeList<A, C, E>, EvensOnly<TypeList<A, B, C, D, E>>>, "");
+  static_assert(is_same_v<TypeList<>, EvensOnly<TypeList<>>>, "");
+  static_assert(is_same_v<TypeList<A>, EvensOnly<TypeList<A>>>, "");
+  static_assert(is_same_v<TypeList<A>, EvensOnly<TypeList<A, B>>>, "");
+  static_assert(is_same_v<TypeList<A, C>, EvensOnly<TypeList<A, B, C>>>, "");
+  static_assert(is_same_v<TypeList<A, C>, EvensOnly<TypeList<A, B, C, D>>>, "");
+  static_assert(is_same_v<TypeList<A, C, E>, EvensOnly<TypeList<A, B, C, D, E>>>, "");
 };
 
 TEST(TemplateMetaprogrammingInternalTest, CallIf) {
@@ -283,7 +286,6 @@ TEST(TemplateMetaprogrammingInternalTest, NonemptyConstructorForCombiner) {
 namespace current_decay_t_test {
 
 using current::decay_t;
-using std::is_same_v;
 
 static_assert(is_same_v<int, decay_t<int>>, "");
 static_assert(is_same_v<int, decay_t<int&>>, "");
@@ -359,9 +361,9 @@ namespace current_is_unique_ptr_test {
 using current::is_unique_ptr;
 
 static_assert(!is_unique_ptr<int>::value, "");
-static_assert(std::is_same_v<int, typename is_unique_ptr<int>::underlying_type>, "");
+static_assert(is_same_v<int, typename is_unique_ptr<int>::underlying_type>, "");
 
 static_assert(is_unique_ptr<std::unique_ptr<int>>::value, "");
-static_assert(std::is_same_v<int, typename is_unique_ptr<std::unique_ptr<int>>::underlying_type>, "");
+static_assert(is_same_v<int, typename is_unique_ptr<std::unique_ptr<int>>::underlying_type>, "");
 
 }  // namespace current_is_unique_ptr_test
diff --git a/bricks/template/tuple.h b/bricks/template/tuple.h
index 7ff39e80a..8a7310bd2 100644
--- a/bricks/template/tuple.h
+++ b/bricks/template/tuple.h
@@ -65,10 +65,10 @@ struct wrapped_into_tuple_impl<std::tuple<TS...>> {
 template <typename T>
 using wrapped_into_tuple_t = typename wrapped_into_tuple_impl<T>::tuple_t;
 
-static_assert(std::is_same_v<std::tuple<>, wrapped_into_tuple_t<std::tuple<>>>, "");
-static_assert(std::is_same_v<std::tuple<int>, wrapped_into_tuple_t<int>>, "");
-static_assert(std::is_same_v<std::tuple<int>, wrapped_into_tuple_t<std::tuple<int>>>, "");
-static_assert(std::is_same_v<std::tuple<char, double>, wrapped_into_tuple_t<std::tuple<char, double>>>, "");
+static_assert(std::is_same<std::tuple<>, wrapped_into_tuple_t<std::tuple<>>>::value, "");
+static_assert(std::is_same<std::tuple<int>, wrapped_into_tuple_t<int>>::value, "");
+static_assert(std::is_same<std::tuple<int>, wrapped_into_tuple_t<std::tuple<int>>>::value, "");
+static_assert(std::is_same<std::tuple<char, double>, wrapped_into_tuple_t<std::tuple<char, double>>>::value, "");
 
 template <class LHS, class RHS>
 struct tuple_cat_type_impl;
@@ -81,12 +81,12 @@ struct tuple_cat_type_impl<std::tuple<LHS_TS...>, std::tuple<RHS_TS...>> {
 template <typename LHS, typename RHS>
 using tuple_cat_t = typename tuple_cat_type_impl<wrapped_into_tuple_t<LHS>, wrapped_into_tuple_t<RHS>>::tuple_t;
 
-static_assert(std::is_same_v<std::tuple<char, double>, tuple_cat_t<char, double>>, "");
-static_assert(std::is_same_v<std::tuple<char, double>, tuple_cat_t<std::tuple<char>, double>>, "");
-static_assert(std::is_same_v<std::tuple<char, double>, tuple_cat_t<char, std::tuple<double>>>, "");
-static_assert(std::is_same_v<std::tuple<char, double>, tuple_cat_t<std::tuple<char>, std::tuple<double>>>, "");
-static_assert(std::is_same_v<std::tuple<char, double>, tuple_cat_t<std::tuple<char, double>, std::tuple<>>>, "");
-static_assert(std::is_same_v<std::tuple<char, double>, tuple_cat_t<std::tuple<>, std::tuple<char, double>>>, "");
+static_assert(std::is_same<std::tuple<char, double>, tuple_cat_t<char, double>>::value, "");
+static_assert(std::is_same<std::tuple<char, double>, tuple_cat_t<std::tuple<char>, double>>::value, "");
+static_assert(std::is_same<std::tuple<char, double>, tuple_cat_t<char, std::tuple<double>>>::value, "");
+static_assert(std::is_same<std::tuple<char, double>, tuple_cat_t<std::tuple<char>, std::tuple<double>>>::value, "");
+static_assert(std::is_same<std::tuple<char, double>, tuple_cat_t<std::tuple<char, double>, std::tuple<>>>::value, "");
+static_assert(std::is_same<std::tuple<char, double>, tuple_cat_t<std::tuple<>, std::tuple<char, double>>>::value, "");
 
 }  // namespace metaprogramming
 }  // namespace current
diff --git a/bricks/template/typelist.h b/bricks/template/typelist.h
index 732f8098f..57a7beb9e 100644
--- a/bricks/template/typelist.h
+++ b/bricks/template/typelist.h
@@ -81,7 +81,7 @@ struct TypeListContains;
 template <typename... TS, typename T>
 struct TypeListContains<TypeListImpl<TS...>, T> {
   constexpr static bool value =
-      std::is_base_of_v<DuplicateTypeInTypeList<T>, ConfirmTypeListContainsNoDuplicates<TS...>>;
+      std::is_base_of<DuplicateTypeInTypeList<T>, ConfirmTypeListContainsNoDuplicates<TS...>>::value;
 };
 
 static_assert(!TypeListContains<TypeListImpl<>, int>::value, "");
@@ -134,17 +134,17 @@ struct TypeListCatWrapper<A, X, XS...> {
 template <typename... INPUT_TYPELISTS>
 using TypeListCat = typename TypeListCatWrapper<INPUT_TYPELISTS...>::result;
 
-static_assert(std::is_same_v<TypeListImpl<>, TypeListCat<TypeListImpl<>, TypeListImpl<>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, TypeListCat<TypeListImpl<int>, TypeListImpl<>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, TypeListCat<TypeListImpl<>, TypeListImpl<int>>>, "");
+static_assert(std::is_same<TypeListImpl<>, TypeListCat<TypeListImpl<>, TypeListImpl<>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, TypeListCat<TypeListImpl<int>, TypeListImpl<>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, TypeListCat<TypeListImpl<>, TypeListImpl<int>>>::value, "");
 static_assert(
-    std::is_same_v<TypeListImpl<int, char, double>, TypeListCat<TypeListImpl<int>, TypeListImpl<char, double>>>, "");
+    std::is_same<TypeListImpl<int, char, double>, TypeListCat<TypeListImpl<int>, TypeListImpl<char, double>>>::value, "");
 static_assert(
-    std::is_same_v<TypeListImpl<int, char, double>, TypeListCat<TypeListImpl<int, char>, TypeListImpl<double>>>, "");
-static_assert(std::is_same_v<TypeListImpl<>, TypeListCat<>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, TypeListCat<TypeListImpl<int>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int, char, double>,
-                             TypeListCat<TypeListImpl<int>, TypeListImpl<char>, TypeListImpl<double>>>,
+    std::is_same<TypeListImpl<int, char, double>, TypeListCat<TypeListImpl<int, char>, TypeListImpl<double>>>::value, "");
+static_assert(std::is_same<TypeListImpl<>, TypeListCat<>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, TypeListCat<TypeListImpl<int>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int, char, double>,
+                             TypeListCat<TypeListImpl<int>, TypeListImpl<char>, TypeListImpl<double>>>::value,
               "");
 
 template <typename LHS, typename RHS>
@@ -176,15 +176,15 @@ struct TypeListRemoveVoidsImpl<TypeListImpl<TS...>> {
 template <typename T>
 using TypeListRemoveVoids = typename TypeListRemoveVoidsImpl<T>::type;
 
-static_assert(std::is_same_v<TypeListImpl<>, TypeListRemoveVoids<TypeListImpl<>>>, "");
-static_assert(std::is_same_v<TypeListImpl<>, TypeListRemoveVoids<TypeListImpl<void>>>, "");
-static_assert(std::is_same_v<TypeListImpl<>, TypeListRemoveVoids<TypeListImpl<void, void>>>, "");
-static_assert(std::is_same_v<TypeListImpl<>, TypeListRemoveVoids<TypeListImpl<void, void, void>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, TypeListRemoveVoids<TypeListImpl<void, int>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, TypeListRemoveVoids<TypeListImpl<int, void>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, TypeListRemoveVoids<TypeListImpl<int, void, void>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, TypeListRemoveVoids<TypeListImpl<void, int, void>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, TypeListRemoveVoids<TypeListImpl<void, void, int>>>, "");
+static_assert(std::is_same<TypeListImpl<>, TypeListRemoveVoids<TypeListImpl<>>>::value, "");
+static_assert(std::is_same<TypeListImpl<>, TypeListRemoveVoids<TypeListImpl<void>>>::value, "");
+static_assert(std::is_same<TypeListImpl<>, TypeListRemoveVoids<TypeListImpl<void, void>>>::value, "");
+static_assert(std::is_same<TypeListImpl<>, TypeListRemoveVoids<TypeListImpl<void, void, void>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, TypeListRemoveVoids<TypeListImpl<void, int>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, TypeListRemoveVoids<TypeListImpl<int, void>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, TypeListRemoveVoids<TypeListImpl<int, void, void>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, TypeListRemoveVoids<TypeListImpl<void, int, void>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, TypeListRemoveVoids<TypeListImpl<void, void, int>>>::value, "");
 
 // `TypeListUnion` creates a `TypeList<{types belonging to either LHS.. or RHS...}>`.
 // It's a `TypeListCat` that allows duplicates.
@@ -253,20 +253,20 @@ struct TypeListUnionWrapper<A, X, XS...> {
 template <typename... TYPELISTS>
 using TypeListUnion = typename TypeListUnionWrapper<TYPELISTS...>::result;
 
-static_assert(std::is_same_v<TypeListImpl<>, TypeListUnion<TypeListImpl<>, TypeListImpl<>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, TypeListUnion<TypeListImpl<int>, TypeListImpl<>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, TypeListUnion<TypeListImpl<>, TypeListImpl<int>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, TypeListUnion<TypeListImpl<int>, TypeListImpl<int>>>, "");
+static_assert(std::is_same<TypeListImpl<>, TypeListUnion<TypeListImpl<>, TypeListImpl<>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, TypeListUnion<TypeListImpl<int>, TypeListImpl<>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, TypeListUnion<TypeListImpl<>, TypeListImpl<int>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, TypeListUnion<TypeListImpl<int>, TypeListImpl<int>>>::value, "");
 static_assert(
-    std::is_same_v<TypeListImpl<int, char, double>, TypeListUnion<TypeListImpl<int, char>, TypeListImpl<char, double>>>,
+    std::is_same<TypeListImpl<int, char, double>, TypeListUnion<TypeListImpl<int, char>, TypeListImpl<char, double>>>::value,
     "");
-static_assert(std::is_same_v<TypeListImpl<>, TypeListUnion<>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, TypeListUnion<TypeListImpl<int>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, TypeListUnion<TypeListImpl<int>, TypeListImpl<int>, TypeListImpl<int>>>,
+static_assert(std::is_same<TypeListImpl<>, TypeListUnion<>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, TypeListUnion<TypeListImpl<int>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, TypeListUnion<TypeListImpl<int>, TypeListImpl<int>, TypeListImpl<int>>>::value,
               "");
 static_assert(
-    std::is_same_v<TypeListImpl<int, char>,
-                   TypeListUnion<TypeListImpl<int>, TypeListImpl<char>, TypeListImpl<int>, TypeListImpl<char>>>,
+    std::is_same<TypeListImpl<int, char>,
+                   TypeListUnion<TypeListImpl<int>, TypeListImpl<char>, TypeListImpl<int>, TypeListImpl<char>>>::value,
     "");
 
 // `FlattenImpl<TypeListImpl<LHS...>, TypeListImpl<REST...>>` flattens all the types from `REST...`
@@ -304,13 +304,13 @@ struct FlattenImplExtractor<TypeListImpl<TS...>> {
 template <typename INPUT_TYPELIST>
 using Flatten = typename FlattenImplExtractor<INPUT_TYPELIST>::extracted_flattened;
 
-static_assert(std::is_same_v<TypeListImpl<>, Flatten<TypeListImpl<>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, Flatten<TypeListImpl<int>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, Flatten<TypeListImpl<TypeListImpl<int>>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, Flatten<TypeListImpl<TypeListImpl<TypeListImpl<int>>>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int, double>, Flatten<TypeListImpl<int, double>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int, double>, Flatten<TypeListImpl<TypeListImpl<int>, double>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int, double>, Flatten<TypeListImpl<TypeListImpl<TypeListImpl<int>>, double>>>,
+static_assert(std::is_same<TypeListImpl<>, Flatten<TypeListImpl<>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, Flatten<TypeListImpl<int>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, Flatten<TypeListImpl<TypeListImpl<int>>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, Flatten<TypeListImpl<TypeListImpl<TypeListImpl<int>>>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int, double>, Flatten<TypeListImpl<int, double>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int, double>, Flatten<TypeListImpl<TypeListImpl<int>, double>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int, double>, Flatten<TypeListImpl<TypeListImpl<TypeListImpl<int>>, double>>>::value,
               "");
 
 // Performance alert, @dkorolev @mzhurovich 12/5/2015. Revisited and kept the semantics same. -- D.K. 10/15/2015.
@@ -327,21 +327,21 @@ using SlowTypeList = TypeListUnion<TypeListImpl<>, Flatten<TypeListImpl<TS...>>>
 template <typename... TS>
 using TypeList = TypeListImpl<TS...>;
 
-static_assert(std::is_same_v<TypeListImpl<>, SlowTypeList<>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, SlowTypeList<int>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, SlowTypeList<SlowTypeList<SlowTypeList<int>>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, SlowTypeList<int, int>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, SlowTypeList<int, SlowTypeList<int>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int>, SlowTypeList<int, SlowTypeList<SlowTypeList<int>>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int, double>, SlowTypeList<int, SlowTypeList<SlowTypeList<int>, double>>>,
+static_assert(std::is_same<TypeListImpl<>, SlowTypeList<>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, SlowTypeList<int>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, SlowTypeList<SlowTypeList<SlowTypeList<int>>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, SlowTypeList<int, int>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, SlowTypeList<int, SlowTypeList<int>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int>, SlowTypeList<int, SlowTypeList<SlowTypeList<int>>>>::value, "");
+static_assert(std::is_same<TypeListImpl<int, double>, SlowTypeList<int, SlowTypeList<SlowTypeList<int>, double>>>::value,
               "");
-static_assert(std::is_same_v<TypeListImpl<int, double>, SlowTypeList<int, int, double, double>>, "");
-static_assert(std::is_same_v<TypeListImpl<int, double>, SlowTypeList<int, double, int>>, "");
-static_assert(std::is_same_v<TypeListImpl<int, double>, SlowTypeList<int, double, int, double>>, "");
-static_assert(std::is_same_v<TypeListImpl<int, double>, SlowTypeList<SlowTypeList<int, double, int, double>>>, "");
+static_assert(std::is_same<TypeListImpl<int, double>, SlowTypeList<int, int, double, double>>::value, "");
+static_assert(std::is_same<TypeListImpl<int, double>, SlowTypeList<int, double, int>>::value, "");
+static_assert(std::is_same<TypeListImpl<int, double>, SlowTypeList<int, double, int, double>>::value, "");
+static_assert(std::is_same<TypeListImpl<int, double>, SlowTypeList<SlowTypeList<int, double, int, double>>>::value, "");
 
-static_assert(!std::is_same_v<TypeListImpl<int>, SlowTypeList<double>>, "");
-static_assert(!std::is_same_v<TypeListImpl<int, double>, SlowTypeList<double, int>>, "");
+static_assert(!std::is_same<TypeListImpl<int>, SlowTypeList<double>>::value, "");
+static_assert(!std::is_same<TypeListImpl<int, double>, SlowTypeList<double, int>>::value, "");
 
 template <typename... TS>
 struct IsTypeList {
@@ -436,9 +436,9 @@ namespace metaprogramming {
 template <size_t N, typename TYPE_LIST_IMPL>
 using TypeListElement = typename ::crnt::tle::Q<N, TYPE_LIST_IMPL>::type;
 
-static_assert(std::is_same_v<int, TypeListElement<0, TypeListImpl<int>>>, "");
-static_assert(std::is_same_v<long, TypeListElement<0, TypeListImpl<long, char>>>, "");
-static_assert(std::is_same_v<char, TypeListElement<1, TypeListImpl<long, char>>>, "");
+static_assert(std::is_same<int, TypeListElement<0, TypeListImpl<int>>>::value, "");
+static_assert(std::is_same<long, TypeListElement<0, TypeListImpl<long, char>>>::value, "");
+static_assert(std::is_same<char, TypeListElement<1, TypeListImpl<long, char>>>::value, "");
 
 }  // namespace metaprogramming
 }  // namespace current
diff --git a/bricks/util/comparators.h b/bricks/util/comparators.h
index af7f66bc4..cb2723813 100644
--- a/bricks/util/comparators.h
+++ b/bricks/util/comparators.h
@@ -59,7 +59,7 @@ constexpr auto HasHashMethod(int) -> decltype(std::declval<const T>().Hash(), bo
 
 template <typename T>
 struct GenericHashFunctionSelector {
-  typedef custom_comparator_and_hash_function::GenericHashFunctionImpl<T, HasHashMethod<T>(0), std::is_enum_v<T>> type;
+  typedef custom_comparator_and_hash_function::GenericHashFunctionImpl<T, HasHashMethod<T>(0), std::is_enum<T>::value> type;
 };
 
 }  // namespace custom_comparator_and_hash_function
@@ -117,7 +117,7 @@ struct CurrentComparatorImpl<T, true> {
 }  // namespace custom_comparator_and_hash_function
 
 template <typename T>
-using CurrentComparator = custom_comparator_and_hash_function::CurrentComparatorImpl<T, std::is_enum_v<T>>;
+using CurrentComparator = custom_comparator_and_hash_function::CurrentComparatorImpl<T, std::is_enum<T>::value>;
 
 }  // namespace current
 
diff --git a/bricks/util/test.cc b/bricks/util/test.cc
index 3559b7916..3903fd16e 100644
--- a/bricks/util/test.cc
+++ b/bricks/util/test.cc
@@ -442,6 +442,9 @@ TEST(Util, WaitableTerminateSignalScopedRegisterer) {
   EXPECT_FALSE(signal2);
 }
 
+template <typename A, typename B>
+constexpr bool is_same_v = std::is_same<A, B>::value;
+
 TEST(Util, LazyInstantiation) {
   using current::DelayedInstantiate;
   using current::DelayedInstantiateFromTuple;
@@ -467,9 +470,9 @@ TEST(Util, LazyInstantiation) {
   const auto a_2 = DelayedInstantiate<Foo>(v);             // By value.
   const auto a_3 = DelayedInstantiate<Foo>(std::cref(v));  // By reference.
 
-  static_assert(std::is_same_v<typename decltype(a_1)::lazily_instantiated_t, Foo>, "");
-  static_assert(std::is_same_v<typename decltype(a_2)::lazily_instantiated_t, Foo>, "");
-  static_assert(std::is_same_v<typename decltype(a_3)::lazily_instantiated_t, Foo>, "");
+  static_assert(is_same_v<typename decltype(a_1)::lazily_instantiated_t, Foo>, "");
+  static_assert(is_same_v<typename decltype(a_2)::lazily_instantiated_t, Foo>, "");
+  static_assert(is_same_v<typename decltype(a_3)::lazily_instantiated_t, Foo>, "");
 
   const auto b_1 = DelayedInstantiateFromTuple<Foo>(std::make_tuple(1));
   const auto b_2 = DelayedInstantiateFromTuple<Foo>(std::make_tuple(v));             // By value.
@@ -503,7 +506,7 @@ TEST(Util, LazyInstantiation) {
 
   int q = 0;
   const auto bar_1_q = DelayedInstantiate<Bar>(1, std::ref(q));
-  static_assert(std::is_same_v<typename decltype(bar_1_q)::lazily_instantiated_t, Bar>, "");
+  static_assert(is_same_v<typename decltype(bar_1_q)::lazily_instantiated_t, Bar>, "");
 
   q = 2;
   EXPECT_EQ("1:2", bar_1_q.InstantiateAsSharedPtr()->AsString());
@@ -511,7 +514,7 @@ TEST(Util, LazyInstantiation) {
   EXPECT_EQ("1:3", bar_1_q.InstantiateAsSharedPtr()->AsString());
 
   const auto bar_x_q = DelayedInstantiateWithExtraParameter<Bar, int>(std::cref(q));
-  static_assert(std::is_same_v<typename decltype(bar_x_q)::lazily_instantiated_t, Bar>, "");
+  static_assert(is_same_v<typename decltype(bar_x_q)::lazily_instantiated_t, Bar>, "");
 
   q = 4;
   EXPECT_EQ("100:4", bar_x_q.InstantiateAsSharedPtrWithExtraParameter(100)->AsString());
@@ -525,7 +528,7 @@ TEST(Util, LazyInstantiation) {
   EXPECT_EQ("400:5", bar_x_q.InstantiateAsUniquePtrWithExtraParameter(400)->AsString());
 
   const auto bar_y_q = DelayedInstantiateWithExtraParameterFromTuple<Bar, int>(std::make_tuple(std::cref(q)));
-  static_assert(std::is_same_v<typename decltype(bar_y_q)::lazily_instantiated_t, Bar>, "");
+  static_assert(is_same_v<typename decltype(bar_y_q)::lazily_instantiated_t, Bar>, "");
 
   q = 6;
   EXPECT_EQ("100:6", bar_y_q.InstantiateAsSharedPtrWithExtraParameter(100)->AsString());
diff --git a/examples/streamed_sockets/latencytest/blob.h b/examples/streamed_sockets/latencytest/blob.h
index 69dc20d81..23bd56ec2 100644
--- a/examples/streamed_sockets/latencytest/blob.h
+++ b/examples/streamed_sockets/latencytest/blob.h
@@ -28,7 +28,9 @@ SOFTWARE.
 #include <cstddef>
 #include <cstdint>
 
-namespace current::examples::streamed_sockets {
+namespace current {
+namespace examples {
+namespace streamed_sockets {
 
 struct Blob {
   uint64_t index;
@@ -49,5 +51,7 @@ constexpr static uint64_t request_origin_latencytest = 0xaaffffffff;
 // clang-format on
 
 }  // namespace current::examples::streamed_sockets
+}  // namespace current::examples
+}  // namespace current
 
 #endif  // EXAMPLES_STREAMED_SOCKETS_LATENCYTEST_BLOB_H
diff --git a/examples/streamed_sockets/latencytest/dsl/dsl.h b/examples/streamed_sockets/latencytest/dsl/dsl.h
index fdc62855a..ab452067e 100644
--- a/examples/streamed_sockets/latencytest/dsl/dsl.h
+++ b/examples/streamed_sockets/latencytest/dsl/dsl.h
@@ -46,7 +46,9 @@ SOFTWARE.
 #include "../../../../bricks/template/typelist.h"
 #include "../../../../bricks/util/lazy_instantiation.h"
 
-namespace current::examples::streamed_sockets {
+namespace current {
+namespace examples {
+namespace streamed_sockets {
 
 enum class SourceOrWorker : bool { Source = true, Worker = false };
 
@@ -77,7 +79,7 @@ class BlockSourceOrWorker final {
   BlockSourceOrWorker() { impl_ = std::make_shared<Impl>(); }
 
   // NOTE(dkorolev): This ugliness is essential, otherwise this constructor is chosed instead of the copy/move ones. :-(
-  template <typename X, typename... XS, class = std::enable_if_t<!std::is_same_v<std::decay_t<X>, BlockSourceOrWorker>>>
+  template <typename X, typename... XS, class = std::enable_if_t<!std::is_same<std::decay_t<X>, BlockSourceOrWorker>::value>>
   BlockSourceOrWorker(X&& arg, XS&&... args) {
     impl_ = std::make_shared<Impl>(std::forward<X>(arg), std::forward<XS>(args)...);
   }
@@ -869,5 +871,7 @@ struct PipelineRunner<PipelineImpl<SOURCE, WORKERS_AS_TUPLE>> final {
 };
 
 }  // namespace current::examples::streamed_sockets
+}  // namespace current::examples
+}  // namespace current
 
 #endif  // EXAMPLES_STREAMED_SOCKETS_LATENCYTEST_DSL_DSL_H
diff --git a/examples/streamed_sockets/latencytest/dsl/test.cc b/examples/streamed_sockets/latencytest/dsl/test.cc
index 61b3e0a4a..fcb72332f 100644
--- a/examples/streamed_sockets/latencytest/dsl/test.cc
+++ b/examples/streamed_sockets/latencytest/dsl/test.cc
@@ -33,13 +33,17 @@ SOFTWARE.
 
 #ifndef CURRENT_FOR_CPP14  // NOTE(dkorolev): Excluding this part from the C++14 version of Current.
 
-namespace current::examples::streamed_sockets {
+namespace current {
+namespace examples {
+namespace streamed_sockets {
 struct SourceA {};
 struct SourceB {};
 struct WorkerX {};
 struct WorkerY {};
 struct WorkerZ {};
 }  // namespace current::examples::streamed_sockets
+}  // namespace current::examples
+}  // namespace current
 
 TEST(NextRipcurrent, SequentialProcessingTypes) {
   using namespace current::examples::streamed_sockets;
@@ -427,7 +431,9 @@ TEST(NextRipcurrent, ParallelProcessingTypes) {
   }
 }
 
-namespace current::examples::streamed_sockets {
+namespace current {
+namespace examples {
+namespace streamed_sockets {
 
 struct TestBlob final {
   uint64_t x[4];
@@ -640,6 +646,8 @@ void RunProcessingTest(std::array<uint64_t, 4>& init,
 }
 
 }  // namespace current::examples::streamed_sockets
+}  // namespace current::examples
+}  // namespace current
 
 TEST(NextRipcurrent, SequentialProcessing) {
   using namespace current::examples::streamed_sockets;
diff --git a/examples/streamed_sockets/latencytest/workers/indexer.h b/examples/streamed_sockets/latencytest/workers/indexer.h
index a3642abd7..7d02d5da5 100644
--- a/examples/streamed_sockets/latencytest/workers/indexer.h
+++ b/examples/streamed_sockets/latencytest/workers/indexer.h
@@ -27,7 +27,9 @@ SOFTWARE.
 
 #include "../blob.h"
 
-namespace current::examples::streamed_sockets {
+namespace current {
+namespace examples {
+namespace streamed_sockets {
 
 struct IndexingWorker final {
   uint64_t total_index = 0u;
@@ -46,5 +48,7 @@ struct IndexingWorker final {
 };
 
 }  // namespace current::examples::streamed_sockets
+}  // namespace current::examples
+}  // namespace current
 
 #endif  // EXAMPLES_STREAMED_SOCKETS_LATENCYTEST_WORKERS_INDEXER_H
diff --git a/examples/streamed_sockets/latencytest/workers/processor.h b/examples/streamed_sockets/latencytest/workers/processor.h
index 627864cb7..7a6b96420 100644
--- a/examples/streamed_sockets/latencytest/workers/processor.h
+++ b/examples/streamed_sockets/latencytest/workers/processor.h
@@ -33,7 +33,9 @@ SOFTWARE.
 #include "../../../../bricks/net/tcp/tcp.h"
 #include "../../../../bricks/time/chrono.h"
 
-namespace current::examples::streamed_sockets {
+namespace current {
+namespace examples {
+namespace streamed_sockets {
 
 struct ProcessingWorker final {
   struct ProcessingWorkedImpl {
@@ -76,5 +78,7 @@ struct ProcessingWorker final {
 };
 
 }  // namespace current::examples::streamed_sockets
+}  // namespace current::examples
+}  // namespace current
 
 #endif  // EXAMPLES_STREAMED_SOCKETS_LATENCYTEST_WORKERS_PROCESSOR_H
diff --git a/examples/streamed_sockets/latencytest/workers/receiver.h b/examples/streamed_sockets/latencytest/workers/receiver.h
index a153e1b9e..0fb780323 100644
--- a/examples/streamed_sockets/latencytest/workers/receiver.h
+++ b/examples/streamed_sockets/latencytest/workers/receiver.h
@@ -30,7 +30,9 @@ SOFTWARE.
 #include "../../../../bricks/net/tcp/tcp.h"
 #include "../../../../bricks/time/chrono.h"
 
-namespace current::examples::streamed_sockets {
+namespace current {
+namespace examples {
+namespace streamed_sockets {
 
 struct ReceivingWorker final {
   struct ReceivingWorkerImpl {
@@ -58,5 +60,7 @@ struct ReceivingWorker final {
 };
 
 }  // namespace current::examples::streamed_sockets
+}  // namespace current::examples
+}  // namespace current
 
 #endif  // EXAMPLES_STREAMED_SOCKETS_LATENCYTEST_WORKERS_RECEIVER_H
diff --git a/examples/streamed_sockets/latencytest/workers/saver.h b/examples/streamed_sockets/latencytest/workers/saver.h
index 1d8052f5c..4c8807d34 100644
--- a/examples/streamed_sockets/latencytest/workers/saver.h
+++ b/examples/streamed_sockets/latencytest/workers/saver.h
@@ -37,7 +37,9 @@ SOFTWARE.
 #include "../../../../bricks/strings/printf.h"
 #include "../../../../bricks/time/chrono.h"
 
-namespace current::examples::streamed_sockets {
+namespace current {
+namespace examples {
+namespace streamed_sockets {
 
 struct SavingWorker final {
   const std::string dirname;
@@ -123,5 +125,7 @@ struct SavingWorker final {
 };
 
 }  // namespace current::examples::streamed_sockets
+}  // namespace current::examples
+}  // namespace current
 
 #endif  // EXAMPLES_STREAMED_SOCKETS_LATENCYTEST_WORKERS_SAVER_H
diff --git a/examples/streamed_sockets/latencytest/workers/sender.h b/examples/streamed_sockets/latencytest/workers/sender.h
index 1f6d794c1..a6c307503 100644
--- a/examples/streamed_sockets/latencytest/workers/sender.h
+++ b/examples/streamed_sockets/latencytest/workers/sender.h
@@ -30,7 +30,9 @@ SOFTWARE.
 #include "../../../../bricks/net/tcp/tcp.h"
 #include "../../../../bricks/time/chrono.h"
 
-namespace current::examples::streamed_sockets {
+namespace current {
+namespace examples {
+namespace streamed_sockets {
 
 struct SendingWorker final {
   struct SendingWorkedImpl {
@@ -61,5 +63,7 @@ struct SendingWorker final {
 };
 
 }  // namespace current::examples::streamed_sockets
+}  // namespace current::examples
+}  // namespace current
 
 #endif  // EXAMPLES_STREAMED_SOCKETS_LATENCYTEST_WORKERS_SENDER_H
diff --git a/fncas/fncas/mathutil.h b/fncas/fncas/mathutil.h
index 0285a74c7..19eb1ffb0 100644
--- a/fncas/fncas/mathutil.h
+++ b/fncas/fncas/mathutil.h
@@ -53,7 +53,7 @@ inline bool IsNormal(double_t arg) { return (std::isnormal(arg) || arg == 0.0);
 namespace impl {
 
 template <typename T>
-std::enable_if_t<std::is_arithmetic_v<T>, std::vector<T>> SumVectors(std::vector<T> a, const std::vector<T>& b) {
+std::enable_if_t<std::is_arithmetic<T>::value, std::vector<T>> SumVectors(std::vector<T> a, const std::vector<T>& b) {
 #ifndef NDEBUG
   CURRENT_ASSERT(a.size() == b.size());
 #endif
@@ -68,7 +68,7 @@ std::enable_if_t<std::is_arithmetic_v<T>, std::vector<T>> SumVectors(std::vector
 }
 
 template <typename T>
-std::enable_if_t<std::is_arithmetic_v<T>, std::vector<T>> SumVectors(std::vector<T> a,
+std::enable_if_t<std::is_arithmetic<T>::value, std::vector<T>> SumVectors(std::vector<T> a,
                                                                      const std::vector<T>& b,
                                                                      double_t kb) {
 #ifndef NDEBUG
@@ -85,10 +85,10 @@ std::enable_if_t<std::is_arithmetic_v<T>, std::vector<T>> SumVectors(std::vector
 }
 
 template <typename T>
-std::enable_if_t<std::is_arithmetic_v<T>, std::vector<T>> SumVectors(std::vector<T> a,
-                                                                     const std::vector<T>& b,
-                                                                     double_t ka,
-                                                                     double_t kb) {
+std::enable_if_t<std::is_arithmetic<T>::value, std::vector<T>> SumVectors(std::vector<T> a,
+                                                                          const std::vector<T>& b,
+                                                                          double_t ka,
+                                                                          double_t kb) {
 #ifndef NDEBUG
   CURRENT_ASSERT(a.size() == b.size());
 #endif
@@ -103,7 +103,7 @@ std::enable_if_t<std::is_arithmetic_v<T>, std::vector<T>> SumVectors(std::vector
 }
 
 template <typename T>
-std::enable_if_t<std::is_arithmetic_v<T>, T> DotProduct(const std::vector<T>& v1, const std::vector<T>& v2) {
+std::enable_if_t<std::is_arithmetic<T>::value, T> DotProduct(const std::vector<T>& v1, const std::vector<T>& v2) {
 #ifndef NDEBUG
   CURRENT_ASSERT(v1.size() == v2.size());
 #endif
@@ -111,12 +111,12 @@ std::enable_if_t<std::is_arithmetic_v<T>, T> DotProduct(const std::vector<T>& v1
 }
 
 template <typename T>
-std::enable_if_t<std::is_arithmetic_v<T>, T> L2Norm(const std::vector<T>& v) {
+std::enable_if_t<std::is_arithmetic<T>::value, T> L2Norm(const std::vector<T>& v) {
   return DotProduct(v, v);
 }
 
 template <typename T>
-std::enable_if_t<std::is_arithmetic_v<T>> FlipSign(std::vector<T>& v) {
+std::enable_if_t<std::is_arithmetic<T>::value> FlipSign(std::vector<T>& v) {
   std::transform(std::begin(v), std::end(v), std::begin(v), std::negate<T>());
 }
 
diff --git a/fncas/fncas/node.h b/fncas/fncas/node.h
index 95a6f1aa6..73e712008 100644
--- a/fncas/fncas/node.h
+++ b/fncas/fncas/node.h
@@ -336,7 +336,7 @@ struct GenericV : node_index_allocator {
   // Template is used here as a form of forward declaration.
   template <typename TX>
   GenericV differentiate(const TX& x_ref, size_t variable_index) const {
-    static_assert(std::is_same_v<TX, X>, "V::differentiate(const x& x, size_t variable_index);");
+    static_assert(std::is_same<TX, X>::value, "V::differentiate(const x& x, size_t variable_index);");
     // Note: This method will not build unless `fncas_differentiate.h` is included.
     return node_differentiate_impl<TX>::differentiate(x_ref, index_, variable_index);
   }
@@ -484,7 +484,7 @@ struct f_impl<JIT::Blueprint> final : f_super {
   // Template is used here as a form of forward declaration.
   template <typename TX>
   V differentiate(const TX& x_ref, size_t variable_index) const {
-    static_assert(std::is_same_v<TX, X>, "f_impl<JIT::Blueprint>::differentiate(const x& x, size_t variable_index);");
+    static_assert(std::is_same<TX, X>::value, "f_impl<JIT::Blueprint>::differentiate(const x& x, size_t variable_index);");
     CURRENT_ASSERT(&x_ref == internals_singleton().x_ptr_);
     CURRENT_ASSERT(variable_index >= 0);
     CURRENT_ASSERT(variable_index < dim());
diff --git a/fncas/fncas/optimize.h b/fncas/fncas/optimize.h
index 6b4a609b7..3f260aa14 100644
--- a/fncas/fncas/optimize.h
+++ b/fncas/fncas/optimize.h
@@ -164,14 +164,14 @@ class OptimizerParameters {
 
   template <typename T>
   OptimizerParameters& SetValue(std::string name, T value) {
-    static_assert(std::is_arithmetic_v<T>, "Value must be numeric");
+    static_assert(std::is_arithmetic<T>::value, "Value must be numeric");
     params_[name] = value;
     return *this;
   }
 
   template <typename T>
   const T GetValue(std::string name, T default_value) const {
-    static_assert(std::is_arithmetic_v<T>, "Value must be numeric");
+    static_assert(std::is_arithmetic<T>::value, "Value must be numeric");
     if (params_.count(name)) {
       return static_cast<T>(params_.at(name));
     } else {
@@ -228,7 +228,7 @@ class Optimizer : impl::noncopyable {
   Optimizer(const OptimizerParameters& parameters, F& f) : f_reference_(f), parameters_(parameters) {}
 
   template <typename ARG,
-            class = std::enable_if_t<!std::is_same_v<current::decay_t<ARG>, OptimizerParameters>>,
+            class = std::enable_if_t<!std::is_same<current::decay_t<ARG>, OptimizerParameters>::value>,
             typename... ARGS>
   Optimizer(ARG&& arg, ARGS&&... args)
       : f_instance_(std::make_unique<F>(std::forward<ARG>(arg), std::forward<ARGS>(args)...)),
diff --git a/fncas/test.cc b/fncas/test.cc
index 51f2c23b9..be2c92c0f 100644
--- a/fncas/test.cc
+++ b/fncas/test.cc
@@ -68,7 +68,7 @@ static_assert(std::is_same<fncas::term_vector_t, std::vector<fncas::term_t>>::va
 
 // And the `fncas::impl::X` type is the lifetime of the function to thread-locally analyze.
 // It's derived from the now-custom `std::vector<fncas::term_t>`.
-static_assert(std::is_base_of_v<fncas::term_vector_t, fncas::variables_vector_t>, "");
+static_assert(std::is_base_of<fncas::term_vector_t, fncas::variables_vector_t>::value, "");
 
 TEST(FnCAS, ReallyNativeComputationJustToBeSure) {
   EXPECT_EQ(25, SimpleFunction(std::vector<fncas::double_t>({1, 2})));
diff --git a/karl/karl.h b/karl/karl.h
index c48e313df..258a1f44e 100644
--- a/karl/karl.h
+++ b/karl/karl.h
@@ -226,7 +226,7 @@ class GenericKarl final : private KarlStorage<STORAGE_TYPE>,
   using karl_notifiable_t = IKarlNotifiable<runtime_status_variant_t>;
   using fleet_view_renderer_t = IKarlFleetViewRenderer<runtime_status_variant_t>;
 
-  template <class S = STORAGE_TYPE, class = std::enable_if_t<std::is_same_v<S, UseOwnStorage>>>
+  template <class S = STORAGE_TYPE, class = std::enable_if_t<std::is_same<S, UseOwnStorage>::value>>
   explicit GenericKarl(const KarlParameters& parameters)
       : GenericKarl(parameters.storage_persistence_file, parameters, *this, *this, PrivateConstructorSelector()) {}
   GenericKarl(const KarlParameters& parameters, karl_notifiable_t& notifiable)
@@ -237,7 +237,7 @@ class GenericKarl final : private KarlStorage<STORAGE_TYPE>,
       : GenericKarl(
             parameters.storage_persistence_file, parameters, notifiable, renderer, PrivateConstructorSelector()) {}
 
-  template <class S = STORAGE_TYPE, class = std::enable_if_t<!std::is_same_v<S, UseOwnStorage>>>
+  template <class S = STORAGE_TYPE, class = std::enable_if_t<!std::is_same<S, UseOwnStorage>::value>>
   GenericKarl(Borrowed<STORAGE_TYPE> storage, const KarlParameters& parameters)
       : GenericKarl(storage, parameters, *this, *this, PrivateConstructorSelector()) {}
   GenericKarl(Borrowed<STORAGE_TYPE> storage, const KarlParameters& parameters, karl_notifiable_t& notifiable)
diff --git a/nlp/nlp.h b/nlp/nlp.h
index 364d0a1df..bbdf3fc27 100644
--- a/nlp/nlp.h
+++ b/nlp/nlp.h
@@ -153,7 +153,7 @@ struct OrImplWithVariant {
 
 template <typename ANNOTATED_QUERY_TERM, class LHS_IMPL, class RHS_IMPL, typename TYPE>
 struct OrImplSameType {
-  static_assert(!std::is_same_v<TYPE, Unit>, "");
+  static_assert(!std::is_same<TYPE, Unit>::value, "");
   using annotated_query_term_t = ANNOTATED_QUERY_TERM;
   using emitted_t = TYPE;
   const LHS_IMPL& lhs_impl_;
@@ -297,8 +297,8 @@ struct SeqImpl;
 
 template <typename ANNOTATED_QUERY_TERM, class LHS_IMPL, class RHS_IMPL, typename LHS_TYPE, typename RHS_TYPE>
 struct SeqImpl<L2R, ANNOTATED_QUERY_TERM, LHS_IMPL, RHS_IMPL, LHS_TYPE, RHS_TYPE> {
-  static_assert(!std::is_same_v<LHS_TYPE, Unit>, "");
-  static_assert(!std::is_same_v<RHS_TYPE, Unit>, "");
+  static_assert(!std::is_same<LHS_TYPE, Unit>::value, "");
+  static_assert(!std::is_same<RHS_TYPE, Unit>::value, "");
   using annotated_query_term_t = ANNOTATED_QUERY_TERM;
   using emitted_t = current::metaprogramming::tuple_cat_t<LHS_TYPE, RHS_TYPE>;
   const LHS_IMPL& lhs_impl_;
@@ -321,8 +321,8 @@ struct SeqImpl<L2R, ANNOTATED_QUERY_TERM, LHS_IMPL, RHS_IMPL, LHS_TYPE, RHS_TYPE
 
 template <typename ANNOTATED_QUERY_TERM, class LHS_IMPL, class RHS_IMPL, typename LHS_TYPE, typename RHS_TYPE>
 struct SeqImpl<R2L, ANNOTATED_QUERY_TERM, LHS_IMPL, RHS_IMPL, LHS_TYPE, RHS_TYPE> {
-  static_assert(!std::is_same_v<LHS_TYPE, Unit>, "");
-  static_assert(!std::is_same_v<RHS_TYPE, Unit>, "");
+  static_assert(!std::is_same<LHS_TYPE, Unit>::value, "");
+  static_assert(!std::is_same<RHS_TYPE, Unit>::value, "");
   using annotated_query_term_t = ANNOTATED_QUERY_TERM;
   using emitted_t = current::metaprogramming::tuple_cat_t<LHS_TYPE, RHS_TYPE>;
   const LHS_IMPL& lhs_impl_;
@@ -345,7 +345,7 @@ struct SeqImpl<R2L, ANNOTATED_QUERY_TERM, LHS_IMPL, RHS_IMPL, LHS_TYPE, RHS_TYPE
 
 template <typename ANNOTATED_QUERY_TERM, class LHS_IMPL, class RHS_IMPL, typename LHS_TYPE>
 struct SeqImplUnitInRHS {
-  static_assert(!std::is_same_v<LHS_TYPE, Unit>, "");
+  static_assert(!std::is_same<LHS_TYPE, Unit>::value, "");
   using annotated_query_term_t = ANNOTATED_QUERY_TERM;
   using emitted_t = LHS_TYPE;
   const LHS_IMPL& lhs_impl_;
@@ -367,7 +367,7 @@ struct SeqImplUnitInRHS {
 
 template <typename ANNOTATED_QUERY_TERM, class LHS_IMPL, class RHS_IMPL, typename RHS_TYPE>
 struct SeqImplUnitInLHS {
-  static_assert(!std::is_same_v<RHS_TYPE, Unit>, "");
+  static_assert(!std::is_same<RHS_TYPE, Unit>::value, "");
   using annotated_query_term_t = ANNOTATED_QUERY_TERM;
   using emitted_t = RHS_TYPE;
   const LHS_IMPL& lhs_impl_;
diff --git a/nlp/test.cc b/nlp/test.cc
index 67df39aaf..c6a83fd25 100644
--- a/nlp/test.cc
+++ b/nlp/test.cc
@@ -548,6 +548,9 @@ NLPSchema(VariantTypes, MultidimensionalAnnotation) {
   DictionaryAnnotation(c);
 }
 
+template <typename A, typename B>
+constexpr bool is_same_v = std::is_same<A, B>::value;
+
 TEST(NLP, VariantTypes) {
   UseNLPSchema(VariantTypes);
 
@@ -559,107 +562,107 @@ TEST(NLP, VariantTypes) {
   {
     auto r = JustMatchQuery(a | b, "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<A, B>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<A, B>>>, "");
   }
 
   {
     auto r = JustMatchQuery((a | b) | c, "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
   }
 
   {
     auto r = JustMatchQuery(a | (b | c), "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
   }
 
   {
     auto r = JustMatchQuery(a | b | c, "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
   }
 
   {
     auto r = JustMatchQuery((a | b) | a, "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<A, B>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<A, B>>>, "");
   }
 
   {
     auto r = JustMatchQuery((a | b) | b, "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<A, B>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<A, B>>>, "");
   }
 
   {
     auto r = JustMatchQuery(a | (a | b), "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<A, B>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<A, B>>>, "");
   }
 
   {
     auto r = JustMatchQuery(b | (a | b), "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<B, A>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<B, A>>>, "");
   }
 
   {
     auto r = JustMatchQuery(c | (a | b), "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<C, A, B>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<C, A, B>>>, "");
   }
 
   {
     auto r = JustMatchQuery((a | b) | c, "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
   }
 
   {
     auto r = JustMatchQuery((a | b) | (b | a), "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<A, B>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<A, B>>>, "");
   }
 
   {
     auto r = JustMatchQuery((a | b) | (a | c), "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
   }
 
   {
     auto r = JustMatchQuery((a | b) | (b | c), "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
   }
 
   {
     auto r = JustMatchQuery((a | b) | (c | b), "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<Variant<A, B, C>>>, "");
   }
 
   {
     auto r = JustMatchQuery(a & b, "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<std::tuple<A, B>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<std::tuple<A, B>>>, "");
   }
 
   {
     auto r = JustMatchQuery(a & b & c, "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<std::tuple<A, B, C>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<std::tuple<A, B, C>>>, "");
   }
   {
     auto r = JustMatchQuery(a & (b & c), "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<std::tuple<A, B, C>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<std::tuple<A, B, C>>>, "");
   }
   {
     auto r = JustMatchQuery((a & b) & (b & c), "");
     EXPECT_FALSE(Exists(r));
-    static_assert(std::is_same_v<decltype(r), Optional<std::tuple<A, B, B, C>>>, "");
+    static_assert(is_same_v<decltype(r), Optional<std::tuple<A, B, B, C>>>, "");
   }
 }
 
diff --git a/port.h b/port.h
index 04c4378aa..22ca3e566 100644
--- a/port.h
+++ b/port.h
@@ -58,38 +58,6 @@ SOFTWARE.
 #include <memory>       // For `std::unique_ptr`.
 #include <type_traits>  // For `std::is_same_v`
 
-#ifdef CURRENT_FOR_CPP14
-namespace current_injected_cpp17 {
-
-template <class T, class U>
-constexpr bool is_same_v = ::std::is_same<T, U>::value;
-
-template <class B, class D>
-constexpr bool is_base_of_v = ::std::is_base_of<B, D>::value;
-
-template <class T>
-constexpr bool is_enum_v = ::std::is_enum<T>::value;
-
-template <class T>
-constexpr bool is_arithmetic_v = ::std::is_arithmetic<T>::value;
-
-template <class T, class... TS>
-constexpr bool is_constructible_v = ::std::is_constructible<T, TS...>::value;
-
-template <typename... TS>
-struct make_void {
-  typedef void type;
-};
-template <typename... TS>
-using void_t = typename make_void<TS...>::type;
-
-}  // namespace current_injected_cpp17
-
-namespace std {
-using namespace current_injected_cpp17;
-}
-#endif  // CURRENT_FOR_CPP14
-
 // TODO(dkorolev): @deathbaba mentioned this `#define` helps with some issues on Mac,
 // I have not enconutered those yet. Uncomment once we confirm them. -- D.K.
 // #define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
@@ -244,7 +212,7 @@ static_assert(sizeof(double) == 8u, "Only 64-bit `double` is supported.");
 // Usage: static_assert(sizeof(is_same_or_compile_error<A, B>), "");
 template <typename T1, typename T2>
 struct is_same_or_compile_error {
-  enum { value = std::is_same_v<T1, T2> };
+  enum { value = std::is_same<T1, T2>::value };
   char is_same_static_assert_failed[value ? 1 : -1];
 };
 #define CURRENT_FAIL_IF_NOT_SAME_TYPE(A, B) static_assert(sizeof(is_same_or_compile_error<A, B>), "")
diff --git a/regression_tests/typesystem/test.sh b/regression_tests/typesystem/test.sh
index d9ef9d4d8..1e10ff0bb 100755
--- a/regression_tests/typesystem/test.sh
+++ b/regression_tests/typesystem/test.sh
@@ -19,7 +19,7 @@ TEST_LIST=(
 )
 
 CPLUSPLUS=${CPLUSPLUS:-g++}
-CPPFLAGS=${CPPFLAGS:- -std=c++17 -ftemplate-backtrace-limit=0  -ftemplate-depth=10000}
+CPPFLAGS=${CPPFLAGS:- -DCURRENT_FOR_CPP14 -ftemplate-backtrace-limit=0  -ftemplate-depth=10000}
 OS=$(uname)
 if [[ ""$OS != "Darwin" ]]; then
 	LDFLAGS=${LDFLAGS:- -pthread}
diff --git a/ripcurrent/ripcurrent.h b/ripcurrent/ripcurrent.h
index ab608671e..862fe02af 100644
--- a/ripcurrent/ripcurrent.h
+++ b/ripcurrent/ripcurrent.h
@@ -584,7 +584,7 @@ template <typename... LHS_TYPES, typename... RHS_TYPES, typename USER_CLASS>
 class UserCodeInstantiator<LHSTypes<LHS_TYPES...>, RHSTypes<RHS_TYPES...>, USER_CLASS>
     : public AbstractCurrent<LHSTypes<LHS_TYPES...>, RHSTypes<RHS_TYPES...>> {
  public:
-  static_assert(std::is_base_of_v<UserCodeBase<LHSTypes<LHS_TYPES...>, RHSTypes<RHS_TYPES...>>, USER_CLASS>,
+  static_assert(std::is_base_of<UserCodeBase<LHSTypes<LHS_TYPES...>, RHSTypes<RHS_TYPES...>>, USER_CLASS>::value,
                 "User class for RipCurrent data processor should use `RIPCURRENT_NODE()` + `RIPCURRENT_MACRO()`.");
 
   using instantiator_input_t = LHSTypes<LHS_TYPES...>;
diff --git a/ripcurrent/test.cc b/ripcurrent/test.cc
index 3238ac385..2d161be48 100644
--- a/ripcurrent/test.cc
+++ b/ripcurrent/test.cc
@@ -44,6 +44,9 @@ SOFTWARE.
 // clang-format off
 namespace ripcurrent_unittest {
 
+template <typename A, typename B>
+constexpr bool is_same_v = std::is_same<A, B>::value;
+
 struct LifeUniverseAndEverything {};
 
 CURRENT_STRUCT(Integer) {
@@ -263,8 +266,8 @@ TEST(RipCurrent, MoreTypeSystemGuarantees) {
   using namespace ripcurrent_unittest;
 
   EXPECT_EQ("RCEmit", RCEmit::UnitTestClassName());
-  static_assert(std::is_same_v<RCEmit::input_t, current::ripcurrent::LHSTypes<>>, "");
-  static_assert(std::is_same_v<RCEmit::output_t, current::ripcurrent::RHSTypes<Integer>>, "");
+  static_assert(is_same_v<RCEmit::input_t, current::ripcurrent::LHSTypes<>>, "");
+  static_assert(is_same_v<RCEmit::output_t, current::ripcurrent::RHSTypes<Integer>>, "");
 
   EXPECT_EQ("RCEmit", RIPCURRENT_UNDERLYING_TYPE(RCEmit())::UnitTestClassName());
 
@@ -272,8 +275,8 @@ TEST(RipCurrent, MoreTypeSystemGuarantees) {
   EXPECT_EQ("RCEmit", RIPCURRENT_UNDERLYING_TYPE(emit)::UnitTestClassName());
 
   EXPECT_EQ("RCMult", RCMult::UnitTestClassName());
-  static_assert(std::is_same_v<RCMult::input_t, current::ripcurrent::LHSTypes<Integer>>, "");
-  static_assert(std::is_same_v<RCMult::output_t, current::ripcurrent::RHSTypes<Integer>>, "");
+  static_assert(is_same_v<RCMult::input_t, current::ripcurrent::LHSTypes<Integer>>, "");
+  static_assert(is_same_v<RCMult::output_t, current::ripcurrent::RHSTypes<Integer>>, "");
 
   EXPECT_EQ("RCMult", RIPCURRENT_UNDERLYING_TYPE(RCMult())::UnitTestClassName());
 
@@ -281,8 +284,8 @@ TEST(RipCurrent, MoreTypeSystemGuarantees) {
   EXPECT_EQ("RCMult", RIPCURRENT_UNDERLYING_TYPE(mult)::UnitTestClassName());
 
   EXPECT_EQ("RCDump", RCDump::UnitTestClassName());
-  static_assert(std::is_same_v<RCDump::input_t, current::ripcurrent::LHSTypes<Integer>>, "");
-  static_assert(std::is_same_v<RCDump::output_t, current::ripcurrent::RHSTypes<>>, "");
+  static_assert(is_same_v<RCDump::input_t, current::ripcurrent::LHSTypes<Integer>>, "");
+  static_assert(is_same_v<RCDump::output_t, current::ripcurrent::RHSTypes<>>, "");
 
   EXPECT_EQ("RCDump", RIPCURRENT_UNDERLYING_TYPE(RCDump())::UnitTestClassName());
 
@@ -299,44 +302,44 @@ TEST(RipCurrent, MoreTypeSystemGuarantees) {
   const auto emit_mult_mult_dump_3 = ((emit | mult) | mult) | dump;
   const auto emit_mult_mult_dump_4 = emit | (mult | (mult | dump));
 
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult)::input_t, current::ripcurrent::LHSTypes<>>, "");
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult)::output_t, current::ripcurrent::RHSTypes<Integer>>,
+  static_assert(is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult)::input_t, current::ripcurrent::LHSTypes<>>, "");
+  static_assert(is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult)::output_t, current::ripcurrent::RHSTypes<Integer>>,
                 "");
 
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(mult_dump)::input_t, current::ripcurrent::LHSTypes<Integer>>,
+  static_assert(is_same_v<RIPCURRENT_UNDERLYING_TYPE(mult_dump)::input_t, current::ripcurrent::LHSTypes<Integer>>,
                 "");
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(mult_dump)::output_t, current::ripcurrent::RHSTypes<>>, "");
+  static_assert(is_same_v<RIPCURRENT_UNDERLYING_TYPE(mult_dump)::output_t, current::ripcurrent::RHSTypes<>>, "");
 
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_dump)::input_t, current::ripcurrent::LHSTypes<>>, "");
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_dump)::output_t, current::ripcurrent::RHSTypes<>>, "");
+  static_assert(is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_dump)::input_t, current::ripcurrent::LHSTypes<>>, "");
+  static_assert(is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_dump)::output_t, current::ripcurrent::RHSTypes<>>, "");
 
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_1)::input_t, current::ripcurrent::LHSTypes<>>,
+  static_assert(is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_1)::input_t, current::ripcurrent::LHSTypes<>>,
                 "");
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_1)::output_t, current::ripcurrent::RHSTypes<>>,
+  static_assert(is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_1)::output_t, current::ripcurrent::RHSTypes<>>,
                 "");
 
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_2)::input_t, current::ripcurrent::LHSTypes<>>,
+  static_assert(is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_2)::input_t, current::ripcurrent::LHSTypes<>>,
                 "");
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_2)::output_t, current::ripcurrent::RHSTypes<>>,
+  static_assert(is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_2)::output_t, current::ripcurrent::RHSTypes<>>,
                 "");
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_1)::input_t, current::ripcurrent::LHSTypes<>>, "");
+      is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_1)::input_t, current::ripcurrent::LHSTypes<>>, "");
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_1)::output_t, current::ripcurrent::RHSTypes<>>, "");
+      is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_1)::output_t, current::ripcurrent::RHSTypes<>>, "");
 
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_2)::input_t, current::ripcurrent::LHSTypes<>>, "");
+      is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_2)::input_t, current::ripcurrent::LHSTypes<>>, "");
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_2)::output_t, current::ripcurrent::RHSTypes<>>, "");
+      is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_2)::output_t, current::ripcurrent::RHSTypes<>>, "");
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_3)::input_t, current::ripcurrent::LHSTypes<>>, "");
+      is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_3)::input_t, current::ripcurrent::LHSTypes<>>, "");
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_3)::output_t, current::ripcurrent::RHSTypes<>>, "");
+      is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_3)::output_t, current::ripcurrent::RHSTypes<>>, "");
 
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_4)::input_t, current::ripcurrent::LHSTypes<>>, "");
+      is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_4)::input_t, current::ripcurrent::LHSTypes<>>, "");
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_4)::output_t, current::ripcurrent::RHSTypes<>>, "");
+      is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_4)::output_t, current::ripcurrent::RHSTypes<>>, "");
 
   emit_mult.Dismiss();
   mult_dump.Dismiss();
diff --git a/storage/api.h b/storage/api.h
index 7b40a7107..142e1c210 100644
--- a/storage/api.h
+++ b/storage/api.h
@@ -313,8 +313,8 @@ struct PerFieldRESTfulHandlerGenerator {
 
   template <typename ENTRY_TYPE_WRAPPER, typename PARTIAL_KEY_OPERATION>
   std::function<void(Request)> GenerateRowOrColHandler(const std::string& field_name) {
-    static_assert(std::is_same_v<PARTIAL_KEY_OPERATION, semantics::rest::operation::OnMatrixRow> ||
-                      std::is_same_v<PARTIAL_KEY_OPERATION, semantics::rest::operation::OnMatrixCol>,
+    static_assert(std::is_same<PARTIAL_KEY_OPERATION, semantics::rest::operation::OnMatrixRow>::value ||
+                  std::is_same<PARTIAL_KEY_OPERATION, semantics::rest::operation::OnMatrixCol>::value,
                   "");
     auto& storage = this->storage;
     const std::string restful_url_prefix = this->restful_url_prefix;
diff --git a/storage/api_types.h b/storage/api_types.h
index e5ce0c87c..7b52c5e5b 100644
--- a/storage/api_types.h
+++ b/storage/api_types.h
@@ -276,8 +276,8 @@ struct RESTfulGETInput : RESTfulGenericInput<STORAGE> {
 // A dedicated "GETInput" for the GETs over row or col of a matrix container.
 template <typename STORAGE, typename INCOMPLETE_KEY_TYPE, typename FIELD>
 struct RESTfulGETRowColInput : RESTfulGenericInput<STORAGE> {
-  static_assert(std::is_same_v<INCOMPLETE_KEY_TYPE, semantics::key_completeness::PartialRowKey> ||
-                    std::is_same_v<INCOMPLETE_KEY_TYPE, semantics::key_completeness::PartialColKey>,
+  static_assert(std::is_same<INCOMPLETE_KEY_TYPE, semantics::key_completeness::PartialRowKey>::value ||
+                    std::is_same<INCOMPLETE_KEY_TYPE, semantics::key_completeness::PartialColKey>::value,
                 "");
 
   using field_t = FIELD;
diff --git a/storage/container/sfinae.h b/storage/container/sfinae.h
index 9ff0d47b7..ae403916a 100644
--- a/storage/container/sfinae.h
+++ b/storage/container/sfinae.h
@@ -69,7 +69,7 @@ struct impl_key_accessor_t<ENTRY, true> {
   // CF return type by design.
   using cf_key_t = decltype(std::declval<ENTRY>().key());
   using key_t = current::decay_t<cf_key_t>;
-  static_assert(std::is_same_v<cf_key_t, CF<key_t>>, "");
+  static_assert(std::is_same<cf_key_t, CF<key_t>>::value, "");
 
   static cf_key_t GetKey(const ENTRY& entry) { return entry.key(); }
   static void SetKey(ENTRY& entry, cf_key_t key) { entry.set_key(key); }
@@ -132,7 +132,7 @@ template <typename ENTRY>
 struct impl_row_accessor_t<ENTRY, true> {
   using cf_row_t = decltype(std::declval<ENTRY>().row());
   using row_t = current::decay_t<cf_row_t>;
-  static_assert(std::is_same_v<cf_row_t, CF<row_t>>, "");
+  static_assert(std::is_same<cf_row_t, CF<row_t>>::value, "");
 
   static cf_row_t GetRow(const ENTRY& entry) { return entry.row(); }
   static void SetRow(ENTRY& entry, cf_row_t row) { entry.set_row(row); }
@@ -140,8 +140,8 @@ struct impl_row_accessor_t<ENTRY, true> {
 
 template <typename ROW, typename COL>
 struct impl_row_accessor_t<std::pair<ROW, COL>, false> {
-  static_assert(std::is_same_v<ROW, current::decay_t<ROW>>, "");
-  static_assert(std::is_same_v<COL, current::decay_t<COL>>, "");
+  static_assert(std::is_same<ROW, current::decay_t<ROW>>::value, "");
+  static_assert(std::is_same<COL, current::decay_t<COL>>::value, "");
   using pair_t = std::pair<ROW, COL>;
   using row_t = ROW;
   using cf_row_t = CF<ROW>;
@@ -203,7 +203,7 @@ template <typename ENTRY>
 struct impl_col_accessor_t<ENTRY, true> {
   using cf_col_t = decltype(std::declval<ENTRY>().col());
   using col_t = current::decay_t<cf_col_t>;
-  static_assert(std::is_same_v<cf_col_t, CF<col_t>>, "");
+  static_assert(std::is_same<cf_col_t, CF<col_t>>::value, "");
 
   static cf_col_t GetCol(const ENTRY& entry) { return entry.col(); }
   static void SetCol(ENTRY& entry, cf_col_t col) { entry.set_col(col); }
@@ -211,8 +211,8 @@ struct impl_col_accessor_t<ENTRY, true> {
 
 template <typename ROW, typename COL>
 struct impl_col_accessor_t<std::pair<ROW, COL>, false> {
-  static_assert(std::is_same_v<ROW, current::decay_t<ROW>>, "");
-  static_assert(std::is_same_v<COL, current::decay_t<COL>>, "");
+  static_assert(std::is_same<ROW, current::decay_t<ROW>>::value, "");
+  static_assert(std::is_same<COL, current::decay_t<COL>>::value, "");
   using pair_t = std::pair<ROW, COL>;
   using col_t = COL;
   using cf_col_t = CF<COL>;
diff --git a/storage/docu/docu_3_code.cc b/storage/docu/docu_3_code.cc
index bb687a765..f5a22a528 100644
--- a/storage/docu/docu_3_code.cc
+++ b/storage/docu/docu_3_code.cc
@@ -743,13 +743,13 @@ namespace storage_docu {
     struct RESTfulDataHandler : SUPER::RESTfulDataHandler<HTTP_VERB, OPERATION, PARTICULAR_FIELD, ENTRY, KEY> {
       using ACTUAL_SUPER = SUPER::RESTfulDataHandler<HTTP_VERB, OPERATION, PARTICULAR_FIELD, ENTRY, KEY>;
 
-      template <class INPUT, bool IS_GET = std::is_same_v<HTTP_VERB, GET>>
+      template <class INPUT, bool IS_GET = std::is_same<HTTP_VERB, GET>::value>
       std::enable_if_t<!IS_GET, Response> Run(const INPUT& input) const {
         input.fields.SetTransactionMetaField("who", "unittest");
         return this->ACTUAL_SUPER::template Run<INPUT>(input);
       }
 
-      template <class INPUT, bool IS_GET = std::is_same_v<HTTP_VERB, GET>>
+      template <class INPUT, bool IS_GET = std::is_same<HTTP_VERB, GET>::value>
       std::enable_if_t<IS_GET, Response> Run(const INPUT& input) const {
         return this->ACTUAL_SUPER::template Run<INPUT>(input);
       }
diff --git a/storage/persister/stream.h b/storage/persister/stream.h
index 595a50de5..48d96757b 100644
--- a/storage/persister/stream.h
+++ b/storage/persister/stream.h
@@ -44,7 +44,7 @@ class StreamStreamPersisterImpl final {
   using variant_t = MUTATIONS_VARIANT;
   using transaction_t = Transaction<variant_t>;
   using stream_entry_t =
-      std::conditional_t<std::is_same_v<STREAM_RECORD_TYPE, NoCustomPersisterParam>, transaction_t, STREAM_RECORD_TYPE>;
+      std::conditional_t<std::is_same<STREAM_RECORD_TYPE, NoCustomPersisterParam>::value, transaction_t, STREAM_RECORD_TYPE>;
   using stream_t = stream::Stream<stream_entry_t, UNDERLYING_PERSISTER>;
   using fields_update_function_t = std::function<void(const variant_t&)>;
 
diff --git a/storage/rest/hypermedia.h b/storage/rest/hypermedia.h
index a0aa1bdab..b1b519253 100644
--- a/storage/rest/hypermedia.h
+++ b/storage/rest/hypermedia.h
@@ -94,7 +94,7 @@ struct HypermediaResponseFormatter {
                                            const std::string& url_collection,
                                            const ENTRY& entry) {
     using brief_t = sfinae::brief_of_t<ENTRY>;
-    if (std::is_same_v<ENTRY, brief_t>) {
+    if (std::is_same<ENTRY, brief_t>::value) {
       return Response(HypermediaRESTSingleRecordResponse<ENTRY>(url, url_collection, entry));
     } else {
       if (!context.brief) {
@@ -112,7 +112,7 @@ struct HypermediaResponseFormatter {
                                               const std::string& collection_url,
                                               ITERABLE&& span) {
     using inner_element_t = sfinae::brief_of_t<INNER_HYPERMEDIA_TYPE>;
-    using collection_element_t = std::conditional_t<std::is_same_v<INNER_HYPERMEDIA_TYPE, inner_element_t>,
+    using collection_element_t = std::conditional_t<std::is_same<INNER_HYPERMEDIA_TYPE, inner_element_t>::value,
                                                     HypermediaRESTFullCollectionRecord<inner_element_t>,
                                                     HypermediaRESTBriefCollectionRecord<inner_element_t>>;
 
diff --git a/storage/tests_flip/test.cc b/storage/tests_flip/test.cc
index f9dc89e68..feb208975 100644
--- a/storage/tests_flip/test.cc
+++ b/storage/tests_flip/test.cc
@@ -208,7 +208,7 @@ TEST(TransactionalStorage, UseExternallyProvidedStreamStreamOfBroaderType) {
   using pre_storage_t = TestStorage<StreamInMemoryStreamPersister>;
   using transaction_t = typename pre_storage_t::transaction_t;
 
-  static_assert(std::is_same_v<transaction_t, typename pre_storage_t::persister_t::transaction_t>, "");
+  static_assert(std::is_same<transaction_t, typename pre_storage_t::persister_t::transaction_t>::value, "");
 
   using storage_t = TestStorage<StreamInMemoryStreamPersister,
                                 current::storage::transaction_policy::Synchronous,
diff --git a/typesystem/enum.h b/typesystem/enum.h
index d0e7b56cb..4c9b2bc9f 100644
--- a/typesystem/enum.h
+++ b/typesystem/enum.h
@@ -40,12 +40,12 @@ namespace reflection {
 
 struct EnumNameSingletonImpl {
   template <typename T>
-  std::enable_if_t<std::is_enum_v<T>> Register(const char* name) {
+  std::enable_if_t<std::is_enum<T>::value> Register(const char* name) {
     names_[std::type_index(typeid(T))] = name;
   }
 
   template <typename T>
-  std::enable_if_t<std::is_enum_v<T>, std::string> GetName() const {
+  std::enable_if_t<std::is_enum<T>::value, std::string> GetName() const {
     const std::type_index type_index = std::type_index(typeid(T));
     if (names_.count(type_index) != 0u) {
       return names_.at(type_index);
@@ -62,12 +62,12 @@ struct EnumNameSingletonImpl {
 };
 
 template <typename T>
-inline std::enable_if_t<std::is_enum_v<T>> RegisterEnum(const char* name) {
+inline std::enable_if_t<std::is_enum<T>::value> RegisterEnum(const char* name) {
   current::Singleton<EnumNameSingletonImpl>().Register<T>(name);
 };
 
 template <typename T>
-inline std::enable_if_t<std::is_enum_v<T>, std::string> EnumName() {
+inline std::enable_if_t<std::is_enum<T>::value, std::string> EnumName() {
   return current::Singleton<EnumNameSingletonImpl>().GetName<T>();
 }
 
diff --git a/typesystem/evolution/test.cc b/typesystem/evolution/test.cc
index 26e47b50e..13ad7cffa 100644
--- a/typesystem/evolution/test.cc
+++ b/typesystem/evolution/test.cc
@@ -582,7 +582,7 @@ TEST(TypeEvolutionTest, AutogeneratedCurrentStructsAreReadyForEvolution) {
 
 #ifndef JUST_GENERATE_THAT_GOLDEN_FILE
   // Confirm the types we are dealing with are indeed different.
-  static_assert(!std::is_same_v<typename SchemaV1::SimpleStruct, typename SchemaXX::SimpleStruct>, "");
+  static_assert(!std::is_same<typename SchemaV1::SimpleStruct, typename SchemaXX::SimpleStruct>::value, "");
 
   { // Plain `SimpleStruct` tests, just copy the fields over, no evolution.
    {// Local `SimpleStruct` into autogenerated `SimpleStruct`.
@@ -976,8 +976,8 @@ TEST(TypeEvolutionTest, StorageTransactionsEvolution) {
   using post_evolution_transaction_t = current::storage::transaction_t<type_evolution_test::post_evolution::Storage>;
 
   static_assert(
-      !std::is_same_v<typename type_evolution_test::SchemaV1::Name, typename type_evolution_test::SchemaV2::Name>, "");
-  static_assert(!std::is_same_v<pre_evolution_transaction_t, post_evolution_transaction_t>, "");
+      !std::is_same<typename type_evolution_test::SchemaV1::Name, typename type_evolution_test::SchemaV2::Name>::value, "");
+  static_assert(!std::is_same<pre_evolution_transaction_t, post_evolution_transaction_t>::value, "");
 
   {
     using namespace current::reflection;
diff --git a/typesystem/helpers.h b/typesystem/helpers.h
index 4fd01ae37..390d12557 100644
--- a/typesystem/helpers.h
+++ b/typesystem/helpers.h
@@ -106,7 +106,7 @@ struct ExistsImplCaller<T, T> {
 struct DefaultExistsInvocation {};
 template <typename TEST = DefaultExistsInvocation, typename T>
 bool Exists(T&& x) {
-  return ExistsImplCaller<std::conditional_t<std::is_same_v<TEST, DefaultExistsInvocation>, current::decay_t<T>, TEST>,
+  return ExistsImplCaller<std::conditional_t<std::is_same<TEST, DefaultExistsInvocation>::value, current::decay_t<T>, TEST>,
                           current::decay_t<T>>::CallExistsImpl(std::forward<T>(x));
 }
 
@@ -150,10 +150,10 @@ struct PowerfulValueImplCaller<T, T, true> {
 struct DefaultValueInvocation {};
 template <typename OUTPUT = DefaultValueInvocation, typename INPUT>
 auto Value(INPUT&& x) -> decltype(
-    PowerfulValueImplCaller<std::conditional_t<std::is_same_v<OUTPUT, DefaultValueInvocation>, INPUT, OUTPUT>,
+    PowerfulValueImplCaller<std::conditional_t<std::is_same<OUTPUT, DefaultValueInvocation>::value, INPUT, OUTPUT>,
                             INPUT,
                             sfinae::ValueImplMethodTest<INPUT>::value>::AccessValue(std::declval<INPUT>())) {
-  return PowerfulValueImplCaller<std::conditional_t<std::is_same_v<OUTPUT, DefaultValueInvocation>, INPUT, OUTPUT>,
+  return PowerfulValueImplCaller<std::conditional_t<std::is_same<OUTPUT, DefaultValueInvocation>::value, INPUT, OUTPUT>,
                                  INPUT,
                                  sfinae::ValueImplMethodTest<INPUT>::value>::AccessValue(std::forward<INPUT>(x));
 }
diff --git a/typesystem/optional.h b/typesystem/optional.h
index aa6b0a627..97813a734 100644
--- a/typesystem/optional.h
+++ b/typesystem/optional.h
@@ -250,7 +250,7 @@ class Optional<T, std::enable_if_t<std::is_pod<T>::value>> final {
   }
 
   // Important to be able to assign `0` to `Optional<double` et. al.
-  template <typename TT = T, class ENABLE = std::enable_if_t<std::is_arithmetic_v<TT>>>
+  template <typename TT = T, class ENABLE = std::enable_if_t<std::is_arithmetic<TT>::value>>
   Optional<T>& operator=(int value) {
     value_ = value;
     exists_ = true;
diff --git a/typesystem/reflection/reflection.h b/typesystem/reflection/reflection.h
index fbef5585d..4ba4793da 100644
--- a/typesystem/reflection/reflection.h
+++ b/typesystem/reflection/reflection.h
@@ -138,7 +138,7 @@ struct RecursiveTypeTraverser {
 #undef CURRENT_DECLARE_PRIMITIVE_TYPE
 
   template <typename T>
-  std::enable_if_t<std::is_enum_v<T>, TypeID> operator()(TypeSelector<T>) {
+  std::enable_if_t<std::is_enum<T>::value, TypeID> operator()(TypeSelector<T>) {
     return ReflectedType_Enum(EnumName<T>(), CurrentTypeID_<typename std::underlying_type<T>::type>()).type_id;
   }
 
@@ -226,22 +226,22 @@ struct RecursiveTypeTraverser {
 
  private:
   template <typename T>
-  std::enable_if_t<std::is_same_v<SuperType<T>, CurrentStruct>, Optional<TypeID>> ReflectSuper() {
+  std::enable_if_t<std::is_same<SuperType<T>, CurrentStruct>::value, Optional<TypeID>> ReflectSuper() {
     return nullptr;
   }
 
   template <typename T>
-  std::enable_if_t<!std::is_same_v<SuperType<T>, CurrentStruct>, Optional<TypeID>> ReflectSuper() {
+  std::enable_if_t<!std::is_same<SuperType<T>, CurrentStruct>::value, Optional<TypeID>> ReflectSuper() {
     return CurrentTypeID_<SuperType<T>>();
   }
 
   template <typename T>
-  std::enable_if_t<std::is_same_v<TemplateInnerType<T>, void>, Optional<TypeID>> ReflectTemplateInnerType() {
+  std::enable_if_t<std::is_same<TemplateInnerType<T>, void>::value, Optional<TypeID>> ReflectTemplateInnerType() {
     return nullptr;
   }
 
   template <typename T>
-  std::enable_if_t<!std::is_same_v<TemplateInnerType<T>, void>, Optional<TypeID>> ReflectTemplateInnerType() {
+  std::enable_if_t<!std::is_same<TemplateInnerType<T>, void>::value, Optional<TypeID>> ReflectTemplateInnerType() {
     return CurrentTypeID_<TemplateInnerType<T>>();
   }
 };
@@ -379,7 +379,7 @@ struct ReflectorImpl {
 #undef CURRENT_DECLARE_PRIMITIVE_TYPE
 
   template <typename T>
-  std::enable_if_t<std::is_enum_v<T>, ReflectedType> operator()(TypeSelector<T>) {
+  std::enable_if_t<std::is_enum<T>::value, ReflectedType> operator()(TypeSelector<T>) {
     ReflectType<typename std::underlying_type<T>::type>();
     return ReflectedType(ReflectedType_Enum(EnumName<T>(), CurrentTypeID<typename std::underlying_type<T>::type>()));
   }
@@ -494,23 +494,23 @@ struct ReflectorImpl {
 
  private:
   template <typename T>
-  std::enable_if_t<std::is_same_v<SuperType<T>, CurrentStruct>, Optional<TypeID>> ReflectSuper() {
+  std::enable_if_t<std::is_same<SuperType<T>, CurrentStruct>::value, Optional<TypeID>> ReflectSuper() {
     return nullptr;
   }
 
   template <typename T>
-  std::enable_if_t<!std::is_same_v<SuperType<T>, CurrentStruct>, Optional<TypeID>> ReflectSuper() {
+  std::enable_if_t<!std::is_same<SuperType<T>, CurrentStruct>::value, Optional<TypeID>> ReflectSuper() {
     ReflectType<SuperType<T>>();
     return CurrentTypeID<SuperType<T>>();
   }
 
   template <typename T>
-  std::enable_if_t<std::is_same_v<TemplateInnerType<T>, void>, Optional<TypeID>> ReflectTemplateInnerType() {
+  std::enable_if_t<std::is_same<TemplateInnerType<T>, void>::value, Optional<TypeID>> ReflectTemplateInnerType() {
     return nullptr;
   }
 
   template <typename T>
-  std::enable_if_t<!std::is_same_v<TemplateInnerType<T>, void>, Optional<TypeID>> ReflectTemplateInnerType() {
+  std::enable_if_t<!std::is_same<TemplateInnerType<T>, void>::value, Optional<TypeID>> ReflectTemplateInnerType() {
     ReflectType<TemplateInnerType<T>>();  // NOTE(dkorolev): Unnecessary, but why not keep it in the schema output?
     return CurrentTypeID<TemplateInnerType<T>>();
   }
diff --git a/typesystem/reflection/test.cc b/typesystem/reflection/test.cc
index bb5f3bb05..f1243d07e 100644
--- a/typesystem/reflection/test.cc
+++ b/typesystem/reflection/test.cc
@@ -125,39 +125,42 @@ CURRENT_STRUCT(WithArray) {
 
 using current::reflection::Reflector;
 
+template <typename A, typename B>
+constexpr bool is_same_v = std::is_same<A, B>::value;
+
 static_assert(
-    std::is_same_v<current::reflection::FieldTypeWrapper<uint64_t>,
-                   decltype(Foo::CURRENT_REFLECTION(current::reflection::Index<current::reflection::FieldType, 0>()))>,
+    is_same_v<current::reflection::FieldTypeWrapper<uint64_t>,
+              decltype(Foo::CURRENT_REFLECTION(current::reflection::Index<current::reflection::FieldType, 0>()))>,
     "");
 
 static_assert(
-    std::is_same_v<current::reflection::FieldTypeWrapper<std::vector<uint64_t>>,
-                   decltype(Bar::CURRENT_REFLECTION(current::reflection::Index<current::reflection::FieldType, 0>()))>,
+    is_same_v<current::reflection::FieldTypeWrapper<std::vector<uint64_t>>,
+              decltype(Bar::CURRENT_REFLECTION(current::reflection::Index<current::reflection::FieldType, 0>()))>,
     "");
 static_assert(
-    std::is_same_v<current::reflection::FieldTypeWrapper<std::vector<Foo>>,
-                   decltype(Bar::CURRENT_REFLECTION(current::reflection::Index<current::reflection::FieldType, 1>()))>,
+    is_same_v<current::reflection::FieldTypeWrapper<std::vector<Foo>>,
+              decltype(Bar::CURRENT_REFLECTION(current::reflection::Index<current::reflection::FieldType, 1>()))>,
     "");
 static_assert(
-    std::is_same_v<current::reflection::FieldTypeWrapper<std::vector<std::vector<Foo>>>,
-                   decltype(Bar::CURRENT_REFLECTION(current::reflection::Index<current::reflection::FieldType, 2>()))>,
+    is_same_v<current::reflection::FieldTypeWrapper<std::vector<std::vector<Foo>>>,
+              decltype(Bar::CURRENT_REFLECTION(current::reflection::Index<current::reflection::FieldType, 2>()))>,
     "");
 
-static_assert(std::is_same_v<current::reflection::FieldTypeWrapper<std::string>,
-                             decltype(Templated<uint64_t>::CURRENT_REFLECTION(
+static_assert(is_same_v<current::reflection::FieldTypeWrapper<std::string>,
+                        decltype(Templated<uint64_t>::CURRENT_REFLECTION(
                                  current::reflection::Index<current::reflection::FieldType, 0>()))>,
               "");
-static_assert(std::is_same_v<current::reflection::FieldTypeWrapper<uint64_t>,
-                             decltype(Templated<uint64_t>::CURRENT_REFLECTION(
+static_assert(is_same_v<current::reflection::FieldTypeWrapper<uint64_t>,
+                        decltype(Templated<uint64_t>::CURRENT_REFLECTION(
                                  current::reflection::Index<current::reflection::FieldType, 1>()))>,
               "");
 
-static_assert(std::is_same_v<current::reflection::FieldTypeWrapper<std::string>,
-                             decltype(Templated<Foo>::CURRENT_REFLECTION(
+static_assert(is_same_v<current::reflection::FieldTypeWrapper<std::string>,
+                        decltype(Templated<Foo>::CURRENT_REFLECTION(
                                  current::reflection::Index<current::reflection::FieldType, 0>()))>,
               "");
-static_assert(std::is_same_v<current::reflection::FieldTypeWrapper<Foo>,
-                             decltype(Templated<Foo>::CURRENT_REFLECTION(
+static_assert(is_same_v<current::reflection::FieldTypeWrapper<Foo>,
+                        decltype(Templated<Foo>::CURRENT_REFLECTION(
                                  current::reflection::Index<current::reflection::FieldType, 1>()))>,
               "");
 
@@ -481,7 +484,7 @@ TEST(Reflection, TemplatedTypeIDs) {
   const auto templated_struct_typeid = static_cast<uint64_t>(CurrentTypeID<Templated<Foo>>());
   EXPECT_EQ(9204032299541411163ull, templated_struct_typeid);
 
-  static_assert(std::is_same_v<current::reflection::TemplateInnerType<Templated<Foo>>, Foo>, "");
+  static_assert(is_same_v<current::reflection::TemplateInnerType<Templated<Foo>>, Foo>, "");
   EXPECT_EQ(foo_typeid, static_cast<uint64_t>(CurrentTypeID<current::reflection::TemplateInnerType<Templated<Foo>>>()));
 
   EXPECT_EQ(templated_struct_typeid, static_cast<uint64_t>(CurrentTypeID<Templated<Foo>>()));
@@ -493,7 +496,7 @@ TEST(Reflection, TemplatedTypeIDs) {
   EXPECT_STREQ("Templated<Foo>", CurrentTypeName<templated_same::Templated<Foo>>());
   EXPECT_STREQ("Templated_Z", (CurrentTypeName<templated_same::Templated<Foo>, NameFormat::Z>()));
   EXPECT_STREQ("Templated_T_Foo", (CurrentTypeName<templated_same::Templated<Foo>, NameFormat::AsIdentifier>()));
-  static_assert(std::is_same_v<current::reflection::TemplateInnerType<templated_same::Templated<Foo>>, Foo>, "");
+  static_assert(is_same_v<current::reflection::TemplateInnerType<templated_same::Templated<Foo>>, Foo>, "");
   EXPECT_EQ(
       foo_typeid,
       static_cast<uint64_t>(CurrentTypeID<current::reflection::TemplateInnerType<templated_same::Templated<Foo>>>()));
@@ -517,7 +520,7 @@ TEST(Reflection, TemplatedTypeIDs) {
   EXPECT_STREQ("Templated<Foo>", CurrentTypeName<templated_as_exported::Templated>());
   EXPECT_STREQ("Templated_Z", (CurrentTypeName<templated_as_exported::Templated, NameFormat::Z>()));
   EXPECT_STREQ("Templated_T_Foo", (CurrentTypeName<templated_as_exported::Templated, NameFormat::AsIdentifier>()));
-  static_assert(std::is_same_v<current::reflection::TemplateInnerType<templated_as_exported::Templated>, Foo>, "");
+  static_assert(is_same_v<current::reflection::TemplateInnerType<templated_as_exported::Templated>, Foo>, "");
   EXPECT_EQ(
       foo_typeid,
       static_cast<uint64_t>(CurrentTypeID<current::reflection::TemplateInnerType<templated_as_exported::Templated>>()));
@@ -531,7 +534,7 @@ TEST(Reflection, TemplatedTypeIDs) {
       "Templated_T_Foo",
       (CurrentTypeName<original_name_does_not_matter_when_exporting::BlahBlahBlah, NameFormat::AsIdentifier>()));
   static_assert(
-      std::is_same_v<current::reflection::TemplateInnerType<original_name_does_not_matter_when_exporting::BlahBlahBlah>,
+      is_same_v<current::reflection::TemplateInnerType<original_name_does_not_matter_when_exporting::BlahBlahBlah>,
                      Foo>,
       "");
   EXPECT_EQ(
@@ -606,10 +609,10 @@ namespace explicitly_declared_named_variant_two {
 CURRENT_VARIANT(Variant_B_A_X_Y_E, A, X, Y);
 }  // namespace explicitly_declared_named_variant_two
 
-static_assert(!std::is_same_v<explicitly_declared_named_variant_one::Variant_B_A_X_Y_E, Variant<A, X, Y>>, "");
-static_assert(!std::is_same_v<explicitly_declared_named_variant_two::Variant_B_A_X_Y_E, Variant<A, X, Y>>, "");
-static_assert(!std::is_same_v<explicitly_declared_named_variant_one::Variant_B_A_X_Y_E,
-                              explicitly_declared_named_variant_two::Variant_B_A_X_Y_E>,
+static_assert(!is_same_v<explicitly_declared_named_variant_one::Variant_B_A_X_Y_E, Variant<A, X, Y>>, "");
+static_assert(!is_same_v<explicitly_declared_named_variant_two::Variant_B_A_X_Y_E, Variant<A, X, Y>>, "");
+static_assert(!is_same_v<explicitly_declared_named_variant_one::Variant_B_A_X_Y_E,
+                         explicitly_declared_named_variant_two::Variant_B_A_X_Y_E>,
               "");
 
 }  // namespace reflection_test
@@ -630,7 +633,7 @@ TEST(Reflection, CurrentStructInternals) {
   using namespace reflection_test;
   using namespace current::reflection;
 
-  static_assert(std::is_same_v<SuperType<Foo>, ::current::CurrentStruct>, "");
+  static_assert(is_same_v<SuperType<Foo>, ::current::CurrentStruct>, "");
   EXPECT_EQ(1u, FieldCounter<Foo>::value + 0u);
 
   Foo::CURRENT_REFLECTION([](TypeSelector<uint64_t>, const std::string& name) { EXPECT_EQ("i", name); },
@@ -653,13 +656,13 @@ TEST(Reflection, CurrentStructInternals) {
       Index<FieldNameAndMutableValue, 0>());
   EXPECT_EQ(123u, foo.i);
 
-  static_assert(std::is_same_v<SuperType<Bar>, ::current::CurrentStruct>, "");
+  static_assert(is_same_v<SuperType<Bar>, ::current::CurrentStruct>, "");
   EXPECT_EQ(4u, FieldCounter<Bar>::value + 0u);
-  static_assert(std::is_same_v<SuperType<DerivedFromFoo>, Foo>, "");
+  static_assert(is_same_v<SuperType<DerivedFromFoo>, Foo>, "");
   EXPECT_EQ(1u, FieldCounter<DerivedFromFoo>::value + 0u);
 
-  static_assert(std::is_same_v<TemplateInnerType<Bar>, void>, "");
-  static_assert(std::is_same_v<TemplateInnerType<Templated<Bar>>, Bar>, "");
+  static_assert(is_same_v<TemplateInnerType<Bar>, void>, "");
+  static_assert(is_same_v<TemplateInnerType<Templated<Bar>>, Bar>, "");
 }
 
 namespace reflection_test {
@@ -704,12 +707,12 @@ struct CollectFieldValues {
   std::vector<std::string>& output_;
 
   template <typename T>
-  std::enable_if_t<!std::is_enum_v<T>> operator()(const std::string&, const T& value) const {
+  std::enable_if_t<!std::is_enum<T>::value> operator()(const std::string&, const T& value) const {
     output_.push_back(current::ToString(value));
   }
 
   template <typename T>
-  std::enable_if_t<std::is_enum_v<T>> operator()(const std::string&, const T& value) const {
+  std::enable_if_t<std::is_enum<T>::value> operator()(const std::string&, const T& value) const {
     output_.push_back(current::ToString(static_cast<typename std::underlying_type<T>::type>(value)));
   }
 
diff --git a/typesystem/reflection/typeid.h b/typesystem/reflection/typeid.h
index c8082a0a4..1cd73bc85 100644
--- a/typesystem/reflection/typeid.h
+++ b/typesystem/reflection/typeid.h
@@ -34,7 +34,8 @@ SOFTWARE.
 
 // TODO(dkorolev): If I get to extend this further, also export original names in schema-dumped C-structs.
 
-namespace current::reflection {
+namespace current {
+namespace reflection {
 
 enum class TypeID : uint64_t;
 
@@ -57,15 +58,18 @@ reflection::TypeID CurrentTypeID() {
 }
 
 }  // namespace current::reflection
+}  // namespace current
 
 #define CURRENT_INJECT_TYPE_ID(type,id)      \
-namespace current::reflection {              \
+namespace current {                          \
+namespace reflection {                       \
 template <>                                  \
 struct InjectableCurrentTypeID<type> final { \
   static TypeID GetTypeID() {                \
     return static_cast<TypeID>(id);          \
   }                                          \
 };                                           \
+}                                            \
 }
 
 #endif  // CURRENT_TYPE_SYSTEM_REFLECTION_TYPEID_H
diff --git a/typesystem/serialization/json/enum.h b/typesystem/serialization/json/enum.h
index c4cf16a20..fcce94357 100644
--- a/typesystem/serialization/json/enum.h
+++ b/typesystem/serialization/json/enum.h
@@ -34,14 +34,14 @@ namespace current {
 namespace serialization {
 
 template <class JSON_FORMAT, typename T>
-struct SerializeImpl<json::JSONStringifier<JSON_FORMAT>, T, std::enable_if_t<std::is_enum_v<T>>> {
+struct SerializeImpl<json::JSONStringifier<JSON_FORMAT>, T, std::enable_if_t<std::is_enum<T>::value>> {
   static void DoSerialize(json::JSONStringifier<JSON_FORMAT>& json_stringifier, const T enum_value) {
     json_stringifier = static_cast<typename std::underlying_type<T>::type>(enum_value);
   }
 };
 
 template <class JSON_FORMAT, typename T>
-struct DeserializeImpl<json::JSONParser<JSON_FORMAT>, T, std::enable_if_t<std::is_enum_v<T>>> {
+struct DeserializeImpl<json::JSONParser<JSON_FORMAT>, T, std::enable_if_t<std::is_enum<T>::value>> {
   static void DoDeserialize(json::JSONParser<JSON_FORMAT>& json_parser, T& destination) {
     if (json_parser && json_parser.Current().IsNumber()) {
       if (std::numeric_limits<typename std::underlying_type<T>::type>::is_signed) {
diff --git a/typesystem/serialization/json/json.h b/typesystem/serialization/json/json.h
index 17441083a..7de150cb3 100644
--- a/typesystem/serialization/json/json.h
+++ b/typesystem/serialization/json/json.h
@@ -49,8 +49,8 @@ struct IsJSONSerializableImpl;
 template <typename T>
 struct IsJSONSerializable {
   constexpr static bool value =
-      IsJSONSerializableImpl<IS_CURRENT_STRUCT(T), IS_CURRENT_VARIANT(T), std::is_enum_v<T>, T>::value &&
-      !std::is_same_v<T, CurrentStruct> && !std::is_same_v<T, CurrentStruct>;
+      IsJSONSerializableImpl<IS_CURRENT_STRUCT(T), IS_CURRENT_VARIANT(T), std::is_enum<T>::value, T>::value &&
+      !std::is_same<T, CurrentStruct>::value && !std::is_same<T, CurrentStruct>::value;
 };
 
 // Helper logic for `IsJSONSerializable`.
diff --git a/typesystem/serialization/json/map.h b/typesystem/serialization/json/map.h
index 3713bc6cc..f5c6a2c7b 100644
--- a/typesystem/serialization/json/map.h
+++ b/typesystem/serialization/json/map.h
@@ -69,7 +69,7 @@ struct SerializeImpl<json::JSONStringifier<JSON_FORMAT>, std::map<std::string, T
 template <class JSON_FORMAT, typename TK, typename TV, typename TC, typename TA, class J>
 struct DeserializeImpl<json::JSONParser<JSON_FORMAT>, std::map<TK, TV, TC, TA>, J> {
   template <typename K = TK>
-  static std::enable_if_t<std::is_same_v<std::string, K>> DoDeserialize(json::JSONParser<JSON_FORMAT>& json_parser,
+  static std::enable_if_t<std::is_same<std::string, K>::value> DoDeserialize(json::JSONParser<JSON_FORMAT>& json_parser,
                                                                         std::map<TK, TV, TC, TA>& destination) {
     if (json_parser && json_parser.Current().IsObject()) {
       destination.clear();
@@ -88,7 +88,7 @@ struct DeserializeImpl<json::JSONParser<JSON_FORMAT>, std::map<TK, TV, TC, TA>,
   }
 
   template <typename K = TK>
-  static std::enable_if_t<!std::is_same_v<std::string, K>> DoDeserialize(json::JSONParser<JSON_FORMAT>& json_parser,
+  static std::enable_if_t<!std::is_same<std::string, K>::value> DoDeserialize(json::JSONParser<JSON_FORMAT>& json_parser,
                                                                          std::map<TK, TV, TC, TA>& destination) {
     if (json_parser && json_parser.Current().IsArray()) {
       destination.clear();
diff --git a/typesystem/serialization/json/primitives.h b/typesystem/serialization/json/primitives.h
index c33330370..8e760c53c 100644
--- a/typesystem/serialization/json/primitives.h
+++ b/typesystem/serialization/json/primitives.h
@@ -79,7 +79,7 @@ template <class JSON_FORMAT, typename T>
 struct DeserializeImpl<json::JSONParser<JSON_FORMAT>,
                        T,
                        std::enable_if_t<std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed &&
-                                        !std::is_same_v<T, bool>>> {
+                                        !std::is_same<T, bool>::value>> {
   static void DoDeserialize(json::JSONParser<JSON_FORMAT>& json_parser, T& destination) {
     if (json_parser && json_parser.Current().IsUint64()) {
       destination = static_cast<T>(json_parser.Current().GetUint64());
diff --git a/typesystem/serialization/json/struct.h b/typesystem/serialization/json/struct.h
index 8a1a6a0c7..0517833f3 100644
--- a/typesystem/serialization/json/struct.h
+++ b/typesystem/serialization/json/struct.h
@@ -80,7 +80,7 @@ struct SerializeStructImpl<JSON_FORMAT, CurrentStruct> {
 template <class JSON_FORMAT, typename T>
 struct SerializeImpl<json::JSONStringifier<JSON_FORMAT>,
                      T,
-                     std::enable_if_t<IS_CURRENT_STRUCT(T) && !std::is_same_v<T, CurrentStruct>>> {
+                     std::enable_if_t<IS_CURRENT_STRUCT(T) && !std::is_same<T, CurrentStruct>::value>> {
   static void DoSerialize(json::JSONStringifier<JSON_FORMAT>& json_stringifier, const T& value) {
     json_stringifier.Current().SetObject();
     json::JSONStructFieldsSerializer<JSON_FORMAT> visitor(json_stringifier);
@@ -96,7 +96,7 @@ struct DeserializeImpl<json::JSONParser<JSON_FORMAT>, CurrentStruct> {
 template <class JSON_FORMAT, typename T>
 struct DeserializeImpl<json::JSONParser<JSON_FORMAT>,
                        T,
-                       std::enable_if_t<IS_CURRENT_STRUCT(T) && !std::is_same_v<T, CurrentStruct>>> {
+                       std::enable_if_t<IS_CURRENT_STRUCT(T) && !std::is_same<T, CurrentStruct>::value>> {
   class DeserializeSingleField {
    public:
     explicit DeserializeSingleField(json::JSONParser<JSON_FORMAT>& json_parser) : json_parser_(json_parser) {}
@@ -121,7 +121,7 @@ struct DeserializeImpl<json::JSONParser<JSON_FORMAT>,
     using super_t = current::reflection::SuperType<decayed_t>;
 
     if (json_parser && json_parser.Current().IsObject()) {
-      if (!std::is_same_v<super_t, CurrentStruct>) {
+      if (!std::is_same<super_t, CurrentStruct>::value) {
         Deserialize(json_parser, static_cast<super_t&>(destination));
       }
       current::reflection::VisitAllFields<decayed_t, current::reflection::FieldNameAndMutableValue>::WithObject(
diff --git a/typesystem/serialization/json/unordered_map.h b/typesystem/serialization/json/unordered_map.h
index 1017f320b..26bf448dd 100644
--- a/typesystem/serialization/json/unordered_map.h
+++ b/typesystem/serialization/json/unordered_map.h
@@ -71,7 +71,7 @@ struct SerializeImpl<json::JSONStringifier<JSON_FORMAT>, std::unordered_map<std:
 template <class JSON_FORMAT, typename TK, typename TV, class HASH, class EQ, class ALLOCATOR, class J>
 struct DeserializeImpl<json::JSONParser<JSON_FORMAT>, std::unordered_map<TK, TV, HASH, EQ, ALLOCATOR>, J> {
   template <typename K = TK>
-  static std::enable_if_t<std::is_same_v<std::string, K>> DoDeserialize(
+  static std::enable_if_t<std::is_same<std::string, K>::value> DoDeserialize(
       json::JSONParser<JSON_FORMAT>& json_parser, std::unordered_map<TK, TV, HASH, EQ, ALLOCATOR>& destination) {
     if (json_parser && json_parser.Current().IsObject()) {
       destination.clear();
@@ -90,7 +90,7 @@ struct DeserializeImpl<json::JSONParser<JSON_FORMAT>, std::unordered_map<TK, TV,
   }
 
   template <typename K = TK>
-  static std::enable_if_t<!std::is_same_v<std::string, K>> DoDeserialize(
+  static std::enable_if_t<!std::is_same<std::string, K>::value> DoDeserialize(
       json::JSONParser<JSON_FORMAT>& json_parser, std::unordered_map<TK, TV, HASH, EQ, ALLOCATOR>& destination) {
     if (json_parser && json_parser.Current().IsArray()) {
       destination.clear();
diff --git a/typesystem/struct.h b/typesystem/struct.h
index ee18b46eb..9bdb623c9 100644
--- a/typesystem/struct.h
+++ b/typesystem/struct.h
@@ -57,10 +57,10 @@ template <typename REFLECTION_HELPER, typename INSTANTIATION_TYPE, typename T, t
 struct SUPER_IMPL : SUPER_SELECTOR<INSTANTIATION_TYPE, T>::type {
   using super_t = typename SUPER_SELECTOR<INSTANTIATION_TYPE, T>::type;
 
-  template <class IT = INSTANTIATION_TYPE, class = std::enable_if_t<std::is_same_v<IT, DF>>>
+  template <class IT = INSTANTIATION_TYPE, class = std::enable_if_t<std::is_same<IT, DF>::value>>
   SUPER_IMPL(const super_t& self) : super_t(self) {}
 
-  template <class IT = INSTANTIATION_TYPE, class = std::enable_if_t<std::is_same_v<IT, DF>>>
+  template <class IT = INSTANTIATION_TYPE, class = std::enable_if_t<std::is_same<IT, DF>::value>>
   SUPER_IMPL(super_t&& self) : super_t(self) {}
 
   using super_t::super_t;
@@ -336,12 +336,12 @@ struct CurrentStructFieldsConsistency<T, 0u> {
       class SUPER =                                                                                               \
           ::crnt::r::SUPER_IMPL<CRH_##s, INSTANTIATION_TYPE, typename CSSH_##s::INTERNAL_SUPER, std::false_type>, \
       typename INSTANTIATION_TYPE_IMPL = INSTANTIATION_TYPE,                                                      \
-      class = std::enable_if_t<std::is_same_v<INSTANTIATION_TYPE_IMPL, ::current::reflection::DeclareFields>>>    \
+      class = std::enable_if_t<std::is_same<INSTANTIATION_TYPE_IMPL, ::current::reflection::DeclareFields>::value>>    \
   CSI_##s
 
 #define CURRENT_ASSIGN_OPER(s)                                                                                       \
   template <typename INSTANTIATION_TYPE_IMPL = INSTANTIATION_TYPE,                                                   \
-            class = std::enable_if_t<std::is_same_v<INSTANTIATION_TYPE_IMPL, ::current::reflection::DeclareFields>>> \
+            class = std::enable_if_t<std::is_same<INSTANTIATION_TYPE_IMPL, ::current::reflection::DeclareFields>::value>> \
   CSI_##s& operator=
 
 #define CURRENT_DEFAULT_CONSTRUCTOR(s) CURRENT_CONSTRUCTOR(s)()
@@ -352,7 +352,7 @@ struct CurrentStructFieldsConsistency<T, 0u> {
                                                 typename CURRENT_STRUCT_T_SUPER_HELPER_##s::INTERNAL_SUPER_T,        \
                                                 std::true_type>,                                                     \
             typename INSTANTIATION_TYPE_IMPL = INSTANTIATION_TYPE,                                                   \
-            class = std::enable_if_t<std::is_same_v<INSTANTIATION_TYPE_IMPL, ::current::reflection::DeclareFields>>> \
+            class = std::enable_if_t<std::is_same<INSTANTIATION_TYPE_IMPL, ::current::reflection::DeclareFields>::value>> \
   CSTI_##s
 
 #define CURRENT_DEFAULT_CONSTRUCTOR_T(s) CURRENT_CONSTRUCTOR_T(s)()
@@ -386,7 +386,7 @@ struct CurrentStructFieldsConsistency<T, 0u> {
     using subtype = int;                                          \
   };                                                              \
   using exported_subtype = typename std::                         \
-      conditional_t<std::is_same_v<T, ::crnt::r::DummyT>, CRNT_##exported_subtype##_helper_t, T>::subtype
+      conditional_t<std::is_same<T, ::crnt::r::DummyT>::value, CRNT_##exported_subtype##_helper_t, T>::subtype
 
 #define CETS_IMPL1(a) CURRENT_EXTRACT_T_SUBTYPE_IMPL(a, a)
 #define CETS_IMPL2(a, b) CURRENT_EXTRACT_T_SUBTYPE_IMPL(a, b)
@@ -424,7 +424,7 @@ constexpr bool HasPatch() {
 
 template <class B, class D>
 struct is_same_or_base_of {
-  constexpr static bool value = std::is_base_of_v<B, D>;
+  constexpr static bool value = std::is_base_of<B, D>::value;
 };
 template <class C>
 struct is_same_or_base_of<C, C> {
diff --git a/typesystem/test.cc b/typesystem/test.cc
index 417955917..9a959e526 100644
--- a/typesystem/test.cc
+++ b/typesystem/test.cc
@@ -272,6 +272,9 @@ TEST(TypeSystemTest, ExistsForNonVariants) {
   EXPECT_FALSE(Exists<int>(foo_rref));
 }
 
+template <typename A, typename B>
+constexpr bool is_same_v = std::is_same<A, B>::value;
+
 TEST(TypeSystemTest, ValueOfMutableAndImmutableObjects) {
   using namespace struct_definition_test;
 
@@ -279,11 +282,11 @@ TEST(TypeSystemTest, ValueOfMutableAndImmutableObjects) {
   int& x_ref = x;
   const int& x_cref = x;
   const int cx = 1;
-  static_assert(std::is_same_v<decltype(Value(x)), int&>, "");
-  static_assert(std::is_same_v<decltype(Value(x_ref)), int&>, "");
-  static_assert(std::is_same_v<decltype(Value(x_cref)), const int&>, "");
-  static_assert(std::is_same_v<decltype(Value(std::move(x))), int&&>, "");
-  static_assert(std::is_same_v<decltype(Value(cx)), const int&>, "");
+  static_assert(is_same_v<decltype(Value(x)), int&>, "");
+  static_assert(is_same_v<decltype(Value(x_ref)), int&>, "");
+  static_assert(is_same_v<decltype(Value(x_cref)), const int&>, "");
+  static_assert(is_same_v<decltype(Value(std::move(x))), int&&>, "");
+  static_assert(is_same_v<decltype(Value(cx)), const int&>, "");
 
   Foo foo(42);
   EXPECT_TRUE(Exists<Foo>(foo));
@@ -421,10 +424,10 @@ TEST(TypeSystemTest, ImmutableOptional) {
   {
     ImmutableOptional<int> foo(100);
     const ImmutableOptional<int>& foo_cref = foo;
-    static_assert(std::is_same_v<decltype(Value(foo)), int>, "");
-    static_assert(std::is_same_v<decltype(Value(foo_cref)), int>, "");
+    static_assert(is_same_v<decltype(Value(foo)), int>, "");
+    static_assert(is_same_v<decltype(Value(foo_cref)), int>, "");
     const ImmutableOptional<int> bar(200);
-    static_assert(std::is_same_v<decltype(Value(bar)), int>, "");
+    static_assert(is_same_v<decltype(Value(bar)), int>, "");
   }
   {
     ImmutableOptional<int> foo(100);
@@ -447,10 +450,10 @@ TEST(TypeSystemTest, ImmutableOptional) {
   {
     ImmutableOptional<Foo> foo(100);
     const ImmutableOptional<Foo>& foo_cref = foo;
-    static_assert(std::is_same_v<decltype(Value(foo)), const Foo&>, "");
-    static_assert(std::is_same_v<decltype(Value(foo_cref)), const Foo&>, "");
+    static_assert(is_same_v<decltype(Value(foo)), const Foo&>, "");
+    static_assert(is_same_v<decltype(Value(foo_cref)), const Foo&>, "");
     const ImmutableOptional<Foo> bar(200);
-    static_assert(std::is_same_v<decltype(Value(bar)), const Foo&>, "");
+    static_assert(is_same_v<decltype(Value(bar)), const Foo&>, "");
   }
   {
     ImmutableOptional<Foo> meh(nullptr);
@@ -499,11 +502,11 @@ TEST(TypeSystemTest, Optional) {
   {
     Optional<int> foo(200);
     const Optional<int>& foo_cref = foo;
-    static_assert(std::is_same_v<decltype(Value(foo)), int&>, "");
-    static_assert(std::is_same_v<decltype(Value(foo_cref)), int>, "");
-    static_assert(std::is_same_v<decltype(Value(std::move(foo))), int&>, "");
+    static_assert(is_same_v<decltype(Value(foo)), int&>, "");
+    static_assert(is_same_v<decltype(Value(foo_cref)), int>, "");
+    static_assert(is_same_v<decltype(Value(std::move(foo))), int&>, "");
     const Optional<int> bar(200);
-    static_assert(std::is_same_v<decltype(Value(bar)), int>, "");
+    static_assert(is_same_v<decltype(Value(bar)), int>, "");
   }
   // POD version: Initialize in ctor.
   {
@@ -567,10 +570,10 @@ TEST(TypeSystemTest, Optional) {
   {
     Optional<Foo> foo(200);
     const Optional<Foo>& foo_cref = foo;
-    static_assert(std::is_same_v<decltype(Value(foo)), Foo&>, "");
-    static_assert(std::is_same_v<decltype(Value(foo_cref)), const Foo&>, "");
+    static_assert(is_same_v<decltype(Value(foo)), Foo&>, "");
+    static_assert(is_same_v<decltype(Value(foo_cref)), const Foo&>, "");
     const Optional<Foo> bar(200);
-    static_assert(std::is_same_v<decltype(Value(bar)), const Foo&>, "");
+    static_assert(is_same_v<decltype(Value(bar)), const Foo&>, "");
   }
   // Non-POD version: Construct from `Foo&`.
   {
diff --git a/typesystem/typename.h b/typesystem/typename.h
index 834fa4c1f..0b6178b63 100644
--- a/typesystem/typename.h
+++ b/typesystem/typename.h
@@ -76,7 +76,7 @@ struct CurrentTypeNameCaller {
                                      T,
                                      IS_CURRENT_STRUCT(T),
                                      IS_CURRENT_VARIANT(T),
-                                     std::is_enum_v<T>,
+                                     std::is_enum<T>::value,
                                      current::metaprogramming::is_std_tuple<T>::value>;
   static const char* CallGetCurrentTypeName() {
     static const std::string value = impl_t::GetCurrentTypeName();
diff --git a/typesystem/types.h b/typesystem/types.h
index dc63bf04f..e4a729e31 100644
--- a/typesystem/types.h
+++ b/typesystem/types.h
@@ -59,9 +59,9 @@ struct CurrentStruct : CurrentSuper {};
 // The superclass for `Variant` type.
 struct CurrentVariant : CurrentSuper {};
 
-#define IS_CURRENT_STRUCT(T) (std::is_base_of_v<::crnt::CurrentStruct, ::current::decay_t<T>>)
-#define IS_CURRENT_VARIANT(T) (std::is_base_of_v<::crnt::CurrentVariant, ::current::decay_t<T>>)
-#define IS_CURRENT_STRUCT_OR_VARIANT(T) (std::is_base_of_v<::crnt::CurrentSuper, ::current::decay_t<T>>)
+#define IS_CURRENT_STRUCT(T) (std::is_base_of<::crnt::CurrentStruct, ::current::decay_t<T>>::value)
+#define IS_CURRENT_VARIANT(T) (std::is_base_of<::crnt::CurrentVariant, ::current::decay_t<T>>::value)
+#define IS_CURRENT_STRUCT_OR_VARIANT(T) (std::is_base_of<::crnt::CurrentSuper, ::current::decay_t<T>>::value)
 
 #define IS_EMPTY_CURRENT_STRUCT(T) (::current::reflection::IsEmptyCurrentStruct<T, IS_CURRENT_STRUCT(T)>::value)
 
@@ -291,7 +291,7 @@ struct VisitAllFields {
     static current::variadic_indexes::indexes<NS...> remaining_indexes;
     t.CURRENT_REFLECTION(std::forward<F>(f), Index<VISITOR_TYPE, N>());
     // `WithObjectImpl()` is called only from `WithObject()`, and by this point `TT` is `T`.
-    static_assert(std::is_same_v<current::decay_t<TT>, T>, "");  // To be on the safe side.
+    static_assert(std::is_same<current::decay_t<TT>, T>::value, "");  // To be on the safe side.
     WithObjectImpl(std::forward<TT>(t), std::forward<F>(f), remaining_indexes);
   }
 
diff --git a/typesystem/variant.h b/typesystem/variant.h
index 2611f1a41..0dc50da3e 100644
--- a/typesystem/variant.h
+++ b/typesystem/variant.h
@@ -251,12 +251,12 @@ struct VariantImpl<NAME, TypeListImpl<TYPES...>> : IHasUncheckedMoveFromUniquePt
   bool ExistsImpl() const { return (object_.get() != nullptr); }
 
   template <typename X>
-  std::enable_if_t<!std::is_same_v<X, current::variant::object_base_t>, bool> VariantExistsImpl() const {
+  std::enable_if_t<!std::is_same<X, current::variant::object_base_t>::value, bool> VariantExistsImpl() const {
     return dynamic_cast<const X*>(object_.get()) != nullptr;
   }
 
   template <typename X>
-  std::enable_if_t<!std::is_same_v<X, current::variant::object_base_t>, X&> VariantValueImpl() {
+  std::enable_if_t<!std::is_same<X, current::variant::object_base_t>::value, X&> VariantValueImpl() {
     X* ptr = dynamic_cast<X*>(object_.get());
     if (ptr) {
       return *ptr;
@@ -276,7 +276,7 @@ struct VariantImpl<NAME, TypeListImpl<TYPES...>> : IHasUncheckedMoveFromUniquePt
   }
 
   template <typename X>
-  std::enable_if_t<std::is_same_v<X, VariantImpl>, const VariantImpl&> VariantValueImpl() const {
+  std::enable_if_t<std::is_same<X, VariantImpl>::value, const VariantImpl&> VariantValueImpl() const {
     if (ExistsImpl()) {
       return *this;
     } else {