diff --git a/include/frozen/bits/basic_types.h b/include/frozen/bits/basic_types.h
index 14490f8..674f6e6 100644
--- a/include/frozen/bits/basic_types.h
+++ b/include/frozen/bits/basic_types.h
@@ -68,6 +68,19 @@ struct size_integer {
 template <std::size_t total_size>
 using size_integer_t = typename size_integer<total_size>::type;
 
+// Helper type to work around apparent compiler bugs in MSVC related to having "too complex"
+// template parameters involving either NTTP or references-to-array.
+template <class T, std::size_t N>
+struct array_ref {
+  using array_type = const T(&) [N];
+  using pointer = T*;
+
+  pointer array;
+
+  operator pointer   () const noexcept { return array; }
+  operator array_type() const noexcept { return array; }
+};
+
 template <class T, std::size_t N>
 class cvector {
 public:
diff --git a/include/frozen/bits/pic_array.h b/include/frozen/bits/pic_array.h
index 8451754..97fb5e4 100644
--- a/include/frozen/bits/pic_array.h
+++ b/include/frozen/bits/pic_array.h
@@ -525,23 +525,23 @@ struct pic_array {
 
 // Helpers to preserve arrays in type information, instead of letting them decay to pointers
 template <typename T, typename U, std::size_t TN, std::size_t UN>
-constexpr std::pair<T (&)[TN], U (&)[UN]> kv_pair(T (& key)[TN], U (& val)[UN]) {
-  return {key, val};
+constexpr auto kv_pair(T (& key)[TN], U (& val)[UN]) {
+  return std::pair<bits::array_ref<T, TN>, bits::array_ref<U, UN>>{{key}, {val}};
 }
 
 template <typename T, typename U, std::size_t N>
-constexpr std::pair<T (&)[N], U> kv_pair(T (& key)[N], U val) {
-  return {key, val};
+constexpr auto kv_pair(T (& key)[N], U val) {
+  return std::pair<bits::array_ref<T, N>, U>{{key}, {val}};
 }
 
 template <typename T, typename U, std::size_t N>
-constexpr std::pair<T, U (&)[N]> kv_pair(T key, U (& val)[N]) {
-  return {key, val};
+constexpr auto kv_pair(T key, U (& val)[N]) {
+  return std::pair<T, bits::array_ref<U, N>>{{key}, {val}};
 }
 
 template <typename T, typename U>
-constexpr std::pair<T, U> kv_pair(T key, U val) {
-  return {key, val};
+constexpr auto kv_pair(T key, U val) {
+  return std::pair<T, U>{{key}, {val}};
 }
 
 } // namespace frozen
diff --git a/include/frozen/map.h b/include/frozen/map.h
index abb6349..ad0a425 100644
--- a/include/frozen/map.h
+++ b/include/frozen/map.h
@@ -361,55 +361,108 @@ constexpr auto make_map(std::array<std::pair<T, U>, N> const &items, Compare con
   return map<T, U, N, Compare>{items, compare};
 }
 
-template <typename T, typename U, typename Compare, std::size_t... KNs,
-          std::enable_if_t<!bits::is_pair<Compare>::value>* = nullptr>
+template <
+    typename T
+  , typename U
+  , typename Compare
+  , std::enable_if_t<
+      !bits::is_pair<Compare>::value
+    , std::size_t>... KNs
+  >
 constexpr auto make_map(
   Compare const& compare,
   std::pair<
-    bits::element_t<T> const (&)[KNs]
+    bits::array_ref<const bits::element_t<T>, KNs>
   , U> const&... items) {
   constexpr const auto key_storage_size = bits::accumulate({KNs...});
   using container_type = bits::pic_array<std::pair<const T, U>, sizeof...(KNs), key_storage_size>;
-  return map<T, U, sizeof...(KNs), Compare, container_type>{container_type{items...}, compare};
+  using value_type = typename container_type::value_type;
+  return map<T, U, sizeof...(KNs), Compare, container_type>{
+    container_type{value_type(T(items.first.array), U(items.second))...},
+    compare,
+  };
 }
 
-template <typename T, typename U, std::size_t... KNs>
-constexpr auto make_map(std::pair<bits::element_t<T> const (&)[KNs], U> const&... items) {
+template <
+    typename T
+  , typename U
+  , std::size_t... KNs
+  >
+constexpr auto make_map(
+  std::pair<
+    bits::array_ref<const bits::element_t<T>, KNs>
+  , U> const&... items) {
   return make_map<T, U>(std::less<T>{}, items...);
 }
 
-template <typename T, typename U, typename Compare, std::size_t... VNs,
-          std::enable_if_t<!bits::is_pair<Compare>::value>* = nullptr>
+template <
+    typename T
+  , typename U
+  , typename Compare
+  , std::enable_if_t<
+      !bits::is_pair<Compare>::value
+    , std::size_t>... VNs
+  >
 constexpr auto make_map(
   Compare const& compare,
   std::pair<
     T
-  , bits::element_t<U> const (&)[VNs]> const&... items) {
+  , bits::array_ref<const bits::element_t<U>, VNs>> const&... items) {
   constexpr const auto key_storage_size = bits::accumulate({VNs...});
   using container_type = bits::pic_array<std::pair<const T, U>, sizeof...(VNs), key_storage_size>;
-  return map<T, U, sizeof...(VNs), Compare, container_type>{container_type{items...}, compare};
+  using value_type = typename container_type::value_type;
+  return map<T, U, sizeof...(VNs), Compare, container_type>{
+    container_type{value_type(T(items.first), U(items.second.array))...},
+    compare,
+  };
 }
 
-template <typename T, typename U, std::size_t... KNs>
-constexpr auto make_map(std::pair<T, bits::element_t<U> const (&)[KNs]> const&... items) {
+template <
+    typename T
+  , typename U
+  , std::size_t... KNs
+  >
+constexpr auto make_map(
+  std::pair<
+    T
+  , bits::array_ref<const bits::element_t<U>, KNs>> const&... items) {
   return make_map<T, U>(std::less<T>{}, items...);
 }
 
-template <typename T, typename U, typename Compare, std::size_t... KNs, std::size_t... VNs,
-          std::enable_if_t<!bits::is_pair<Compare>::value>* = nullptr>
+template <
+    typename T
+  , typename U
+  , typename Compare
+  , std::size_t... KNs
+  , std::enable_if_t<
+      !bits::is_pair<Compare>::value
+    , std::size_t>... VNs
+  >
 constexpr auto make_map(
   Compare const& compare,
   std::pair<
-    bits::element_t<T> const (&)[KNs]
-  , bits::element_t<U> const (&)[VNs]> const&... items) {
+    bits::array_ref<const bits::element_t<T>, KNs>
+  , bits::array_ref<const bits::element_t<U>, VNs>> const&... items) {
   constexpr const auto key_storage_size = bits::accumulate({KNs...});
   constexpr const auto val_storage_size = bits::accumulate({VNs...});
   using container_type = bits::pic_array<std::pair<const T, U>, sizeof...(KNs), key_storage_size + val_storage_size>;
-  return map<T, U, sizeof...(KNs), Compare, container_type>{container_type{items...}, compare};
+  using value_type = typename container_type::value_type;
+  return map<T, U, sizeof...(KNs), Compare, container_type>{
+    container_type{value_type(T(items.first.array), U(items.second.array))...},
+    compare,
+  };
 }
 
-template <typename T, typename U, std::size_t... KNs, std::size_t... VNs>
-constexpr auto make_map(std::pair<bits::element_t<T> const (&)[KNs], bits::element_t<U> const (&)[VNs]> const&... items) {
+template <
+    typename T
+  , typename U
+  , std::size_t... KNs
+  , std::size_t... VNs
+  >
+constexpr auto make_map(
+  std::pair<
+    bits::array_ref<const bits::element_t<T>, KNs>
+  , bits::array_ref<const bits::element_t<U>, VNs>> const&... items) {
   return make_map<T, U>(std::less<T>{}, items...);
 }
 
diff --git a/include/frozen/unordered_map.h b/include/frozen/unordered_map.h
index 4bf7e19..5591307 100644
--- a/include/frozen/unordered_map.h
+++ b/include/frozen/unordered_map.h
@@ -251,77 +251,145 @@ constexpr auto make_unordered_map(
   return unordered_map<T, U, N, Hasher, Equal>{items, hash, equal};
 }
 
-template <typename T, typename U, typename Hasher, typename Equal, std::size_t... KNs,
-          std::enable_if_t<
-             !bits::has_type<bits::element_type<U>>::value
-          && !bits::is_pair<Hasher>::value
-          && !bits::is_pair<Equal>::value>* = nullptr>
+template <
+    typename T
+  , typename U
+  , typename Hasher
+  , typename Equal
+  , typename ElemT
+  , std::enable_if_t<
+      !bits::has_type<bits::element_type<U>>::value
+   && !bits::is_pair<Hasher>::value
+   && !bits::is_pair<Equal>::value
+   && std::is_same<ElemT, bits::element_t<T>>::value
+    , std::size_t>... KNs
+  >
 constexpr auto make_unordered_map(
   Hasher const &hash,
   Equal const &equal,
   std::pair<
-    bits::element_t<T> const (&)[KNs]
+    bits::array_ref<const ElemT, KNs>
   , U> const&... items) {
   constexpr const auto key_storage_size = bits::accumulate({KNs...});
   using container_type = bits::pic_array<std::pair<const T, U>, sizeof...(KNs), key_storage_size>;
-  return unordered_map<T, U, sizeof...(KNs), Hasher, Equal, container_type>{container_type{items...}, hash, equal};
+  using value_type = typename container_type::value_type;
+  return unordered_map<T, U, sizeof...(KNs), Hasher, Equal, container_type>{
+    container_type{value_type(T(items.first.array), U(items.second))...},
+    hash,
+    equal,
+  };
 }
 
-template <typename T, typename U, std::size_t... KNs,
-          std::enable_if_t<!bits::has_type<bits::element_type<U>>::value>* = nullptr>
+template <
+    typename T
+  , typename U
+  , typename ElemT
+  , std::enable_if_t<
+      !bits::has_type<bits::element_type<U>>::value
+   && std::is_same<ElemT, bits::element_t<T>>::value
+    , std::size_t>... KNs
+  >
 constexpr auto make_unordered_map(
   std::pair<
-    bits::element_t<T> const (&)[KNs]
+    bits::array_ref<const ElemT, KNs>
   , U> const&... items) {
   return make_unordered_map<T, U>(anna<T>{}, std::equal_to<T>{}, items...);
 }
 
-template <typename T, typename U, typename Hasher, typename Equal, std::size_t... VNs,
-          std::enable_if_t<
-            !bits::has_type<bits::element_type<T>>::value
-         && !bits::is_pair<Hasher>::value
-         && !bits::is_pair<Equal>::value>* = nullptr>
+template <
+    typename T
+  , typename U
+  , typename Hasher
+  , typename Equal
+  , typename ElemT
+  , std::enable_if_t<
+      !bits::has_type<bits::element_type<T>>::value
+   && !bits::is_pair<Hasher>::value
+   && !bits::is_pair<Equal>::value
+   && std::is_same<ElemT, bits::element_t<U>>::value
+    , std::size_t>... VNs
+  >
 constexpr auto make_unordered_map(
   Hasher const &hash,
   Equal const &equal,
   std::pair<
     T
-  , bits::element_t<U> const (&)[VNs]
+  , bits::array_ref<const ElemT, VNs>
   > const&... items) {
   constexpr const auto val_storage_size = bits::accumulate({VNs...});
   using container_type = bits::pic_array<std::pair<const T, U>, sizeof...(VNs), val_storage_size>;
-  return unordered_map<T, U, sizeof...(VNs), Hasher, Equal, container_type>{container_type{items...}, hash, equal};
+  using value_type = typename container_type::value_type;
+  return unordered_map<T, U, sizeof...(VNs), Hasher, Equal, container_type>{
+    container_type{value_type(T(items.first), U(items.second.array))...},
+    hash,
+    equal,
+  };
 }
 
-template <typename T, typename U, std::size_t... VNs,
-          std::enable_if_t<!bits::has_type<bits::element_type<T>>::value>* = nullptr>
+template <
+    typename T
+  , typename U
+  , typename ElemT
+  , std::enable_if_t<
+      !bits::has_type<bits::element_type<T>>::value
+   && std::is_same<ElemT, bits::element_t<U>>::value
+    , std::size_t>... VNs
+  >
 constexpr auto make_unordered_map(
   std::pair<
     T
-  , bits::element_t<U> const (&)[VNs]
+  , bits::array_ref<const ElemT, VNs>
   > const&... items) {
   return make_unordered_map<T, U>(anna<T>{}, std::equal_to<T>{}, items...);
 }
 
-template <typename T, typename U, typename Hasher, typename Equal, std::size_t... KNs, std::size_t... VNs,
-          std::enable_if_t<!bits::is_pair<Hasher>::value && !bits::is_pair<Equal>::value>* = nullptr>
+template <
+    typename T
+  , typename U
+  , typename Hasher
+  , typename Equal
+  , typename ElemT
+  , typename ElemU
+  , std::size_t... KNs
+  , std::enable_if_t<
+      !bits::is_pair<Hasher>::value
+   && !bits::is_pair<Equal>::value
+   && std::is_same<ElemT, bits::element_t<T>>::value
+   && std::is_same<ElemU, bits::element_t<U>>::value
+    , std::size_t>... VNs
+  >
 constexpr auto make_unordered_map(
   Hasher const &hash,
   Equal const &equal,
   std::pair<
-    bits::element_t<T> const (&)[KNs]
-  , bits::element_t<U> const (&)[VNs]
+    bits::array_ref<const ElemT, KNs>
+  , bits::array_ref<const ElemU, VNs>
   > const&... items) {
   constexpr const auto key_storage_size = bits::accumulate({KNs...});
   constexpr const auto val_storage_size = bits::accumulate({VNs...});
   using container_type = bits::pic_array<std::pair<const T, U>, sizeof...(KNs), key_storage_size + val_storage_size>;
-  return unordered_map<T, U, sizeof...(KNs), Hasher, Equal, container_type>{container_type{items...}, hash, equal};
+  using value_type = typename container_type::value_type;
+  return unordered_map<T, U, sizeof...(KNs), Hasher, Equal, container_type>{
+    container_type{value_type(T(items.first.array), U(items.second.array))...},
+    hash,
+    equal,
+  };
 }
 
-template <typename T, typename U, std::size_t... KNs, std::size_t... VNs>
+template <
+    typename T
+  , typename U
+  , typename ElemT
+  , typename ElemU
+  , std::size_t... KNs
+  , std::enable_if_t<
+      std::is_same<ElemT, bits::element_t<T>>::value
+   && std::is_same<ElemU, bits::element_t<U>>::value
+    , std::size_t>... VNs
+  >
 constexpr auto make_unordered_map(std::pair<
-    bits::element_t<T> const (&)[KNs]
-  , bits::element_t<U> const (&)[VNs]
+    bits::array_ref<const ElemT, KNs>
+  , bits::array_ref<const ElemU, VNs>
   > const&... items) {
   return make_unordered_map<T, U>(anna<T>{}, std::equal_to<T>{}, items...);
 }
diff --git a/tests/test_map.cpp b/tests/test_map.cpp
index 566a8eb..4d353e7 100644
--- a/tests/test_map.cpp
+++ b/tests/test_map.cpp
@@ -499,3 +499,23 @@ TEST_CASE("frozen::map <> frozen::make_map transparent", "[map]") {
     REQUIRE(frozen_empty_map3.begin() == frozen_empty_map3.end());
   }
 }
+
+TEST_CASE("frozen::make_map variations with frozen::string", "[map]") {
+  using frozen::kv_pair;
+
+  constexpr auto si = frozen::make_map<frozen::string, int>(
+      kv_pair("a", 1)
+    , kv_pair("b", 2)
+  );
+  constexpr auto is = frozen::make_map<int, frozen::string>(
+      kv_pair(1, "a")
+    , kv_pair(2, "b")
+  );
+  constexpr auto ss = frozen::make_map<frozen::string, frozen::string>(
+      kv_pair("1", "a")
+    , kv_pair("2", "b")
+  );
+
+  static_assert(is.at(si.at("a")) == "a", "");
+  static_assert(ss.at("1") == "a", "");
+}
diff --git a/tests/test_unordered_map_str.cpp b/tests/test_unordered_map_str.cpp
index 35bb9db..29dd3fc 100644
--- a/tests/test_unordered_map_str.cpp
+++ b/tests/test_unordered_map_str.cpp
@@ -86,3 +86,23 @@ TEST_CASE("various frozen::unordered_map config", "[unordered_map]") {
   (void)olaf0;
   (void)olaf1;
 }
+
+TEST_CASE("frozen::make_unordered_map variations with frozen::string", "[unordered_map]") {
+  using frozen::kv_pair;
+
+  constexpr auto si = frozen::make_unordered_map<frozen::string, int>(
+      kv_pair("a", 1)
+    , kv_pair("b", 2)
+  );
+  constexpr auto is = frozen::make_unordered_map<int, frozen::string>(
+      kv_pair(1, "a")
+    , kv_pair(2, "b")
+  );
+  constexpr auto ss = frozen::make_unordered_map<frozen::string, frozen::string>(
+      kv_pair("1", "a")
+    , kv_pair("2", "b")
+  );
+
+  static_assert(is.at(si.at("a")) == "a", "");
+  static_assert(ss.at("1") == "a", "");
+}