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.

.circleci/config.yml

@@ -0,0 +1,59 @@
+version: 2.1
+
+jobs:
+  test_suite:
+    environment:
+      - GOPATH: /home/circleci/go
+    docker:
+      - image: circleci/golang:1.9
+    steps:
+      - checkout
+      - run:
+          command: |
+              g++ --version
+              cd tests/
+              g++ -std=c++11 -O2 -Wall -Wextra -Werror -I../ check_toml_test.cpp -o check_toml_test
+              go get github.com/BurntSushi/toml-test
+              $GOPATH/bin/toml-test ./check_toml_test
+  output_result:
+    docker:
+      - image: circleci/buildpack-deps:bionic
+    steps:
+      - checkout
+      - run:
+          command: |
+              g++ --version
+              cd tests/
+              g++ -std=c++11 -O2 -Wall -Wextra -Werror -I../ check.cpp -o check
+              git clone https://github.com/BurntSushi/toml-test.git
+              cp check toml-test/tests/invalid
+              cp check toml-test/tests/valid
+              cd toml-test/tests/invalid
+              for f in $(ls ./*.toml);
+                do echo "==> ${f}";
+                cat ${f};
+                echo "---------------------------------------";
+                ./check ${f} invalid;
+                if [ $? -ne 0 ] ; then
+                  exit 1
+                fi
+                echo "=======================================";
+              done
+              cd ../valid
+              for f in $(ls ./*.toml);
+                do echo "==> ${f}";
+                cat ${f};
+                echo "---------------------------------------";
+                ./check ${f} valid;
+                if [ $? -ne 0 ] ; then
+                  exit 1
+                fi
+                echo "=======================================";
+              done
+
+workflows:
+  version: 2.1
+  test:
+    jobs:
+      - test_suite
+      - output_result

.travis.yml

@@ -5,20 +5,62 @@ matrix:
   - os: linux
     language: cpp
     compiler: gcc
-    env: COMPILER="g++-5"
+    env: COMPILER="g++-5" CXX_STANDARD=11
     addons:
       apt:
         sources:
         - ubuntu-toolchain-r-test
         packages:
         - g++-5
-        - build-essential
-        - cmake
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: gcc
+    env: COMPILER="g++-6" CXX_STANDARD=11
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        packages:
+        - g++-6
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: gcc
+    env: COMPILER="g++-7" CXX_STANDARD=11
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        packages:
+        - g++-7
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: gcc
+    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:
+        - ubuntu-toolchain-r-test
+        packages:
+        - g++-8
         - libboost-all-dev
   - os: linux
     language: cpp
     compiler: clang
-    env: COMPILER="clang++-3.7"
+    env: COMPILER="clang++-3.7" CXX_STANDARD=11
     addons:
       apt:
         sources:
@@ -26,17 +68,99 @@ matrix:
         - llvm-toolchain-precise-3.7
         packages:
         - clang-3.7
-        - build-essential
-        - cmake
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-4.0" CXX_STANDARD=11
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-4.0
+        packages:
+        - clang-4.0
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-5.0" CXX_STANDARD=11
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-5.0
+        packages:
+        - clang-5.0
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-6.0" CXX_STANDARD=11
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-6.0
+        packages:
+        - clang-6.0
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-7" CXX_STANDARD=11
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-7
+        packages:
+        - clang-7
+        - libboost-all-dev
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-8" CXX_STANDARD=11
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-8
+        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.

tests/CMakeLists.txt

@@ -20,14 +20,17 @@ set(TEST_NAMES
     test_parse_inline_table
     test_parse_key
     test_parse_table_key
+    test_literals
+    test_comments
     test_get
     test_get_related_func
-    test_to_toml
     test_from_toml
     test_parse_file
     test_serialize_file
     test_parse_unicode
     test_error_detection
+    test_format_error
+    test_extended_conversions
 )
 
 CHECK_CXX_COMPILER_FLAG("-Wall" COMPILER_SUPPORTS_WALL)
@@ -97,3 +100,8 @@ foreach(TEST_NAME ${TEST_NAMES})
         )
     endif()
 endforeach(TEST_NAME)
+
+# this test is to check it compiles. it will not run
+add_executable(test_multiple_translation_unit
+               test_multiple_translation_unit_1.cpp
+               test_multiple_translation_unit_2.cpp)

tests/check.cpp

@@ -0,0 +1,41 @@
+#include "toml.hpp"
+#include <iostream>
+#include <iomanip>
+
+int main(int argc, char **argv)
+{
+    if(argc != 3)
+    {
+        std::cerr << "usage: ./check [filename] [valid|invalid]" << std::endl;
+        return 1;
+    }
+
+    const std::string file_kind(argv[2]);
+
+    try
+    {
+        const auto data = toml::parse(argv[1]);
+        std::cout << std::setprecision(16) << std::setw(80) << data;
+        if(file_kind == "valid")
+        {
+            return 0;
+        }
+        else
+        {
+            return 1;
+        }
+    }
+    catch(const toml::syntax_error& err)
+    {
+        std::cout << "what(): " << err.what() << std::endl;
+        if(file_kind == "invalid")
+        {
+            return 0;
+        }
+        else
+        {
+            return 1;
+        }
+    }
+    return 127;
+}

tests/check_toml_test.cpp

@@ -0,0 +1,142 @@
+#include "toml.hpp"
+#include <iostream>
+#include <iomanip>
+
+struct json_serializer
+{
+    void operator()(toml::boolean v)
+    {
+        std::cout << "{\"type\":\"bool\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(toml::integer v)
+    {
+        std::cout << "{\"type\":\"integer\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(toml::floating v)
+    {
+        std::cout << "{\"type\":\"float\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(const toml::string& v)
+    {
+        // since toml11 automatically convert string to multiline string that is
+        // valid only in TOML, we need to format the string to make it valid in
+        // JSON.
+        std::cout << "{\"type\":\"string\",\"value\":\""
+                  << this->escape_string(v.str) << "\"}";
+        return ;
+    }
+    void operator()(const toml::local_time& v)
+    {
+        std::cout << "{\"type\":\"local_time\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(const toml::local_date& v)
+    {
+        std::cout << "{\"type\":\"local_date\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(const toml::local_datetime& v)
+    {
+        std::cout << "{\"type\":\"local_datetime\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(const toml::offset_datetime& v)
+    {
+        std::cout << "{\"type\":\"datetime\",\"value\":\"" << toml::value(v) << "\"}";
+        return ;
+    }
+    void operator()(const toml::array& v)
+    {
+        if(!v.empty() && v.front().is_table())
+        {
+            std::cout << '[';
+            bool is_first = true;
+            for(const auto& elem : v)
+            {
+                if(!is_first) {std::cout << ", ";}
+                is_first = false;
+                toml::visit(*this, elem);
+            }
+            std::cout << ']';
+        }
+        else
+        {
+            std::cout << "{\"type\":\"array\",\"value\":[";
+            bool is_first = true;
+            for(const auto& elem : v)
+            {
+                if(!is_first) {std::cout << ", ";}
+                is_first = false;
+                toml::visit(*this, elem);
+            }
+            std::cout << "]}";
+        }
+        return ;
+    }
+    void operator()(const toml::table& v)
+    {
+        std::cout << '{';
+        bool is_first = true;
+        for(const auto& elem : v)
+        {
+            if(!is_first) {std::cout << ", ";}
+            is_first = false;
+            std::cout << toml::format(toml::string(elem.first),
+                                      std::numeric_limits<std::size_t>::max());
+            std::cout << ':';
+            toml::visit(*this, elem.second);
+        }
+        std::cout << '}';
+        return ;
+    }
+
+    std::string escape_string(const std::string& s) const
+    {
+        std::string retval;
+        for(const char c : s)
+        {
+            switch(c)
+            {
+                case '\\': {retval += "\\\\"; break;}
+                case '\"': {retval += "\\\""; break;}
+                case '\b': {retval += "\\b";  break;}
+                case '\t': {retval += "\\t";  break;}
+                case '\f': {retval += "\\f";  break;}
+                case '\n': {retval += "\\n";  break;}
+                case '\r': {retval += "\\r";  break;}
+                default  : {retval += c;      break;}
+            }
+        }
+        return retval;
+    }
+};
+
+int main()
+{
+    try
+    {
+        std::vector<char> buf;
+        std::cin.peek();
+        while(!std::cin.eof())
+        {
+            buf.push_back(std::cin.get());
+            std::cin.peek();
+        }
+        std::string bufstr(buf.begin(), buf.end());
+
+        std::istringstream ss(bufstr);
+
+        const auto data = toml::parse(ss);
+        std::cout << std::setprecision(std::numeric_limits<double>::max_digits10);
+        toml::visit(json_serializer(), data);
+        return 0;
+    }
+    catch(const toml::syntax_error& err)
+    {
+        std::cout << "what(): " << err.what() << std::endl;
+        return 1;
+    }
+}

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_extended_conversions.cpp

@@ -0,0 +1,116 @@
+#define BOOST_TEST_MODULE "test_extended_conversions"
+#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>
+
+namespace extlib
+{
+struct foo
+{
+    int a;
+    std::string b;
+};
+struct bar
+{
+    int a;
+    std::string b;
+
+    void from_toml(const toml::value& v)
+    {
+        this->a = toml::find<int>(v, "a");
+        this->b = toml::find<std::string>(v, "b");
+        return ;
+    }
+
+    toml::table into_toml() const
+    {
+        return toml::table{{"a", this->a}, {"b", this->b}};
+    }
+};
+} // extlib
+
+namespace toml
+{
+template<>
+struct from<extlib::foo>
+{
+    static extlib::foo from_toml(const toml::value& v)
+    {
+        return extlib::foo{toml::find<int>(v, "a"), toml::find<std::string>(v, "b")};
+    }
+};
+
+template<>
+struct into<extlib::foo>
+{
+    static toml::table into_toml(const extlib::foo& f)
+    {
+        return toml::table{{"a", f.a}, {"b", f.b}};
+    }
+};
+} // toml
+
+
+BOOST_AUTO_TEST_CASE(test_conversion_by_member_methods)
+{
+    const toml::value v{{"a", 42}, {"b", "baz"}};
+
+    const auto foo = toml::get<extlib::foo>(v);
+    BOOST_CHECK_EQUAL(foo.a, 42);
+    BOOST_CHECK_EQUAL(foo.b, "baz");
+
+    const toml::value v2(foo);
+
+    BOOST_CHECK_EQUAL(v, v2);
+}
+
+BOOST_AUTO_TEST_CASE(test_conversion_by_specialization)
+{
+    const toml::value v{{"a", 42}, {"b", "baz"}};
+
+    const auto bar = toml::get<extlib::bar>(v);
+    BOOST_CHECK_EQUAL(bar.a, 42);
+    BOOST_CHECK_EQUAL(bar.b, "baz");
+
+    const toml::value v2(bar);
+
+    BOOST_CHECK_EQUAL(v, v2);
+}
+
+BOOST_AUTO_TEST_CASE(test_recursive_conversion)
+{
+    const toml::value v{
+        toml::table{{"a", 42}, {"b", "baz"}},
+        toml::table{{"a", 43}, {"b", "qux"}},
+        toml::table{{"a", 44}, {"b", "quux"}},
+        toml::table{{"a", 45}, {"b", "foobar"}},
+    };
+
+    const auto foos = toml::get<std::vector<extlib::foo>>(v);
+    BOOST_CHECK_EQUAL(foos.size()  , 4ul);
+    BOOST_CHECK_EQUAL(foos.at(0).a , 42);
+    BOOST_CHECK_EQUAL(foos.at(1).a , 43);
+    BOOST_CHECK_EQUAL(foos.at(2).a , 44);
+    BOOST_CHECK_EQUAL(foos.at(3).a , 45);
+
+    BOOST_CHECK_EQUAL(foos.at(0).b , "baz");
+    BOOST_CHECK_EQUAL(foos.at(1).b , "qux");
+    BOOST_CHECK_EQUAL(foos.at(2).b , "quux");
+    BOOST_CHECK_EQUAL(foos.at(3).b , "foobar");
+
+    const auto bars = toml::get<std::vector<extlib::bar>>(v);
+    BOOST_CHECK_EQUAL(bars.size()  , 4ul);
+    BOOST_CHECK_EQUAL(bars.at(0).a , 42);
+    BOOST_CHECK_EQUAL(bars.at(1).a , 43);
+    BOOST_CHECK_EQUAL(bars.at(2).a , 44);
+    BOOST_CHECK_EQUAL(bars.at(3).a , 45);
+
+    BOOST_CHECK_EQUAL(bars.at(0).b , "baz");
+    BOOST_CHECK_EQUAL(bars.at(1).b , "qux");
+    BOOST_CHECK_EQUAL(bars.at(2).b , "quux");
+    BOOST_CHECK_EQUAL(bars.at(3).b , "foobar");
+}

tests/test_format_error.cpp

@@ -0,0 +1,75 @@
+#define BOOST_TEST_MODULE "test_value"
+#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>
+
+// to check it successfully compiles. it does not check the formatted string.
+
+BOOST_AUTO_TEST_CASE(test_1_value)
+{
+    toml::value val(42);
+
+    {
+        const std::string pretty_error =
+            toml::format_error("[error] test error", val, "this is a value");
+        std::cout << pretty_error << std::endl;
+    }
+
+    {
+        const std::string pretty_error =
+            toml::format_error("[error] test error", val, "this is a value",
+                               {"this is a hint"});
+        std::cout << pretty_error << std::endl;
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_2_values)
+{
+    toml::value v1(42);
+    toml::value v2(3.14);
+    {
+        const std::string pretty_error =
+            toml::format_error("[error] test error with two values",
+                               v1, "this is the answer",
+                               v2, "this is the pi");
+        std::cout << pretty_error << std::endl;
+    }
+
+    {
+        const std::string pretty_error =
+            toml::format_error("[error] test error with two values",
+                               v1, "this is the answer",
+                               v2, "this is the pi",
+                               {"hint"});
+        std::cout << pretty_error << std::endl;
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_3_values)
+{
+    toml::value v1(42);
+    toml::value v2(3.14);
+    toml::value v3("foo");
+    {
+        const std::string pretty_error =
+            toml::format_error("[error] test error with two values",
+                               v1, "this is the answer",
+                               v2, "this is the pi",
+                               v3, "this is a meta-syntactic variable");
+        std::cout << pretty_error << std::endl;
+    }
+
+    {
+        const std::string pretty_error =
+            toml::format_error("[error] test error with two values",
+                               v1, "this is the answer",
+                               v2, "this is the pi",
+                               v3, "this is a meta-syntactic variable",
+                               {"hint 1", "hint 2"});
+        std::cout << pretty_error << std::endl;
+    }
+}

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_get_related_func.cpp

@@ -45,21 +45,194 @@ BOOST_AUTO_TEST_CASE(test_find)
 
 BOOST_AUTO_TEST_CASE(test_get_or)
 {
-    {
-        toml::table v{{"num", 42}};
-        BOOST_CHECK_EQUAL(42, toml::get_or<int>(v, "num", 0));
-        BOOST_CHECK_EQUAL(0,  toml::get_or<int>(v, "foo", 0));
-    }
-    {
-        toml::value v = toml::table{{"num", 42}};
-        BOOST_CHECK_EQUAL(42, toml::get_or<int>(v, "num", 0));
-        BOOST_CHECK_EQUAL(0,  toml::get_or<int>(v, "foo", 0));
-    }
+    // requires conversion int -> uint
     {
         toml::value v1(42);
         toml::value v2(3.14);
-        BOOST_CHECK_EQUAL(42, toml::get_or<int>(v1, 0));
-        BOOST_CHECK_EQUAL(0,  toml::get_or<int>(v2, 0));
+        BOOST_CHECK_EQUAL(42u, toml::get_or(v1, 0u));
+        BOOST_CHECK_EQUAL(0u,  toml::get_or(v2, 0u));
+    }
+
+    // exact toml type
+    {
+        toml::value v1(42);
+        toml::value v2(3.14);
+
+        toml::integer opt(0);
+        BOOST_CHECK_EQUAL(42, toml::get_or(v1, opt));
+        BOOST_CHECK_EQUAL(0,  toml::get_or(v2, opt));
+
+        toml::value v3("foobar");
+        toml::string s("bazqux");
+
+        BOOST_CHECK_EQUAL("foobar", toml::get_or(v3, s));
+        BOOST_CHECK_EQUAL("bazqux", toml::get_or(v1, s));
+
+    }
+
+    // std::string
+    {
+        toml::value v1("foobar");
+        toml::value v2(42);
+
+        std::string       s1("bazqux");
+        const std::string s2("bazqux");
+
+        BOOST_CHECK_EQUAL("foobar", toml::get_or(v1, s1));
+        BOOST_CHECK_EQUAL("bazqux", toml::get_or(v2, s1));
+
+        std::string& v1r = toml::get_or(v1, s1);
+        std::string& s1r = toml::get_or(v2, s1);
+
+        BOOST_CHECK_EQUAL("foobar", v1r);
+        BOOST_CHECK_EQUAL("bazqux", s1r);
+
+        BOOST_CHECK_EQUAL("foobar", toml::get_or(v1, s2));
+        BOOST_CHECK_EQUAL("bazqux", toml::get_or(v2, s2));
+
+        BOOST_CHECK_EQUAL("foobar", toml::get_or(v1, std::move(s1)));
+        BOOST_CHECK_EQUAL("bazqux", toml::get_or(v2, std::move(s1)));
+    }
+
+    // string literal
+    {
+        toml::value v1("foobar");
+        toml::value v2(42);
+
+        BOOST_CHECK_EQUAL("foobar", toml::get_or(v1, "bazqux"));
+        BOOST_CHECK_EQUAL("bazqux", toml::get_or(v2, "bazqux"));
+
+        const char* lit = "bazqux";
+        BOOST_CHECK_EQUAL("foobar", toml::get_or(v1, lit));
+        BOOST_CHECK_EQUAL("bazqux", toml::get_or(v2, lit));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_find_or)
+{
+    // ========================================================================
+    // pass toml::value
+    //
+    // requires conversion int -> uint
+    {
+        toml::table v{{"num", 42}};
+        BOOST_CHECK_EQUAL(42u, toml::find_or(v, "num", 0u));
+        BOOST_CHECK_EQUAL(0u,  toml::find_or(v, "foo", 0u));
+    }
+    // exact toml type
+    {
+        toml::table v1{{"key", 42  }};
+        toml::table v2{{"key", 3.14}};
+        toml::table v3{{"not", "key"}};
+
+        toml::integer opt(0);
+        BOOST_CHECK_EQUAL(42, toml::find_or(v1, "key", opt));
+        BOOST_CHECK_EQUAL(0,  toml::find_or(v2, "key", opt));
+        BOOST_CHECK_EQUAL(0,  toml::find_or(v3, "key", opt));
+
+        toml::table v4{{"str", "foobar"}};
+        toml::string s("bazqux");
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v4, "str", s));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v1, "str", s));
+    }
+    // std::string
+    {
+        toml::table v1{{"key", "foobar"}};
+        toml::table v2{{"key", 42}};
+
+        std::string       s1("bazqux");
+        const std::string s2("bazqux");
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", s1));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", s1));
+
+        std::string& v1r = toml::find_or(v1, "key", s1);
+        std::string& s1r = toml::find_or(v2, "key", s1);
+
+        BOOST_CHECK_EQUAL("foobar", v1r);
+        BOOST_CHECK_EQUAL("bazqux", s1r);
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", s2));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", s2));
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(std::move(v1), "key", std::move(s1)));
+        s1 = "bazqux"; // restoring moved value
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(std::move(v2), "key", std::move(s1)));
+    }
+    // string literal
+    {
+        toml::table v1{{"key", "foobar"}};
+        toml::table v2{{"key",42}};
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", "bazqux"));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", "bazqux"));
+
+        const char* lit = "bazqux";
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", lit));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", lit));
+    }
+
+    // ========================================================================
+    // pass toml::value
+    //
+    // requires conversion int -> uint
+    {
+        toml::table v = toml::table{{"num", 42}};
+        BOOST_CHECK_EQUAL(42u, toml::find_or(v, "num", 0u));
+        BOOST_CHECK_EQUAL(0u,  toml::find_or(v, "foo", 0u));
+    }
+    // exact toml type
+    {
+        toml::value v1 = toml::table{{"key", 42  }};
+        toml::value v2 = toml::table{{"key", 3.14}};
+        toml::value v3 = toml::table{{"not", "key"}};
+
+        BOOST_CHECK_EQUAL(42, toml::find_or(v1, "key", toml::integer(0)));
+        BOOST_CHECK_EQUAL( 0, toml::find_or(v2, "key", toml::integer(0)));
+        BOOST_CHECK_EQUAL( 0, toml::find_or(v3, "key", toml::integer(0)));
+
+        toml::value v4 = toml::table{{"str", "foobar"}};
+        toml::string s("bazqux");
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v4, "str", s));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v1, "str", s));
+    }
+    // std::string
+    {
+        toml::value v1 = toml::table{{"key", "foobar"}};
+        toml::value v2 = toml::table{{"key", 42}};
+
+        std::string       s1("bazqux");
+        const std::string s2("bazqux");
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", s1));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", s1));
+
+        std::string& v1r = toml::find_or(v1, "key", s1);
+        std::string& s1r = toml::find_or(v2, "key", s1);
+
+        BOOST_CHECK_EQUAL("foobar", v1r);
+        BOOST_CHECK_EQUAL("bazqux", s1r);
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", s2));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", s2));
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(std::move(v1), "key", std::move(s1)));
+        s1 = "bazqux"; // restoring moved value
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(std::move(v2), "key", std::move(s1)));
+    }
+    // string literal
+    {
+        toml::value v1 = toml::table{{"key", "foobar"}};
+        toml::value v2 = toml::table{{"key",42}};
+
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", "bazqux"));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", "bazqux"));
+
+        const char* lit = "bazqux";
+        BOOST_CHECK_EQUAL("foobar", toml::find_or(v1, "key", lit));
+        BOOST_CHECK_EQUAL("bazqux", toml::find_or(v2, "key", lit));
     }
 }
 

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_literals.cpp

@@ -0,0 +1,154 @@
+#define BOOST_TEST_MODULE "test_literals"
+#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>
+#include <map>
+
+BOOST_AUTO_TEST_CASE(test_file_as_literal)
+{
+    using namespace toml::literals::toml_literals;
+
+    {
+        const toml::value r{{"a", 42}, {"b", "baz"}};
+        const toml::value v = u8R"(
+            a = 42
+            b = "baz"
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(r, v);
+    }
+    {
+        const toml::value r{
+            {"c", 3.14},
+            {"table", toml::table{{"a", 42}, {"b", "baz"}}}
+        };
+        const toml::value v = u8R"(
+            c = 3.14
+            [table]
+            a = 42
+            b = "baz"
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(r, v);
+    }
+    {
+        const toml::value r{
+            {"table", toml::table{{"a", 42}, {"b", "baz"}}}
+        };
+        const toml::value v = u8R"(
+            [table]
+            a = 42
+            b = "baz"
+        )"_toml;
+
+        BOOST_CHECK_EQUAL(r, v);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_value_as_literal)
+{
+    using namespace toml::literals::toml_literals;
+
+    {
+        const toml::value v1 = u8"true"_toml;
+        const toml::value v2 = u8"false"_toml;
+
+        BOOST_CHECK(v1.is_boolean());
+        BOOST_CHECK(v2.is_boolean());
+        BOOST_CHECK(toml::get<bool>(v1));
+        BOOST_CHECK(!toml::get<bool>(v2));
+    }
+    {
+        const toml::value v1 = u8"123_456"_toml;
+        const toml::value v2 = u8"0b0010"_toml;
+        const toml::value v3 = u8"0xDEADBEEF"_toml;
+
+        BOOST_CHECK(v1.is_integer());
+        BOOST_CHECK(v2.is_integer());
+        BOOST_CHECK(v3.is_integer());
+        BOOST_CHECK_EQUAL(toml::get<toml::integer>(v1), 123456);
+        BOOST_CHECK_EQUAL(toml::get<toml::integer>(v2), 2);
+        BOOST_CHECK_EQUAL(toml::get<toml::integer>(v3), 0xDEADBEEF);
+    }
+    {
+        const toml::value v1 = u8"3.1415"_toml;
+        const toml::value v2 = u8"6.02e+23"_toml;
+
+        BOOST_CHECK(v1.is_float());
+        BOOST_CHECK(v2.is_float());
+        BOOST_CHECK_CLOSE(toml::get<double>(v1), 3.1415,  0.00001);
+        BOOST_CHECK_CLOSE(toml::get<double>(v2), 6.02e23, 0.0001);
+    }
+    {
+        const toml::value v1 = u8R"("foo")"_toml;
+        const toml::value v2 = u8R"('foo')"_toml;
+        const toml::value v3 = u8R"("""foo""")"_toml;
+        const toml::value v4 = u8R"('''foo''')"_toml;
+
+        BOOST_CHECK(v1.is_string());
+        BOOST_CHECK(v2.is_string());
+        BOOST_CHECK(v3.is_string());
+        BOOST_CHECK(v4.is_string());
+        BOOST_CHECK_EQUAL(toml::get<std::string>(v1), "foo");
+        BOOST_CHECK_EQUAL(toml::get<std::string>(v2), "foo");
+        BOOST_CHECK_EQUAL(toml::get<std::string>(v3), "foo");
+        BOOST_CHECK_EQUAL(toml::get<std::string>(v4), "foo");
+    }
+    {
+        const toml::value v1 = u8R"([1,2,3])"_toml;
+
+        BOOST_CHECK(v1.is_array());
+        BOOST_CHECK((toml::get<std::vector<int>>(v1) == std::vector<int>{1,2,3}));
+
+        const toml::value v2 = u8R"([1,])"_toml;
+
+        BOOST_CHECK(v2.is_array());
+        BOOST_CHECK((toml::get<std::vector<int>>(v2) == std::vector<int>{1}));
+
+        const toml::value v3 = u8R"([[1,]])"_toml;
+        BOOST_CHECK(v3.is_array());
+        BOOST_CHECK((toml::get<std::vector<int>>(toml::get<toml::array>(v3).front()) == std::vector<int>{1}));
+
+        const toml::value v4 = u8R"([[1],])"_toml;
+        BOOST_CHECK(v4.is_array());
+        BOOST_CHECK((toml::get<std::vector<int>>(toml::get<toml::array>(v4).front()) == std::vector<int>{1}));
+    }
+    {
+        const toml::value v1 = u8R"({a = 42})"_toml;
+
+        BOOST_CHECK(v1.is_table());
+        BOOST_CHECK((toml::get<std::map<std::string,int>>(v1) ==
+                               std::map<std::string,int>{{"a", 42}}));
+    }
+    {
+        const toml::value v1 = u8"1979-05-27"_toml;
+
+        BOOST_CHECK(v1.is_local_date());
+        BOOST_CHECK_EQUAL(toml::get<toml::local_date>(v1),
+                          toml::local_date(1979, toml::month_t::May, 27));
+    }
+    {
+        const toml::value v1 = u8"12:00:00"_toml;
+
+        BOOST_CHECK(v1.is_local_time());
+        BOOST_CHECK(toml::get<std::chrono::hours>(v1) == std::chrono::hours(12));
+    }
+    {
+        const toml::value v1 = u8"1979-05-27T07:32:00"_toml;
+        BOOST_CHECK(v1.is_local_datetime());
+        BOOST_CHECK_EQUAL(toml::get<toml::local_datetime>(v1),
+            toml::local_datetime(toml::local_date(1979, toml::month_t::May, 27),
+                                 toml::local_time(7, 32, 0)));
+    }
+    {
+        const toml::value v1 = "1979-05-27T07:32:00Z"_toml;
+        BOOST_CHECK(v1.is_offset_datetime());
+        BOOST_CHECK_EQUAL(toml::get<toml::offset_datetime>(v1),
+            toml::offset_datetime(toml::local_date(1979, toml::month_t::May, 27),
+                                  toml::local_time(7, 32, 0), toml::time_offset(0, 0)));
+    }
+}

tests/test_multiple_translation_unit_1.cpp

@@ -0,0 +1,11 @@
+#include <toml.hpp>
+
+int read_a(const toml::table&);
+
+int main()
+{
+    const std::string content("a = 0");
+    std::istringstream iss(content);
+    const auto data = toml::parse(iss, "test_multiple_translation_unit.toml");
+    return read_a(data);
+}

tests/test_multiple_translation_unit_2.cpp

@@ -0,0 +1,6 @@
+#include <toml.hpp>
+
+int read_a(const toml::table& t)
+{
+    return toml::get<int>(t.at("a"));
+}

tests/test_to_toml.cpp

@@ -1,189 +0,0 @@
-#define BOOST_TEST_MODULE "test_to_toml"
-#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>
-#include <map>
-#include <list>
-
-BOOST_AUTO_TEST_CASE(test_value_boolean)
-{
-    toml::value v1 = toml::to_toml(true);
-    toml::value v2 = toml::to_toml(false);
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Boolean);
-    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::Boolean);
-    BOOST_CHECK(v1.is(toml::value_t::Boolean));
-    BOOST_CHECK(v2.is(toml::value_t::Boolean));
-    BOOST_CHECK(v1.is<toml::Boolean>());
-    BOOST_CHECK(v2.is<toml::Boolean>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Boolean>(), true);
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Boolean>(), false);
-}
-
-BOOST_AUTO_TEST_CASE(test_value_integer)
-{
-    toml::value v1 = toml::to_toml(-42);
-    toml::value v2 = toml::to_toml(42u);
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Integer);
-    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::Integer);
-    BOOST_CHECK(v1.is(toml::value_t::Integer));
-    BOOST_CHECK(v2.is(toml::value_t::Integer));
-    BOOST_CHECK(v1.is<toml::Integer>());
-    BOOST_CHECK(v2.is<toml::Integer>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Integer>(), -42);
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Integer>(),  42u);
-}
-
-BOOST_AUTO_TEST_CASE(test_value_float)
-{
-    toml::value v1 = toml::to_toml(3.14);
-    toml::value v2 = toml::to_toml(3.14f);
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Float);
-    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::Float);
-    BOOST_CHECK(v1.is(toml::value_t::Float));
-    BOOST_CHECK(v2.is(toml::value_t::Float));
-    BOOST_CHECK(v1.is<toml::Float>());
-    BOOST_CHECK(v2.is<toml::Float>());
-
-    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_AUTO_TEST_CASE(test_value_string)
-{
-    toml::value v1 = toml::to_toml(std::string("foo"));
-    toml::value v2 = toml::to_toml(std::string("foo"), toml::string_t::literal);
-    toml::value v3 = toml::to_toml("foo");
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::String);
-    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::String);
-    BOOST_CHECK_EQUAL(v3.type(), toml::value_t::String);
-    BOOST_CHECK(v1.is(toml::value_t::String));
-    BOOST_CHECK(v2.is(toml::value_t::String));
-    BOOST_CHECK(v3.is(toml::value_t::String));
-    BOOST_CHECK(v1.is<toml::String>());
-    BOOST_CHECK(v2.is<toml::String>());
-    BOOST_CHECK(v3.is<toml::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_AUTO_TEST_CASE(test_value_local_date)
-{
-    toml::value v1 = toml::to_toml(toml::local_date(2018, toml::month_t::Jan, 31));
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalDate);
-    BOOST_CHECK(v1.is(toml::value_t::LocalDate));
-    BOOST_CHECK(v1.is<toml::LocalDate>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDate>(),
-                      toml::local_date(2018, toml::month_t::Jan, 31));
-}
-
-BOOST_AUTO_TEST_CASE(test_value_local_time)
-{
-    toml::value v1 = toml::to_toml(toml::local_time(12, 30, 45));
-    toml::value v2 = toml::to_toml(std::chrono::hours(12) + std::chrono::minutes(30) +
-                   std::chrono::seconds(45));
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalTime);
-    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::LocalTime);
-    BOOST_CHECK(v1.is(toml::value_t::LocalTime));
-    BOOST_CHECK(v2.is(toml::value_t::LocalTime));
-    BOOST_CHECK(v1.is<toml::LocalTime>());
-    BOOST_CHECK(v2.is<toml::LocalTime>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalTime>(),
-                      toml::local_time(12, 30, 45));
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::LocalTime>(),
-                      toml::local_time(12, 30, 45));
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalTime>(),
-                      v2.cast<toml::value_t::LocalTime>());
-}
-
-BOOST_AUTO_TEST_CASE(test_value_local_datetime)
-{
-    toml::value v1 = toml::to_toml(toml::local_datetime(
-                toml::local_date(2018, toml::month_t::Jan, 31),
-                toml::local_time(12, 30, 45)
-                ));
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalDatetime);
-    BOOST_CHECK(v1.is(toml::value_t::LocalDatetime));
-    BOOST_CHECK(v1.is<toml::LocalDatetime>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDatetime>(),
-                      toml::local_datetime(
-                          toml::local_date(2018, toml::month_t::Jan, 31),
-                          toml::local_time(12, 30, 45)));
-}
-
-BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
-{
-    toml::value v1 = toml::to_toml(toml::offset_datetime(
-                toml::local_date(2018, toml::month_t::Jan, 31),
-                toml::local_time(12, 30, 45),
-                toml::time_offset(9, 0)
-                ));
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::OffsetDatetime);
-    BOOST_CHECK(v1.is(toml::value_t::OffsetDatetime));
-    BOOST_CHECK(v1.is<toml::OffsetDatetime>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::OffsetDatetime>(),
-            toml::offset_datetime(
-                toml::local_date(2018, toml::month_t::Jan, 31),
-                toml::local_time(12, 30, 45),
-                toml::time_offset(9, 0)
-                ));
-}
-
-BOOST_AUTO_TEST_CASE(test_value_array)
-{
-    std::vector<int> v{1,2,3,4,5};
-    toml::value v1 = toml::to_toml(v);
-    toml::value v2 = toml::to_toml(6,7,8,9,0);
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Array);
-    BOOST_CHECK(v1.is(toml::value_t::Array));
-    BOOST_CHECK(v1.is<toml::Array>());
-
-    BOOST_CHECK_EQUAL(v2.type(), toml::value_t::Array);
-    BOOST_CHECK(v2.is(toml::value_t::Array));
-    BOOST_CHECK(v2.is<toml::Array>());
-
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(0).cast<toml::value_t::Integer>(), 1);
-    BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(1).cast<toml::value_t::Integer>(), 2);
-    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(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);
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(2).cast<toml::value_t::Integer>(), 8);
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(3).cast<toml::value_t::Integer>(), 9);
-    BOOST_CHECK_EQUAL(v2.cast<toml::value_t::Array>().at(4).cast<toml::value_t::Integer>(), 0);
-}
-
-BOOST_AUTO_TEST_CASE(test_value_table)
-{
-    toml::value v1 = toml::to_toml({{"foo", 42}, {"bar", 3.14}, {"baz", "qux"}});
-
-    BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Table);
-    BOOST_CHECK(v1.is(toml::value_t::Table));
-    BOOST_CHECK(v1.is<toml::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");
-}

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);
@@ -20,9 +25,13 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
     BOOST_CHECK(v2.is(toml::value_t::Boolean));
     BOOST_CHECK(v1.is<toml::Boolean>());
     BOOST_CHECK(v2.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
+    BOOST_CHECK(v2.is_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;
@@ -33,9 +42,13 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
     BOOST_CHECK(v2.is(toml::value_t::Boolean));
     BOOST_CHECK(v1.is<toml::Boolean>());
     BOOST_CHECK(v2.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
+    BOOST_CHECK(v2.is_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);
@@ -48,9 +61,13 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
     BOOST_CHECK(v4.is(toml::value_t::Boolean));
     BOOST_CHECK(v3.is<toml::Boolean>());
     BOOST_CHECK(v4.is<toml::Boolean>());
+    BOOST_CHECK(v3.is_boolean());
+    BOOST_CHECK(v4.is_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));
@@ -61,9 +78,13 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
     BOOST_CHECK(v6.is(toml::value_t::Boolean));
     BOOST_CHECK(v5.is<toml::Boolean>());
     BOOST_CHECK(v6.is<toml::Boolean>());
+    BOOST_CHECK(v3.is_boolean());
+    BOOST_CHECK(v4.is_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;
@@ -74,9 +95,13 @@ BOOST_AUTO_TEST_CASE(test_value_boolean)
     BOOST_CHECK(v2.is(toml::value_t::Float));
     BOOST_CHECK(v1.is<toml::Integer>());
     BOOST_CHECK(v2.is<toml::Float>());
+    BOOST_CHECK(v1.is_integer());
+    BOOST_CHECK(v2.is_float());
 
     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)
@@ -90,9 +115,13 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
     BOOST_CHECK(v2.is(toml::value_t::Integer));
     BOOST_CHECK(v1.is<toml::Integer>());
     BOOST_CHECK(v2.is<toml::Integer>());
+    BOOST_CHECK(v1.is_integer());
+    BOOST_CHECK(v2.is_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;
@@ -103,9 +132,13 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
     BOOST_CHECK(v2.is(toml::value_t::Integer));
     BOOST_CHECK(v1.is<toml::Integer>());
     BOOST_CHECK(v2.is<toml::Integer>());
+    BOOST_CHECK(v1.is_integer());
+    BOOST_CHECK(v2.is_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);
@@ -118,9 +151,13 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
     BOOST_CHECK(v4.is(toml::value_t::Integer));
     BOOST_CHECK(v3.is<toml::Integer>());
     BOOST_CHECK(v4.is<toml::Integer>());
+    BOOST_CHECK(v3.is_integer());
+    BOOST_CHECK(v4.is_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));
@@ -131,9 +168,13 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
     BOOST_CHECK(v6.is(toml::value_t::Integer));
     BOOST_CHECK(v5.is<toml::Integer>());
     BOOST_CHECK(v6.is<toml::Integer>());
+    BOOST_CHECK(v5.is_integer());
+    BOOST_CHECK(v6.is_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;
@@ -144,9 +185,13 @@ BOOST_AUTO_TEST_CASE(test_value_integer)
     BOOST_CHECK(v2.is(toml::value_t::Boolean));
     BOOST_CHECK(v1.is<toml::Boolean>());
     BOOST_CHECK(v2.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
+    BOOST_CHECK(v2.is_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);
 }
 
 BOOST_AUTO_TEST_CASE(test_value_float)
@@ -160,9 +205,13 @@ BOOST_AUTO_TEST_CASE(test_value_float)
     BOOST_CHECK(v2.is(toml::value_t::Float));
     BOOST_CHECK(v1.is<toml::Float>());
     BOOST_CHECK(v2.is<toml::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;
@@ -173,9 +222,13 @@ BOOST_AUTO_TEST_CASE(test_value_float)
     BOOST_CHECK(v2.is(toml::value_t::Float));
     BOOST_CHECK(v1.is<toml::Float>());
     BOOST_CHECK(v2.is<toml::Float>());
+    BOOST_CHECK(v1.is_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);
@@ -188,9 +241,13 @@ BOOST_AUTO_TEST_CASE(test_value_float)
     BOOST_CHECK(v4.is(toml::value_t::Float));
     BOOST_CHECK(v3.is<toml::Float>());
     BOOST_CHECK(v4.is<toml::Float>());
+    BOOST_CHECK(v3.is_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));
@@ -201,9 +258,13 @@ BOOST_AUTO_TEST_CASE(test_value_float)
     BOOST_CHECK(v6.is(toml::value_t::Float));
     BOOST_CHECK(v5.is<toml::Float>());
     BOOST_CHECK(v6.is<toml::Float>());
+    BOOST_CHECK(v5.is_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;
@@ -214,9 +275,13 @@ BOOST_AUTO_TEST_CASE(test_value_float)
     BOOST_CHECK(v2.is(toml::value_t::Boolean));
     BOOST_CHECK(v1.is<toml::Boolean>());
     BOOST_CHECK(v2.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
+    BOOST_CHECK(v2.is_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);
 }
 
 BOOST_AUTO_TEST_CASE(test_value_string)
@@ -234,10 +299,17 @@ BOOST_AUTO_TEST_CASE(test_value_string)
     BOOST_CHECK(v1.is<toml::String>());
     BOOST_CHECK(v2.is<toml::String>());
     BOOST_CHECK(v3.is<toml::String>());
+    BOOST_CHECK(v1.is_string());
+    BOOST_CHECK(v2.is_string());
+    BOOST_CHECK(v3.is_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";
@@ -249,13 +321,17 @@ BOOST_AUTO_TEST_CASE(test_value_string)
     BOOST_CHECK(v1.is(toml::value_t::String));
     BOOST_CHECK(v2.is(toml::value_t::String));
     BOOST_CHECK(v3.is(toml::value_t::String));
-    BOOST_CHECK(v1.is<toml::String>());
-    BOOST_CHECK(v2.is<toml::String>());
-    BOOST_CHECK(v3.is<toml::String>());
+    BOOST_CHECK(v1.is_string());
+    BOOST_CHECK(v2.is_string());
+    BOOST_CHECK(v3.is_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);
@@ -273,10 +349,17 @@ BOOST_AUTO_TEST_CASE(test_value_string)
     BOOST_CHECK(v4.is<toml::String>());
     BOOST_CHECK(v5.is<toml::String>());
     BOOST_CHECK(v6.is<toml::String>());
+    BOOST_CHECK(v4.is_string());
+    BOOST_CHECK(v5.is_string());
+    BOOST_CHECK(v6.is_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';
@@ -291,10 +374,13 @@ BOOST_AUTO_TEST_CASE(test_value_string)
     BOOST_CHECK(v4.is<toml::String>());
     BOOST_CHECK(v5.is<toml::String>());
     BOOST_CHECK(v6.is<toml::String>());
+    BOOST_CHECK(v4.is_string());
+    BOOST_CHECK(v5.is_string());
+    BOOST_CHECK(v6.is_string());
 
-    BOOST_CHECK_EQUAL(v4.cast<toml::value_t::String>(), "baz");
-    BOOST_CHECK_EQUAL(v5.cast<toml::value_t::String>(), "baz");
-    BOOST_CHECK_EQUAL(v6.cast<toml::value_t::String>(), "baz");
+    BOOST_CHECK_EQUAL(v4.as_string(), "baz");
+    BOOST_CHECK_EQUAL(v5.as_string(), "baz");
+    BOOST_CHECK_EQUAL(v6.as_string(), "baz");
 
     v1 = true;
     v2 = true;
@@ -309,10 +395,35 @@ BOOST_AUTO_TEST_CASE(test_value_string)
     BOOST_CHECK(v1.is<toml::Boolean>());
     BOOST_CHECK(v2.is<toml::Boolean>());
     BOOST_CHECK(v3.is<toml::Boolean>());
+    BOOST_CHECK(v1.is_boolean());
+    BOOST_CHECK(v2.is_boolean());
+    BOOST_CHECK(v3.is_boolean());
 
     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)
@@ -322,18 +433,24 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalDate);
     BOOST_CHECK(v1.is(toml::value_t::LocalDate));
     BOOST_CHECK(v1.is<toml::LocalDate>());
+    BOOST_CHECK(v1.is_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);
 
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalDate);
     BOOST_CHECK(v1.is(toml::value_t::LocalDate));
     BOOST_CHECK(v1.is<toml::LocalDate>());
+    BOOST_CHECK(v1.is_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);
@@ -341,15 +458,20 @@ BOOST_AUTO_TEST_CASE(test_value_local_date)
     BOOST_CHECK_EQUAL(v2.type(), toml::value_t::LocalDate);
     BOOST_CHECK(v2.is(toml::value_t::LocalDate));
     BOOST_CHECK(v2.is<toml::LocalDate>());
+    BOOST_CHECK(v2.is_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);
     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_local_time)
@@ -364,21 +486,34 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)
     BOOST_CHECK(v2.is(toml::value_t::LocalTime));
     BOOST_CHECK(v1.is<toml::LocalTime>());
     BOOST_CHECK(v2.is<toml::LocalTime>());
+    BOOST_CHECK(v1.is_local_time());
+    BOOST_CHECK(v2.is_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);
 
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalTime);
     BOOST_CHECK(v1.is(toml::value_t::LocalTime));
     BOOST_CHECK(v1.is<toml::LocalTime>());
+    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);
@@ -386,15 +521,20 @@ BOOST_AUTO_TEST_CASE(test_value_local_time)
     BOOST_CHECK_EQUAL(v3.type(), toml::value_t::LocalTime);
     BOOST_CHECK(v3.is(toml::value_t::LocalTime));
     BOOST_CHECK(v3.is<toml::LocalTime>());
+    BOOST_CHECK(v3.is_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);
     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_local_datetime)
@@ -407,11 +547,16 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalDatetime);
     BOOST_CHECK(v1.is(toml::value_t::LocalDatetime));
     BOOST_CHECK(v1.is<toml::LocalDatetime>());
+    BOOST_CHECK(v1.is_local_datetime());
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDatetime>(),
                       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),
@@ -420,11 +565,16 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::LocalDatetime);
     BOOST_CHECK(v1.is(toml::value_t::LocalDatetime));
     BOOST_CHECK(v1.is<toml::LocalDatetime>());
+    BOOST_CHECK(v1.is_local_datetime());
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::LocalDatetime>(),
                       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);
@@ -432,17 +582,25 @@ BOOST_AUTO_TEST_CASE(test_value_local_datetime)
     BOOST_CHECK_EQUAL(v2.type(), toml::value_t::LocalDatetime);
     BOOST_CHECK(v2.is(toml::value_t::LocalDatetime));
     BOOST_CHECK(v2.is<toml::LocalDatetime>());
+    BOOST_CHECK(v2.is_local_datetime());
 
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::LocalDatetime>(),
                       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);
     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_offset_datetime)
@@ -456,6 +614,7 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::OffsetDatetime);
     BOOST_CHECK(v1.is(toml::value_t::OffsetDatetime));
     BOOST_CHECK(v1.is<toml::OffsetDatetime>());
+    BOOST_CHECK(v1.is_offset_datetime());
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::OffsetDatetime>(),
             toml::offset_datetime(
@@ -463,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),
@@ -472,12 +637,19 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::OffsetDatetime);
     BOOST_CHECK(v1.is(toml::value_t::OffsetDatetime));
     BOOST_CHECK(v1.is<toml::OffsetDatetime>());
+    BOOST_CHECK(v1.is_offset_datetime());
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::OffsetDatetime>(),
             toml::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);
@@ -485,17 +657,26 @@ BOOST_AUTO_TEST_CASE(test_value_offset_datetime)
     BOOST_CHECK_EQUAL(v2.type(), toml::value_t::OffsetDatetime);
     BOOST_CHECK(v2.is(toml::value_t::OffsetDatetime));
     BOOST_CHECK(v2.is<toml::OffsetDatetime>());
+    BOOST_CHECK(v2.is_offset_datetime());
 
     BOOST_CHECK_EQUAL(v2.cast<toml::value_t::OffsetDatetime>(),
             toml::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)
@@ -507,16 +688,24 @@ BOOST_AUTO_TEST_CASE(test_value_array)
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Array);
     BOOST_CHECK(v1.is(toml::value_t::Array));
     BOOST_CHECK(v1.is<toml::Array>());
+    BOOST_CHECK(v1.is_array());
 
     BOOST_CHECK_EQUAL(v2.type(), toml::value_t::Array);
     BOOST_CHECK(v2.is(toml::value_t::Array));
     BOOST_CHECK(v2.is<toml::Array>());
+    BOOST_CHECK(v2.is_array());
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(0).cast<toml::value_t::Integer>(), 1);
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(1).cast<toml::value_t::Integer>(), 2);
     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);
@@ -530,22 +719,36 @@ BOOST_AUTO_TEST_CASE(test_value_array)
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Array);
     BOOST_CHECK(v1.is(toml::value_t::Array));
     BOOST_CHECK(v1.is<toml::Array>());
+    BOOST_CHECK(v1.is_array());
 
     BOOST_CHECK_EQUAL(v2.type(), toml::value_t::Array);
     BOOST_CHECK(v2.is(toml::value_t::Array));
     BOOST_CHECK(v2.is<toml::Array>());
+    BOOST_CHECK(v2.is_array());
 
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(0).cast<toml::value_t::Integer>(), 6);
     BOOST_CHECK_EQUAL(v1.cast<toml::value_t::Array>().at(1).cast<toml::value_t::Integer>(), 7);
     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);
@@ -553,18 +756,27 @@ BOOST_AUTO_TEST_CASE(test_value_array)
     BOOST_CHECK_EQUAL(v3.type(), toml::value_t::Array);
     BOOST_CHECK(v3.is(toml::value_t::Array));
     BOOST_CHECK(v3.is<toml::Array>());
+    BOOST_CHECK(v3.is_array());
 
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Array>().at(0).cast<toml::value_t::Integer>(), 6);
     BOOST_CHECK_EQUAL(v3.cast<toml::value_t::Array>().at(1).cast<toml::value_t::Integer>(), 7);
     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);
     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_table)
@@ -574,20 +786,30 @@ BOOST_AUTO_TEST_CASE(test_value_table)
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Table);
     BOOST_CHECK(v1.is(toml::value_t::Table));
     BOOST_CHECK(v1.is<toml::Table>());
+    BOOST_CHECK(v1.is_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"}};
 
     BOOST_CHECK_EQUAL(v1.type(), toml::value_t::Table);
     BOOST_CHECK(v1.is(toml::value_t::Table));
     BOOST_CHECK(v1.is<toml::Table>());
+    BOOST_CHECK(v1.is_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);
@@ -595,14 +817,28 @@ BOOST_AUTO_TEST_CASE(test_value_table)
     BOOST_CHECK_EQUAL(v3.type(), toml::value_t::Table);
     BOOST_CHECK(v3.is(toml::value_t::Table));
     BOOST_CHECK(v3.is<toml::Table>());
+    BOOST_CHECK(v3.is_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);
     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_empty)
+{
+    toml::value v1;
+    BOOST_CHECK(v1.is_uninitialized());
+    BOOST_CHECK(v1.is(toml::value_t::Empty));
 }

toml.hpp

@@ -34,8 +34,8 @@
 #endif
 
 #include "toml/parser.hpp"
+#include "toml/literal.hpp"
 #include "toml/serializer.hpp"
-#include "toml/to_toml.hpp"
 #include "toml/from_toml.hpp"
 #include "toml/get.hpp"
 

toml/combinator.hpp

@@ -9,7 +9,10 @@
 #include <type_traits>
 #include <iterator>
 #include <limits>
+#include <array>
 #include <iomanip>
+#include <cstdio>
+#include <cassert>
 #include <cctype>
 
 // they scans characters and returns region if it matches to the condition.
@@ -38,10 +41,12 @@ inline std::string show_char(const char c)
     }
     else
     {
-        std::ostringstream oss;
-        oss << "0x" << std::hex << std::setfill('0') << std::setw(2)
-            << static_cast<int>(c);
-        return oss.str();
+        std::array<char, 5> buf;
+        buf.fill('\0');
+        const auto r = std::snprintf(
+                buf.data(), buf.size(), "0x%02x", static_cast<int>(c) & 0xFF);
+        assert(r == buf.size() - 1);
+        return std::string(buf.data());
     }
 }
 
@@ -51,26 +56,24 @@ struct character
     static constexpr char target = C;
 
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, none_t>
+    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)
         {
-            return err(concat_to_string("expected '", show_char(target),
-                                        "' but got '", show_char(c), "'."));
+            return none();
         }
-        ++(loc.iter()); // update location
+        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;
@@ -86,30 +89,24 @@ struct in_range
     static constexpr char lower = Low;
 
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, none_t>
+    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)
         {
-            return err(concat_to_string("expected character in range "
-                "[", show_char(lower), ", ", show_char(upper), "] but got ",
-                "'", show_char(c), "'."));
+            return none();
         }
 
-        ++(loc.iter());
+        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;
@@ -120,30 +117,24 @@ template<typename Combinator>
 struct exclude
 {
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, none_t>
+    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);
         if(rslt.is_ok())
         {
-            loc.iter() = first; // rollback
-            return err(concat_to_string(
-                "invalid pattern (", Combinator::pattern(), ") appeared ",
-                rslt.unwrap().str()));
+            loc.reset(first);
+            return none();
         }
-        loc.iter() = std::next(first);
+        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.
@@ -151,7 +142,8 @@ template<typename Combinator>
 struct maybe
 {
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
@@ -163,11 +155,6 @@ struct maybe
         }
         return ok(region<Cont>(loc));
     }
-
-    static std::string pattern()
-    {
-        return concat_to_string('(', Combinator::pattern(), ")?");
-    }
 };
 
 template<typename ... Ts>
@@ -177,7 +164,8 @@ template<typename Head, typename ... Tail>
 struct sequence<Head, Tail...>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
@@ -186,31 +174,26 @@ struct sequence<Head, Tail...>
         const auto rslt = Head::invoke(loc);
         if(rslt.is_err())
         {
-            loc.iter() = first;
-            return err(rslt.unwrap_err());
+            loc.reset(first);
+            return none();
         }
         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)
     {
         const auto rslt = Head::invoke(loc);
         if(rslt.is_err())
         {
-            loc.iter() = first;
-            return err(rslt.unwrap_err());
+            loc.reset(first);
+            return none();
         }
         reg += rslt.unwrap(); // concat regions
         return sequence<Tail...>::invoke(loc, std::move(reg), first);
     }
-
-    static std::string pattern()
-    {
-        return concat_to_string(Head::pattern(), sequence<Tail...>::pattern());
-    }
 };
 
 template<typename Head>
@@ -218,19 +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)
     {
         const auto rslt = Head::invoke(loc);
         if(rslt.is_err())
         {
-            loc.iter() = first;
-            return err(rslt.unwrap_err());
+            loc.reset(first);
+            return none();
         }
         reg += rslt.unwrap(); // concat regions
         return ok(reg);
     }
-    static std::string pattern() {return Head::pattern();}
 };
 
 template<typename ... Ts>
@@ -240,7 +222,8 @@ template<typename Head, typename ... Tail>
 struct either<Head, Tail...>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
     {
         static_assert(std::is_same<char, typename Cont::value_type>::value,
                       "internal error: container::value_type should be `char`.");
@@ -249,26 +232,18 @@ struct either<Head, Tail...>
         if(rslt.is_ok()) {return rslt;}
         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> invoke(location<Cont>& loc)
+    static result<region<Cont>, none_t>
+    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);
     }
-    static std::string pattern()
-    {
-        return concat_to_string('(', Head::pattern(), ')');
-    }
 };
 
 template<typename T, typename N>
@@ -282,7 +257,8 @@ template<typename T, std::size_t N>
 struct repeat<T, exactly<N>>
 {
     template<typename Cont>
-    static result<region<Cont>, std::string> invoke(location<Cont>& loc)
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
     {
         region<Cont> retval(loc);
         const auto first = loc.iter();
@@ -291,24 +267,21 @@ struct repeat<T, exactly<N>>
             auto rslt = T::invoke(loc);
             if(rslt.is_err())
             {
-                loc.iter() = first;
-                return err(rslt.unwrap_err());
+                loc.reset(first);
+                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> invoke(location<Cont>& loc)
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
     {
         region<Cont> retval(loc);
 
@@ -318,8 +291,8 @@ struct repeat<T, at_least<N>>
             auto rslt = T::invoke(loc);
             if(rslt.is_err())
             {
-                loc.iter() = first;
-                return err(rslt.unwrap_err());
+                loc.reset(first);
+                return none();
             }
             retval += rslt.unwrap();
         }
@@ -333,17 +306,14 @@ 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> invoke(location<Cont>& loc)
+    static result<region<Cont>, none_t>
+    invoke(location<Cont>& loc)
     {
         region<Cont> retval(loc);
         while(true)
@@ -356,7 +326,6 @@ struct repeat<T, unlimited>
             retval += rslt.unwrap();
         }
     }
-    static std::string pattern() {return concat_to_string('(', T::pattern(), ")*");}
 };
 
 } // detail

toml/datetime.hpp

@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_DATETIME
-#define TOML11_DATETIME
+#ifndef TOML11_DATETIME_HPP
+#define TOML11_DATETIME_HPP
 #include <chrono>
 #include <tuple>
 #include <array>
@@ -25,20 +25,22 @@ inline std::tm localtime_s(const std::time_t* src)
 {
     std::tm dst;
     const auto result = ::localtime_r(src, &dst);
-    if(!result)
-    {
-        throw std::runtime_error("localtime_r failed.");
-    }
+    if (!result) { throw std::runtime_error("localtime_r failed."); }
+    return dst;
+}
+#elif _MSC_VER
+inline std::tm localtime_s(const std::time_t* src)
+{
+    std::tm dst;
+    const auto result = ::localtime_s(&dst, src);
+    if (result) { throw std::runtime_error("localtime_s failed."); }
     return dst;
 }
 #else
-// XXX: On Windows, std::localtime is thread-safe because they uses thread-local
-// storage to store the instance of std::tm. On the other platforms, it may not
-// be thread-safe.
 inline std::tm localtime_s(const std::time_t* src)
 {
     const auto result = std::localtime(src);
-    if(!result) {throw std::runtime_error("localtime failed.");}
+    if (!result) { throw std::runtime_error("localtime failed."); }
     return *result;
 }
 #endif
@@ -332,17 +334,10 @@ operator<<(std::basic_ostream<charT, traits>& os, const time_offset& offset)
         os << 'Z';
         return os;
     }
-    if(static_cast<int>(offset.hour) * static_cast<int>(offset.minute) < 0)
-    {
-        const int min = static_cast<int>(offset.hour) * 60 + offset.minute;
-        if(min < 0){os << '-';} else {os << '+';}
-        os << std::setfill('0') << std::setw(2) << min / 60 << ':';
-        os << std::setfill('0') << std::setw(2) << min % 60;
-        return os;
-    }
-    if(offset.hour < 0){os << '-';} else {os << '+';}
-    os << std::setfill('0') << std::setw(2) << static_cast<int>(offset.hour) << ':';
-    os << std::setfill('0') << std::setw(2) << static_cast<int>(offset.minute);
+    int minute = static_cast<int>(offset.hour) * 60 + offset.minute;
+    if(minute < 0){os << '-'; minute = std::abs(minute);} else {os << '+';}
+    os << std::setfill('0') << std::setw(2) << minute / 60 << ':';
+    os << std::setfill('0') << std::setw(2) << minute % 60;
     return os;
 }
 
@@ -358,21 +353,21 @@ 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->time = local_time(time);
+        this->date = local_date(ltime);
+        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));
-        this->time.millisecond = std::chrono::duration_cast<
-            std::chrono::milliseconds>(t_diff).count();
-        this->time.microsecond = std::chrono::duration_cast<
-            std::chrono::microseconds>(t_diff).count();
-        this->time.nanosecond = std::chrono::duration_cast<
-            std::chrono::nanoseconds >(t_diff).count();
+            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>(
+          std::chrono::duration_cast<std::chrono::microseconds>(t_diff).count());
+        this->time.nanosecond = static_cast<std::uint16_t>(
+          std::chrono::duration_cast<std::chrono::nanoseconds >(t_diff).count());
     }
 
     explicit local_datetime(const std::time_t t)

toml/exception.hpp

@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_EXCEPTION
-#define TOML11_EXCEPTION
+#ifndef TOML11_EXCEPTION_HPP
+#define TOML11_EXCEPTION_HPP
 #include <stdexcept>
 #include <string>
 

toml/from.hpp

@@ -0,0 +1,20 @@
+//     Copyright Toru Niina 2019.
+// Distributed under the MIT License.
+#ifndef TOML11_FROM_HPP
+#define TOML11_FROM_HPP
+#include "traits.hpp"
+
+namespace toml
+{
+
+template<typename T>
+struct from;
+// {
+//     static T from_toml(const toml::value& v)
+//     {
+//         // User-defined conversions ...
+//     }
+// };
+
+} // toml
+#endif // TOML11_FROM_HPP

toml/from_toml.hpp

@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_FROM_TOML
-#define TOML11_FROM_TOML
+#ifndef TOML11_FROM_TOML_HPP
+#define TOML11_FROM_TOML_HPP
 #include "get.hpp"
 
 namespace toml
@@ -51,7 +51,7 @@ struct from_toml_tie_impl
 template<typename ... Ts>
 struct from_toml_tie_impl<0, Ts...>
 {
-    static void invoke(std::tuple<Ts& ...> tie, const toml::value& v)
+    static void invoke(std::tuple<Ts& ...>, const toml::value&)
     {
         return;
     }

toml/get.hpp

@@ -1,7 +1,8 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_GET
-#define TOML11_GET
+#ifndef TOML11_GET_HPP
+#define TOML11_GET_HPP
+#include "from.hpp"
 #include "result.hpp"
 #include "value.hpp"
 #include <algorithm>
@@ -107,12 +108,24 @@ 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.
 
 template<typename T, typename std::enable_if<
     detail::is_chrono_duration<T>::value, std::nullptr_t>::type = nullptr>
-inline T get(value& v)
+inline T get(const value& v)
 {
     return std::chrono::duration_cast<T>(
             std::chrono::nanoseconds(v.cast<value_t::LocalTime>()));
@@ -124,7 +137,7 @@ inline T get(value& v)
 template<typename T, typename std::enable_if<
     std::is_same<std::chrono::system_clock::time_point, T>::value,
     std::nullptr_t>::type = nullptr>
-inline T get(value& v)
+inline T get(const value& v)
 {
     switch(v.type())
     {
@@ -173,6 +186,20 @@ template<typename T, typename std::enable_if<detail::conjunction<
     >::value, std::nullptr_t>::type = nullptr>
 T get(const toml::value& v);
 
+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>>, // not a toml::value
+    detail::has_from_toml_method<T>, // but has from_toml(toml::value) memfn
+    std::is_default_constructible<T> // and default constructible
+    >::value, std::nullptr_t>::type = nullptr>
+T get(const toml::value& v);
+
+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>> // not a toml::value
+    >::value, std::nullptr_t>::type = nullptr,
+    std::size_t = sizeof(::toml::from<T>) // and has from<T> specialization
+    >
+T get(const toml::value& v);
+
 // ============================================================================
 // array-like types; most likely STL container, like std::vector, etc.
 
@@ -210,8 +237,9 @@ T get(const value& v)
     {
         throw std::out_of_range(detail::format_underline(concat_to_string(
             "[erorr] toml::get specified container size is ", container.size(),
-            " but there are ", ar.size(), " elements in toml array."),
-            detail::get_region(v), "here"));
+            " but there are ", ar.size(), " elements in toml array."), {
+                {std::addressof(detail::get_region(v)), "here"}
+            }));
     }
     std::transform(ar.cbegin(), ar.cend(), container.begin(),
                    [](const value& x){return ::toml::get<value_type>(x);});
@@ -233,7 +261,9 @@ T get(const value& v)
     {
         throw std::out_of_range(detail::format_underline(concat_to_string(
             "[erorr] toml::get specified std::pair but there are ", ar.size(),
-            " elements in toml array."), detail::get_region(v), "here"));
+            " elements in toml array."), {
+                {std::addressof(detail::get_region(v)), "here"}
+            }));
     }
     return std::make_pair(::toml::get<first_type >(ar.at(0)),
                           ::toml::get<second_type>(ar.at(1)));
@@ -246,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))...);
@@ -264,7 +294,9 @@ T get(const value& v)
         throw std::out_of_range(detail::format_underline(concat_to_string(
             "[erorr] toml::get specified std::tuple with ",
             std::tuple_size<T>::value, "elements, but there are ", ar.size(),
-            " elements in toml array."), detail::get_region(v), "here"));
+            " elements in toml array."), {
+                {std::addressof(detail::get_region(v)), "here"}
+            }));
     }
     return detail::get_tuple_impl<T>(ar,
             detail::make_index_sequence<std::tuple_size<T>::value>{});
@@ -292,6 +324,29 @@ T get(const toml::value& v)
     return map;
 }
 
+
+// ============================================================================
+// user-defined, but compatible types.
+
+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>>, // not a toml::value
+    detail::has_from_toml_method<T>, // but has from_toml(toml::value) memfn
+    std::is_default_constructible<T> // and default constructible
+    >::value, std::nullptr_t>::type>
+T get(const toml::value& v)
+{
+    T ud;
+    ud.from_toml(v);
+    return ud;
+}
+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>> // not a toml::value
+    >::value, std::nullptr_t>::type, std::size_t>   // and has from<T>
+T get(const toml::value& v)
+{
+    return ::toml::from<T>::from_toml(v);
+}
+
 // ============================================================================
 // find and get
 
@@ -340,8 +395,9 @@ find(const toml::value& v, const toml::key& ky)
     if(tab.count(ky) == 0)
     {
         throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), detail::get_region(v),
-            "in this table"));
+            "[error] key \"", ky, "\" not found"), {
+                {std::addressof(detail::get_region(v)), "in this table"}
+            }));
     }
     return ::toml::get<T>(tab.at(ky));
 }
@@ -353,8 +409,9 @@ find(toml::value& v, const toml::key& ky)
     if(tab.count(ky) == 0)
     {
         throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), detail::get_region(v),
-            "in this table"));
+            "[error] key \"", ky, "\" not found"), {
+                {std::addressof(detail::get_region(v)), "in this table"}
+            }));
     }
     return ::toml::get<T>(tab.at(ky));
 }
@@ -366,21 +423,23 @@ find(toml::value&& v, const toml::key& ky)
     if(tab.count(ky) == 0)
     {
         throw std::out_of_range(detail::format_underline(concat_to_string(
-            "[error] key \"", ky, "\" not found"), detail::get_region(v),
-            "in this table"));
+            "[error] key \"", ky, "\" not found"), {
+                {std::addressof(detail::get_region(v)), "in this table"}
+            }));
     }
     return ::toml::get<T>(std::move(tab[ky]));
 }
 
 
 // ============================================================================
-// get_or
+// get_or(value, fallback)
 
-template<typename T>
-decltype(::toml::get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(
-        std::declval<const toml::value&>()))
-get_or(const toml::value& v, T&& opt)
+// ----------------------------------------------------------------------------
+// specialization for the exact toml types (return type becomes lvalue ref)
+
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T const& get_or(const toml::value& v, const T& opt)
 {
     try
     {
@@ -389,14 +448,12 @@ get_or(const toml::value& v, T&& opt)
     }
     catch(...)
     {
-        return std::forward<T>(opt);
+        return opt;
     }
 }
-template<typename T>
-decltype(::toml::get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(
-        std::declval<toml::value&>()))
-get_or(toml::value& v, T&& opt)
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T& get_or(toml::value& v, T& opt)
 {
     try
     {
@@ -405,75 +462,270 @@ get_or(toml::value& v, T&& opt)
     }
     catch(...)
     {
-        return std::forward<T>(opt);
+        return opt;
     }
 }
-template<typename T>
-decltype(::toml::get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(
-        std::declval<toml::value&&>()))
-get_or(toml::value&& v, T&& opt)
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T&& get_or(toml::value&& v, T&& opt)
 {
     try
     {
         return get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(std::move(v));
+            typename std::remove_reference<T>::type>::type>(v);
     }
     catch(...)
     {
-        return std::forward<T>(opt);
+        return opt;
     }
 }
 
+// ----------------------------------------------------------------------------
+// specialization for std::string (return type becomes lvalue ref)
 
-template<typename T>
-auto get_or(const toml::table& tab, const toml::key& ky, T&& opt)
-    -> decltype(get_or(std::declval<value const&>(), std::forward<T>(opt)))
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string const& get_or(const toml::value& v, const T& opt)
 {
-    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
-    return ::toml::get_or(tab.at(ky), std::forward<T>(opt));
+    try
+    {
+        return get<std::string>(v);
+    }
+    catch(...)
+    {
+        return opt;
+    }
 }
-template<typename T>
-auto get_or(toml::table& tab, const toml::key& ky, T&& opt)
-    -> decltype(get_or(std::declval<value&>(), std::forward<T>(opt)))
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string& get_or(toml::value& v, T& opt)
 {
-    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
-    return ::toml::get_or(tab[ky], std::forward<T>(opt));
+    try
+    {
+        return get<std::string>(v);
+    }
+    catch(...)
+    {
+        return opt;
+    }
 }
-template<typename T>
-auto get_or(toml::table&& tab, const toml::key& ky, T&& opt)
-    -> decltype(get_or(std::declval<value&&>(), std::forward<T>(opt)))
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string get_or(toml::value&& v, T&& opt)
 {
-    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
-    return ::toml::get_or(std::move(tab[ky]), std::forward<T>(opt));
+    try
+    {
+        return get<std::string>(v);
+    }
+    catch(...)
+    {
+        return opt;
+    }
+}
+template<typename T, typename std::enable_if<
+    detail::is_string_literal<typename std::remove_reference<T>::type>::value,
+    std::nullptr_t>::type = nullptr>
+std::string get_or(const toml::value& v, T&& opt)
+{
+    try
+    {
+        return get<std::string>(v);
+    }
+    catch(...)
+    {
+        return std::string(opt);
+    }
 }
 
-template<typename T>
-auto get_or(const toml::value& v, const toml::key& ky, T&& opt)
-    -> decltype(get_or(std::declval<value const&>(), std::forward<T>(opt)))
+// ----------------------------------------------------------------------------
+// others (require type conversion and return type cannot be lvalue reference)
+
+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>>,
+    detail::negation<std::is_same<T, std::string>>,
+    detail::negation<detail::is_string_literal<typename std::remove_reference<T>::type>>
+    >::value, std::nullptr_t>::type = nullptr>
+T get_or(const toml::value& v, T&& opt)
 {
-    if(v.type() != toml::value_t::Table){return std::forward<T>(opt);}
+    try
+    {
+        return get<typename std::remove_cv<
+            typename std::remove_reference<T>::type>::type>(v);
+    }
+    catch(...)
+    {
+        return opt;
+    }
+}
+
+// ===========================================================================
+// find_or(value, key, fallback)
+
+// ---------------------------------------------------------------------------
+// exact types (return type can be a reference)
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T const& find_or(const toml::value& v, const toml::key& ky, const T& opt)
+{
+    if(!v.is_table()) {return opt;}
     const auto& tab = toml::get<toml::table>(v);
-    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
-    return ::toml::get_or(tab.at(ky), std::forward<T>(opt));
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab.at(ky), opt);
 }
-template<typename T>
-auto get_or(toml::value& v, const toml::key& ky, T&& opt)
-    -> decltype(get_or(std::declval<value&>(), std::forward<T>(opt)))
+
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T& find_or(toml::value& v, const toml::key& ky, T& opt)
 {
-    if(v.type() != toml::value_t::Table){return std::forward<T>(opt);}
+    if(!v.is_table()) {return opt;}
     auto& tab = toml::get<toml::table>(v);
-    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
-    return ::toml::get_or(tab[ky], std::forward<T>(opt));
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab[ky], opt);
 }
-template<typename T>
-auto get_or(toml::value&& v, const toml::key& ky, T&& opt)
-    -> decltype(get_or(std::declval<value&&>(), std::forward<T>(opt)))
+
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T&& find_or(toml::value&& v, const toml::key& ky, T&& opt)
 {
-    if(v.type() != toml::value_t::Table){return 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 std::forward<T>(opt);}
-    return ::toml::get_or(std::move(tab[ky]), std::forward<T>(opt));
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(std::move(tab[ky]), std::forward<T>(opt));
+}
+
+// ---------------------------------------------------------------------------
+// std::string (return type can be a reference)
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string const& find_or(const toml::value& v, const toml::key& ky, const T& opt)
+{
+    if(!v.is_table()) {return opt;}
+    const auto& tab = toml::get<toml::table>(v);
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab.at(ky), opt);
+}
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string& find_or(toml::value& v, const toml::key& ky, T& opt)
+{
+    if(!v.is_table()) {return opt;}
+    auto& tab = toml::get<toml::table>(v);
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab[ky], opt);
+}
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string find_or(toml::value&& v, const toml::key& ky, 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 get_or(std::move(tab[ky]), std::forward<T>(opt));
+}
+
+// ---------------------------------------------------------------------------
+// string literal (deduced as std::string)
+template<typename T, typename std::enable_if<
+    detail::is_string_literal<typename std::remove_reference<T>::type>::value,
+    std::nullptr_t>::type = nullptr>
+std::string find_or(const toml::value& v, const toml::key& ky, T&& opt)
+{
+    if(!v.is_table()) {return opt;}
+    const auto& tab = toml::get<toml::table>(v);
+    if(tab.count(ky) == 0) {return std::string(opt);}
+    return get_or(tab.at(ky), std::forward<T>(opt));
+}
+
+// ---------------------------------------------------------------------------
+// others (require type conversion and return type cannot be lvalue reference)
+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>>,
+    detail::negation<std::is_same<T, std::string>>,
+    detail::negation<detail::is_string_literal<typename std::remove_reference<T>::type>>
+    >::value, std::nullptr_t>::type = nullptr>
+T find_or(const toml::value& v, const toml::key& ky, T&& opt)
+{
+    if(!v.is_table()) {return opt;}
+    const auto& tab = toml::get<toml::table>(v);
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab.at(ky), std::forward<T>(opt));
+}
+
+// ===========================================================================
+// find_or(table, key, opt)
+
+// ---------------------------------------------------------------------------
+// exact types (return type can be a reference)
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T const& find_or(const toml::table& tab, const toml::key& ky, const T& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab.at(ky), opt);
+}
+
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T& find_or(toml::table& tab, const toml::key& ky, T& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab[ky], opt);
+}
+
+template<typename T, typename std::enable_if<
+    detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+T&& find_or(toml::table&& tab, const toml::key& ky, T&& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(std::move(tab[ky]), std::forward<T>(opt));
+}
+
+// ---------------------------------------------------------------------------
+// std::string (return type can be a reference)
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string const& find_or(const toml::table& tab, const toml::key& ky, const T& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab.at(ky), opt);
+}
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string& find_or(toml::table& tab, const toml::key& ky, T& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab[ky], opt);
+}
+template<typename T, typename std::enable_if<
+    std::is_same<T, std::string>::value, std::nullptr_t>::type = nullptr>
+std::string find_or(toml::table&& tab, const toml::key& ky, T&& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(std::move(tab[ky]), std::forward<T>(opt));
+}
+
+// ---------------------------------------------------------------------------
+// string literal (deduced as std::string)
+template<typename T, typename std::enable_if<
+    detail::is_string_literal<typename std::remove_reference<T>::type>::value,
+    std::nullptr_t>::type = nullptr>
+std::string find_or(const toml::table& tab, const toml::key& ky, T&& opt)
+{
+    if(tab.count(ky) == 0) {return std::string(opt);}
+    return get_or(tab.at(ky), std::forward<T>(opt));
+}
+
+// ---------------------------------------------------------------------------
+// others (require type conversion and return type cannot be lvalue reference)
+template<typename T, typename std::enable_if<detail::conjunction<
+    detail::negation<detail::is_exact_toml_type<T>>,
+    detail::negation<std::is_same<T, std::string>>,
+    detail::negation<detail::is_string_literal<typename std::remove_reference<T>::type>>
+    >::value, std::nullptr_t>::type = nullptr>
+T find_or(const toml::table& tab, const toml::key& ky, T&& opt)
+{
+    if(tab.count(ky) == 0) {return opt;}
+    return get_or(tab.at(ky), std::forward<T>(opt));
 }
 
 // ============================================================================

toml/into.hpp

@@ -0,0 +1,20 @@
+//     Copyright Toru Niina 2019.
+// Distributed under the MIT License.
+#ifndef TOML11_INTO_HPP
+#define TOML11_INTO_HPP
+#include "traits.hpp"
+
+namespace toml
+{
+
+template<typename T>
+struct into;
+// {
+//     static toml::value into_toml(const T& user_defined_type)
+//     {
+//         // User-defined conversions ...
+//     }
+// };
+
+} // toml
+#endif // TOML11_INTO_HPP

toml/literal.hpp

@@ -0,0 +1,91 @@
+//     Copyright Toru Niina 2019.
+// Distributed under the MIT License.
+#ifndef TOML11_LITERAL_HPP
+#define TOML11_LITERAL_HPP
+#include "parser.hpp"
+
+namespace toml
+{
+inline namespace literals
+{
+inline namespace toml_literals
+{
+
+inline ::toml::value operator""_toml(const char* str, std::size_t len)
+{
+    ::toml::detail::location<std::vector<char>>
+        loc(/* filename = */ std::string("TOML literal encoded in a C++ code"),
+            /* contents = */ std::vector<char>(str, str + len));
+
+    // if there are some comments or empty lines, skip them.
+    using skip_line = ::toml::detail::repeat<toml::detail::sequence<
+            ::toml::detail::maybe<::toml::detail::lex_ws>,
+            ::toml::detail::maybe<::toml::detail::lex_comment>,
+            ::toml::detail::lex_newline
+        >, ::toml::detail::at_least<1>>;
+    skip_line::invoke(loc);
+
+    // if there are some whitespaces before a value, skip them.
+    using skip_ws = ::toml::detail::repeat<
+        ::toml::detail::lex_ws, ::toml::detail::at_least<1>>;
+    skip_ws::invoke(loc);
+
+    // to distinguish arrays and tables, first check it is a table or not.
+    //
+    // "[1,2,3]"_toml;   // this is an array
+    // "[table]"_toml;   // a table that has an empty table named "table" inside.
+    // "[[1,2,3]]"_toml; // this is an array of arrays
+    // "[[table]]"_toml; // this is a table that has an array of tables inside.
+    //
+    // "[[1]]"_toml;     // this can be both... (currently it becomes a table)
+    // "1 = [{}]"_toml;  // this is a table that has an array of table named 1.
+    // "[[1,]]"_toml;    // this is an array of arrays.
+    // "[[1],]"_toml;    // this also.
+
+    const auto the_front = loc.iter();
+
+    const bool is_table_key = ::toml::detail::lex_std_table::invoke(loc);
+    loc.reset(the_front);
+
+    const bool is_aots_key  = ::toml::detail::lex_array_table::invoke(loc);
+    loc.reset(the_front);
+
+    // If it is neither a table-key or a array-of-table-key, it may be a value.
+    if(!is_table_key && !is_aots_key)
+    {
+        if(auto data = ::toml::detail::parse_value(loc))
+        {
+            return data.unwrap();
+        }
+    }
+
+    // Note that still it can be a table, because the literal might be something
+    // like the following.
+    // ```cpp
+    // R"( // c++11 raw string literals
+    //   key = "value"
+    //   int = 42
+    // )"_toml;
+    // ```
+    // It is a valid toml file.
+    // It should be parsed as if we parse a file with this content.
+
+    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)));
+    }
+    else // none of them.
+    {
+        throw ::toml::syntax_error(data.unwrap_err());
+    }
+}
+
+} // toml_literals
+} // literals
+} // toml
+#endif//TOML11_LITERAL_HPP

toml/region.hpp

@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_REGION_H
-#define TOML11_REGION_H
+#ifndef TOML11_REGION_HPP
+#define TOML11_REGION_HPP
 #include "exception.hpp"
 #include <memory>
 #include <vector>
@@ -15,7 +15,7 @@ namespace toml
 namespace detail
 {
 
-// helper function to avoid std::string(0, 'c')
+// helper function to avoid std::string(0, 'c') or std::string(iter, iter)
 template<typename Iterator>
 std::string make_string(Iterator first, Iterator last)
 {
@@ -28,9 +28,7 @@ inline std::string make_string(std::size_t len, char c)
     return std::string(len, c);
 }
 
-// region in a container, normally in a file content.
-// shared_ptr points the resource that the iter points.
-// combinators returns this.
+// region_base is a base class of location and region that are defined below.
 // it will be used to generate better error messages.
 struct region_base
 {
@@ -48,25 +46,40 @@ struct region_base
     virtual std::string line()     const {return std::string("unknown line");}
     virtual std::string line_num() const {return std::string("?");}
 
-    virtual std::size_t before()   const noexcept {return 0;}
+    // length of the region
     virtual std::size_t size()     const noexcept {return 0;}
+    // number of characters in the line before the region
+    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 in a container, normally in a file content.
-// shared_ptr points the resource that the iter points.
-// it can be used not only for resource handling, but also error message.
-//
+// location represents a position in a container, which contains a file content.
 // it can be considered as a region that contains only one character.
+//
+// it contains pointer to the file content and iterator that points the current
+// location.
 template<typename Container>
 struct location final : public region_base
 {
-    static_assert(std::is_same<char, typename Container::value_type>::value,"");
     using const_iterator = typename Container::const_iterator;
     using source_ptr     = std::shared_ptr<const Container>;
 
+    static_assert(std::is_same<char, typename Container::value_type>::value,"");
+    static_assert(std::is_same<std::random_access_iterator_tag,
+        typename std::iterator_traits<const_iterator>::iterator_category>::value,
+        "container should be randomly accessible");
+
     location(std::string name, Container cont)
-      : source_(std::make_shared<Container>(std::move(cont))),
+      : source_(std::make_shared<Container>(std::move(cont))), line_number_(1),
         source_name_(std::move(name)), iter_(source_->cbegin())
     {}
     location(const location&) = default;
@@ -77,18 +90,54 @@ struct location final : public region_base
 
     bool is_ok() const noexcept override {return static_cast<bool>(source_);}
 
-    const_iterator& iter()       noexcept {return iter_;}
-    const_iterator  iter() const noexcept {return iter_;}
+    // this const prohibits codes like `++(loc.iter())`.
+    const const_iterator iter()  const noexcept {return iter_;}
 
-    const_iterator  begin() const noexcept {return source_->cbegin();}
-    const_iterator  end()   const noexcept {return source_->cend();}
+    const_iterator begin() const noexcept {return source_->cbegin();}
+    const_iterator end()   const noexcept {return source_->cend();}
+
+    // XXX `location::line_num()` used to be implemented using `std::count` to
+    // count a number of '\n'. But with a long toml file (typically, 10k lines),
+    // it becomes intolerably slow because each time it generates error messages,
+    // it counts '\n' from thousands of characters. To workaround it, I decided
+    // to introduce `location::line_number_` member variable and synchronize it
+    // to the location changes the point to look. So an overload of `iter()`
+    // which returns mutable reference is removed and `advance()`, `retrace()`
+    // and `reset()` is added.
+    void advance(std::size_t n = 1) noexcept
+    {
+        this->line_number_ += std::count(this->iter_, this->iter_ + n, '\n');
+        this->iter_ += n;
+        return;
+    }
+    void retrace(std::size_t n = 1) noexcept
+    {
+        this->line_number_ -= std::count(this->iter_ - n, this->iter_, '\n');
+        this->iter_ -= n;
+        return;
+    }
+    void reset(const_iterator rollback) noexcept
+    {
+        // since c++11, std::distance works in both ways for random-access
+        // iterators and returns a negative value if `first > last`.
+        if(0 <= std::distance(rollback, this->iter_)) // rollback < iter
+        {
+            this->line_number_ -= std::count(rollback, this->iter_, '\n');
+        }
+        else // iter < rollback [[unlikely]]
+        {
+            this->line_number_ += std::count(this->iter_, rollback, '\n');
+        }
+        this->iter_ = rollback;
+        return;
+    }
 
     std::string str()  const override {return make_string(1, *this->iter());}
     std::string name() const override {return source_name_;}
 
     std::string line_num() const override
     {
-        return std::to_string(1+std::count(this->begin(), this->iter(), '\n'));
+        return std::to_string(this->line_number_);
     }
 
     std::string line() const override
@@ -127,17 +176,26 @@ struct location final : public region_base
   private:
 
     source_ptr     source_;
+    std::size_t    line_number_;
     std::string    source_name_;
     const_iterator iter_;
 };
 
+// region represents a range in a container, which contains a file content.
+//
+// it contains pointer to the file content and iterator that points the first
+// and last location.
 template<typename Container>
 struct region final : public region_base
 {
-    static_assert(std::is_same<char, typename Container::value_type>::value,"");
     using const_iterator = typename Container::const_iterator;
     using source_ptr     = std::shared_ptr<const Container>;
 
+    static_assert(std::is_same<char, typename Container::value_type>::value,"");
+    static_assert(std::is_same<std::random_access_iterator_tag,
+        typename std::iterator_traits<const_iterator>::iterator_category>::value,
+        "container should be randomly accessible");
+
     // delete default constructor. source_ never be null.
     region() = delete;
 
@@ -230,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_;
@@ -237,149 +381,6 @@ struct region final : public region_base
     const_iterator first_, last_;
 };
 
-// to show a better error message.
-inline std::string format_underline(const std::string& message,
-        const region_base& reg, const std::string& comment_for_underline,
-        std::vector<std::string> helps = {})
-{
-#ifdef _WIN32
-    const auto newline = "\r\n";
-#else
-    const char newline = '\n';
-#endif
-    const auto line        = reg.line();
-    const auto line_number = reg.line_num();
-
-    std::string retval;
-    retval += message;
-    retval += newline;
-    retval += " --> ";
-    retval += reg.name();
-    retval += newline;
-    retval += ' ';
-    retval += line_number;
-    retval += " | ";
-    retval += line;
-    retval += newline;
-    retval += make_string(line_number.size() + 1, ' ');
-    retval += " | ";
-    retval += make_string(reg.before(), ' ');
-    if(reg.size() == 1)
-    {
-        // invalid
-        // ^------
-        retval += '^';
-        retval += make_string(reg.after(), '-');
-    }
-    else
-    {
-        // invalid
-        // ~~~~~~~
-        retval += make_string(reg.size(), '~');
-    }
-    retval += ' ';
-    retval += comment_for_underline;
-    if(helps.size() != 0)
-    {
-        retval += newline;
-        retval += make_string(line_number.size() + 1, ' ');
-        retval += " | ";
-        for(const auto help : helps)
-        {
-            retval += newline;
-            retval += "Hint: ";
-            retval += help;
-        }
-    }
-    return retval;
-}
-
-// to show a better error message.
-inline std::string format_underline(const std::string& message,
-        const region_base& reg1, const std::string& comment_for_underline1,
-        const region_base& reg2, const std::string& comment_for_underline2,
-        std::vector<std::string> helps = {})
-{
-#ifdef _WIN32
-    const auto newline = "\r\n";
-#else
-    const char newline = '\n';
-#endif
-    const auto line1        = reg1.line();
-    const auto line_number1 = reg1.line_num();
-    const auto line2        = reg2.line();
-    const auto line_number2 = reg2.line_num();
-    const auto line_num_width =
-        std::max(line_number1.size(), line_number2.size());
-
-    std::ostringstream retval;
-    retval << message << newline;
-    retval << " --> " << reg1.name() << newline;
-//  ---------------------------------------
-    retval << ' ' << std::setw(line_num_width) << line_number1;
-    retval << " | " << line1 << newline;
-    retval << make_string(line_num_width + 1, ' ');
-    retval << " | ";
-    retval << make_string(reg1.before(), ' ');
-    if(reg1.size() == 1)
-    {
-        // invalid
-        // ^------
-        retval << '^';
-        retval << make_string(reg1.after(), '-');
-    }
-    else
-    {
-        // invalid
-        // ~~~~~~~
-        retval << make_string(reg1.size(), '~');
-    }
-    retval << ' ';
-    retval << comment_for_underline1 << newline;
-//  ---------------------------------------
-    if(reg2.name() != reg1.name())
-    {
-        retval << " --> " << reg2.name() << newline;
-    }
-    else
-    {
-        retval << " ..." << newline;
-    }
-    retval << ' ' << std::setw(line_num_width) << line_number2;
-    retval << " | " << line2 << newline;
-    retval << make_string(line_num_width + 1, ' ');
-    retval << " | ";
-    retval << make_string(reg2.before(), ' ');
-    if(reg2.size() == 1)
-    {
-        // invalid
-        // ^------
-        retval << '^';
-        retval << make_string(reg2.after(), '-');
-    }
-    else
-    {
-        // invalid
-        // ~~~~~~~
-        retval << make_string(reg2.size(), '~');
-    }
-    retval << ' ';
-    retval << comment_for_underline2;
-    if(helps.size() != 0)
-    {
-        retval << newline;
-        retval << make_string(line_num_width + 1, ' ');
-        retval << " | ";
-        for(const auto help : helps)
-        {
-            retval << newline;
-            retval << "Hint: ";
-            retval << help;
-        }
-    }
-    return retval.str();
-}
-
 // to show a better error message.
 inline std::string format_underline(const std::string& message,
         std::vector<std::pair<region_base const*, std::string>> reg_com,
@@ -408,10 +409,11 @@ inline std::string format_underline(const std::string& message,
     {
         if(i!=0 && reg_com.at(i-1).first->name() == reg_com.at(i).first->name())
         {
-            retval << " ..." << newline;
+            retval << newline << " ..." << newline;
         }
         else
         {
+            if(i != 0) {retval << newline;}
             retval << " --> " << reg_com.at(i).first->name() << newline;
         }
 
@@ -435,11 +437,12 @@ 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 << ' ';
-        retval << comment << newline;
+        retval << comment;
     }
 
     if(helps.size() != 0)
@@ -457,7 +460,6 @@ inline std::string format_underline(const std::string& message,
     return retval.str();
 }
 
-
 } // detail
 } // toml
 #endif// TOML11_REGION_H

toml/result.hpp

@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_RESULT_H
-#define TOML11_RESULT_H
+#ifndef TOML11_RESULT_HPP
+#define TOML11_RESULT_HPP
 #include "traits.hpp"
 #include <type_traits>
 #include <stdexcept>
@@ -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

@@ -5,6 +5,7 @@
 #include "value.hpp"
 #include "lexer.hpp"
 #include <limits>
+#include <cstdio>
 
 namespace toml
 {
@@ -30,13 +31,12 @@ struct serializer
     }
     std::string operator()(const toml::floating f) const
     {
-        std::string token = [=] {
-            // every float value needs decimal point (or exponent).
-            std::ostringstream oss;
-            oss << std::setprecision(float_prec_) << std::showpoint << f;
-            return oss.str();
-        }();
+        const auto fmt = "%.*g";
+        const auto bsz = std::snprintf(nullptr, 0, fmt, this->float_prec_, f);
+        std::vector<char> buf(bsz + 1, '\0'); // +1 for null character(\0)
+        std::snprintf(buf.data(), buf.size(), fmt, this->float_prec_, f);
 
+        std::string token(buf.begin(), std::prev(buf.end()));
         if(token.back() == '.') // 1. => 1.0
         {
             token += '0';
@@ -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;}
-
-        const auto& a = v.cast<value_t::Array>();
-        return !a.empty() && a.front().is(value_t::Table);
+        if(!v.is_array()) {return false;}
+        const auto& a = v.as_array();
+        return !a.empty() && a.front().is_table();
     }
 
   private:
@@ -483,15 +482,19 @@ struct serializer
 
 inline std::string
 format(const value& v, std::size_t w = 80,
-       int fprec = std::numeric_limits<toml::floating>::max_digits10)
+       int fprec = std::numeric_limits<toml::floating>::max_digits10,
+       bool force_inline = false)
 {
-    return visit(serializer(w, fprec, true), v);
+    // if value is a table, it is considered to be a root object.
+    // the root object can't be an inline table. so pass false. otherwise, true.
+    return visit(serializer(w, fprec, (!v.is_table()) || force_inline), v);
 }
 inline std::string
 format(const table& t, std::size_t w = 80,
-       int fprec = std::numeric_limits<toml::floating>::max_digits10)
+       int fprec = std::numeric_limits<toml::floating>::max_digits10,
+       bool force_inline = false)
 {
-    return serializer(w, fprec, true)(t);
+    return serializer(w, fprec, force_inline)(t);
 }
 
 template<typename charT, typename traits>
@@ -506,6 +509,18 @@ operator<<(std::basic_ostream<charT, traits>& os, const value& v)
     os << visit(serializer(w, fprec, false), v);
     return os;
 }
+template<typename charT, typename traits>
+std::basic_ostream<charT, traits>&
+operator<<(std::basic_ostream<charT, traits>& os, const table& v)
+{
+    // get status of std::setw().
+    const std::size_t w     = os.width();
+    const int         fprec = os.precision();
+    os.width(0);
+    // the root object can't be an inline table. so pass `false`.
+    os << serializer(w, fprec, false)(v);
+    return os;
+}
 
 } // toml
 #endif// TOML11_SERIALIZER_HPP

toml/string.hpp

@@ -1,9 +1,14 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_STRING_H
-#define TOML11_STRING_H
+#ifndef TOML11_STRING_HPP
+#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/to_toml.hpp

@@ -1,43 +0,0 @@
-//     Copyright Toru Niina 2017.
-// Distributed under the MIT License.
-#ifndef TOML11_TO_TOML
-#define TOML11_TO_TOML
-#include "value.hpp"
-
-namespace toml
-{
-
-template<typename T>
-inline value to_toml(T&& x)
-{
-    return value(std::forward<T>(x));
-}
-
-template<typename T>
-inline value to_toml(T&& x, string_t kind)
-{
-    return value(std::forward<T>(x), kind);
-}
-
-inline value to_toml(local_date d, local_time t)
-{
-    return value(local_datetime(d, t));
-}
-inline value to_toml(local_date d, local_time t, time_offset ofs)
-{
-    return value(offset_datetime(d, t, ofs));
-}
-
-template<typename ... Ts>
-inline value to_toml(Ts&& ... xs)
-{
-    return value(toml::array{toml::value(std::forward<Ts>(xs)) ... });
-}
-
-inline value to_toml(std::initializer_list<std::pair<std::string, toml::value>> xs)
-{
-    return value(toml::table(xs.begin(), xs.end()));
-}
-
-} // toml
-#endif // TOML11_TO_TOML

toml/traits.hpp

@@ -1,7 +1,7 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_TRAITS
-#define TOML11_TRAITS
+#ifndef TOML11_TRAITS_HPP
+#define TOML11_TRAITS_HPP
 #include <type_traits>
 #include <utility>
 #include <chrono>
@@ -9,6 +9,9 @@
 
 namespace toml
 {
+
+class value; // forward decl
+
 namespace detail
 {
 
@@ -45,6 +48,22 @@ struct has_resize_method_impl
     template<typename T> static std::false_type check(...);
 };
 
+struct has_from_toml_method_impl
+{
+    template<typename T>
+    static std::true_type  check(
+        decltype(std::declval<T>().from_toml(std::declval<::toml::value>()))*);
+    template<typename T>
+    static std::false_type check(...);
+};
+struct has_into_toml_method_impl
+{
+    template<typename T>
+    static std::true_type  check(decltype(std::declval<T>().into_toml())*);
+    template<typename T>
+    static std::false_type check(...);
+};
+
 /// Intel C++ compiler can not use decltype in parent class declaration, here
 /// is a hack to work around it. https://stackoverflow.com/a/23953090/4692076
 #ifdef __INTEL_COMPILER
@@ -62,6 +81,14 @@ struct has_mapped_type : decltype(has_mapped_type_impl::check<T>(nullptr)){};
 template<typename T>
 struct has_resize_method : decltype(has_resize_method_impl::check<T>(nullptr)){};
 
+
+template<typename T>
+struct has_from_toml_method
+: decltype(has_from_toml_method_impl::check<T>(nullptr)){};
+template<typename T>
+struct has_into_toml_method
+: decltype(has_into_toml_method_impl::check<T>(nullptr)){};
+
 #ifdef __INTEL_COMPILER
 #undef decltype(...)
 #endif
@@ -142,6 +169,21 @@ using return_type_of_t = typename std::result_of<F(Args...)>::type;
 
 #endif
 
+// ---------------------------------------------------------------------------
+// is_string_literal
+//
+// to use this, pass `typename remove_reference<T>::type` to T.
+
+template<typename T>
+struct is_string_literal:
+disjunction<
+    std::is_same<const char*, T>,
+    conjunction<
+        std::is_array<T>,
+        std::is_same<const char, typename std::remove_extent<T>::type>
+        >
+    >{};
+
 }// detail
 }//toml
 #endif // TOML_TRAITS

toml/types.hpp

@@ -1,12 +1,17 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_TYPES_H
-#define TOML11_TYPES_H
+#ifndef TOML11_TYPES_HPP
+#define TOML11_TYPES_HPP
 #include "datetime.hpp"
 #include "string.hpp"
 #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<> 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<Float         >{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<OffsetDatetime>{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<LocalDate     >{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<Array         >{static constexpr value_t value = value_t::Array         ;};
-template<> struct toml_value_t<Table         >{static constexpr value_t value = value_t::Table         ;};
+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<integer        >{static constexpr value_t value = value_t::Integer       ;};
+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<offset_datetime>{static constexpr value_t value = value_t::OffsetDatetime;};
+template<> struct toml_value_t<local_datetime >{static constexpr value_t value = value_t::LocalDatetime ;};
+template<> struct toml_value_t<local_date     >{static constexpr value_t value = value_t::LocalDate     ;};
+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<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, Integer >,
-    std::is_same<T, Float   >,
-    std::is_same<T, String  >,
+    std::is_same<T, boolean        >,
+    std::is_same<T, integer        >,
+    std::is_same<T, floating       >,
+    std::is_same<T, string         >,
     std::is_same<T, offset_datetime>,
-    std::is_same<T, local_datetime>,
-    std::is_same<T, local_date>,
-    std::is_same<T, local_time>,
-    std::is_same<T, Array   >,
-    std::is_same<T, Table   >
+    std::is_same<T, local_datetime >,
+    std::is_same<T, local_date     >,
+    std::is_same<T, local_time     >,
+    std::is_same<T, array          >,
+    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

@@ -1,12 +1,22 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_UTILITY
-#define TOML11_UTILITY
+#ifndef TOML11_UTILITY_HPP
+#define TOML11_UTILITY_HPP
 #include "traits.hpp"
 #include <utility>
 #include <memory>
 #include <sstream>
 
+#if __cplusplus >= 201402L
+#  define TOML11_MARK_AS_DEPRECATED(msg) [[deprecated(msg)]]
+#elif defined(__GNUC__)
+#  define TOML11_MARK_AS_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#elif defined(_MSC_VER)
+#  define TOML11_MARK_AS_DEPRECATED(msg) __declspec(deprecated(msg))
+#else
+#  define TOML11_MARK_AS_DEPRECATED
+#endif
+
 namespace toml
 {
 
@@ -69,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

@@ -1,8 +1,9 @@
 //     Copyright Toru Niina 2017.
 // Distributed under the MIT License.
-#ifndef TOML11_VALUE
-#define TOML11_VALUE
+#ifndef TOML11_VALUE_HPP
+#define TOML11_VALUE_HPP
 #include "traits.hpp"
+#include "into.hpp"
 #include "utility.hpp"
 #include "exception.hpp"
 #include "storage.hpp"
@@ -13,6 +14,9 @@
 #include <unordered_map>
 #include <cassert>
 #include <cstdint>
+#if __cplusplus >= 201703L
+#include <string_view>
+#endif
 
 namespace toml
 {
@@ -44,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;
@@ -292,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)
@@ -473,7 +501,7 @@ class value
           region_info_(std::make_shared<region_base>(region_base{}))
     {
         array ary; ary.reserve(list.size());
-        for(auto& elem : list) {ary.emplace_back(std::move(elem));}
+        for(const auto& elem : list) {ary.emplace_back(elem);}
         assigner(this->array_, std::move(ary));
     }
     template<typename T, typename std::enable_if<detail::is_container<T>::value,
@@ -485,7 +513,7 @@ class value
         this->region_info_ = std::make_shared<region_base>(region_base{});
 
         array ary; ary.reserve(list.size());
-        for(auto& elem : list) {ary.emplace_back(std::move(elem));}
+        for(const auto& elem : list) {ary.emplace_back(elem);}
         assigner(this->array_, std::move(ary));
         return *this;
     }
@@ -533,10 +561,70 @@ class value
         return *this;
     }
 
+    // user-defined =========================================================
+
+    // convert using into_toml() method -------------------------------------
+
+    template<typename T, typename std::enable_if<detail::conjunction<
+        detail::negation<detail::is_exact_toml_type<T>>, // not a toml::value
+        detail::has_into_toml_method<T> // but has `into_toml` method
+        >::value, std::nullptr_t>::type = nullptr>
+    value(const T& ud): value(ud.into_toml()) {}
+
+    template<typename T, typename std::enable_if<detail::conjunction<
+        detail::negation<detail::is_exact_toml_type<T>>, // not a toml::value
+        detail::has_into_toml_method<T> // but has `into_toml` method
+        >::value, std::nullptr_t>::type = nullptr>
+    value& operator=(const T& ud)
+    {
+        *this = ud.into_toml();
+        return *this;
+    }
+
+    // convert using into<T> struct -----------------------------------------
+
+    template<typename T, typename std::enable_if<
+        detail::negation<detail::is_exact_toml_type<T>>::value,
+        std::nullptr_t>::type = nullptr,
+        std::size_t S = sizeof(::toml::into<T>)>
+    value(const T& ud): value(::toml::into<T>::into_toml(ud)) {}
+
+    template<typename T, typename std::enable_if<
+        detail::negation<detail::is_exact_toml_type<T>>::value,
+        std::nullptr_t>::type = nullptr,
+        std::size_t S = sizeof(::toml::into<T>)>
+    value& operator=(const T& ud)
+    {
+        *this = ::toml::into<T>::into_toml(ud);
+        return *this;
+    }
+
+    // for internal use ------------------------------------------------------
+
+    template<typename T, typename Container, typename std::enable_if<
+        detail::is_exact_toml_type<T>::value, std::nullptr_t>::type = nullptr>
+    value(std::pair<T, detail::region<Container>> parse_result)
+        : value(std::move(parse_result.first), std::move(parse_result.second))
+    {}
+
+    // type checking and casting ============================================
+
     template<typename T>
     bool is() const noexcept {return value_traits<T>::type_index == this->type_;}
     bool is(value_t t) const noexcept {return t == this->type_;}
 
+    bool is_uninitialized()   const noexcept {return this->is(value_t::Empty         );}
+    bool is_boolean()         const noexcept {return this->is(value_t::Boolean       );}
+    bool is_integer()         const noexcept {return this->is(value_t::Integer       );}
+    bool is_float()           const noexcept {return this->is(value_t::Float         );}
+    bool is_string()          const noexcept {return this->is(value_t::String        );}
+    bool is_offset_datetime() const noexcept {return this->is(value_t::OffsetDatetime);}
+    bool is_local_datetime()  const noexcept {return this->is(value_t::LocalDatetime );}
+    bool is_local_date()      const noexcept {return this->is(value_t::LocalDate     );}
+    bool is_local_time()      const noexcept {return this->is(value_t::LocalTime     );}
+    bool is_array()           const noexcept {return this->is(value_t::Array         );}
+    bool is_table()           const noexcept {return this->is(value_t::Table         );}
+
     value_t type() const {return type_;}
 
     template<value_t T>
@@ -546,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
@@ -565,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>;
@@ -613,101 +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 Boolean const& invoke(value const& v) {return v.boolean_;}
-    static Boolean&&      invoke(value&&      v) {return std::move(v.boolean_);}
+    static ::toml::boolean&       invoke(value&       v) {return v.as_boolean();}
+    static ::toml::boolean const& invoke(value const& v) {return v.as_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 Integer const& invoke(value const& v) {return v.integer_;}
-    static Integer&&      invoke(value&&      v) {return std::move(v.integer_);}
+    static ::toml::integer&       invoke(value&       v) {return v.as_integer();}
+    static ::toml::integer const& invoke(value const& v) {return v.as_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 Float const& invoke(value const& v) {return v.floating_;}
-    static Float&&      invoke(value&&      v) {return std::move(v.floating_);}
+    static ::toml::floating&       invoke(value&       v) {return v.as_float();}
+    static ::toml::floating const& invoke(value const& v) {return v.as_float();}
+    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 String const& invoke(value const& v) {return v.string_;}
-    static String&&      invoke(value&&      v) {return std::move(v.string_);}
+    static ::toml::string&       invoke(value&       v) {return v.as_string();}
+    static ::toml::string const& invoke(value const& v) {return v.as_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 OffsetDatetime const& invoke(value const& v) {return v.offset_datetime_;}
-    static OffsetDatetime&&      invoke(value&&      v) {return std::move(v.offset_datetime_);}
+    static ::toml::offset_datetime&       invoke(value&       v) {return v.as_offset_datetime();}
+    static ::toml::offset_datetime const& invoke(value const& v) {return v.as_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 LocalDatetime const& invoke(value const& v) {return v.local_datetime_;}
-    static LocalDatetime&&      invoke(value&&      v) {return std::move(v.local_datetime_);}
+    static ::toml::local_datetime&       invoke(value&       v) {return v.as_local_datetime();}
+    static ::toml::local_datetime const& invoke(value const& v) {return v.as_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 LocalDate const& invoke(value const& v) {return v.local_date_;}
-    static LocalDate&&      invoke(value&&      v) {return std::move(v.local_date_);}
+    static ::toml::local_date&       invoke(value&       v) {return v.as_local_date();}
+    static ::toml::local_date const& invoke(value const& v) {return v.as_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 LocalTime const& invoke(value const& v) {return v.local_time_;}
-    static LocalTime&&      invoke(value&&      v) {return std::move(v.local_time_);}
+    static ::toml::local_time&       invoke(value&       v) {return v.as_local_time();}
+    static ::toml::local_time const& invoke(value const& v) {return v.as_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 Array const& invoke(value const& v) {return v.array_.value();}
-    static Array&&      invoke(value&&      v) {return std::move(v.array_.value());}
+    static ::toml::array&       invoke(value&       v) {return v.as_array();}
+    static ::toml::array const& invoke(value const& v) {return v.as_array();}
+    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 Table const& invoke(value const& v) {return v.table_.value();}
-    static Table&&      invoke(value&&      v) {return std::move(v.table_.value());}
+    static ::toml::table&       invoke(value&       v) {return v.as_table();}
+    static ::toml::table const& invoke(value const& v) {return v.as_table();}
+    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(format_underline(concat_to_string(
-            "[error] toml::value bad_cast to ", T), *region_info_,
-            concat_to_string("the actual type is ", this->type_)));
+        detail::throw_bad_cast<T>(this->type_, *this);
     }
-    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(format_underline(concat_to_string(
-            "[error] toml::value bad_cast to ", T), *region_info_,
-            concat_to_string("the actual type is ", this->type_)));
+        detail::throw_bad_cast<T>(this->type_, *this);
     }
-    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(format_underline(concat_to_string(
-            "[error] toml::value bad_cast to ", T), *region_info_,
-            concat_to_string("the actual type is ", this->type_)));
+        detail::throw_bad_cast<T>(this->type_, *this);
     }
-    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)
@@ -716,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;
-        case value_t::Unknown : return false;
-        default: return false;
+        {
+            return lhs.as_table() == rhs.as_table();
+        }
+        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)
@@ -746,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;
-        case value_t::Unknown : return false;
-        default: return false;
+        {
+            return lhs.as_table() < rhs.as_table();
+        }
+        case value_t::Empty   : {return false;}
+        case value_t::Unknown : {return false;}
+        default:                {return false;}
     }
 }
 
@@ -792,8 +978,10 @@ inline std::string format_error(const std::string& err_msg,
         const toml::value& v, const std::string& comment,
         std::vector<std::string> hints = {})
 {
-    return detail::format_underline(err_msg, detail::get_region(v), comment,
-                                    std::move(hints));
+    return detail::format_underline(err_msg,
+        std::vector<std::pair<detail::region_base const*, std::string>>{
+            {std::addressof(detail::get_region(v)), comment}
+        }, std::move(hints));
 }
 
 inline std::string format_error(const std::string& err_msg,
@@ -801,9 +989,25 @@ inline std::string format_error(const std::string& err_msg,
         const toml::value& v2, const std::string& comment2,
         std::vector<std::string> hints = {})
 {
-    return detail::format_underline(err_msg, detail::get_region(v1), comment1,
-                                             detail::get_region(v2), comment2,
-                                             std::move(hints));
+    return detail::format_underline(err_msg,
+        std::vector<std::pair<detail::region_base const*, std::string>>{
+            {std::addressof(detail::get_region(v1)), comment1},
+            {std::addressof(detail::get_region(v2)), comment2}
+        }, std::move(hints));
+}
+
+inline std::string format_error(const std::string& err_msg,
+        const toml::value& v1, const std::string& comment1,
+        const toml::value& v2, const std::string& comment2,
+        const toml::value& v3, const std::string& comment3,
+        std::vector<std::string> hints = {})
+{
+    return detail::format_underline(err_msg,
+        std::vector<std::pair<detail::region_base const*, std::string>>{
+            {std::addressof(detail::get_region(v1)), comment1},
+            {std::addressof(detail::get_region(v2)), comment2},
+            {std::addressof(detail::get_region(v3)), comment3}
+        }, std::move(hints));
 }
 
 template<typename Visitor>
@@ -812,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::Integer       : {return visitor(v.cast<value_t::Integer       >());}
-        case value_t::Float         : {return visitor(v.cast<value_t::Float         >());}
-        case value_t::String        : {return visitor(v.cast<value_t::String        >());}
-        case value_t::OffsetDatetime: {return visitor(v.cast<value_t::OffsetDatetime>());}
-        case value_t::LocalDatetime : {return visitor(v.cast<value_t::LocalDatetime >());}
-        case value_t::LocalDate     : {return visitor(v.cast<value_t::LocalDate     >());}
-        case value_t::LocalTime     : {return visitor(v.cast<value_t::LocalTime     >());}
-        case value_t::Array         : {return visitor(v.cast<value_t::Array         >());}
-        case value_t::Table         : {return visitor(v.cast<value_t::Table         >());}
+        case value_t::Boolean       : {return visitor(v.as_boolean        ());}
+        case value_t::Integer       : {return visitor(v.as_integer        ());}
+        case value_t::Float         : {return visitor(v.as_float          ());}
+        case value_t::String        : {return visitor(v.as_string         ());}
+        case value_t::OffsetDatetime: {return visitor(v.as_offset_datetime());}
+        case value_t::LocalDatetime : {return visitor(v.as_local_datetime ());}
+        case value_t::LocalDate     : {return visitor(v.as_local_date     ());}
+        case value_t::LocalTime     : {return visitor(v.as_local_time     ());}
+        case value_t::Array         : {return visitor(v.as_array          ());}
+        case value_t::Table         : {return visitor(v.as_table          ());}
         case value_t::Empty         : break;
         case value_t::Unknown       : break;
         default: break;
@@ -836,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::Integer       : {return visitor(v.cast<value_t::Integer       >());}
-        case value_t::Float         : {return visitor(v.cast<value_t::Float         >());}
-        case value_t::String        : {return visitor(v.cast<value_t::String        >());}
-        case value_t::OffsetDatetime: {return visitor(v.cast<value_t::OffsetDatetime>());}
-        case value_t::LocalDatetime : {return visitor(v.cast<value_t::LocalDatetime >());}
-        case value_t::LocalDate     : {return visitor(v.cast<value_t::LocalDate     >());}
-        case value_t::LocalTime     : {return visitor(v.cast<value_t::LocalTime     >());}
-        case value_t::Array         : {return visitor(v.cast<value_t::Array         >());}
-        case value_t::Table         : {return visitor(v.cast<value_t::Table         >());}
+        case value_t::Boolean       : {return visitor(v.as_boolean        ());}
+        case value_t::Integer       : {return visitor(v.as_integer        ());}
+        case value_t::Float         : {return visitor(v.as_float          ());}
+        case value_t::String        : {return visitor(v.as_string         ());}
+        case value_t::OffsetDatetime: {return visitor(v.as_offset_datetime());}
+        case value_t::LocalDatetime : {return visitor(v.as_local_datetime ());}
+        case value_t::LocalDate     : {return visitor(v.as_local_date     ());}
+        case value_t::LocalTime     : {return visitor(v.as_local_time     ());}
+        case value_t::Array         : {return visitor(v.as_array          ());}
+        case value_t::Table         : {return visitor(v.as_table          ());}
         case value_t::Empty         : break;
         case value_t::Unknown       : break;
         default: break;
@@ -855,21 +1059,21 @@ visit(Visitor&& visitor, toml::value& v)
 }
 
 template<typename Visitor>
-detail::return_type_of_t<Visitor, toml::boolean&>
+detail::return_type_of_t<Visitor, toml::boolean&&>
 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::Integer       : {return visitor(std::move(v.cast<value_t::Integer       >()));}
-        case value_t::Float         : {return visitor(std::move(v.cast<value_t::Float         >()));}
-        case value_t::String        : {return visitor(std::move(v.cast<value_t::String        >()));}
-        case value_t::OffsetDatetime: {return visitor(std::move(v.cast<value_t::OffsetDatetime>()));}
-        case value_t::LocalDatetime : {return visitor(std::move(v.cast<value_t::LocalDatetime >()));}
-        case value_t::LocalDate     : {return visitor(std::move(v.cast<value_t::LocalDate     >()));}
-        case value_t::LocalTime     : {return visitor(std::move(v.cast<value_t::LocalTime     >()));}
-        case value_t::Array         : {return visitor(std::move(v.cast<value_t::Array         >()));}
-        case value_t::Table         : {return visitor(std::move(v.cast<value_t::Table         >()));}
+        case value_t::Boolean       : {return visitor(std::move(v.as_boolean        ()));}
+        case value_t::Integer       : {return visitor(std::move(v.as_integer        ()));}
+        case value_t::Float         : {return visitor(std::move(v.as_float          ()));}
+        case value_t::String        : {return visitor(std::move(v.as_string         ()));}
+        case value_t::OffsetDatetime: {return visitor(std::move(v.as_offset_datetime()));}
+        case value_t::LocalDatetime : {return visitor(std::move(v.as_local_datetime ()));}
+        case value_t::LocalDate     : {return visitor(std::move(v.as_local_date     ()));}
+        case value_t::LocalTime     : {return visitor(std::move(v.as_local_time     ()));}
+        case value_t::Array         : {return visitor(std::move(v.as_array          ()));}
+        case value_t::Table         : {return visitor(std::move(v.as_table          ()));}
         case value_t::Empty         : break;
         case value_t::Unknown       : break;
         default: break;