diff --git a/README.md b/README.md
index ab42327..0554bf8 100644
--- a/README.md
+++ b/README.md
@@ -111,15 +111,34 @@ void parsing()
     auto opt_v = value.find("not_exists");
     std::cout << "Did we find the \"not_exists\"? " << opt_v.has_value() << std::endl;
 
-    std::vector<int> to_vec = value["list"].to_vector<int>();
-    std::list<int> to_list = value["list"].to_vector<int, std::list>();
-    std::set<int> to_set = value["list"].to_vector<int, std::set>();
+    bool is_vec = value["list"].is<std::vector<int>>();
+
+    std::vector<int> to_vec = value["list"].as_collection<int>();
+    to_vec = (std::vector<int>)value["list"];       // same as above
+    to_vec = value["list"].as<std::vector<int>>();  // same as above
+
     // Output: 1, 2, 3
     for (auto&& i : to_vec) {
         std::cout << i << std::endl;
     }
-    std::map<std::string, std::string> to_map = value["author"].to_map<std::string>();
-    auto to_hashmap = value["author"].to_map<std::string, std::unordered_map>();
+
+    std::list<int> to_list = value["list"].as_collection<int, std::list>();
+    to_list = (std::list<int>)value["list"];        // same as above
+    to_list = value["list"].as<std::list<int>>();   // same as above
+
+    std::set<int> to_set = value["list"].as_collection<int, std::set>();
+    to_set = (std::set<int>)value["list"];          // same as above
+    to_set = value["list"].as<std::set<int>>();     // same as above
+    
+    bool is_map = value["author"].is<std::map<std::string, std::string>>();
+
+    std::map<std::string, std::string> to_map = value["author"].as_map<std::string>();
+    to_map = (std::map<std::string, std::string>)value["author"];       // same as above
+    to_map = value["author"].as<std::map<std::string, std::string>>();  // same as above
+
+    auto to_hashmap = value["author"].as_map<std::string, std::unordered_map>();
+    to_hashmap = (std::unordered_map<std::string, std::string>)value["author"];     // same as above
+    to_hashmap = value["author"].as<std::unordered_map<std::string, std::string>>();// same as above
 
     // Output: "literals"
     using namespace json::literals;
diff --git a/README_en.md b/README_en.md
index a0f1699..9abab83 100644
--- a/README_en.md
+++ b/README_en.md
@@ -111,15 +111,34 @@ void parsing()
     auto opt_v = value.find("not_exists");
     std::cout << "Did we find the \"not_exists\"? " << opt_v.has_value() << std::endl;
 
-    std::vector<int> to_vec = value["list"].to_vector<int>();
-    std::list<int> to_list = value["list"].to_vector<int, std::list>();
-    std::set<int> to_set = value["list"].to_vector<int, std::set>();
+    bool is_vec = value["list"].is<std::vector<int>>();
+
+    std::vector<int> to_vec = value["list"].as_collection<int>();
+    to_vec = (std::vector<int>)value["list"];       // same as above
+    to_vec = value["list"].as<std::vector<int>>();  // same as above
+
     // Output: 1, 2, 3
     for (auto&& i : to_vec) {
         std::cout << i << std::endl;
     }
-    std::map<std::string, std::string> to_map = value["author"].to_map<std::string>();
-    auto to_hashmap = value["author"].to_map<std::string, std::unordered_map>();
+
+    std::list<int> to_list = value["list"].as_collection<int, std::list>();
+    to_list = (std::list<int>)value["list"];        // same as above
+    to_list = value["list"].as<std::list<int>>();   // same as above
+
+    std::set<int> to_set = value["list"].as_collection<int, std::set>();
+    to_set = (std::set<int>)value["list"];          // same as above
+    to_set = value["list"].as<std::set<int>>();     // same as above
+    
+    bool is_map = value["author"].is<std::map<std::string, std::string>>();
+    
+    std::map<std::string, std::string> to_map = value["author"].as_map<std::string>();
+    to_map = (std::map<std::string, std::string>)value["author"];       // same as above
+    to_map = value["author"].as<std::map<std::string, std::string>>();  // same as above
+
+    auto to_hashmap = value["author"].as_map<std::string, std::unordered_map>();
+    to_hashmap = (std::unordered_map<std::string, std::string>)value["author"];     // same as above
+    to_hashmap = value["author"].as<std::unordered_map<std::string, std::string>>();// same as above
 
     // Output: "literals"
     using namespace json::literals;
diff --git a/include/json.hpp b/include/json.hpp
index 4790ae2..2fd001f 100644
--- a/include/json.hpp
+++ b/include/json.hpp
@@ -43,6 +43,22 @@ namespace utils
     using iter_value_t = typename std::iterator_traits<remove_cvref_t<T>>::value_type;
     template <typename R>
     using range_value_t = iter_value_t<iterator_t<R>>;
+
+    template <typename T, typename = void>
+    constexpr bool is_container = false;
+    template <typename T>
+    constexpr bool is_container<T, std::void_t<typename T::value_type, utils::range_value_t<T>>> =
+        std::is_same_v<typename T::value_type, utils::range_value_t<T>>;
+
+    template <typename T, typename = void>
+    constexpr bool is_map = false;
+    template <typename T>
+    constexpr bool is_map<T, std::void_t<typename T::key_type, typename T::mapped_type>> = is_container<T>;
+
+    template <typename T, typename = void>
+    constexpr bool is_collection = false;
+    template <typename T>
+    constexpr bool is_collection<T> = is_container<T> && !is_map<T>;
 }
 
 // *********************************
@@ -132,6 +148,9 @@ class basic_value
     template <typename value_t>
     bool is() const noexcept;
 
+    template <typename value_t>
+    bool all() const;
+
     bool contains(const string_t& key) const;
     bool contains(size_t pos) const;
     bool exists(const string_t& key) const { return contains(key); }
@@ -165,6 +184,12 @@ class basic_value
     string_t as_string() const;
     const basic_array<string_t>& as_array() const;
     const basic_object<string_t>& as_object() const;
+
+    template <typename value_t, template <typename...> typename collection_t = std::vector>
+    collection_t<value_t> as_collection() const;
+    template <typename value_t, template <typename...> typename map_t = std::map>
+    map_t<string_t, value_t> as_map() const;
+
     template <typename value_t>
     value_t as() const;
 
@@ -194,12 +219,18 @@ class basic_value
         return format(indent, 0);
     }
 
-    template <typename value_t>
-    bool all() const;
     template <typename value_t, template <typename...> typename vector_t = std::vector>
-    vector_t<value_t> to_vector() const;
+    // deprecated, please use `as_collection` instead.
+    vector_t<value_t> to_vector() const
+    {
+        return to_vector<value_t, vector_t>();
+    }
     template <typename value_t, template <typename...> typename map_t = std::map>
-    map_t<string_t, value_t> to_map() const;
+    // deprecated, please use `as_map` instead.
+    map_t<string_t, value_t> to_map() const
+    {
+        return as_map<value_t, map_t>();
+    }
 
     basic_value<string_t>& operator=(const basic_value<string_t>& rhs);
     basic_value<string_t>& operator=(basic_value<string_t>&&) noexcept;
@@ -240,6 +271,19 @@ class basic_value
     explicit operator long double() const { return as_long_double(); }
     explicit operator string_t() const { return as_string(); }
 
+    template <typename value_t, template <typename...> typename collection_t = std::vector,
+              typename _ = std::enable_if_t<utils::is_collection<collection_t<value_t>>>>
+    explicit operator collection_t<value_t>() const
+    {
+        return as_collection<value_t, collection_t>();
+    }
+    template <typename value_t, template <typename...> typename map_t = std::map,
+              typename _ = std::enable_if_t<utils::is_map<map_t<string_t, value_t>>>>
+    explicit operator map_t<string_t, value_t>() const
+    {
+        return as_map<value_t, map_t>();
+    }
+
 private:
     friend class basic_array<string_t>;
     friend class basic_object<string_t>;
@@ -317,8 +361,8 @@ class basic_array
     }
     template <typename value_t>
     bool all() const;
-    template <typename value_t, template <typename...> typename vector_t = std::vector>
-    vector_t<value_t> to_vector() const;
+    template <typename value_t, template <typename...> typename collection_t = std::vector>
+    collection_t<value_t> as_collection() const;
 
     // Usage: get(key_1, key_2, ..., default_value);
     template <typename... key_then_default_value_t>
@@ -432,7 +476,7 @@ class basic_object
     template <typename value_t>
     bool all() const;
     template <typename value_t, template <typename...> typename map_t = std::map>
-    map_t<string_t, value_t> to_map() const;
+    map_t<string_t, value_t> as_map() const;
 
     // Usage: get(key_1, key_2, ..., default_value);
     template <typename... key_then_default_value_t>
@@ -733,19 +777,26 @@ inline bool basic_value<string_t>::is() const noexcept
         return true;
     }
     else if constexpr (std::is_same_v<bool, value_t>) {
-        return _type == value_type::boolean;
+        return is_boolean();
     }
     else if constexpr (std::is_arithmetic_v<value_t>) {
-        return _type == value_type::number;
+        return is_number();
     }
     else if constexpr (std::is_same_v<basic_array<string_t>, value_t>) {
-        return _type == value_type::array;
+        return is_array();
+    }
+    else if constexpr (utils::is_collection<value_t>) {
+        return is_array() && all<typename value_t::value_type>();
     }
     else if constexpr (std::is_same_v<basic_object<string_t>, value_t>) {
-        return _type == value_type::object;
+        return is_object();
+    }
+    else if constexpr (utils::is_map<value_t>) {
+        return is_object() && std::is_constructible_v<string_t, typename value_t::key_type> &&
+               all<typename value_t::mapped_type>();
     }
     else if constexpr (std::is_constructible_v<string_t, value_t>) {
-        return _type == value_type::string;
+        return is_string();
     }
     else {
         static_assert(!sizeof(value_t), "Unsupported type");
@@ -1174,17 +1225,17 @@ inline bool basic_value<string_t>::all() const
 }
 
 template <typename string_t>
-template <typename value_t, template <typename...> typename vector_t>
-inline vector_t<value_t> basic_value<string_t>::to_vector() const
+template <typename value_t, template <typename...> typename collection_t>
+inline collection_t<value_t> basic_value<string_t>::as_collection() const
 {
-    return as_array().template to_vector<value_t, vector_t>();
+    return as_array().template as_collection<value_t, collection_t>();
 }
 
 template <typename string_t>
 template <typename value_t, template <typename...> typename map_t>
-inline map_t<string_t, value_t> basic_value<string_t>::to_map() const
+inline map_t<string_t, value_t> basic_value<string_t>::as_map() const
 {
-    return as_object().template to_map<value_t, map_t>();
+    return as_object().template as_map<value_t, map_t>();
 }
 
 template <typename string_t>
@@ -1465,7 +1516,7 @@ inline bool basic_array<string_t>::all() const
     return true;
 }
 
-namespace _to_vector_helper
+namespace _as_collection_helper
 {
     template <typename T>
     class has_emplace_back
@@ -1482,12 +1533,12 @@ namespace _to_vector_helper
 }
 
 template <typename string_t>
-template <typename value_t, template <typename...> typename vector_t>
-inline vector_t<value_t> basic_array<string_t>::to_vector() const
+template <typename value_t, template <typename...> typename collection_t>
+inline collection_t<value_t> basic_array<string_t>::as_collection() const
 {
 
-    vector_t<value_t> result;
-    if constexpr (_to_vector_helper::has_emplace_back<vector_t<value_t>>::value) {
+    collection_t<value_t> result;
+    if constexpr (_as_collection_helper::has_emplace_back<collection_t<value_t>>::value) {
         for (const auto& elem : _array_data) {
             result.emplace_back(elem.template as<value_t>());
         }
@@ -1819,7 +1870,7 @@ inline bool basic_object<string_t>::all() const
 
 template <typename string_t>
 template <typename value_t, template <typename...> typename map_t>
-inline map_t<string_t, value_t> basic_object<string_t>::to_map() const
+inline map_t<string_t, value_t> basic_object<string_t>::as_map() const
 {
     map_t<string_t, value_t> result;
     for (const auto& [key, val] : _object_data) {
@@ -2586,22 +2637,6 @@ namespace _serialization_helper
         static constexpr bool value = decltype(test<T>(0))::value;
     };
 
-    template <typename T, typename = void>
-    constexpr bool is_container = false;
-    template <typename T>
-    constexpr bool is_container<T, std::void_t<typename T::value_type, utils::range_value_t<T>>> =
-        std::is_same_v<typename T::value_type, utils::range_value_t<T>>;
-
-    template <typename T, typename = void>
-    constexpr bool is_map = false;
-    template <typename T>
-    constexpr bool is_map<T, std::void_t<typename T::key_type, typename T::mapped_type>> = is_container<T>;
-
-    template <typename T, typename = void>
-    constexpr bool is_collection = false;
-    template <typename T>
-    constexpr bool is_collection<T> = is_container<T> && !is_map<T>;
-
     template <bool loose, typename string_t>
     struct string_converter
     {
@@ -2664,7 +2699,7 @@ basic_value<string_t> serialize(any_t&& arg, string_converter_t&& string_convert
     else if constexpr (std::decay_t<string_converter_t>::template is_convertible<any_t>) {
         return string_converter(std::forward<any_t>(arg));
     }
-    else if constexpr (is_collection<std::decay_t<any_t>>) {
+    else if constexpr (utils::is_collection<std::decay_t<any_t>>) {
         basic_value<string_t> result;
         for (auto&& val : arg) {
             using value_t = decltype(val);
@@ -2674,7 +2709,7 @@ basic_value<string_t> serialize(any_t&& arg, string_converter_t&& string_convert
         }
         return result;
     }
-    else if constexpr (is_map<std::decay_t<any_t>>) {
+    else if constexpr (utils::is_map<std::decay_t<any_t>>) {
         basic_value<string_t> result;
         for (auto&& [key, val] : arg) {
             using key_t = decltype(key);
diff --git a/sample/sample.cpp b/sample/sample.cpp
index f893295..e00c3be 100644
--- a/sample/sample.cpp
+++ b/sample/sample.cpp
@@ -3,8 +3,8 @@
 #include <list>
 #include <map>
 #include <set>
-#include <vector>
 #include <unordered_map>
+#include <vector>
 
 #include "json.hpp"
 
@@ -103,16 +103,36 @@ bool parsing()
     auto opt_v = value.find("not_exists");
     std::cout << "Did we find the \"not_exists\"? " << opt_v.has_value() << std::endl;
 
-    std::vector<int> to_vec = value["list"].to_vector<int>();
-    std::list<int> to_list = value["list"].to_vector<int, std::list>();
-    std::set<int> to_set = value["list"].to_vector<int, std::set>();
-    // Output: 1, 2, 3
-    for (auto&& i : to_vec) {
-        std::cout << i << std::endl;
+    bool is_vec = value["list"].is<std::vector<int>>();
+    if (is_vec) {
+        std::vector<int> to_vec = value["list"].as_collection<int>();
+        to_vec = (std::vector<int>)value["list"];
+        to_vec = value["list"].as<std::vector<int>>();
+
+        // Output: 1, 2, 3
+        for (auto&& i : to_vec) {
+            std::cout << i << std::endl;
+        }
+    }
+
+    std::list<int> to_list = value["list"].as_collection<int, std::list>();
+    to_list = (std::list<int>)value["list"];
+    to_list = value["list"].as<std::list<int>>();
+
+    std::set<int> to_set = value["list"].as_collection<int, std::set>();
+    to_set = (std::set<int>)value["list"];
+    to_set = value["list"].as<std::set<int>>();
+
+    bool is_map = value["author"].is<std::map<std::string, std::string>>();
+    if (is_map) {
+        std::map<std::string, std::string> to_map = value["author"].as_map<std::string>();
+        to_map = (std::map<std::string, std::string>)value["author"];
+        to_map = value["author"].as<std::map<std::string, std::string>>();
     }
 
-    std::map<std::string, std::string> to_map = value["author"].to_map<std::string>();
-    auto to_hashmap = value["author"].to_map<std::string, std::unordered_map>();
+    auto to_hashmap = value["author"].as_map<std::string, std::unordered_map>();
+    to_hashmap = (std::unordered_map<std::string, std::string>)value["author"];
+    to_hashmap = value["author"].as<std::unordered_map<std::string, std::string>>();
 
     using namespace json::literals;
     json::value val = "{\"hi\":\"literals\"}"_json;
diff --git a/test/serializing_test.cpp b/test/serializing_test.cpp
index ae094f9..e7bd1a9 100644
--- a/test/serializing_test.cpp
+++ b/test/serializing_test.cpp
@@ -43,13 +43,13 @@ bool serializing()
         std::cerr << "not all int: " << root["arr"].as_string() << std::endl;
         return false;
     }
-    auto to_vec = root["arr"].to_vector<int>();
-    auto to_vec_2 = root["arr"].to_vector<int, std::vector>();
-    auto to_list = root["arr"].to_vector<int, std::list>();
-    auto to_set = root["arr"].to_vector<int, std::set>();
-    auto to_hashset = root["arr"].to_vector<int, std::unordered_set>();
-    auto to_deque = root["arr"].to_vector<int, std::deque>();
-    auto to_q = root["arr"].to_vector<int, std::queue>();
+    auto to_vec = root["arr"].as_collection<int>();
+    auto to_vec_2 = root["arr"].as_collection<int, std::vector>();
+    auto to_list = root["arr"].as_collection<int, std::list>();
+    auto to_set = root["arr"].as_collection<int, std::set>();
+    auto to_hashset = root["arr"].as_collection<int, std::unordered_set>();
+    auto to_deque = root["arr"].as_collection<int, std::deque>();
+    auto to_q = root["arr"].as_collection<int, std::queue>();
     
 
     std::vector<int> vec = { 1, 2, 3, 4, 5 };
@@ -69,9 +69,9 @@ bool serializing()
         std::cerr << "not all int: " << root["obj from map"].as_string() << std::endl;
         return false;
     }
-    auto to_map = root["obj from map"].to_map<int>();
-    auto to_map_2 = root["obj from map"].to_map<int, std::map>();
-    auto to_hashmap = root["obj from map"].to_map<int, std::unordered_map>();
+    auto as_map = root["obj from map"].as_map<int>();
+    auto as_map_2 = root["obj from map"].as_map<int, std::map>();
+    auto to_hashmap = root["obj from map"].as_map<int, std::unordered_map>();
 
     std::vector<std::list<std::set<int>>> complex { { { 1, 2, 3 }, { 4, 5 } }, { { 6 }, { 7, 8 } } };
     root["complex"] = json::serialize<false>(complex);