feat: use detail::none_t instead of char

Although the error value from combinators currently does not have any
information, it can have an information because it is a char value. It
is better to use no-information-type explicitly to make it clear that
it does not have any information. So I added none_t in toml::detai and
use it in combinators and parsers as an error value from combinators.

.travis.yml

@@ -5,7 +5,7 @@ matrix:
   - os: linux
     language: cpp
     compiler: gcc
-    env: COMPILER="g++-5"
+    env: COMPILER="g++-5" CXX_STANDARD=11
     addons:
       apt:
         sources:
@@ -16,7 +16,7 @@ matrix:
   - os: linux
     language: cpp
     compiler: gcc
-    env: COMPILER="g++-6"
+    env: COMPILER="g++-6" CXX_STANDARD=11
     addons:
       apt:
         sources:
@@ -27,7 +27,7 @@ matrix:
   - os: linux
     language: cpp
     compiler: gcc
-    env: COMPILER="g++-7"
+    env: COMPILER="g++-7" CXX_STANDARD=11
     addons:
       apt:
         sources:
@@ -38,7 +38,18 @@ matrix:
   - os: linux
     language: cpp
     compiler: gcc
-    env: COMPILER="g++-8"
+    env: COMPILER="g++-8" CXX_STANDARD=11
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        packages:
+        - g++-8
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: gcc
+    env: COMPILER="g++-8" CXX_STANDARD=17
     addons:
       apt:
         sources:
@@ -49,7 +60,7 @@ matrix:
   - os: linux
     language: cpp
     compiler: clang
-    env: COMPILER="clang++-3.7"
+    env: COMPILER="clang++-3.7" CXX_STANDARD=11
     addons:
       apt:
         sources:
@@ -61,7 +72,7 @@ matrix:
   - os: linux
     language: cpp
     compiler: clang
-    env: COMPILER="clang++-4.0"
+    env: COMPILER="clang++-4.0" CXX_STANDARD=11
     addons:
       apt:
         sources:
@@ -73,7 +84,7 @@ matrix:
   - os: linux
     language: cpp
     compiler: clang
-    env: COMPILER="clang++-5.0"
+    env: COMPILER="clang++-5.0" CXX_STANDARD=11
     addons:
       apt:
         sources:
@@ -85,7 +96,7 @@ matrix:
   - os: linux
     language: cpp
     compiler: clang
-    env: COMPILER="clang++-6.0"
+    env: COMPILER="clang++-6.0" CXX_STANDARD=11
     addons:
       apt:
         sources:
@@ -97,7 +108,7 @@ matrix:
   - os: linux
     language: cpp
     compiler: clang
-    env: COMPILER="clang++-7"
+    env: COMPILER="clang++-7" CXX_STANDARD=11
     addons:
       apt:
         sources:
@@ -109,7 +120,7 @@ matrix:
   - os: linux
     language: cpp
     compiler: clang
-    env: COMPILER="clang++-8"
+    env: COMPILER="clang++-8" CXX_STANDARD=11
     addons:
       apt:
         sources:
@@ -118,14 +129,38 @@ matrix:
         packages:
         - clang-8
         - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-8" CXX_STANDARD=17
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-8
+        packages:
+        - clang-8
+        - g++-8
+        - libboost-all-dev
   - os: osx
     language: cpp
     compiler: clang
+    env: CXX_STANDARD=11
 
 script:
+- |
+  if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
+    mkdir -p cmake
+    travis_retry wget "https://cmake.org/files/v3.11/cmake-3.11.2-Linux-x86_64.tar.gz"
+    tar xf cmake-3.11.2-Linux-x86_64.tar.gz -C cmake --strip-components=1
+    export PATH=${TRAVIS_BUILD_DIR}/cmake/bin:${PATH}
+  else
+    brew upgrade cmake
+  fi
+- cmake --version
 - mkdir build
 - cd build
 - git clone https://github.com/toml-lang/toml.git
-- cmake -DCMAKE_CXX_COMPILER=$COMPILER ..
+- cmake -DCMAKE_CXX_COMPILER=$COMPILER -DCMAKE_CXX_STANDARD=$CXX_STANDARD ..
 - make
 - ctest --output-on-failure

CMakeLists.txt

@@ -4,7 +4,10 @@ project(toml11)
 
 include(CheckCXXCompilerFlag)
 if("${CMAKE_VERSION}" VERSION_GREATER 3.1)
-    set(CMAKE_CXX_STANDARD 11)
+    set(CMAKE_CXX_EXTENSIONS OFF)
+    if(NOT DEFINED CMAKE_CXX_STANDARD)
+        set(CMAKE_CXX_STANDARD 11)
+    endif()
     set(CXX_STANDARD_REQUIRED ON)
 else()
     # Manually check for C++11 compiler flag.

README.md

@@ -63,6 +63,7 @@ int main()
 - [Conversion between toml value and arbitrary types](#conversion-between-toml-value-and-arbitrary-types)
 - [Invalid UTF-8 Codepoints](#invalid-utf-8-codepoints)
 - [Formatting user-defined error messages](#formatting-user-defined-error-messages)
+- [Getting comments related to a value](#getting-comments)
 - [Serializing TOML data](#serializing-toml-data)
 - [Underlying types](#underlying-types)
 - [Running Tests](#running-tests)
@@ -187,6 +188,12 @@ See also [underlying types](#underlying-types).
 
 NOTE: To enable to get a reference, conversions between Float and Integer are not supported.
 
+After C++17, you can use `std::string_view` to get a string from a `toml::value`.
+
+```cpp
+const auto sv = toml::get<std::string_view>(tab.at("key"));
+```
+
 ### In the case of type error
 
 If you pass an invalid type to `toml::get`, `toml::type_error` will be thrown.
@@ -500,9 +507,9 @@ You can check what type of value does `toml::value` contains by `is_*` function.
 
 ```cpp
 toml::value v = /* ... */;
-if(v.is_integer() && toml::get<int>(v) == 42)
+if(v.is_integer())
 {
-    std::cout << "value is 42" << std::endl;
+    std::cout << "value is an integer" << std::endl;
 }
 ```
 
@@ -546,6 +553,36 @@ toml::value v = /* ... */;
 if(v.is(toml::value_t::Boolean)) // ...
 ```
 
+## Casting value
+
+So far, `toml::get` is introduced, but if you don't need any type conversion,
+`as_*` is simpler to use.
+
+```cpp
+toml::value v = /* ... */;
+if(v.is_integer() && v.as_integer() == 42)
+{
+    std::cout << "value is 42" << std::endl;
+}
+```
+
+The complete list of the functions is below.
+
+```cpp
+const toml::value v(/*...*/);
+v.as_boolean();
+v.as_integer();
+v.as_float();
+v.as_string();
+v.as_offset_datetime();
+v.as_local_datetime();
+v.as_local_date();
+v.as_local_time();
+v.as_array();
+v.as_table();
+v.as_uninitialized();
+```
+
 ## Visiting a toml::value
 
 toml11 provides `toml::visit` to apply a function to `toml::value` in the
@@ -618,7 +655,7 @@ add a comma after the first element (like `[1,]`).
 "[[table]]"_toml; // This is a table that has an array of tables inside.
 
 "[[1]]"_toml;     // This literal is ambiguous.
-                  // Currently, it becomes a table taht has array of table "1".
+                  // Currently, it becomes a table that has array of table "1".
 "1 = [{}]"_toml;  // This is a table that has an array of table named 1.
 "[[1,]]"_toml;    // This is an array of arrays.
 "[[1],]"_toml;    // ditto.
@@ -831,6 +868,53 @@ you will get an error message like this.
    |       ~~ maximum number here
 ```
 
+## Getting comments
+
+Since toml11 keeps a file data until all the values are destructed, you can
+also extract a comment related to a value by calling `toml::value::comment()`.
+
+If there is a comment just after a value (within the same line), you can get
+the specific comment by `toml::value::comment_inline()`.
+
+If there are comments just before a value (without any newline between them),
+you can get the comments by `toml::value::comment_before()`.
+
+`toml::value::comment()` returns the results of both functions after
+concatenating them.
+
+```toml
+a = 42 # comment for a.
+
+# comment for b.
+# this is also a comment for b.
+b = "foo"
+
+c = [ # comment for c.
+    3.14, # this is not a comment for c, but for 3.14.
+] # this is also a comment for c.
+```
+
+```cpp
+// "# comment for a."
+const std::string com1 = toml::find(data, "a").comment();
+
+// "# comment for b."
+const std::string com2 = toml::find(data, "b").comment();
+
+// "# comment for c.\n# this is also a comment for c."
+const std::string com3 = toml::find(data, "c").comment();
+
+// "# this is not a comment for c, but for 3.14."
+const std::string com3 = toml::find<toml::array>(data, "c").front().comment();
+```
+
+Note that once a data in a value is modified, the related file region
+information would be deleted. Thus after modifying a data, you cannot find any
+comments.
+
+Also note that currently it does not support any way to set a comment to a value.
+And currently, serializer does not take comments into account.
+
 ## Serializing TOML data
 
 toml11 (after v2.1.0) enables you to serialize data into toml format.
@@ -984,6 +1068,8 @@ I appreciate the help of the contributors who introduced the great feature to th
   - Improved error messages for invaild keys to show the location where the parser fails
 - Petr Beneš (@wbenny)
   - Fixed warnings on MSVC
+- Ivan Shynkarenka (@chronoxor)
+  - Fixed Visual Studio 2019 warnings
 
 ## Licensing terms
 

tests/CMakeLists.txt

@@ -21,6 +21,7 @@ set(TEST_NAMES
     test_parse_key
     test_parse_table_key
     test_literals
+    test_comments
     test_get
     test_get_related_func
     test_from_toml

tests/test_comments.cpp

@@ -0,0 +1,125 @@
+#define BOOST_TEST_MODULE "test_comments"
+#ifdef UNITTEST_FRAMEWORK_LIBRARY_EXIST
+#include <boost/test/unit_test.hpp>
+#else
+#define BOOST_TEST_NO_LIB
+#include <boost/test/included/unit_test.hpp>
+#endif
+
+#include <toml.hpp>
+
+BOOST_AUTO_TEST_CASE(test_comment_before)
+{
+    using namespace toml::literals::toml_literals;
+    {
+        const toml::value v = u8R"(
+            # comment for a.
+            a = 42
+            # comment for b.
+            b = "baz"
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_before(), u8"# comment for a.");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_before(), u8"# comment for b.");
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_inline(), "");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_inline(), "");
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment(), u8"# comment for a.");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment(), u8"# comment for b.");
+    }
+
+    {
+        const toml::value v = u8R"(
+            # comment for a.
+            # another comment for a.
+            a = 42
+            # comment for b.
+            # also comment for b.
+            b = "baz"
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_before(), u8R"(# comment for a.
+# another comment for a.)");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_before(), u8R"(# comment for b.
+# also comment for b.)");
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_inline(), u8"");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_inline(), u8"");
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment(), u8R"(# comment for a.
+# another comment for a.)");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment(), u8R"(# comment for b.
+# also comment for b.)");
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_comment_inline)
+{
+    using namespace toml::literals::toml_literals;
+    {
+        const toml::value v = u8R"(
+            a = 42    # comment for a.
+            b = "baz" # comment for b.
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_before(), "");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_before(), "");
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_inline(), u8"# comment for a.");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_inline(), u8"# comment for b.");
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment(), u8"# comment for a.");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment(), u8"# comment for b.");
+    }
+    {
+        const toml::value v = u8R"(
+            a = [    # comment for a.
+                42,
+            ] # this also.
+            b = [ # comment for b.
+                "bar",
+            ]
+            c = [
+                3.14, # this is not a comment for c, but 3.14.
+            ] # comment for c.
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_before(), "");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_before(), "");
+        BOOST_CHECK_EQUAL(toml::find(v, "c").comment_before(), "");
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_inline(), u8R"(# comment for a.
+# this also.)");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_inline(), u8"# comment for b.");
+        BOOST_CHECK_EQUAL(toml::find(v, "c").comment_inline(), u8"# comment for c.");
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment(),  u8R"(# comment for a.
+# this also.)");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment(), u8"# comment for b.");
+        BOOST_CHECK_EQUAL(toml::find(v, "c").comment(), u8"# comment for c.");
+
+        const auto& c0 = toml::find<toml::array>(v, "c").at(0);
+        BOOST_CHECK_EQUAL(c0.comment(), u8"# this is not a comment for c, but 3.14.");
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_comment_both)
+{
+    using namespace toml::literals::toml_literals;
+    {
+        const toml::value v = u8R"(
+            # comment for a.
+            a = 42 # inline comment for a.
+            # comment for b.
+            b = "baz" # inline comment for b.
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_before(), "# comment for a.");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_before(), "# comment for b.");
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment_inline(), "# inline comment for a.");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment_inline(), "# inline comment for b.");
+
+        BOOST_CHECK_EQUAL(toml::find(v, "a").comment(), u8R"(# comment for a.
+# inline comment for a.)");
+        BOOST_CHECK_EQUAL(toml::find(v, "b").comment(), u8R"(# comment for b.
+# inline comment for b.)");
+    }
+}

tests/test_get.cpp

@@ -12,6 +12,9 @@
 #include <list>
 #include <deque>
 #include <array>
+#if __cplusplus >= 201703L
+#include <string_view>
+#endif
 
 
 BOOST_AUTO_TEST_CASE(test_get_exact)
@@ -166,6 +169,17 @@ BOOST_AUTO_TEST_CASE(test_get_string_type)
         toml::get<std::string>(v) += "bar";
         BOOST_CHECK_EQUAL("foobar", toml::get<std::string>(v));
     }
+
+#if __cplusplus >= 201703L
+    {
+        toml::value v("foo", toml::string_t::basic);
+        BOOST_CHECK_EQUAL("foo", toml::get<std::string_view>(v));
+    }
+    {
+        toml::value v("foo", toml::string_t::literal);
+        BOOST_CHECK_EQUAL("foo", toml::get<std::string_view>(v));
+    }
+#endif
 }
 
 BOOST_AUTO_TEST_CASE(test_get_toml_array)

tests/test_lex_aux.hpp

@@ -18,7 +18,7 @@ do {                                                                           \
     BOOST_CHECK_EQUAL(static_cast<std::size_t>(std::distance(                  \
                     loc.begin(), loc.iter())), region.size());                 \
     } else {                                                                   \
-    std::cerr << "lexer " << lxr::pattern() << " failed with input `";         \
+    std::cerr << "lexer failed with input `";                                  \
     std::cerr << token << "`. expected `" << expected << "`\n";                \
     std::cerr << "reason: " << result.unwrap_err() << '\n';                    \
     }                                                                          \

tests/test_value.cpp

@@ -9,6 +9,11 @@
 #include <map>
 #include <list>
 
+#if __cplusplus >= 201703L
+#include <string_view>
+#endif
+
+
 BOOST_AUTO_TEST_CASE(test_value_boolean)
 {
     toml::value v1(true);
@@ -25,6 +30,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), false);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
+    BOOST_CHECK_EQUAL(v2.as_boolean(), false);
 
     v1 = false;
     v2 = true;
@@ -40,6 +47,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), false);
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), false);
+    BOOST_CHECK_EQUAL(v2.as_boolean(), true);
 
     toml::value v3(v1);
     toml::value v4(v2);
@@ -57,6 +66,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
 
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Boolean>(), false);
     BOOST_CHECK_EQUAL(v4.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v3.as_boolean(), false);
+    BOOST_CHECK_EQUAL(v4.as_boolean(), true);
 
     toml::value v5(std::move(v1));
     toml::value v6(std::move(v2));
@@ -72,6 +83,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
 
     BOOST_CHECK_EQUAL(v5.cast<toml::value_t::Boolean>(), false);
     BOOST_CHECK_EQUAL(v6.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v5.as_boolean(), false);
+    BOOST_CHECK_EQUAL(v6.as_boolean(), true);
 
     v1 = 42;
     v2 = 3.14;
@@ -87,6 +100,8 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Integer>(), 42);
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Float>(),   3.14);
+    BOOST_CHECK_EQUAL(v1.as_integer(),  42);
+    BOOST_CHECK_EQUAL(v2.as_float(), 3.14);
 }
 
 BOOST_AUTO_TEST_CASE(test_value_integer)
@@ -105,6 +120,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Integer>(), -42);
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Integer>(),  42u);
+    BOOST_CHECK_EQUAL(v1.as_integer(), -42);
+    BOOST_CHECK_EQUAL(v2.as_integer(),  42u);
 
     v1 = 54;
     v2 = -54;
@@ -120,6 +137,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Integer>(),  54);
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Integer>(), -54);
+    BOOST_CHECK_EQUAL(v1.as_integer(),  54);
+    BOOST_CHECK_EQUAL(v2.as_integer(), -54);
 
     toml::value v3(v1);
     toml::value v4(v2);
@@ -137,6 +156,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
 
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Integer>(),  54);
     BOOST_CHECK_EQUAL(v4.cast<toml::value_t::Integer>(), -54);
+    BOOST_CHECK_EQUAL(v3.as_integer(),  54);
+    BOOST_CHECK_EQUAL(v4.as_integer(), -54);
 
     toml::value v5(std::move(v1));
     toml::value v6(std::move(v2));
@@ -152,6 +173,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
 
     BOOST_CHECK_EQUAL(v5.cast<toml::value_t::Integer>(),  54);
     BOOST_CHECK_EQUAL(v6.cast<toml::value_t::Integer>(), -54);
+    BOOST_CHECK_EQUAL(v5.as_integer(),  54);
+    BOOST_CHECK_EQUAL(v6.as_integer(), -54);
 
     v1 = true;
     v2 = false;
@@ -167,6 +190,8 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), false);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
+    BOOST_CHECK_EQUAL(v2.as_boolean(), false);
 }
 
 BOOST_AUTO_TEST_CASE(test_value_float)
@@ -183,8 +208,10 @@ BOOST_AUTO_TEST_CASE(test_value_float)
     BOOST_CHECK(v1.is_float());
     BOOST_CHECK(v2.is_float());
 
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Float>(), 3.14);
+    BOOST_CHECK_EQUAL         (v1.cast<toml::value_t::Float>(), 3.14);
     BOOST_CHECK_CLOSE_FRACTION(v2.cast<toml::value_t::Float>(), 3.14, 1e-2);
+    BOOST_CHECK_EQUAL         (v1.as_float(), 3.14);
+    BOOST_CHECK_CLOSE_FRACTION(v2.as_float(), 3.14, 1e-2);
 
     v1 = 2.718f;
     v2 = 2.718;
@@ -199,7 +226,9 @@ BOOST_AUTO_TEST_CASE(test_value_float)
     BOOST_CHECK(v2.is_float());
 
     BOOST_CHECK_CLOSE_FRACTION(v1.cast<toml::value_t::Float>(), 2.718, 1e-3);
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Float>(), 2.718);
+    BOOST_CHECK_EQUAL         (v2.cast<toml::value_t::Float>(), 2.718);
+    BOOST_CHECK_CLOSE_FRACTION(v1.as_float(), 2.718, 1e-3);
+    BOOST_CHECK_EQUAL         (v2.as_float(), 2.718);
 
     toml::value v3(v1);
     toml::value v4(v2);
@@ -216,7 +245,9 @@ BOOST_AUTO_TEST_CASE(test_value_float)
     BOOST_CHECK(v4.is_float());
 
     BOOST_CHECK_CLOSE_FRACTION(v3.cast<toml::value_t::Float>(), 2.718, 1e-3);
-    BOOST_CHECK_EQUAL(v4.cast<toml::value_t::Float>(), 2.718);
+    BOOST_CHECK_EQUAL         (v4.cast<toml::value_t::Float>(), 2.718);
+    BOOST_CHECK_CLOSE_FRACTION(v3.as_float(), 2.718, 1e-3);
+    BOOST_CHECK_EQUAL         (v4.as_float(), 2.718);
 
     toml::value v5(std::move(v1));
     toml::value v6(std::move(v2));
@@ -231,7 +262,9 @@ BOOST_AUTO_TEST_CASE(test_value_float)
     BOOST_CHECK(v6.is_float());
 
     BOOST_CHECK_CLOSE_FRACTION(v5.cast<toml::value_t::Float>(), 2.718, 1e-3);
-    BOOST_CHECK_EQUAL(v6.cast<toml::value_t::Float>(), 2.718);
+    BOOST_CHECK_EQUAL         (v6.cast<toml::value_t::Float>(), 2.718);
+    BOOST_CHECK_CLOSE_FRACTION(v5.as_float(), 2.718, 1e-3);
+    BOOST_CHECK_EQUAL         (v6.as_float(), 2.718);
 
     v1 = true;
     v2 = false;
@@ -247,6 +280,8 @@ BOOST_AUTO_TEST_CASE(test_value_float)
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), false);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
+    BOOST_CHECK_EQUAL(v2.as_boolean(), false);
 }
 
 BOOST_AUTO_TEST_CASE(test_value_string)
@@ -271,6 +306,10 @@ BOOST_AUTO_TEST_CASE(test_value_string)
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::String>(), "foo");
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::String>(), "foo");
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::String>(), "foo");
+    BOOST_CHECK_EQUAL(v1.as_string(), "foo");
+    BOOST_CHECK_EQUAL(v2.as_string(), "foo");
+    BOOST_CHECK_EQUAL(v3.as_string(), "foo");
+
 
     v1 = "bar";
     v2 = "bar";
@@ -289,6 +328,10 @@ BOOST_AUTO_TEST_CASE(test_value_string)
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::String>(), "bar");
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::String>(), "bar");
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::String>(), "bar");
+    BOOST_CHECK_EQUAL(v1.as_string(), "bar");
+    BOOST_CHECK_EQUAL(v2.as_string(), "bar");
+    BOOST_CHECK_EQUAL(v3.as_string(), "bar");
+
 
     toml::value v4(v1);
     toml::value v5(v2);
@@ -313,6 +356,10 @@ BOOST_AUTO_TEST_CASE(test_value_string)
     BOOST_CHECK_EQUAL(v4.cast<toml::value_t::String>(), "bar");
     BOOST_CHECK_EQUAL(v5.cast<toml::value_t::String>(), "bar");
     BOOST_CHECK_EQUAL(v6.cast<toml::value_t::String>(), "bar");
+    BOOST_CHECK_EQUAL(v4.as_string(), "bar");
+    BOOST_CHECK_EQUAL(v5.as_string(), "bar");
+    BOOST_CHECK_EQUAL(v6.as_string(), "bar");
+
 
     v4.cast<toml::value_t::String>().str.at(2) = 'z';
     v5.cast<toml::value_t::String>().str.at(2) = 'z';
@@ -331,9 +378,9 @@ BOOST_AUTO_TEST_CASE(test_value_string)
     BOOST_CHECK(v5.is_string());
     BOOST_CHECK(v6.is_string());
 
-    BOOST_CHECK_EQUAL(v4.cast<toml::value_t::String>(), "baz");
+    BOOST_CHECK_EQUAL(v4.as_string(), "baz");
-    BOOST_CHECK_EQUAL(v5.cast<toml::value_t::String>(), "baz");
+    BOOST_CHECK_EQUAL(v5.as_string(), "baz");
-    BOOST_CHECK_EQUAL(v6.cast<toml::value_t::String>(), "baz");
+    BOOST_CHECK_EQUAL(v6.as_string(), "baz");
 
     v1 = true;
     v2 = true;
@@ -355,6 +402,28 @@ BOOST_AUTO_TEST_CASE(test_value_string)
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), true);
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
+    BOOST_CHECK_EQUAL(v2.as_boolean(), true);
+    BOOST_CHECK_EQUAL(v3.as_boolean(), true);
+
+#if __cplusplus >= 201703L
+    std::string_view sv = "foo";
+
+    toml::value v7(sv);
+    toml::value v8(sv, toml::string_t::literal);
+
+    BOOST_CHECK_EQUAL(v7.type(), toml::value_t::String);
+    BOOST_CHECK_EQUAL(v8.type(), toml::value_t::String);
+    BOOST_CHECK(v7.is(toml::value_t::String));
+    BOOST_CHECK(v8.is(toml::value_t::String));
+    BOOST_CHECK(v7.is<toml::String>());
+    BOOST_CHECK(v8.is<toml::String>());
+    BOOST_CHECK(v7.is_string());
+    BOOST_CHECK(v8.is_string());
+
+    BOOST_CHECK_EQUAL(v7.cast<toml::value_t::String>(), "foo");
+    BOOST_CHECK_EQUAL(v8.cast<toml::value_t::String>(), "foo");
+#endif
 }
 
 BOOST_AUTO_TEST_CASE(test_value_local_date)
@@ -368,6 +437,8 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDate>(),
                       toml::local_date(2018, toml::month_t::Jan, 31));
+    BOOST_CHECK_EQUAL(v1.as_local_date(),
+                      toml::local_date(2018, toml::month_t::Jan, 31));
 
     v1 = toml::local_date(2018, toml::month_t::Apr, 1);
 
@@ -378,6 +449,8 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDate>(),
                       toml::local_date(2018, toml::month_t::Apr, 1));
+    BOOST_CHECK_EQUAL(v1.as_local_date(),
+                      toml::local_date(2018, toml::month_t::Apr, 1));
 
     toml::value v2(v1);
     BOOST_CHECK(v2 == v1);
@@ -389,6 +462,8 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)
 
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::LocalDate>(),
                       toml::local_date(2018, toml::month_t::Apr, 1));
+    BOOST_CHECK_EQUAL(v2.as_local_date(),
+                      toml::local_date(2018, toml::month_t::Apr, 1));
 
     v1 = true;
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
@@ -396,6 +471,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)
     BOOST_CHECK(v1.is<toml::Boolean>());
     BOOST_CHECK(v1.is_boolean());
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
 }
 
 BOOST_AUTO_TEST_CASE(test_value_local_time)
@@ -415,10 +491,18 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalTime>(),
                       toml::local_time(12, 30, 45));
+    BOOST_CHECK_EQUAL(v1.as_local_time(),
+                      toml::local_time(12, 30, 45));
+
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::LocalTime>(),
                       toml::local_time(12, 30, 45));
+    BOOST_CHECK_EQUAL(v2.as_local_time(),
+                      toml::local_time(12, 30, 45));
+
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalTime>(),
                       v2.cast<toml::value_t::LocalTime>());
+    BOOST_CHECK_EQUAL(v1.as_local_time(),
+                      v2.as_local_time());
 
     v1 = toml::local_time(1, 30, 0, /*ms*/ 100, /*us*/ 0);
 
@@ -428,6 +512,8 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)
     BOOST_CHECK(v1.is_local_time());
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalTime>(),
                       toml::local_time(1, 30, 0, 100, 0));
+    BOOST_CHECK_EQUAL(v1.as_local_time(),
+                      toml::local_time(1, 30, 0, 100, 0));
 
     toml::value v3(v1);
     BOOST_CHECK(v3 == v1);
@@ -439,6 +525,8 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)
 
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::LocalTime>(),
                       toml::local_time(1, 30, 0, 100, 0));
+    BOOST_CHECK_EQUAL(v3.as_local_time(),
+                      toml::local_time(1, 30, 0, 100, 0));
 
     v1 = true;
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
@@ -446,6 +534,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)
     BOOST_CHECK(v1.is<toml::Boolean>());
     BOOST_CHECK(v1.is_boolean());
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
 }
 
 BOOST_AUTO_TEST_CASE(test_value_local_datetime)
@@ -464,6 +553,10 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
                       toml::local_datetime(
                           toml::local_date(2018, toml::month_t::Jan, 31),
                           toml::local_time(12, 30, 45)));
+    BOOST_CHECK_EQUAL(v1.as_local_datetime(),
+                      toml::local_datetime(
+                          toml::local_date(2018, toml::month_t::Jan, 31),
+                          toml::local_time(12, 30, 45)));
 
     v1 = toml::local_datetime(
                 toml::local_date(2018, toml::month_t::Apr, 1),
@@ -478,6 +571,10 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
                       toml::local_datetime(
                           toml::local_date(2018, toml::month_t::Apr, 1),
                           toml::local_time(1, 15, 30)));
+    BOOST_CHECK_EQUAL(v1.as_local_datetime(),
+                      toml::local_datetime(
+                          toml::local_date(2018, toml::month_t::Apr, 1),
+                          toml::local_time(1, 15, 30)));
 
     toml::value v2(v1);
     BOOST_CHECK(v2 == v1);
@@ -491,6 +588,11 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
                       toml::local_datetime(
                           toml::local_date(2018, toml::month_t::Apr, 1),
                           toml::local_time(1, 15, 30)));
+    BOOST_CHECK_EQUAL(v2.as_local_datetime(),
+                      toml::local_datetime(
+                          toml::local_date(2018, toml::month_t::Apr, 1),
+                          toml::local_time(1, 15, 30)));
+
 
     v1 = true;
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
@@ -498,6 +600,7 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
     BOOST_CHECK(v1.is<toml::Boolean>());
     BOOST_CHECK(v1.is_boolean());
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
 }
 
 BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
@@ -519,6 +622,12 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
                 toml::local_time(12, 30, 45),
                 toml::time_offset(9, 0)
                 ));
+    BOOST_CHECK_EQUAL(v1.as_offset_datetime(),
+            toml::offset_datetime(
+                toml::local_date(2018, toml::month_t::Jan, 31),
+                toml::local_time(12, 30, 45),
+                toml::time_offset(9, 0)
+                ));
 
     v1 = toml::offset_datetime(
                 toml::local_date(2018, toml::month_t::Apr, 1),
@@ -535,6 +644,12 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
                 toml::local_date(2018, toml::month_t::Apr, 1),
                 toml::local_time(1, 15, 30),
                 toml::time_offset(9, 0)));
+    BOOST_CHECK_EQUAL(v1.as_offset_datetime(),
+            toml::offset_datetime(
+                toml::local_date(2018, toml::month_t::Apr, 1),
+                toml::local_time(1, 15, 30),
+                toml::time_offset(9, 0)));
+
 
     toml::value v2(v1);
     BOOST_CHECK(v2 == v1);
@@ -549,12 +664,19 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
                 toml::local_date(2018, toml::month_t::Apr, 1),
                 toml::local_time(1, 15, 30),
                 toml::time_offset(9, 0)));
+    BOOST_CHECK_EQUAL(v2.as_offset_datetime(),
+            toml::offset_datetime(
+                toml::local_date(2018, toml::month_t::Apr, 1),
+                toml::local_time(1, 15, 30),
+                toml::time_offset(9, 0)));
+
     v1 = true;
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
     BOOST_CHECK(v1.is(toml::value_t::Boolean));
     BOOST_CHECK(v1.is<toml::Boolean>());
     BOOST_CHECK(v1.is_boolean());
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
 }
 
 BOOST_AUTO_TEST_CASE(test_value_array)
@@ -578,6 +700,12 @@ BOOST_AUTO_TEST_CASE(test_value_array)
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(2).cast<toml::value_t::Integer>(), 3);
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(3).cast<toml::value_t::Integer>(), 4);
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(4).cast<toml::value_t::Integer>(), 5);
+    BOOST_CHECK_EQUAL(v1.as_array().at(0).as_integer(), 1);
+    BOOST_CHECK_EQUAL(v1.as_array().at(1).as_integer(), 2);
+    BOOST_CHECK_EQUAL(v1.as_array().at(2).as_integer(), 3);
+    BOOST_CHECK_EQUAL(v1.as_array().at(3).as_integer(), 4);
+    BOOST_CHECK_EQUAL(v1.as_array().at(4).as_integer(), 5);
+
 
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(0).cast<toml::value_t::Integer>(), 6);
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(1).cast<toml::value_t::Integer>(), 7);
@@ -603,12 +731,24 @@ BOOST_AUTO_TEST_CASE(test_value_array)
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(2).cast<toml::value_t::Integer>(), 8);
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(3).cast<toml::value_t::Integer>(), 9);
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(4).cast<toml::value_t::Integer>(), 0);
+    BOOST_CHECK_EQUAL(v1.as_array().at(0).as_integer(), 6);
+    BOOST_CHECK_EQUAL(v1.as_array().at(1).as_integer(), 7);
+    BOOST_CHECK_EQUAL(v1.as_array().at(2).as_integer(), 8);
+    BOOST_CHECK_EQUAL(v1.as_array().at(3).as_integer(), 9);
+    BOOST_CHECK_EQUAL(v1.as_array().at(4).as_integer(), 0);
+
 
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(0).cast<toml::value_t::Integer>(), 1);
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(1).cast<toml::value_t::Integer>(), 2);
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(2).cast<toml::value_t::Integer>(), 3);
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(3).cast<toml::value_t::Integer>(), 4);
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(4).cast<toml::value_t::Integer>(), 5);
+    BOOST_CHECK_EQUAL(v2.as_array().at(0).as_integer(), 1);
+    BOOST_CHECK_EQUAL(v2.as_array().at(1).as_integer(), 2);
+    BOOST_CHECK_EQUAL(v2.as_array().at(2).as_integer(), 3);
+    BOOST_CHECK_EQUAL(v2.as_array().at(3).as_integer(), 4);
+    BOOST_CHECK_EQUAL(v2.as_array().at(4).as_integer(), 5);
+
 
     toml::value v3(v1);
     BOOST_CHECK(v3 == v1);
@@ -623,6 +763,12 @@ BOOST_AUTO_TEST_CASE(test_value_array)
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Array>().at(2).cast<toml::value_t::Integer>(), 8);
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Array>().at(3).cast<toml::value_t::Integer>(), 9);
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Array>().at(4).cast<toml::value_t::Integer>(), 0);
+    BOOST_CHECK_EQUAL(v3.as_array().at(0).as_integer(), 6);
+    BOOST_CHECK_EQUAL(v3.as_array().at(1).as_integer(), 7);
+    BOOST_CHECK_EQUAL(v3.as_array().at(2).as_integer(), 8);
+    BOOST_CHECK_EQUAL(v3.as_array().at(3).as_integer(), 9);
+    BOOST_CHECK_EQUAL(v3.as_array().at(4).as_integer(), 0);
+
 
     v1 = true;
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
@@ -630,6 +776,7 @@ BOOST_AUTO_TEST_CASE(test_value_array)
     BOOST_CHECK(v1.is<toml::Boolean>());
     BOOST_CHECK(v1.is_boolean());
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
 }
 
 BOOST_AUTO_TEST_CASE(test_value_table)
@@ -644,6 +791,10 @@ BOOST_AUTO_TEST_CASE(test_value_table)
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("foo").cast<toml::value_t::Integer>(),    42);
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("bar").cast<toml::value_t::Float>(),      3.14);
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("baz").cast<toml::value_t::String>().str, "qux");
+    BOOST_CHECK_EQUAL(v1.as_table().at("foo").as_integer(),    42);
+    BOOST_CHECK_EQUAL(v1.as_table().at("bar").as_float(),   3.14);
+    BOOST_CHECK_EQUAL(v1.as_table().at("baz").as_string().str, "qux");
+
 
     v1 = toml::table{{"foo", 2.71}, {"bar", 54}, {"baz", "quux"}};
 
@@ -655,6 +806,10 @@ BOOST_AUTO_TEST_CASE(test_value_table)
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("foo").cast<toml::value_t::Float>(),      2.71);
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("bar").cast<toml::value_t::Integer>(),    54);
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Table>().at("baz").cast<toml::value_t::String>().str, "quux");
+    BOOST_CHECK_EQUAL(v1.as_table().at("foo").as_float(),   2.71);
+    BOOST_CHECK_EQUAL(v1.as_table().at("bar").as_integer(),    54);
+    BOOST_CHECK_EQUAL(v1.as_table().at("baz").as_string().str, "quux");
+
 
     toml::value v3(v1);
     BOOST_CHECK(v3 == v1);
@@ -667,6 +822,10 @@ BOOST_AUTO_TEST_CASE(test_value_table)
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Table>().at("foo").cast<toml::value_t::Float>(),      2.71);
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Table>().at("bar").cast<toml::value_t::Integer>(),    54);
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Table>().at("baz").cast<toml::value_t::String>().str, "quux");
+    BOOST_CHECK_EQUAL(v3.as_table().at("foo").as_float(),   2.71);
+    BOOST_CHECK_EQUAL(v3.as_table().at("bar").as_integer(),    54);
+    BOOST_CHECK_EQUAL(v3.as_table().at("baz").as_string().str, "quux");
+
 
     v1 = true;
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
@@ -674,6 +833,7 @@ BOOST_AUTO_TEST_CASE(test_value_table)
     BOOST_CHECK(v1.is<toml::Boolean>());
     BOOST_CHECK(v1.is_boolean());
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
+    BOOST_CHECK_EQUAL(v1.as_boolean(), true);
 }
 
 BOOST_AUTO_TEST_CASE(test_value_empty)

toml/combinator.hpp

@@ -56,31 +56,24 @@ struct character
     static constexpr char target = C;
 
     template<typename Cont>
-    static result<region<Cont>, std::string>
+    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, const bool msg = false)
+    invoke(location<Cont>& loc)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
 
-        if(loc.iter() == loc.end()) {return err("not sufficient characters");}
+        if(loc.iter() == loc.end()) {return none();}
         const auto first = loc.iter();
 
         const char c = *(loc.iter());
         if(c != target)
         {
-            if(msg)
+            return none();
-            {
-                return err(concat_to_string("expected '", show_char(target),
-                                            "' but got '", show_char(c), "'."));
-            }
-            return err("");
         }
         loc.advance(); // update location
 
         return ok(region<Cont>(loc, first, loc.iter()));
     }
-
-    static std::string pattern() {return show_char(target);}
 };
 template<char C>
 constexpr char character<C>::target;
@@ -96,35 +89,24 @@ struct in_range
     static constexpr char lower = Low;
 
     template<typename Cont>
-    static result<region<Cont>, std::string>
+    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, const bool msg = false)
+    invoke(location<Cont>& loc)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
 
-        if(loc.iter() == loc.end()) {return err("not sufficient characters");}
+        if(loc.iter() == loc.end()) {return none();}
         const auto first = loc.iter();
 
         const char c = *(loc.iter());
         if(c < lower || upper < c)
         {
-            if(msg)
+            return none();
-            {
-                return err(concat_to_string("expected character in range "
-                    "[", show_char(lower), ", ", show_char(upper), "] but got ",
-                    "'", show_char(c), "'."));
-            }
-            return err("");
         }
 
         loc.advance();
         return ok(region<Cont>(loc, first, loc.iter()));
     }
-
-    static std::string pattern()
-    {
-        return concat_to_string("[",show_char(lower),"-",show_char(upper),"]");
-    }
 };
 template<char L, char U> constexpr char in_range<L, U>::upper;
 template<char L, char U> constexpr char in_range<L, U>::lower;
@@ -135,34 +117,24 @@ template<typename Combinator>
 struct exclude
 {
     template<typename Cont>
-    static result<region<Cont>, std::string>
+    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, const bool msg = false)
+    invoke(location<Cont>& loc)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
 
-        if(loc.iter() == loc.end()) {return err("not sufficient characters");}
+        if(loc.iter() == loc.end()) {return none();}
         auto first = loc.iter();
 
-        auto rslt = Combinator::invoke(loc, msg);
+        auto rslt = Combinator::invoke(loc);
         if(rslt.is_ok())
         {
             loc.reset(first);
-            if(msg)
+            return none();
-            {
-                return err(concat_to_string("invalid pattern (",
-                    Combinator::pattern(), ") appeared ", rslt.unwrap().str()));
-            }
-            return err("");
         }
         loc.reset(std::next(first)); // XXX maybe loc.advance() is okay but...
         return ok(region<Cont>(loc, first, loc.iter()));
     }
-
-    static std::string pattern()
-    {
-        return concat_to_string("^(", Combinator::pattern(), ')');
-    }
 };
 
 // increment `iter`, if matches. otherwise, just return empty string.
@@ -170,24 +142,19 @@ template<typename Combinator>
 struct maybe
 {
     template<typename Cont>
-    static result<region<Cont>, std::string>
+    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, const bool msg = false)
+    invoke(location<Cont>& loc)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
 
-        const auto rslt = Combinator::invoke(loc, msg);
+        const auto rslt = Combinator::invoke(loc);
         if(rslt.is_ok())
         {
             return rslt;
         }
         return ok(region<Cont>(loc));
     }
-
-    static std::string pattern()
-    {
-        return concat_to_string('(', Combinator::pattern(), ")?");
-    }
 };
 
 template<typename ... Ts>
@@ -197,41 +164,35 @@ template<typename Head, typename ... Tail>
 struct sequence<Head, Tail...>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string>
+    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, const bool msg = false)
+    invoke(location<Cont>& loc)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
 
         const auto first = loc.iter();
-        const auto rslt = Head::invoke(loc, msg);
+        const auto rslt = Head::invoke(loc);
         if(rslt.is_err())
         {
             loc.reset(first);
-            return err(rslt.unwrap_err());
+            return none();
         }
-        return sequence<Tail...>::invoke(loc, std::move(rslt.unwrap()), first, msg);
+        return sequence<Tail...>::invoke(loc, std::move(rslt.unwrap()), first);
     }
 
     // called from the above function only, recursively.
     template<typename Cont, typename Iterator>
-    static result<region<Cont>, std::string>
+    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, region<Cont> reg, Iterator first,
+    invoke(location<Cont>& loc, region<Cont> reg, Iterator first)
-           const bool msg = false)
     {
-        const auto rslt = Head::invoke(loc, msg);
+        const auto rslt = Head::invoke(loc);
         if(rslt.is_err())
         {
             loc.reset(first);
-            return err(rslt.unwrap_err());
+            return none();
         }
         reg += rslt.unwrap(); // concat regions
-        return sequence<Tail...>::invoke(loc, std::move(reg), first, msg);
+        return sequence<Tail...>::invoke(loc, std::move(reg), first);
-    }
-
-    static std::string pattern()
-    {
-        return concat_to_string(Head::pattern(), sequence<Tail...>::pattern());
     }
 };
 
@@ -240,20 +201,18 @@ struct sequence<Head>
 {
     // would be called from sequence<T ...>::invoke only.
     template<typename Cont, typename Iterator>
-    static result<region<Cont>, std::string>
+    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, region<Cont> reg, Iterator first,
+    invoke(location<Cont>& loc, region<Cont> reg, Iterator first)
-           const bool msg = false)
     {
-        const auto rslt = Head::invoke(loc, msg);
+        const auto rslt = Head::invoke(loc);
         if(rslt.is_err())
         {
             loc.reset(first);
-            return err(rslt.unwrap_err());
+            return none();
         }
         reg += rslt.unwrap(); // concat regions
         return ok(reg);
     }
-    static std::string pattern() {return Head::pattern();}
 };
 
 template<typename ... Ts>
@@ -263,36 +222,27 @@ template<typename Head, typename ... Tail>
 struct either<Head, Tail...>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string>
+    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, const bool msg = false)
+    invoke(location<Cont>& loc)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
 
-        const auto rslt = Head::invoke(loc, msg);
+        const auto rslt = Head::invoke(loc);
         if(rslt.is_ok()) {return rslt;}
-        return either<Tail...>::invoke(loc, msg);
+        return either<Tail...>::invoke(loc);
-    }
-
-    static std::string pattern()
-    {
-        return concat_to_string('(', Head::pattern(), ")|", either<Tail...>::pattern());
     }
 };
 template<typename Head>
 struct either<Head>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string>
+    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, const bool msg = false)
+    invoke(location<Cont>& loc)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
-        return Head::invoke(loc, msg);
+        return Head::invoke(loc);
-    }
-    static std::string pattern()
-    {
-        return concat_to_string('(', Head::pattern(), ')');
     }
 };
 
@@ -307,52 +257,48 @@ template<typename T, std::size_t N>
 struct repeat<T, exactly<N>>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string>
+    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, const bool msg = false)
+    invoke(location<Cont>& loc)
     {
         region<Cont> retval(loc);
         const auto first = loc.iter();
         for(std::size_t i=0; i<N; ++i)
         {
-            auto rslt = T::invoke(loc, msg);
+            auto rslt = T::invoke(loc);
             if(rslt.is_err())
             {
                 loc.reset(first);
-                return err(rslt.unwrap_err());
+                return none();
             }
             retval += rslt.unwrap();
         }
         return ok(std::move(retval));
     }
-    static std::string pattern()
-    {
-        return concat_to_string('(', T::pattern(), "){", N, '}');
-    }
 };
 
 template<typename T, std::size_t N>
 struct repeat<T, at_least<N>>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string>
+    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, const bool msg = false)
+    invoke(location<Cont>& loc)
     {
         region<Cont> retval(loc);
 
         const auto first = loc.iter();
         for(std::size_t i=0; i<N; ++i)
         {
-            auto rslt = T::invoke(loc, msg);
+            auto rslt = T::invoke(loc);
             if(rslt.is_err())
             {
                 loc.reset(first);
-                return err(rslt.unwrap_err());
+                return none();
             }
             retval += rslt.unwrap();
         }
         while(true)
         {
-            auto rslt = T::invoke(loc, msg);
+            auto rslt = T::invoke(loc);
             if(rslt.is_err())
             {
                 return ok(std::move(retval));
@@ -360,23 +306,19 @@ struct repeat<T, at_least<N>>
             retval += rslt.unwrap();
         }
     }
-    static std::string pattern()
-    {
-        return concat_to_string('(',T::pattern(), "){", N, ",}");
-    }
 };
 
 template<typename T>
 struct repeat<T, unlimited>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string>
+    static result<region<Cont>, none_t>
-    invoke(location<Cont>& loc, const bool msg = false)
+    invoke(location<Cont>& loc)
     {
         region<Cont> retval(loc);
         while(true)
         {
-            auto rslt = T::invoke(loc, msg);
+            auto rslt = T::invoke(loc);
             if(rslt.is_err())
             {
                 return ok(std::move(retval));
@@ -384,7 +326,6 @@ struct repeat<T, unlimited>
             retval += rslt.unwrap();
         }
     }
-    static std::string pattern() {return concat_to_string('(', T::pattern(), ")*");}
 };
 
 } // detail

toml/datetime.hpp

@@ -353,15 +353,15 @@ struct local_datetime
     explicit local_datetime(const std::chrono::system_clock::time_point& tp)
     {
         const auto t = std::chrono::system_clock::to_time_t(tp);
-        std::tm time = detail::localtime_s(&t);
+        std::tm ltime = detail::localtime_s(&t);
 
-        this->date = local_date(time);
+        this->date = local_date(ltime);
-        this->time = local_time(time);
+        this->time = local_time(ltime);
 
         // std::tm lacks subsecond information, so diff between tp and tm
         // can be used to get millisecond & microsecond information.
         const auto t_diff = tp -
-            std::chrono::system_clock::from_time_t(std::mktime(&time));
+            std::chrono::system_clock::from_time_t(std::mktime(&ltime));
         this->time.millisecond = static_cast<std::uint16_t>(
           std::chrono::duration_cast<std::chrono::milliseconds>(t_diff).count());
         this->time.microsecond = static_cast<std::uint16_t>(

toml/get.hpp

@@ -108,6 +108,18 @@ inline std::string get(value&& v)
     return std::move(v.cast<value_t::String>().str);
 }
 
+// ============================================================================
+// std::string_view
+
+#if __cplusplus >= 201703L
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string_view>::value, std::nullptr_t>::type = nullptr>
+inline std::string_view get(const value& v)
+{
+    return std::string_view(v.cast<value_t::String>().str);
+}
+#endif
+
 // ============================================================================
 // std::chrono::duration from toml::local_time.
 
@@ -264,7 +276,7 @@ namespace detail
 {
 
 template<typename T, std::size_t ...I>
-T get_tuple_impl(const toml::Array& a, index_sequence<I...>)
+T get_tuple_impl(const toml::array& a, index_sequence<I...>)
 {
     return std::make_tuple(
         ::toml::get<typename std::tuple_element<I, T>::type>(a.at(I))...);
@@ -546,67 +558,6 @@ T get_or(const toml::value& v, T&& opt)
     }
 }
 
-// ===========================================================================
-// get_or(table, key, fallback)
-//
-// DEPRECATED: use find_or instead.
-
-template<typename T>
-TOML11_MARK_AS_DEPRECATED("use toml::find_or(table, key, opt) instead.")
-auto get_or(const toml::table& tab, const toml::key& ky, T&& opt)
-    -> decltype(get_or(std::declval<value const&>(), std::forward<T>(opt)))
-{
-    if(tab.count(ky) == 0) {return opt;}
-    return ::toml::get_or(tab.at(ky), std::forward<T>(opt));
-}
-template<typename T>
-TOML11_MARK_AS_DEPRECATED("use toml::find_or(table, key, opt) instead.")
-auto get_or(toml::table& tab, const toml::key& ky, T&& opt)
-    -> decltype(get_or(std::declval<value&>(), std::forward<T>(opt)))
-{
-    if(tab.count(ky) == 0) {return opt;}
-    return ::toml::get_or(tab[ky], std::forward<T>(opt));
-}
-template<typename T>
-TOML11_MARK_AS_DEPRECATED("use toml::find_or(table, key, opt) instead.")
-auto get_or(toml::table&& tab, const toml::key& ky, T&& opt)
-    -> decltype(get_or(std::declval<value&&>(), std::forward<T>(opt)))
-{
-    if(tab.count(ky) == 0) {return opt;}
-    return ::toml::get_or(std::move(tab[ky]), std::forward<T>(opt));
-}
-
-template<typename T>
-TOML11_MARK_AS_DEPRECATED("use toml::find_or(value, key, opt) instead.")
-auto get_or(const toml::value& v, const toml::key& ky, T&& opt)
-    -> decltype(get_or(std::declval<value const&>(), std::forward<T>(opt)))
-{
-    if(!v.is_table()) {return opt;}
-    const auto& tab = toml::get<toml::table>(v);
-    if(tab.count(ky) == 0) {return opt;}
-    return ::toml::get_or(tab.at(ky), std::forward<T>(opt));
-}
-template<typename T>
-TOML11_MARK_AS_DEPRECATED("use toml::find_or(value, key, opt) instead.")
-auto get_or(toml::value& v, const toml::key& ky, T&& opt)
-    -> decltype(get_or(std::declval<value&>(), std::forward<T>(opt)))
-{
-    if(!v.is_table()) {return opt;}
-    auto& tab = toml::get<toml::table>(v);
-    if(tab.count(ky) == 0) {return opt;}
-    return ::toml::get_or(tab[ky], std::forward<T>(opt));
-}
-template<typename T>
-TOML11_MARK_AS_DEPRECATED("use toml::find_or(value, key, opt) instead.")
-auto get_or(toml::value&& v, const toml::key& ky, T&& opt)
-    -> decltype(get_or(std::declval<value&&>(), std::forward<T>(opt)))
-{
-    if(!v.is_table()) {return opt;}
-    auto tab = toml::get<toml::table>(std::move(v));
-    if(tab.count(ky) == 0) {return opt;}
-    return ::toml::get_or(std::move(tab[ky]), std::forward<T>(opt));
-}
-
 // ===========================================================================
 // find_or(value, key, fallback)
 

toml/literal.hpp

@@ -73,6 +73,9 @@ inline ::toml::value operator""_toml(const char* str, std::size_t len)
     if(auto data = ::toml::detail::parse_toml_file(loc))
     {
         loc.reset(loc.begin()); // rollback to the top of the literal
+        // skip needless characters for error message
+        skip_line::invoke(loc); // skip the first several needless lines
+        skip_ws::invoke(loc);   // skip the first several needless whitespaces
         return ::toml::value(std::move(data.unwrap()),
                 ::toml::detail::region<std::vector<char>>(std::move(loc)));
     }

toml/parser.hpp

@@ -376,7 +376,7 @@ parse_ml_basic_string(location<Container>& loc)
         // immediate newline is ignored (if exists)
         /* discard return value */ lex_newline::invoke(inner_loc);
 
-        delim = err("tmp");
+        delim = none();
         while(!delim)
         {
             using lex_unescaped_seq = repeat<
@@ -432,7 +432,7 @@ parse_basic_string(location<Container>& loc)
         std::string retval;
         retval.reserve(token.unwrap().size());
 
-        quot = err("tmp");
+        quot = none();
         while(!quot)
         {
             using lex_unescaped_seq = repeat<lex_basic_unescaped, unlimited>;
@@ -587,23 +587,17 @@ parse_local_date(location<Container>& loc)
         const auto y = lex_date_fullyear::invoke(inner_loc);
         if(!y || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != '-')
         {
-            const std::string msg = y.map_err_or_else(
-                [](const std::string& msg) {return msg;}, "should be `-`");
-
             throw internal_error(format_underline("[error]: "
                 "toml::parse_inner_local_date: invalid year format",
-                {{std::addressof(inner_loc), msg}}));
+                {{std::addressof(inner_loc), "should be `-`"}}));
         }
         inner_loc.advance();
         const auto m = lex_date_month::invoke(inner_loc);
         if(!m || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != '-')
         {
-            const std::string msg = m.map_err_or_else(
-                [](const std::string& msg) {return msg;}, "should be `-`");
-
             throw internal_error(format_underline("[error]: "
                 "toml::parse_local_date: invalid month format",
-                {{std::addressof(inner_loc), msg}}));
+                {{std::addressof(inner_loc), "should be `-`"}}));
         }
         inner_loc.advance();
         const auto d = lex_date_mday::invoke(inner_loc);
@@ -611,7 +605,7 @@ parse_local_date(location<Container>& loc)
         {
             throw internal_error(format_underline("[error]: "
                 "toml::parse_local_date: invalid day format",
-                {{std::addressof(inner_loc), d.unwrap_err()}}));
+                {{std::addressof(inner_loc), "here"}}));
         }
         return ok(std::make_pair(local_date(
             static_cast<std::int16_t>(from_string<int>(y.unwrap().str(), 0)),
@@ -640,23 +634,17 @@ parse_local_time(location<Container>& loc)
         const auto h = lex_time_hour::invoke(inner_loc);
         if(!h || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != ':')
         {
-            const std::string msg = h.map_err_or_else(
-                [](const std::string& msg) {return msg;}, "should be `:`");
-
             throw internal_error(format_underline("[error]: "
                 "toml::parse_local_time: invalid year format",
-                {{std::addressof(inner_loc), msg}}));
+                {{std::addressof(inner_loc), "should be `:`"}}));
         }
         inner_loc.advance();
         const auto m = lex_time_minute::invoke(inner_loc);
         if(!m || inner_loc.iter() == inner_loc.end() || *inner_loc.iter() != ':')
         {
-            const std::string msg = m.map_err_or_else(
-                [](const std::string& msg) {return msg;}, "should be `:`");
-
             throw internal_error(format_underline("[error]: "
                 "toml::parse_local_time: invalid month format",
-                {{std::addressof(inner_loc), msg}}));
+                {{std::addressof(inner_loc), "should be `:`"}}));
         }
         inner_loc.advance();
         const auto s = lex_time_second::invoke(inner_loc);
@@ -664,7 +652,7 @@ parse_local_time(location<Container>& loc)
         {
             throw internal_error(format_underline("[error]: "
                 "toml::parse_local_time: invalid second format",
-                {{std::addressof(inner_loc), s.unwrap_err()}}));
+                {{std::addressof(inner_loc), "here"}}));
         }
         local_time time(
             static_cast<std::int8_t>(from_string<int>(h.unwrap().str(), 0)),
@@ -700,7 +688,7 @@ parse_local_time(location<Container>& loc)
             {
                 throw internal_error(format_underline("[error]: "
                     "toml::parse_local_time: invalid subsecond format",
-                    {{std::addressof(inner_loc), secfrac.unwrap_err()}}));
+                    {{std::addressof(inner_loc), "here"}}));
             }
         }
         return ok(std::make_pair(time, token.unwrap()));
@@ -724,12 +712,9 @@ parse_local_datetime(location<Container>& loc)
         const auto date = parse_local_date(inner_loc);
         if(!date || inner_loc.iter() == inner_loc.end())
         {
-            const std::string msg = date.map_err_or_else(
-                [](const std::string& msg) {return msg;}, "date, not datetime");
-
             throw internal_error(format_underline("[error]: "
                 "toml::parse_local_datetime: invalid datetime format",
-                {{std::addressof(inner_loc), msg}}));
+                {{std::addressof(inner_loc), "date, not datetime"}}));
         }
         const char delim = *(inner_loc.iter());
         if(delim != 'T' && delim != 't' && delim != ' ')
@@ -769,12 +754,9 @@ parse_offset_datetime(location<Container>& loc)
         const auto datetime = parse_local_datetime(inner_loc);
         if(!datetime || inner_loc.iter() == inner_loc.end())
         {
-            const std::string msg = datetime.map_err_or_else(
-                [](const std::string& msg){return msg;}, "date, not datetime");
-
             throw internal_error(format_underline("[error]: "
                 "toml::parse_offset_datetime: invalid datetime format",
-                {{std::addressof(inner_loc), msg}}));
+                {{std::addressof(inner_loc), "date, not datetime"}}));
         }
         time_offset offset(0, 0);
         if(const auto ofs = lex_time_numoffset::invoke(inner_loc))
@@ -1167,7 +1149,7 @@ insert_nested_key(table& root, const toml::value& v,
             {
                 if(tab->count(k) == 1) // there is already an array of table
                 {
-                    if(tab->at(k).is(value_t::Table))
+                    if(tab->at(k).is_table())
                     {
                         // show special err msg for conflicting table
                         throw syntax_error(format_underline(concat_to_string(
@@ -1180,7 +1162,7 @@ insert_nested_key(table& root, const toml::value& v,
                                  "this conflicts with the previous table"}
                             }));
                     }
-                    else if(!(tab->at(k).is(value_t::Array)))
+                    else if(!(tab->at(k).is_array()))
                     {
                         throw syntax_error(format_underline(concat_to_string(
                             "[error] toml::insert_value: array of table (\"",
@@ -1193,8 +1175,9 @@ insert_nested_key(table& root, const toml::value& v,
                                  "while inserting this array-of-tables"}
                             }));
                     }
-                    array& a = tab->at(k).template cast<toml::value_t::Array>();
+                    // the above if-else-if checks tab->at(k) is an array
-                    if(!(a.front().is(value_t::Table)))
+                    array& a = tab->at(k).as_array();
+                    if(!(a.front().is_table()))
                     {
                         throw syntax_error(format_underline(concat_to_string(
                             "[error] toml::insert_value: array of table (\"",
@@ -1248,7 +1231,7 @@ insert_nested_key(table& root, const toml::value& v,
 
             if(tab->count(k) == 1)
             {
-                if(tab->at(k).is(value_t::Table) && v.is(value_t::Table))
+                if(tab->at(k).is_table() && v.is_table())
                 {
                     if(!is_valid_forward_table_definition(
                                 tab->at(k), first, iter, last))
@@ -1268,18 +1251,18 @@ insert_nested_key(table& root, const toml::value& v,
                     // d = 42
                     // [a]
                     // e = 2.71
-                    auto& t = tab->at(k).cast<value_t::Table>();
+                    auto& t = tab->at(k).as_table();
-                    for(const auto& kv : v.cast<value_t::Table>())
+                    for(const auto& kv : v.as_table())
                     {
                         t[kv.first] = kv.second;
                     }
                     detail::change_region(tab->at(k), key_reg);
                     return ok(true);
                 }
-                else if(v.is(value_t::Table)                          &&
+                else if(v.is_table()                     &&
-                        tab->at(k).is(value_t::Array)                 &&
+                        tab->at(k).is_array()            &&
-                        tab->at(k).cast<value_t::Array>().size() > 0  &&
+                        tab->at(k).as_array().size() > 0 &&
-                        tab->at(k).cast<value_t::Array>().front().is(value_t::Table))
+                        tab->at(k).as_array().front().is_table())
                 {
                     throw syntax_error(format_underline(concat_to_string(
                         "[error] toml::insert_value: array of tables (\"",
@@ -1319,14 +1302,14 @@ insert_nested_key(table& root, const toml::value& v,
             }
 
             // type checking...
-            if(tab->at(k).is(value_t::Table))
+            if(tab->at(k).is_table())
             {
-                tab = std::addressof((*tab)[k].template cast<value_t::Table>());
+                tab = std::addressof((*tab)[k].as_table());
             }
-            else if(tab->at(k).is(value_t::Array)) // inserting to array-of-tables?
+            else if(tab->at(k).is_array()) // inserting to array-of-tables?
             {
-                array& a = (*tab)[k].template cast<value_t::Array>();
+                array& a = (*tab)[k].as_array();
-                if(!a.back().is(value_t::Table))
+                if(!a.back().is_table())
                 {
                     throw syntax_error(format_underline(concat_to_string(
                         "[error] toml::insert_value: target (",
@@ -1337,7 +1320,7 @@ insert_nested_key(table& root, const toml::value& v,
                             {std::addressof(get_region(v)), "inserting this"}
                         }));
                 }
-                tab = std::addressof(a.back().template cast<value_t::Table>());
+                tab = std::addressof(a.back().as_table());
             }
             else
             {
@@ -1560,7 +1543,7 @@ template<typename Container>
 result<std::pair<std::vector<key>, region<Container>>, std::string>
 parse_array_table_key(location<Container>& loc)
 {
-    if(auto token = lex_array_table::invoke(loc, true))
+    if(auto token = lex_array_table::invoke(loc))
     {
         location<std::string> inner_loc(loc.name(), token.unwrap().str());
 
@@ -1672,12 +1655,12 @@ result<table, std::string> parse_ml_table(location<Container>& loc)
         const auto newline = skip_line::invoke(loc);
         if(!newline && loc.iter() != loc.end())
         {
-            const auto before = loc.iter();
+            const auto before2 = loc.iter();
             lex_ws::invoke(loc); // skip whitespace
             const auto msg = format_underline("[error] toml::parse_table: "
                 "invalid line format", {{std::addressof(loc), concat_to_string(
                 "expected newline, but got '", show_char(*loc.iter()), "'.")}});
-            loc.reset(before);
+            loc.reset(before2);
             return err(msg);
         }
 

toml/region.hpp

@@ -52,6 +52,14 @@ struct region_base
     virtual std::size_t before()   const noexcept {return 0;}
     // number of characters in the line after the region
     virtual std::size_t after()    const noexcept {return 0;}
+
+    virtual std::string comment_before() const {return "";} // just before
+    virtual std::string comment_inline() const {return "";} // in the same line
+    virtual std::string comment()        const {return "";} // concatenate
+    // ```toml
+    // # comment_before
+    // key = "value" # comment_inline
+    // ```
 };
 
 // location represents a position in a container, which contains a file content.
@@ -280,6 +288,92 @@ struct region final : public region_base
 
     std::string name() const override {return source_name_;}
 
+    std::string comment_before() const override
+    {
+        auto iter = this->line_begin(); // points the first element
+        std::vector<std::pair<decltype(iter), decltype(iter)>> comments;
+        while(iter != this->begin())
+        {
+            iter = std::prev(iter);
+            using rev_iter = std::reverse_iterator<decltype(iter)>;
+            auto line_before = std::find(rev_iter(iter), rev_iter(this->begin()),
+                                         '\n').base();
+            // range [line_before, iter) represents the previous line
+
+            auto comment_found = std::find(line_before, iter, '#');
+            if(iter != comment_found && std::all_of(line_before, comment_found,
+                    [](const char c) noexcept -> bool {
+                        return c == ' ' || c == '\t';
+                    }))
+            {
+                // the line before this range contains only a comment.
+                comments.push_back(std::make_pair(comment_found, iter));
+            }
+            else
+            {
+                break;
+            }
+            iter = line_before;
+        }
+
+        std::string com;
+        for(auto i = comments.crbegin(), e = comments.crend(); i!=e; ++i)
+        {
+            if(i != comments.crbegin()) {com += '\n';}
+            com += std::string(i->first, i->second);
+        }
+        return com;
+    }
+
+    std::string comment_inline() const override
+    {
+        if(this->contain_newline())
+        {
+            std::string com;
+            // check both the first and the last line.
+            const auto first_line_end =
+                std::find(this->line_begin(), this->last(), '\n');
+            const auto first_comment_found =
+                std::find(this->line_begin(), first_line_end, '#');
+
+            if(first_comment_found != first_line_end)
+            {
+                com += std::string(first_comment_found, first_line_end);
+            }
+
+            const auto last_comment_found =
+                std::find(this->last(), this->line_end(), '#');
+            if(last_comment_found != this->line_end())
+            {
+                if(!com.empty()){com += '\n';}
+                com += std::string(last_comment_found, this->line_end());
+            }
+            return com;
+        }
+        const auto comment_found =
+            std::find(this->line_begin(), this->line_end(), '#');
+        return std::string(comment_found, this->line_end());
+    }
+
+    std::string comment() const override
+    {
+        std::string com_bef = this->comment_before();
+        std::string com_inl = this->comment_inline();
+        if(!com_bef.empty() && !com_inl.empty())
+        {
+            com_bef += '\n';
+            return com_bef + com_inl;
+        }
+        else if(com_bef.empty())
+        {
+            return com_inl;
+        }
+        else
+        {
+            return com_bef;
+        }
+    }
+
   private:
 
     source_ptr     source_;
@@ -343,7 +437,8 @@ inline std::string format_underline(const std::string& message,
         {
             // invalid
             // ~~~~~~~
-            retval << make_string(reg->size(), '~');
+            const auto underline_len = std::min(reg->size(), reg->line().size());
+            retval << make_string(underline_len, '~');
         }
 
         retval << ' ';

toml/result.hpp

@@ -113,21 +113,25 @@ struct result
     {
         auto tmp = ::new(std::addressof(this->succ)) success_type(s);
         assert(tmp == std::addressof(this->succ));
+        (void)tmp;
     }
     result(const failure_type& f): is_ok_(false)
     {
         auto tmp = ::new(std::addressof(this->fail)) failure_type(f);
         assert(tmp == std::addressof(this->fail));
+        (void)tmp;
     }
     result(success_type&& s): is_ok_(true)
     {
         auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s));
         assert(tmp == std::addressof(this->succ));
+        (void)tmp;
     }
     result(failure_type&& f): is_ok_(false)
     {
         auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f));
         assert(tmp == std::addressof(this->fail));
+        (void)tmp;
     }
 
     template<typename U>
@@ -135,24 +139,28 @@ struct result
     {
         auto tmp = ::new(std::addressof(this->succ)) success_type(s.value);
         assert(tmp == std::addressof(this->succ));
+        (void)tmp;
     }
     template<typename U>
     result(const failure<U>& f): is_ok_(false)
     {
         auto tmp = ::new(std::addressof(this->fail)) failure_type(f.value);
         assert(tmp == std::addressof(this->fail));
+        (void)tmp;
     }
     template<typename U>
     result(success<U>&& s): is_ok_(true)
     {
         auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s.value));
         assert(tmp == std::addressof(this->succ));
+        (void)tmp;
     }
     template<typename U>
     result(failure<U>&& f): is_ok_(false)
     {
         auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f.value));
         assert(tmp == std::addressof(this->fail));
+        (void)tmp;
     }
 
     result& operator=(const success_type& s)
@@ -161,6 +169,7 @@ struct result
         this->is_ok_ = true;
         auto tmp = ::new(std::addressof(this->succ)) success_type(s);
         assert(tmp == std::addressof(this->succ));
+        (void)tmp;
         return *this;
     }
     result& operator=(const failure_type& f)
@@ -169,6 +178,7 @@ struct result
         this->is_ok_ = false;
         auto tmp = ::new(std::addressof(this->fail)) failure_type(f);
         assert(tmp == std::addressof(this->fail));
+        (void)tmp;
         return *this;
     }
     result& operator=(success_type&& s)
@@ -177,6 +187,7 @@ struct result
         this->is_ok_ = true;
         auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s));
         assert(tmp == std::addressof(this->succ));
+        (void)tmp;
         return *this;
     }
     result& operator=(failure_type&& f)
@@ -185,6 +196,7 @@ struct result
         this->is_ok_ = false;
         auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f));
         assert(tmp == std::addressof(this->fail));
+        (void)tmp;
         return *this;
     }
 
@@ -195,6 +207,7 @@ struct result
         this->is_ok_ = true;
         auto tmp = ::new(std::addressof(this->succ)) success_type(s.value);
         assert(tmp == std::addressof(this->succ));
+        (void)tmp;
         return *this;
     }
     template<typename U>
@@ -204,6 +217,7 @@ struct result
         this->is_ok_ = false;
         auto tmp = ::new(std::addressof(this->fail)) failure_type(f.value);
         assert(tmp == std::addressof(this->fail));
+        (void)tmp;
         return *this;
     }
     template<typename U>
@@ -213,6 +227,7 @@ struct result
         this->is_ok_ = true;
         auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s.value));
         assert(tmp == std::addressof(this->succ));
+        (void)tmp;
         return *this;
     }
     template<typename U>
@@ -222,6 +237,7 @@ struct result
         this->is_ok_ = false;
         auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f.value));
         assert(tmp == std::addressof(this->fail));
+        (void)tmp;
         return *this;
     }
 
@@ -233,11 +249,13 @@ struct result
         {
             auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok());
             assert(tmp == std::addressof(this->succ));
+            (void)tmp;
         }
         else
         {
             auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err());
             assert(tmp == std::addressof(this->fail));
+            (void)tmp;
         }
     }
     result(result&& other): is_ok_(other.is_ok())
@@ -246,11 +264,13 @@ struct result
         {
             auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok()));
             assert(tmp == std::addressof(this->succ));
+            (void)tmp;
         }
         else
         {
             auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err()));
             assert(tmp == std::addressof(this->fail));
+            (void)tmp;
         }
     }
 
@@ -261,11 +281,13 @@ struct result
         {
             auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok());
             assert(tmp == std::addressof(this->succ));
+            (void)tmp;
         }
         else
         {
             auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err());
             assert(tmp == std::addressof(this->fail));
+            (void)tmp;
         }
     }
     template<typename U, typename F>
@@ -275,11 +297,13 @@ struct result
         {
             auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok()));
             assert(tmp == std::addressof(this->succ));
+            (void)tmp;
         }
         else
         {
             auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err()));
             assert(tmp == std::addressof(this->fail));
+            (void)tmp;
         }
     }
 
@@ -290,11 +314,13 @@ struct result
         {
             auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok());
             assert(tmp == std::addressof(this->succ));
+            (void)tmp;
         }
         else
         {
             auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err());
             assert(tmp == std::addressof(this->fail));
+            (void)tmp;
         }
         is_ok_ = other.is_ok();
         return *this;
@@ -306,11 +332,13 @@ struct result
         {
             auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok()));
             assert(tmp == std::addressof(this->succ));
+            (void)tmp;
         }
         else
         {
             auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err()));
             assert(tmp == std::addressof(this->fail));
+            (void)tmp;
         }
         is_ok_ = other.is_ok();
         return *this;
@@ -324,11 +352,13 @@ struct result
         {
             auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok());
             assert(tmp == std::addressof(this->succ));
+            (void)tmp;
         }
         else
         {
             auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err());
             assert(tmp == std::addressof(this->fail));
+            (void)tmp;
         }
         is_ok_ = other.is_ok();
         return *this;
@@ -341,11 +371,13 @@ struct result
         {
             auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok()));
             assert(tmp == std::addressof(this->succ));
+            (void)tmp;
         }
         else
         {
             auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err()));
             assert(tmp == std::addressof(this->fail));
+            (void)tmp;
         }
         is_ok_ = other.is_ok();
         return *this;
@@ -660,5 +692,26 @@ void swap(result<T, E>& lhs, result<T, E>& rhs)
 //     return lhs.is_ok() ? lhs : rhs;
 // }
 
+// ----------------------------------------------------------------------------
+// re-use result<T, E> as a optional<T> with none_t
+
+namespace detail
+{
+struct none_t {};
+inline bool operator==(const none_t&, const none_t&) noexcept {return true;}
+inline bool operator!=(const none_t&, const none_t&) noexcept {return false;}
+inline bool operator< (const none_t&, const none_t&) noexcept {return false;}
+inline bool operator<=(const none_t&, const none_t&) noexcept {return true;}
+inline bool operator> (const none_t&, const none_t&) noexcept {return false;}
+inline bool operator>=(const none_t&, const none_t&) noexcept {return true;}
+template<typename charT, typename traitsT>
+std::basic_ostream<charT, traitsT>&
+operator<<(std::basic_ostream<charT, traitsT>& os, const none_t&)
+{
+    os << "none";
+    return os;
+}
+inline failure<none_t> none() noexcept {return failure<none_t>{none_t{}};}
+} // detail
 } // toml11
 #endif// TOML11_RESULT_H

toml/serializer.hpp

@@ -157,7 +157,7 @@ struct serializer
 
     std::string operator()(const array& v) const
     {
-        if(!v.empty() && v.front().is(value_t::Table))// v is an array of tables
+        if(!v.empty() && v.front().is_table())// v is an array of tables
         {
             // if it's not inlined, we need to add `[[table.key]]`.
             // but if it can be inlined, we need `table.key = [...]`.
@@ -411,7 +411,7 @@ struct serializer
         // remaining non-table values will be assigned into [foo.bar], not [foo]
         for(const auto kv : v)
         {
-            if(kv.second.is(value_t::Table) || is_array_of_tables(kv.second))
+            if(kv.second.is_table() || is_array_of_tables(kv.second))
             {
                 continue;
             }
@@ -438,7 +438,7 @@ struct serializer
         bool multiline_table_printed = false;
         for(const auto& kv : v)
         {
-            if(!kv.second.is(value_t::Table) && !is_array_of_tables(kv.second))
+            if(!kv.second.is_table() && !is_array_of_tables(kv.second))
             {
                 continue; // other stuff are already serialized. skip them.
             }
@@ -467,10 +467,9 @@ struct serializer
 
     bool is_array_of_tables(const value& v) const
     {
-        if(!v.is(value_t::Array)) {return false;}
+        if(!v.is_array()) {return false;}
-
+        const auto& a = v.as_array();
-        const auto& a = v.cast<value_t::Array>();
+        return !a.empty() && a.front().is_table();
-        return !a.empty() && a.front().is(value_t::Table);
     }
 
   private:

toml/string.hpp

@@ -4,6 +4,11 @@
 #define TOML11_STRING_HPP
 #include <string>
 #include <cstdint>
+#if __cplusplus >= 201703L
+#if __has_include(<string_view>)
+#include <string_view>
+#endif
+#endif
 
 namespace toml
 {
@@ -40,6 +45,17 @@ struct string
     operator std::string const& () const& noexcept {return str;}
     operator std::string&&      () &&     noexcept {return std::move(str);}
 
+#if __cplusplus >= 201703L
+    explicit string(std::string_view s): kind(string_t::basic), str(s){}
+    string(std::string_view s, string_t k): kind(k), str(s){}
+
+    string& operator=(std::string_view s)
+    {kind = string_t::basic; str = s; return *this;}
+
+    explicit operator std::string_view() const noexcept
+    {return std::string_view(str);}
+#endif
+
     string_t    kind;
     std::string str;
 };

toml/types.hpp

@@ -7,6 +7,11 @@
 #include "traits.hpp"
 #include <vector>
 #include <unordered_map>
+#if __cplusplus >= 201703L
+#if __has_include(<string_view>)
+#include <string_view>
+#endif
+#endif
 
 namespace toml
 {
@@ -126,30 +131,30 @@ template<> struct toml_default_type<value_t::Table   >      {typedef table
 template<> struct toml_default_type<value_t::Empty   >      {typedef void            type;};
 template<> struct toml_default_type<value_t::Unknown >      {typedef void            type;};
 
-template<typename T> struct toml_value_t      {static constexpr value_t value = value_t::Unknown       ;};
+template<typename T> struct toml_value_t       {static constexpr value_t value = value_t::Unknown       ;};
-template<> struct toml_value_t<Boolean       >{static constexpr value_t value = value_t::Boolean       ;};
+template<> struct toml_value_t<boolean        >{static constexpr value_t value = value_t::Boolean       ;};
-template<> struct toml_value_t<Integer       >{static constexpr value_t value = value_t::Integer       ;};
+template<> struct toml_value_t<integer        >{static constexpr value_t value = value_t::Integer       ;};
-template<> struct toml_value_t<Float         >{static constexpr value_t value = value_t::Float         ;};
+template<> struct toml_value_t<floating       >{static constexpr value_t value = value_t::Float         ;};
-template<> struct toml_value_t<String        >{static constexpr value_t value = value_t::String        ;};
+template<> struct toml_value_t<string         >{static constexpr value_t value = value_t::String        ;};
-template<> struct toml_value_t<OffsetDatetime>{static constexpr value_t value = value_t::OffsetDatetime;};
+template<> struct toml_value_t<offset_datetime>{static constexpr value_t value = value_t::OffsetDatetime;};
-template<> struct toml_value_t<LocalDatetime >{static constexpr value_t value = value_t::LocalDatetime ;};
+template<> struct toml_value_t<local_datetime >{static constexpr value_t value = value_t::LocalDatetime ;};
-template<> struct toml_value_t<LocalDate     >{static constexpr value_t value = value_t::LocalDate     ;};
+template<> struct toml_value_t<local_date     >{static constexpr value_t value = value_t::LocalDate     ;};
-template<> struct toml_value_t<LocalTime     >{static constexpr value_t value = value_t::LocalTime     ;};
+template<> struct toml_value_t<local_time     >{static constexpr value_t value = value_t::LocalTime     ;};
-template<> struct toml_value_t<Array         >{static constexpr value_t value = value_t::Array         ;};
+template<> struct toml_value_t<array          >{static constexpr value_t value = value_t::Array         ;};
-template<> struct toml_value_t<Table         >{static constexpr value_t value = value_t::Table         ;};
+template<> struct toml_value_t<table          >{static constexpr value_t value = value_t::Table         ;};
 
 template<typename T>
 struct is_exact_toml_type : disjunction<
-    std::is_same<T, Boolean >,
+    std::is_same<T, boolean        >,
-    std::is_same<T, Integer >,
+    std::is_same<T, integer        >,
-    std::is_same<T, Float   >,
+    std::is_same<T, floating       >,
-    std::is_same<T, String  >,
+    std::is_same<T, string         >,
     std::is_same<T, offset_datetime>,
-    std::is_same<T, local_datetime>,
+    std::is_same<T, local_datetime >,
-    std::is_same<T, local_date>,
+    std::is_same<T, local_date     >,
-    std::is_same<T, local_time>,
+    std::is_same<T, local_time     >,
-    std::is_same<T, Array   >,
+    std::is_same<T, array          >,
-    std::is_same<T, Table   >
+    std::is_same<T, table          >
     >{};
 template<typename T> struct is_exact_toml_type<T&>               : is_exact_toml_type<T>{};
 template<typename T> struct is_exact_toml_type<T const&>         : is_exact_toml_type<T>{};
@@ -172,6 +177,9 @@ template<typename T>
 struct is_container : conjunction<
     negation<is_map<T>>,
     negation<std::is_same<T, std::string>>,
+#if __cplusplus >= 201703L
+    negation<std::is_same<T, std::string_view>>,
+#endif
     has_iterator<T>,
     has_value_type<T>
     >{};

toml/utility.hpp

@@ -79,7 +79,7 @@ std::string concat_to_string(Ts&& ... args)
 template<typename T, typename U>
 T from_string(const std::string& str, U&& opt)
 {
-    T v(std::forward<U>(opt));
+    T v(static_cast<T>(std::forward<U>(opt)));
     std::istringstream iss(str);
     iss >> v;
     return v;

toml/value.hpp

@@ -14,6 +14,9 @@
 #include <unordered_map>
 #include <cassert>
 #include <cstdint>
+#if __cplusplus >= 201703L
+#include <string_view>
+#endif
 
 namespace toml
 {
@@ -45,6 +48,7 @@ class value
     {
         const auto tmp = ::new(std::addressof(dst)) T(std::forward<U>(v));
         assert(tmp == std::addressof(dst));
+        (void)tmp;
     }
 
     using region_base = detail::region_base;
@@ -293,6 +297,29 @@ class value
         assigner(this->string_, toml::string(std::string(s), kind));
     }
 
+#if __cplusplus >= 201703L
+    value(std::string_view s)
+        : type_(value_t::String),
+          region_info_(std::make_shared<region_base>(region_base{}))
+    {
+        assigner(this->string_, toml::string(s));
+    }
+    value& operator=(std::string_view s)
+    {
+        this->cleanup();
+        this->type_ = value_t::String;
+        this->region_info_ = std::make_shared<region_base>(region_base{});
+        assigner(this->string_, toml::string(s));
+        return *this;
+    }
+    value(std::string_view s, string_t kind)
+        : type_(value_t::String),
+          region_info_(std::make_shared<region_base>(region_base{}))
+    {
+        assigner(this->string_, toml::string(s, kind));
+    }
+#endif
+
     // local date ===========================================================
 
     value(const local_date& ld)
@@ -607,6 +634,52 @@ class value
     template<value_t T>
     typename detail::toml_default_type<T>::type&&      cast() &&;
 
+    boolean         const& as_boolean()         const& noexcept {return this->boolean_;}
+    integer         const& as_integer()         const& noexcept {return this->integer_;}
+    floating        const& as_float()           const& noexcept {return this->floating_;}
+    string          const& as_string()          const& noexcept {return this->string_;}
+    offset_datetime const& as_offset_datetime() const& noexcept {return this->offset_datetime_;}
+    local_datetime  const& as_local_datetime()  const& noexcept {return this->local_datetime_;}
+    local_date      const& as_local_date()      const& noexcept {return this->local_date_;}
+    local_time      const& as_local_time()      const& noexcept {return this->local_time_;}
+    array           const& as_array()           const& noexcept {return this->array_.value();}
+    table           const& as_table()           const& noexcept {return this->table_.value();}
+
+    boolean        & as_boolean()         & noexcept {return this->boolean_;}
+    integer        & as_integer()         & noexcept {return this->integer_;}
+    floating       & as_float()           & noexcept {return this->floating_;}
+    string         & as_string()          & noexcept {return this->string_;}
+    offset_datetime& as_offset_datetime() & noexcept {return this->offset_datetime_;}
+    local_datetime & as_local_datetime()  & noexcept {return this->local_datetime_;}
+    local_date     & as_local_date()      & noexcept {return this->local_date_;}
+    local_time     & as_local_time()      & noexcept {return this->local_time_;}
+    array          & as_array()           & noexcept {return this->array_.value();}
+    table          & as_table()           & noexcept {return this->table_.value();}
+
+    boolean        && as_boolean()         && noexcept {return std::move(this->boolean_);}
+    integer        && as_integer()         && noexcept {return std::move(this->integer_);}
+    floating       && as_float()           && noexcept {return std::move(this->floating_);}
+    string         && as_string()          && noexcept {return std::move(this->string_);}
+    offset_datetime&& as_offset_datetime() && noexcept {return std::move(this->offset_datetime_);}
+    local_datetime && as_local_datetime()  && noexcept {return std::move(this->local_datetime_);}
+    local_date     && as_local_date()      && noexcept {return std::move(this->local_date_);}
+    local_time     && as_local_time()      && noexcept {return std::move(this->local_time_);}
+    array          && as_array()           && noexcept {return std::move(this->array_.value());}
+    table          && as_table()           && noexcept {return std::move(this->table_.value());}
+
+    std::string comment() const
+    {
+        return this->region_info_->comment();
+    }
+    std::string comment_before() const
+    {
+        return this->region_info_->comment_before();
+    }
+    std::string comment_inline() const
+    {
+        return this->region_info_->comment_inline();
+    }
+
   private:
 
     void cleanup() noexcept
@@ -626,9 +699,6 @@ class value
     template<typename Region>
     friend void detail::change_region(value&, Region&&);
 
-    template<value_t T>
-    struct switch_cast;
-
   private:
 
     using array_storage = detail::storage<array>;
@@ -674,107 +744,116 @@ void change_region(value& v, Region&& reg)
     return;
 }
 
-}// detail
+template<value_t Expected>
+[[noreturn]] inline void throw_bad_cast(value_t actual, const ::toml::value& v)
+{
+    throw type_error(detail::format_underline(concat_to_string(
+        "[error] toml::value bad_cast to ", Expected), {
+            {std::addressof(get_region(v)),
+             concat_to_string("the actual type is ", actual)}
+        }));
+}
 
-template<> struct value::switch_cast<value_t::Boolean>
+template<value_t T>
+struct switch_cast;
+template<>
+struct switch_cast<value_t::Boolean>
 {
-    static Boolean&       invoke(value&       v) {return v.boolean_;}
+    static ::toml::boolean&       invoke(value&       v) {return v.as_boolean();}
-    static Boolean const& invoke(value const& v) {return v.boolean_;}
+    static ::toml::boolean const& invoke(value const& v) {return v.as_boolean();}
-    static Boolean&&      invoke(value&&      v) {return std::move(v.boolean_);}
+    static ::toml::boolean&&      invoke(value&&      v) {return std::move(v).as_boolean();}
 };
-template<> struct value::switch_cast<value_t::Integer>
+template<>
+struct switch_cast<value_t::Integer>
 {
-    static Integer&       invoke(value&       v) {return v.integer_;}
+    static ::toml::integer&       invoke(value&       v) {return v.as_integer();}
-    static Integer const& invoke(value const& v) {return v.integer_;}
+    static ::toml::integer const& invoke(value const& v) {return v.as_integer();}
-    static Integer&&      invoke(value&&      v) {return std::move(v.integer_);}
+    static ::toml::integer&&      invoke(value&&      v) {return std::move(v).as_integer();}
 };
-template<> struct value::switch_cast<value_t::Float>
+template<>
+struct switch_cast<value_t::Float>
 {
-    static Float&       invoke(value&       v) {return v.floating_;}
+    static ::toml::floating&       invoke(value&       v) {return v.as_float();}
-    static Float const& invoke(value const& v) {return v.floating_;}
+    static ::toml::floating const& invoke(value const& v) {return v.as_float();}
-    static Float&&      invoke(value&&      v) {return std::move(v.floating_);}
+    static ::toml::floating&&      invoke(value&&      v) {return std::move(v).as_float();}
 };
-template<> struct value::switch_cast<value_t::String>
+template<>
+struct switch_cast<value_t::String>
 {
-    static String&       invoke(value&       v) {return v.string_;}
+    static ::toml::string&       invoke(value&       v) {return v.as_string();}
-    static String const& invoke(value const& v) {return v.string_;}
+    static ::toml::string const& invoke(value const& v) {return v.as_string();}
-    static String&&      invoke(value&&      v) {return std::move(v.string_);}
+    static ::toml::string&&      invoke(value&&      v) {return std::move(v).as_string();}
 };
-template<> struct value::switch_cast<value_t::OffsetDatetime>
+template<>
+struct switch_cast<value_t::OffsetDatetime>
 {
-    static OffsetDatetime&       invoke(value&       v) {return v.offset_datetime_;}
+    static ::toml::offset_datetime&       invoke(value&       v) {return v.as_offset_datetime();}
-    static OffsetDatetime const& invoke(value const& v) {return v.offset_datetime_;}
+    static ::toml::offset_datetime const& invoke(value const& v) {return v.as_offset_datetime();}
-    static OffsetDatetime&&      invoke(value&&      v) {return std::move(v.offset_datetime_);}
+    static ::toml::offset_datetime&&      invoke(value&&      v) {return std::move(v).as_offset_datetime();}
 };
-template<> struct value::switch_cast<value_t::LocalDatetime>
+template<>
+struct switch_cast<value_t::LocalDatetime>
 {
-    static LocalDatetime&       invoke(value&       v) {return v.local_datetime_;}
+    static ::toml::local_datetime&       invoke(value&       v) {return v.as_local_datetime();}
-    static LocalDatetime const& invoke(value const& v) {return v.local_datetime_;}
+    static ::toml::local_datetime const& invoke(value const& v) {return v.as_local_datetime();}
-    static LocalDatetime&&      invoke(value&&      v) {return std::move(v.local_datetime_);}
+    static ::toml::local_datetime&&      invoke(value&&      v) {return std::move(v).as_local_datetime();}
 };
-template<> struct value::switch_cast<value_t::LocalDate>
+template<>
+struct switch_cast<value_t::LocalDate>
 {
-    static LocalDate&       invoke(value&       v) {return v.local_date_;}
+    static ::toml::local_date&       invoke(value&       v) {return v.as_local_date();}
-    static LocalDate const& invoke(value const& v) {return v.local_date_;}
+    static ::toml::local_date const& invoke(value const& v) {return v.as_local_date();}
-    static LocalDate&&      invoke(value&&      v) {return std::move(v.local_date_);}
+    static ::toml::local_date&&      invoke(value&&      v) {return std::move(v).as_local_date();}
 };
-template<> struct value::switch_cast<value_t::LocalTime>
+template<>
+struct switch_cast<value_t::LocalTime>
 {
-    static LocalTime&       invoke(value&       v) {return v.local_time_;}
+    static ::toml::local_time&       invoke(value&       v) {return v.as_local_time();}
-    static LocalTime const& invoke(value const& v) {return v.local_time_;}
+    static ::toml::local_time const& invoke(value const& v) {return v.as_local_time();}
-    static LocalTime&&      invoke(value&&      v) {return std::move(v.local_time_);}
+    static ::toml::local_time&&      invoke(value&&      v) {return std::move(v).as_local_time();}
 };
-template<> struct value::switch_cast<value_t::Array>
+template<>
+struct switch_cast<value_t::Array>
 {
-    static Array&       invoke(value&       v) {return v.array_.value();}
+    static ::toml::array&       invoke(value&       v) {return v.as_array();}
-    static Array const& invoke(value const& v) {return v.array_.value();}
+    static ::toml::array const& invoke(value const& v) {return v.as_array();}
-    static Array&&      invoke(value&&      v) {return std::move(v.array_.value());}
+    static ::toml::array&&      invoke(value&&      v) {return std::move(v).as_array();}
 };
-template<> struct value::switch_cast<value_t::Table>
+template<>
+struct switch_cast<value_t::Table>
 {
-    static Table&       invoke(value&       v) {return v.table_.value();}
+    static ::toml::table&       invoke(value&       v) {return v.as_table();}
-    static Table const& invoke(value const& v) {return v.table_.value();}
+    static ::toml::table const& invoke(value const& v) {return v.as_table();}
-    static Table&&      invoke(value&&      v) {return std::move(v.table_.value());}
+    static ::toml::table&&      invoke(value&&      v) {return std::move(v).as_table();}
 };
+}// detail
 
 template<value_t T>
 typename detail::toml_default_type<T>::type& value::cast() &
 {
     if(T != this->type_)
     {
-        throw type_error(detail::format_underline(concat_to_string(
+        detail::throw_bad_cast<T>(this->type_, *this);
-            "[error] toml::value bad_cast to ", T), {
-                {this->region_info_.get(),
-                 concat_to_string("the actual type is ", this->type_)}
-            }));
     }
-    return switch_cast<T>::invoke(*this);
+    return detail::switch_cast<T>::invoke(*this);
 }
 template<value_t T>
 typename detail::toml_default_type<T>::type const& value::cast() const&
 {
     if(T != this->type_)
     {
-        throw type_error(detail::format_underline(concat_to_string(
+        detail::throw_bad_cast<T>(this->type_, *this);
-            "[error] toml::value bad_cast to ", T), {
-                {this->region_info_.get(),
-                 concat_to_string("the actual type is ", this->type_)}
-            }));
     }
-    return switch_cast<T>::invoke(*this);
+    return detail::switch_cast<T>::invoke(*this);
 }
 template<value_t T>
 typename detail::toml_default_type<T>::type&&      value::cast() &&
 {
     if(T != this->type_)
     {
-        throw type_error(detail::format_underline(concat_to_string(
+        detail::throw_bad_cast<T>(this->type_, *this);
-            "[error] toml::value bad_cast to ", T), {
-                {this->region_info_.get(),
-                 concat_to_string("the actual type is ", this->type_)}
-             }));
     }
-    return switch_cast<T>::invoke(std::move(*this));
+    return detail::switch_cast<T>::invoke(std::move(*this));
 }
 
 inline bool operator==(const toml::value& lhs, const toml::value& rhs)
@@ -783,28 +862,48 @@ inline bool operator==(const toml::value& lhs, const toml::value& rhs)
     switch(lhs.type())
     {
         case value_t::Boolean :
-            return lhs.cast<value_t::Boolean >() == rhs.cast<value_t::Boolean >();
+        {
+            return lhs.as_boolean() == rhs.as_boolean();
+        }
         case value_t::Integer :
-            return lhs.cast<value_t::Integer >() == rhs.cast<value_t::Integer >();
+        {
+            return lhs.as_integer() == rhs.as_integer();
+        }
         case value_t::Float   :
-            return lhs.cast<value_t::Float   >() == rhs.cast<value_t::Float   >();
+        {
+            return lhs.as_float() == rhs.as_float();
+        }
         case value_t::String  :
-            return lhs.cast<value_t::String  >() == rhs.cast<value_t::String  >();
+        {
+            return lhs.as_string() == rhs.as_string();
+        }
         case value_t::OffsetDatetime:
-            return lhs.cast<value_t::OffsetDatetime>() == rhs.cast<value_t::OffsetDatetime>();
+        {
+            return lhs.as_offset_datetime() == rhs.as_offset_datetime();
+        }
         case value_t::LocalDatetime:
-            return lhs.cast<value_t::LocalDatetime>() == rhs.cast<value_t::LocalDatetime>();
+        {
+            return lhs.as_local_datetime() == rhs.as_local_datetime();
+        }
         case value_t::LocalDate:
-            return lhs.cast<value_t::LocalDate>() == rhs.cast<value_t::LocalDate>();
+        {
+            return lhs.as_local_date() == rhs.as_local_date();
+        }
         case value_t::LocalTime:
-            return lhs.cast<value_t::LocalTime>() == rhs.cast<value_t::LocalTime>();
+        {
+            return lhs.as_local_time() == rhs.as_local_time();
+        }
         case value_t::Array   :
-            return lhs.cast<value_t::Array   >() == rhs.cast<value_t::Array   >();
+        {
+            return lhs.as_array() == rhs.as_array();
+        }
         case value_t::Table   :
-            return lhs.cast<value_t::Table   >() == rhs.cast<value_t::Table   >();
+        {
-        case value_t::Empty   : return true;
+            return lhs.as_table() == rhs.as_table();
-        case value_t::Unknown : return false;
+        }
-        default: return false;
+        case value_t::Empty   : {return true; }
+        case value_t::Unknown : {return false;}
+        default:                {return false;}
     }
 }
 inline bool operator<(const toml::value& lhs, const toml::value& rhs)
@@ -813,28 +912,48 @@ inline bool operator<(const toml::value& lhs, const toml::value& rhs)
     switch(lhs.type())
     {
         case value_t::Boolean :
-            return lhs.cast<value_t::Boolean >() < rhs.cast<value_t::Boolean >();
+        {
+            return lhs.as_boolean() < rhs.as_boolean();
+        }
         case value_t::Integer :
-            return lhs.cast<value_t::Integer >() < rhs.cast<value_t::Integer >();
+        {
+            return lhs.as_integer() < rhs.as_integer();
+        }
         case value_t::Float   :
-            return lhs.cast<value_t::Float   >() < rhs.cast<value_t::Float   >();
+        {
+            return lhs.as_float() < rhs.as_float();
+        }
         case value_t::String  :
-            return lhs.cast<value_t::String  >() < rhs.cast<value_t::String  >();
+        {
+            return lhs.as_string() < rhs.as_string();
+        }
         case value_t::OffsetDatetime:
-            return lhs.cast<value_t::OffsetDatetime>() < rhs.cast<value_t::OffsetDatetime>();
+        {
+            return lhs.as_offset_datetime() < rhs.as_offset_datetime();
+        }
         case value_t::LocalDatetime:
-            return lhs.cast<value_t::LocalDatetime>() < rhs.cast<value_t::LocalDatetime>();
+        {
+            return lhs.as_local_datetime() < rhs.as_local_datetime();
+        }
         case value_t::LocalDate:
-            return lhs.cast<value_t::LocalDate>() < rhs.cast<value_t::LocalDate>();
+        {
+            return lhs.as_local_date() < rhs.as_local_date();
+        }
         case value_t::LocalTime:
-            return lhs.cast<value_t::LocalTime>() < rhs.cast<value_t::LocalTime>();
+        {
+            return lhs.as_local_time() < rhs.as_local_time();
+        }
         case value_t::Array   :
-            return lhs.cast<value_t::Array   >() < rhs.cast<value_t::Array   >();
+        {
+            return lhs.as_array() < rhs.as_array();
+        }
         case value_t::Table   :
-            return lhs.cast<value_t::Table   >() < rhs.cast<value_t::Table   >();
+        {
-        case value_t::Empty   : return false;
+            return lhs.as_table() < rhs.as_table();
-        case value_t::Unknown : return false;
+        }
-        default: return false;
+        case value_t::Empty   : {return false;}
+        case value_t::Unknown : {return false;}
+        default:                {return false;}
     }
 }
 
@@ -897,16 +1016,16 @@ visit(Visitor&& visitor, const toml::value& v)
 {
     switch(v.type())
     {
-        case value_t::Boolean       : {return visitor(v.cast<value_t::Boolean       >());}
+        case value_t::Boolean       : {return visitor(v.as_boolean        ());}
-        case value_t::Integer       : {return visitor(v.cast<value_t::Integer       >());}
+        case value_t::Integer       : {return visitor(v.as_integer        ());}
-        case value_t::Float         : {return visitor(v.cast<value_t::Float         >());}
+        case value_t::Float         : {return visitor(v.as_float          ());}
-        case value_t::String        : {return visitor(v.cast<value_t::String        >());}
+        case value_t::String        : {return visitor(v.as_string         ());}
-        case value_t::OffsetDatetime: {return visitor(v.cast<value_t::OffsetDatetime>());}
+        case value_t::OffsetDatetime: {return visitor(v.as_offset_datetime());}
-        case value_t::LocalDatetime : {return visitor(v.cast<value_t::LocalDatetime >());}
+        case value_t::LocalDatetime : {return visitor(v.as_local_datetime ());}
-        case value_t::LocalDate     : {return visitor(v.cast<value_t::LocalDate     >());}
+        case value_t::LocalDate     : {return visitor(v.as_local_date     ());}
-        case value_t::LocalTime     : {return visitor(v.cast<value_t::LocalTime     >());}
+        case value_t::LocalTime     : {return visitor(v.as_local_time     ());}
-        case value_t::Array         : {return visitor(v.cast<value_t::Array         >());}
+        case value_t::Array         : {return visitor(v.as_array          ());}
-        case value_t::Table         : {return visitor(v.cast<value_t::Table         >());}
+        case value_t::Table         : {return visitor(v.as_table          ());}
         case value_t::Empty         : break;
         case value_t::Unknown       : break;
         default: break;
@@ -921,16 +1040,16 @@ visit(Visitor&& visitor, toml::value& v)
 {
     switch(v.type())
     {
-        case value_t::Boolean       : {return visitor(v.cast<value_t::Boolean       >());}
+        case value_t::Boolean       : {return visitor(v.as_boolean        ());}
-        case value_t::Integer       : {return visitor(v.cast<value_t::Integer       >());}
+        case value_t::Integer       : {return visitor(v.as_integer        ());}
-        case value_t::Float         : {return visitor(v.cast<value_t::Float         >());}
+        case value_t::Float         : {return visitor(v.as_float          ());}
-        case value_t::String        : {return visitor(v.cast<value_t::String        >());}
+        case value_t::String        : {return visitor(v.as_string         ());}
-        case value_t::OffsetDatetime: {return visitor(v.cast<value_t::OffsetDatetime>());}
+        case value_t::OffsetDatetime: {return visitor(v.as_offset_datetime());}
-        case value_t::LocalDatetime : {return visitor(v.cast<value_t::LocalDatetime >());}
+        case value_t::LocalDatetime : {return visitor(v.as_local_datetime ());}
-        case value_t::LocalDate     : {return visitor(v.cast<value_t::LocalDate     >());}
+        case value_t::LocalDate     : {return visitor(v.as_local_date     ());}
-        case value_t::LocalTime     : {return visitor(v.cast<value_t::LocalTime     >());}
+        case value_t::LocalTime     : {return visitor(v.as_local_time     ());}
-        case value_t::Array         : {return visitor(v.cast<value_t::Array         >());}
+        case value_t::Array         : {return visitor(v.as_array          ());}
-        case value_t::Table         : {return visitor(v.cast<value_t::Table         >());}
+        case value_t::Table         : {return visitor(v.as_table          ());}
         case value_t::Empty         : break;
         case value_t::Unknown       : break;
         default: break;
@@ -945,16 +1064,16 @@ visit(Visitor&& visitor, toml::value&& v)
 {
     switch(v.type())
     {
-        case value_t::Boolean       : {return visitor(std::move(v.cast<value_t::Boolean       >()));}
+        case value_t::Boolean       : {return visitor(std::move(v.as_boolean        ()));}
-        case value_t::Integer       : {return visitor(std::move(v.cast<value_t::Integer       >()));}
+        case value_t::Integer       : {return visitor(std::move(v.as_integer        ()));}
-        case value_t::Float         : {return visitor(std::move(v.cast<value_t::Float         >()));}
+        case value_t::Float         : {return visitor(std::move(v.as_float          ()));}
-        case value_t::String        : {return visitor(std::move(v.cast<value_t::String        >()));}
+        case value_t::String        : {return visitor(std::move(v.as_string         ()));}
-        case value_t::OffsetDatetime: {return visitor(std::move(v.cast<value_t::OffsetDatetime>()));}
+        case value_t::OffsetDatetime: {return visitor(std::move(v.as_offset_datetime()));}
-        case value_t::LocalDatetime : {return visitor(std::move(v.cast<value_t::LocalDatetime >()));}
+        case value_t::LocalDatetime : {return visitor(std::move(v.as_local_datetime ()));}
-        case value_t::LocalDate     : {return visitor(std::move(v.cast<value_t::LocalDate     >()));}
+        case value_t::LocalDate     : {return visitor(std::move(v.as_local_date     ()));}
-        case value_t::LocalTime     : {return visitor(std::move(v.cast<value_t::LocalTime     >()));}
+        case value_t::LocalTime     : {return visitor(std::move(v.as_local_time     ()));}
-        case value_t::Array         : {return visitor(std::move(v.cast<value_t::Array         >()));}
+        case value_t::Array         : {return visitor(std::move(v.as_array          ()));}
-        case value_t::Table         : {return visitor(std::move(v.cast<value_t::Table         >()));}
+        case value_t::Table         : {return visitor(std::move(v.as_table          ()));}
         case value_t::Empty         : break;
         case value_t::Unknown       : break;
         default: break;