doc: add contributors

test: add test cases for one-way conversion
fix: toml -> T is required; related to #83
2025-12-16 03:08:52 +08:00 · 2019-10-04 14:28:43 +09:00 · 2019-10-04 13:01:15 +09:00 · 2019-10-04 13:00:34 +09:00 · 2019-10-04 12:58:13 +09:00 · 2019-10-03 21:28:06 -04:00
27 changed files with 1961 additions and 355 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -15,6 +15,29 @@ jobs:
              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
+  test_serialization:
+    docker:
+      - image: circleci/buildpack-deps:bionic
+    steps:
+      - checkout
+      - run:
+          command: |
+              g++ --version
+              cd tests/
+              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -Werror -I../ check_serialization.cpp -o check_serialization
+              git clone https://github.com/BurntSushi/toml-test.git
+              cp check_serialization toml-test/tests/valid
+              cd toml-test/tests/valid
+              for f in $(ls ./*.toml);
+                do echo "==> ${f}";
+                cat ${f};
+                echo "---------------------------------------";
+                ./check_serialization ${f};
+                if [ $? -ne 0 ] ; then
+                  exit 1
+                fi
+                echo "=======================================";
+              done
  output_result:
    docker:
      - image: circleci/buildpack-deps:bionic
@@ -24,7 +47,7 @@ jobs:
          command: |
              g++ --version
              cd tests/
-              g++ -std=c++11 -O2 -Wall -Wextra -Werror -I../ check.cpp -o check
+              g++ -std=c++11 -O2 -Wall -Wextra -Wpedantic -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
@@ -56,4 +79,5 @@ workflows:
  test:
    jobs:
      - test_suite
+      - test_serialization
      - output_result
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,7 +5,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-5" CXX_STANDARD=11
+    env: COMPILER="g++-5" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
@@ -17,7 +17,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-6" CXX_STANDARD=11
+    env: COMPILER="g++-6" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
@@ -29,7 +29,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-7" CXX_STANDARD=11
+    env: COMPILER="g++-7" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
@@ -41,7 +41,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-8" CXX_STANDARD=11
+    env: COMPILER="g++-8" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
@@ -53,7 +53,31 @@ matrix:
  - os: linux
    language: cpp
    compiler: gcc
-    env: COMPILER="g++-8" CXX_STANDARD=17
+    env: COMPILER="g++-8" CXX_STANDARD=11 TOML_HEAD=ON
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:mhier/libboost-latest'
+        packages:
+        - g++-8
+        - boost1.70
+  - os: linux
+    language: cpp
+    compiler: gcc
+    env: COMPILER="g++-8" CXX_STANDARD=17 TOML_HEAD=OFF
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - sourceline: 'ppa:mhier/libboost-latest'
+        packages:
+        - g++-8
+        - boost1.70
+  - os: linux
+    language: cpp
+    compiler: gcc
+    env: COMPILER="g++-8" CXX_STANDARD=17 TOML_HEAD=ON
    addons:
      apt:
        sources:
@@ -65,7 +89,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-3.7" CXX_STANDARD=11
+    env: COMPILER="clang++-3.7" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
@@ -79,7 +103,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-4.0" CXX_STANDARD=11
+    env: COMPILER="clang++-4.0" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
@@ -93,7 +117,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-5.0" CXX_STANDARD=11
+    env: COMPILER="clang++-5.0" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
@@ -107,7 +131,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-6.0" CXX_STANDARD=11
+    env: COMPILER="clang++-6.0" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
@@ -121,7 +145,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-7" CXX_STANDARD=11
+    env: COMPILER="clang++-7" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
@@ -135,7 +159,7 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-8" CXX_STANDARD=11
+    env: COMPILER="clang++-8" CXX_STANDARD=11 TOML_HEAD=OFF
    addons:
      apt:
        sources:
@@ -149,7 +173,35 @@ matrix:
  - os: linux
    language: cpp
    compiler: clang
-    env: COMPILER="clang++-8" CXX_STANDARD=17
+    env: COMPILER="clang++-8" CXX_STANDARD=11 TOML_HEAD=ON
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-8
+        - sourceline: 'ppa:mhier/libboost-latest'
+        packages:
+        - g++-8
+        - clang-8
+        - boost1.70
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-8" CXX_STANDARD=17 TOML_HEAD=OFF
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-trusty-8
+        - sourceline: 'ppa:mhier/libboost-latest'
+        packages:
+        - clang-8
+        - g++-8
+        - boost1.70
+  - os: linux
+    language: cpp
+    compiler: clang
+    env: COMPILER="clang++-8" CXX_STANDARD=17 TOML_HEAD=ON
    addons:
      apt:
        sources:
@@ -179,6 +231,6 @@ script:
 - mkdir build
 - cd build
 - git clone https://github.com/toml-lang/toml.git
- cmake -DCMAKE_CXX_COMPILER=$COMPILER -DCMAKE_CXX_STANDARD=$CXX_STANDARD ..
+- cmake -DCMAKE_CXX_COMPILER=$COMPILER -DCMAKE_CXX_STANDARD=$CXX_STANDARD -DTOML11_USE_UNRELEASED_TOML_FEATURES=${TOML_HEAD} ..
 - make
 - ctest --output-on-failure
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,9 +3,9 @@ enable_testing()

 project(toml11)

-set(toml11_VERSION_MAYOR  2)
-set(toml11_VERSION_MINOR  4)
-set(toml11_VERSION_PATCH  0)
+set(toml11_VERSION_MAYOR  3)
+set(toml11_VERSION_MINOR  0)
+set(toml11_VERSION_PATCH  1)
 set(toml11_VERSION
  "${toml11_VERSION_MAYOR}.${toml11_VERSION_MINOR}.${toml11_VERSION_PATCH}"
 )
--- a/README.md
+++ b/README.md
@@ -22,7 +22,7 @@ You can see the error messages about invalid files and serialization results of
 ## Example

 ```cpp
-#include <toml11/toml.hpp>
+#include <toml.hpp>
 #include <iostream>

 int main()
@@ -47,8 +47,9 @@ int main()
 - [Decoding a toml file](#decoding-a-toml-file)
  - [In the case of syntax error](#in-the-case-of-syntax-error)
  - [Invalid UTF-8 Codepoints](#invalid-utf-8-codepoints)
- [Finding a toml value](#finding-a-toml-value-from-a-table)
-  - [In the case of type error](#in-the-case-of-type-error)
+- [Finding a toml value](#finding-a-toml-value)
+  - [Finding a value in a table](#finding-a-value-in-a-table)
+  - [In case of error](#in-case-of-error)
  - [Dotted keys](#dotted-keys)
 - [Casting a toml value](#casting-a-toml-value)
 - [Checking value type](#checking-value-type)
@@ -69,6 +70,7 @@ int main()
 - [Formatting user-defined error messages](#formatting-user-defined-error-messages)
 - [Serializing TOML data](#serializing-toml-data)
 - [Underlying types](#underlying-types)
+- [Unreleased TOML features](#unreleased-toml-features)
 - [Breaking Changes from v2](#breaking-changes-from-v2)
 - [Running Tests](#running-tests)
 - [Contributors](#contributors)
@@ -101,19 +103,19 @@ to pass a filename to the `toml::parse` function.

 ```cpp
 const std::string fname("sample.toml");
-const toml::table data = toml::parse(fname);
+const toml::value data = toml::parse(fname);
 ```

 If it encounters an error while opening a file, it will throw `std::runtime_error`.

 You can also pass a `std::istream` to the  `toml::parse` function.
-To show a filename in an error message, it is recommended to pass the filename
-with the stream.
+To show a filename in an error message, however, it is recommended to pass the
+filename with the stream.

 ```cpp
 std::ifstream ifs("sample.toml", std::ios_base::binary);
 assert(ifs.good());
-const auto data = toml::parse(ifs, /*optional*/ "sample.toml");
+const auto data = toml::parse(ifs, /*optional -> */ "sample.toml");
 ```

 **Note**: When you are **on Windows, open a file in binary mode**.
@@ -185,7 +187,7 @@ representing unicode character is not a valid UTF-8 codepoint.
   |                              ^--------- should be in [0x00..0x10FFFF]
 ```

-## Finding a toml value from a table
+## Finding a toml value

 After parsing successfully, you can obtain the values from the result of
 `toml::parse` using `toml::find` function.
@@ -196,8 +198,6 @@ answer  = 42
 pi      = 3.14
 numbers = [1,2,3]
 time    = 1979-05-27T07:32:00Z
-[tab]
-key = "value"
 ```

 ``` cpp
@@ -206,23 +206,16 @@ const auto answer    = toml::find<std::int64_t    >(data, "answer");
 const auto pi        = toml::find<double          >(data, "pi");
 const auto numbers   = toml::find<std::vector<int>>(data, "numbers");
 const auto timepoint = toml::find<std::chrono::system_clock::time_point>(data, "time");
-const auto tab       = toml::find<toml::table>(data, "tab");
-const auto key       = toml::find<std::string>(tab,  "key");
 ```

-If the value does not exist, `toml::find` throws an error with the location of
-the table.
+By default, `toml::find` returns a `toml::value`.

-```console
-terminate called after throwing an instance of 'std::out_of_range'
-  what():  [error] key "answer" not found
- --> example.toml
- 6 | [tab]
-   | ~~~~~ in this table
+```cpp
+const toml::value& answer = toml::find(data, "answer");
 ```

 When you pass an exact TOML type that does not require type conversion,
-`toml::get` returns a reference without copying the value.
+`toml::find` returns a reference without copying the value.

 ```cpp
 const auto  data   = toml::parse("sample.toml");
@@ -232,12 +225,6 @@ const auto& answer = toml::find<toml::integer>(data, "answer");
 If the specified type requires conversion, you can't take a reference to the value.
 See also [underlying types](#underlying-types).

-By default, `toml::find` returns a `toml::value`.
-
-```cpp
-const toml::value& answer = toml::find(data, "answer");
-```
-
 **NOTE**: For some technical reason, automatic conversion between `integer` and
 `floating` is not supported. If you want to get a floating value even if a value
 has integer value, you need to convert it manually after obtaining a value,
@@ -250,24 +237,59 @@ double x = vx.is_floating() ? vx.as_floating(std::nothrow) :
                                                 // floating nor integer.
 ```

----
+### Finding a value in a table

-`toml::find` accepts arbitrary number of keys to find a value buried in a
-deep recursion of tables.
+There are several way to get a value defined in a table.
+First, you can get a table as a normal value and find a value from the table.

-```cpp
-// # expecting the following example.toml
-// answer.to.the.ultimate.question = 42
-// # is equivalent to {"answer": {"to":{"the":{"ultimate:{"question":42}}}}}
-
-const toml::table data = toml::parse("example.toml");
-const int a = toml::find<int>(data, "answer", "to", "the", "ultimate", "question");
+```toml
+[fruit]
+name = "apple"
+[fruit.physical]
+color = "red"
+shape = "round"
 ```

-Of course, alternatively, you can call `toml::find` as many as you need.
-But it is a bother.
+``` cpp
+const auto  data  = toml::parse("fruit.toml");
+const auto& fruit = toml::find(data, "fruit");
+const auto  name  = toml::find<std::string>(fruit, "apple");

-### In the case of type error
+const auto& physical = toml::find(fruit, "physical");
+const auto  color    = toml::find<std::string>(fruit, "color");
+const auto  shape    = toml::find<std::string>(fruit, "shape");
+```
+
+Here, variable `fruit` is a `toml::value` and can be used as the first argument
+of `toml::find`.
+
+Second, you can pass as many arguments as the number of subtables to `toml::find`.
+
+```cpp
+const auto data  = toml::parse("fruit.toml");
+const auto color = toml::find<std::string>(data, "fruit", "physical", "color");
+const auto shape = toml::find<std::string>(data, "fruit", "physical", "shape");
+```
+
+### In case of error
+
+If the value does not exist, `toml::find` throws an error with the location of
+the table.
+
+```console
+terminate called after throwing an instance of 'std::out_of_range'
+  what():  [error] key "answer" not found
+ --> example.toml
+ 6 | [tab]
+   | ~~~~~ in this table
+```
+
+**Note**: It is recommended to find a table as `toml::value` because it has much information
+compared to `toml::table`, which is an alias of
+`std::unordered_map<std::string, toml::value>`. Since `toml::table` does not have
+any information about toml file, such as where the table was defined in the file.
+
+----

 If the specified type differs from the actual value contained, it throws
 `toml::type_error` that inherits `std::exception`.
@@ -310,13 +332,14 @@ shape = "round"
 You can get both of the above tables with the same c++ code.

 ```cpp
-const auto physical = toml::find<toml::table>(data, "physical");
+const auto physical = toml::find(data, "physical");
 const auto color    = toml::find<std::string>(physical, "color");
 ```

 The following code does not work for the above toml file.

 ```cpp
+// XXX this does not work!
 const auto color = toml::find<std::string>(data, "physical.color");
 ```

@@ -349,18 +372,22 @@ contain one of the following types.
  - It depends. See [customizing containers](#customizing-containers) for detail.

 To get a value inside, you can use `toml::get<T>()`. The usage is the same as
-`toml::find<T>` (actually, `toml::find` internally uses `toml::get`).
+`toml::find<T>` (actually, `toml::find` internally uses `toml::get` after casting
+a value to `toml::table`).

 ``` cpp
 const toml::value  data    = toml::parse("sample.toml");
-const toml::value  answer_ = toml::get<toml::table >(data).at("answer")
+const toml::value  answer_ = toml::get<toml::table >(data).at("answer");
 const std::int64_t answer  = toml::get<std::int64_t>(answer_);
 ```

 When you pass an exact TOML type that does not require type conversion,
-`toml::get` returns a reference through which you can modify the content.
+`toml::get` returns a reference through which you can modify the content
+(if the `toml::value` is `const`, it returns `const` reference).

 ```cpp
+toml::value   data    = toml::parse("sample.toml");
+toml::value   answer_ = toml::get<toml::table >(data).at("answer");
 toml::integer& answer = toml::get<toml::integer>(answer_);
 answer = 6 * 9; // write to data.answer. now `answer_` contains 54.
 ```
@@ -427,7 +454,21 @@ class value {
 } // toml
 ```

+### `at()`

+You can access to the element of a table and an array by `toml::basic_value::at`.
+
+```cpp
+const toml::value v{1,2,3,4,5};
+std::cout << v.at(2).as_integer() << std::endl; // 3
+
+const toml::value v{{"foo", 42}, {"bar", 3.14}};
+std::cout << v.at("foo").as_integer() << std::endl; // 42
+```
+
+If an invalid key (integer for a table, string for an array), it throws
+`toml::type_error` for the conversion. If the provided key is out-of-range,
+it throws `std::out_of_range`.

 ## Checking value type

@@ -909,10 +950,17 @@ const auto data = toml::parse<
    >("example.toml");
 ```

-__NOTE__: Needless to say, the result types from `toml::parse(...)` and
+Needless to say, the result types from `toml::parse(...)` and
 `toml::parse<Com, Map, Cont>(...)` are different (unless you specify the same
 types as default).

+Note that, since `toml::table` and `toml::array` is an alias for a table and an
+array of a default `toml::value`, so it is different from the types actually
+contained in a `toml::basic_value` when you customize containers.
+To get the actual type in a generic way, use
+`typename toml::basic_type<C, T, A>::table_type` and
+`typename toml::basic_type<C, T, A>::array_type`.
+
 ## TOML literal

 toml11 supports `"..."_toml` literal.
@@ -945,7 +993,6 @@ inline namespace literals
 inline namespace toml_literals
 {
 toml::value operator"" _toml(const char* str, std::size_t len);
-
 } // toml_literals
 } // literals
 } // toml
@@ -1044,7 +1091,7 @@ namespace toml
 template<>
 struct from<ext::foo>
 {
-    ext::foo from_toml(const value& v)
+    static ext::foo from_toml(const value& v)
    {
        ext::foo f;
        f.a = find<int        >(v, "a");
@@ -1084,7 +1131,7 @@ template<>
 struct from<ext::foo>
 {
    template<typename C, template<typename ...> class M, template<typename ...> class A>
-    ext::foo from_toml(const basic_value<C, M, A>& v)
+    static ext::foo from_toml(const basic_value<C, M, A>& v)
    {
        ext::foo f;
        f.a = find<int        >(v, "a");
@@ -1140,7 +1187,7 @@ namespace toml
 template<>
 struct into<ext::foo>
 {
-    toml::table into_toml(const ext::foo& f)
+    static toml::table into_toml(const ext::foo& f)
    {
        return toml::table{{"a", f.a}, {"b", f.b}, {"c", f.c}};
    }
@@ -1237,7 +1284,7 @@ const toml::source_location loc = v.location();
 toml11 enables you to serialize data into toml format.

 ```cpp
-const auto data = toml::table{{"foo", 42}, {"bar", "baz"}};
+const toml::value data{{"foo", 42}, {"bar", "baz"}};
 std::cout << data << std::endl;
 // bar = "baz"
 // foo = 42
@@ -1247,11 +1294,11 @@ toml11 automatically makes a small table and small array inline.
 You can specify the width to make them inline by `std::setw` for streams.

 ```cpp
-const auto data = toml::table{
-    {"qux",    toml::table{{"foo", 42}, {"bar", "baz"}}},
-    {"quux",   toml::array{"small", "array", "of", "strings"}},
-    {"foobar", toml::array{"this", "array", "of", "strings", "is", "too", "long",
-                           "to", "print", "into", "single", "line", "isn't", "it?"}},
+const toml::value data{
+    {"qux",    {{"foo", 42}, {"bar", "baz"}}},
+    {"quux",   {"small", "array", "of", "strings"}},
+    {"foobar", {"this", "array", "of", "strings", "is", "too", "long",
+                "to", "print", "into", "single", "line", "isn't", "it?"}},
 };

 // the threshold becomes 80.
@@ -1290,7 +1337,7 @@ To control the precision of floating point numbers, you need to pass
 `std::setprecision` to stream.

 ```cpp
-const auto data = toml::table{
+const toml::value data{
    {"pi", 3.141592653589793},
    {"e",  2.718281828459045}
 };
@@ -1356,6 +1403,9 @@ are used. See [Customizing containers](#customizing-containers) for detail.
 flag that represents a kind of a string, `string_t::basic` and `string_t::literal`.
 Although `std::string` is not an exact toml type, still you can get a reference
 that points to internal `std::string` by using `toml::get<std::string>()` for convenience.
+The most important difference between `std::string` and `toml::string` is that
+`toml::string` will be formatted as a TOML string when outputed with `ostream`.
+This feature is introduced to make it easy to write a custom serializer.

 `Datetime` variants are `struct` that are defined in this library.
 Because `std::chrono::system_clock::time_point` is a __time point__,
@@ -1363,6 +1413,16 @@ not capable of representing a Local Time independent from a specific day.

 It is recommended to get `datetime`s as `std::chrono` classes through `toml::get`.

+## Unreleased TOML features
+
+There are some unreleased features in toml-lang/toml:master.
+Currently, the following features are available after defining
+`TOML11_USE_UNRELEASED_TOML_FEATURES` macro flag.
+
+- Leading zeroes in exponent parts of floats are permitted.
+  - e.g. `1.0e+01`, `5e+05`
+- Allow raw tab characters in basic strings and multi-line basic strings.
+
 ## Breaking Changes from v2

 Although toml11 is relatively new library (it's three years old now), it had
@@ -1384,8 +1444,12 @@ Between v2 and v3, those interfaces are rearranged.
  - See [Casting a toml::value](#casting-a-tomlvalue) and [Checking value type](#checking-value-type) for detail.
 - An overload of `toml::find` for `toml::table` has been dropped. Use `toml::value` version instead.
  - Because type conversion between a table and a value causes ambiguity while overload resolution
+  - Since `toml::parse` now returns a `toml::value`, this feature becomes less important.
  - Also because `toml::table` is a normal STL container, implementing utility function is easy.
-  - See [Finding a toml::value](#finding-a-tomlvalue) for detail.
+  - See [Finding a toml::value](#finding-a-toml-value) for detail.
+- An overload of `operator<<` and `toml::format` for `toml::table`s are dropped.
+  - Use `toml::value` instead.
+  - See [Serializing TOML data](#serializing-toml-data) for detail.
 - Interface around comments.
  - See [Preserving Comments](#preserving-comments) for detail.
 - An ancient `from_toml/into_toml` has been removed. Use arbitrary type conversion support.
@@ -1428,6 +1492,8 @@ I appreciate the help of the contributors who introduced the great feature to th
  - Fixed warnings while type conversion
 - @KerstinKeller
  - Added installation script to CMake
+- J.C. Moyer (@jcmoyer)
+  - Fixed an example code in the documentation

 ## Licensing terms

--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,5 +1,6 @@
 set(TEST_NAMES
    test_datetime
+    test_string
    test_utility
    test_result
    test_traits
@@ -49,6 +50,14 @@ if(COMPILER_SUPPORTS_WPEDANTIC)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wpedantic")
 endif()

+option(TOML11_USE_UNRELEASED_TOML_FEATURES
+    "use features in toml-lang/toml master while testing" OFF)
+
+if(TOML11_USE_UNRELEASED_TOML_FEATURES)
+    message(STATUS "adding TOML11_USE_UNRELEASED_TOML_FEATURES flag")
+    add_definitions("-DTOML11_USE_UNRELEASED_TOML_FEATURES")
+endif()
+
 # Disable some MSVC warnings
 if(MSVC)
    # conversion from 'double' to 'unsigned int', possible loss of data
--- a/tests/check_serialization.cpp
+++ b/tests/check_serialization.cpp
@@ -0,0 +1,57 @@
+#include "toml.hpp"
+#include <iostream>
+#include <iomanip>
+
+int main(int argc, char **argv)
+{
+    if(argc != 2)
+    {
+        std::cerr << "usage: ./check [filename]" << std::endl;
+        return 1;
+    }
+
+    const std::string filename(argv[1]);
+
+    {
+        const auto data = toml::parse(filename);
+        {
+            std::ofstream ofs("tmp.toml");
+            ofs << std::setprecision(16) << std::setw(80) << data;
+        }
+        const auto serialized = toml::parse("tmp.toml");
+
+        if(data != serialized)
+        {
+            std::cerr << "============================================================\n";
+            std::cerr << "result (w/o comment) different: " << filename << std::endl;
+            std::cerr << "------------------------------------------------------------\n";
+            std::cerr << "# serialized\n";
+            std::cerr << serialized;
+            std::cerr << "------------------------------------------------------------\n";
+            std::cerr << "# data\n";
+            std::cerr << data;
+            return 1;
+        }
+    }
+    {
+        const auto data = toml::parse<toml::preserve_comments>(filename);
+        {
+            std::ofstream ofs("tmp.toml");
+            ofs << std::setprecision(16) << std::setw(80) << data;
+        }
+        const auto serialized = toml::parse<toml::preserve_comments>("tmp.toml");
+        if(data != serialized)
+        {
+            std::cerr << "============================================================\n";
+            std::cerr << "result (w/  comment) different: " << filename << std::endl;
+            std::cerr << "------------------------------------------------------------\n";
+            std::cerr << "# serialized\n";
+            std::cerr << serialized;
+            std::cerr << "------------------------------------------------------------\n";
+            std::cerr << "# data\n";
+            std::cerr << data;
+            return 1;
+        }
+    }
+    return 0;
+}
--- a/tests/test_comments.cpp
+++ b/tests/test_comments.cpp
@@ -460,3 +460,55 @@ BOOST_AUTO_TEST_CASE(test_overwrite_comments)
        BOOST_TEST(u.as_integer() == 42);
    }
 }
+
+BOOST_AUTO_TEST_CASE(test_output_comments)
+{
+    using value_type = toml::basic_value<toml::preserve_comments>;
+    {
+        const value_type v(42, {"comment1", "comment2"});
+        std::ostringstream oss;
+        oss << v.comments();
+
+        std::ostringstream ref;
+        ref << "#comment1\n";
+        ref << "#comment2\n";
+
+        BOOST_TEST(oss.str() == ref.str());
+    }
+    {
+        const value_type v(42, {"comment1", "comment2"});
+        std::ostringstream oss;
+
+        // If v is not a table, toml11 assumes that user is writing something
+        // like the following.
+
+        oss << "answer = " << v;
+
+        BOOST_TEST(oss.str() == "answer = 42 #comment1comment2");
+    }
+
+    {
+        const value_type v(42, {"comment1", "comment2"});
+        std::ostringstream oss;
+
+        // If v is not a table, toml11 assumes that user is writing something
+        // like the following.
+
+        oss << toml::nocomment << "answer = " << v;
+
+        BOOST_TEST(oss.str() == "answer = 42");
+    }
+
+    {
+        const value_type v(42, {"comment1", "comment2"});
+        std::ostringstream oss;
+
+        // If v is not a table, toml11 assumes that user is writing something
+        // like the following.
+
+        oss << toml::nocomment << toml::showcomment << "answer = " << v;
+
+        BOOST_TEST(oss.str() == "answer = 42 #comment1comment2");
+    }
+
+}
--- a/tests/test_extended_conversions.cpp
+++ b/tests/test_extended_conversions.cpp
@@ -33,6 +33,17 @@ struct bar
        return toml::table{{"a", this->a}, {"b", this->b}};
    }
 };
+
+struct baz
+{
+    int a;
+    std::string b;
+};
+struct qux
+{
+    int a;
+    std::string b;
+};
 } // extlib

 namespace toml
@@ -54,6 +65,24 @@ struct into<extlib::foo>
        return toml::table{{"a", f.a}, {"b", f.b}};
    }
 };
+
+template<>
+struct from<extlib::baz>
+{
+    static extlib::baz from_toml(const toml::value& v)
+    {
+        return extlib::baz{toml::find<int>(v, "a"), toml::find<std::string>(v, "b")};
+    }
+};
+
+template<>
+struct into<extlib::qux>
+{
+    static toml::table into_toml(const extlib::qux& f)
+    {
+        return toml::table{{"a", f.a}, {"b", f.b}};
+    }
+};
 } // toml

 // ---------------------------------------------------------------------------
@@ -83,6 +112,16 @@ struct bar
        return toml::table{{"a", this->a}, {"b", this->b}};
    }
 };
+struct baz
+{
+    int a;
+    std::string b;
+};
+struct qux
+{
+    int a;
+    std::string b;
+};
 } // extlib2

 namespace toml
@@ -105,6 +144,28 @@ struct into<extlib2::foo>
        return toml::table{{"a", f.a}, {"b", f.b}};
    }
 };
+
+template<>
+struct from<extlib2::baz>
+{
+    template<typename C, template<typename ...> class M, template<typename ...> class A>
+    static extlib2::baz from_toml(const toml::basic_value<C, M, A>& v)
+    {
+        return extlib2::baz{toml::find<int>(v, "a"), toml::find<std::string>(v, "b")};
+    }
+};
+
+template<>
+struct into<extlib2::qux>
+{
+    static toml::basic_value<toml::preserve_comments, std::map>
+    into_toml(const extlib2::qux& f)
+    {
+        return toml::basic_value<toml::preserve_comments, std::map>{
+            {"a", f.a}, {"b", f.b}
+        };
+    }
+};
 } // toml

 // ---------------------------------------------------------------------------
@@ -188,6 +249,41 @@ BOOST_AUTO_TEST_CASE(test_conversion_by_specialization)
    }
 }

+BOOST_AUTO_TEST_CASE(test_conversion_one_way)
+{
+    {
+        const toml::value v{{"a", 42}, {"b", "baz"}};
+
+        const auto baz = toml::get<extlib::baz>(v);
+        BOOST_TEST(baz.a == 42);
+        BOOST_TEST(baz.b == "baz");
+    }
+    {
+        const extlib::qux q{42, "qux"};
+        const toml::value v(q);
+
+        BOOST_TEST(toml::find<int>(v, "a")         == 42);
+        BOOST_TEST(toml::find<std::string>(v, "b") == "qux");
+    }
+
+    {
+        const toml::basic_value<toml::discard_comments, std::map> v{
+            {"a", 42}, {"b", "baz"}
+        };
+
+        const auto baz = toml::get<extlib2::baz>(v);
+        BOOST_TEST(baz.a == 42);
+        BOOST_TEST(baz.b == "baz");
+    }
+    {
+        const extlib::qux q{42, "qux"};
+        const toml::basic_value<toml::preserve_comments, std::map> v(q);
+
+        BOOST_TEST(toml::find<int>(v, "a")         == 42);
+        BOOST_TEST(toml::find<std::string>(v, "b") == "qux");
+    }
+}
+
 BOOST_AUTO_TEST_CASE(test_recursive_conversion)
 {
    {
--- a/tests/test_find.cpp
+++ b/tests/test_find.cpp
@@ -27,6 +27,32 @@ using test_value_types = std::tuple<

 BOOST_AUTO_TEST_CASE(test_find_throws)
 {
+    // -----------------------------------------------------------------------
+    // const-reference version
+    {
+        // value is not a table
+        const toml::value v(true);
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(v, "key"), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not the expected type
+        const toml::value v{{"key", 42}};
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(v, "key"), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not found
+        const toml::value v{{"key", 42}};
+        BOOST_CHECK_THROW(toml::find<toml::integer>(v, "different_key"),
+                          std::out_of_range);
+    }
+    {
+        // the positive control.
+        const toml::value v{{"key", 42}};
+        BOOST_TEST(42 == toml::find<int>(v, "key"));
+    }
+
+    // -----------------------------------------------------------------------
+    // reference version
    {
        // value is not a table
        toml::value v(true);
@@ -48,6 +74,31 @@ BOOST_AUTO_TEST_CASE(test_find_throws)
        toml::value v{{"key", 42}};
        BOOST_TEST(42 == toml::find<int>(v, "key"));
    }
+
+    // -----------------------------------------------------------------------
+    // move version
+
+    {
+        // value is not a table
+        toml::value v(true);
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(std::move(v), "key"), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not the expected type
+        toml::value v{{"key", 42}};
+        BOOST_CHECK_THROW(toml::find<toml::boolean>(std::move(v), "key"), toml::type_error);
+    }
+    {
+        // the value corresponding to the key is not found
+        toml::value v{{"key", 42}};
+        BOOST_CHECK_THROW(toml::find<toml::integer>(std::move(v), "different_key"),
+                          std::out_of_range);
+    }
+    {
+        // the positive control.
+        toml::value v{{"key", 42}};
+        BOOST_TEST(42 == toml::find<int>(std::move(v), "key"));
+    }
 }

 BOOST_AUTO_TEST_CASE(test_find_recursive)
@@ -74,6 +125,9 @@ BOOST_AUTO_TEST_CASE(test_find_recursive)
        auto& num2 = toml::find<toml::integer>(v, a, b, c, d);
        num2 = 42;
        BOOST_TEST(42 == toml::find<int>(v, a, b, c, d));
+
+        auto num3 = toml::find<toml::integer>(std::move(v), a, b, c, d);
+        BOOST_TEST(42 == num3);
    }
 }

@@ -85,6 +139,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)

        toml::find<toml::boolean>(v, "key") = false;
        BOOST_TEST(false == toml::find<toml::boolean>(v, "key"));
+
+        const auto moved = toml::find<toml::boolean>(std::move(v), "key");
+        BOOST_TEST(false == moved);
    }
    {
        value_type v{{"key", 42}};
@@ -92,6 +149,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)

        toml::find<toml::integer>(v, "key") = 54;
        BOOST_TEST(toml::integer(54) == toml::find<toml::integer>(v, "key"));
+
+        const auto moved = toml::find<toml::integer>(std::move(v), "key");
+        BOOST_TEST(toml::integer(54) == moved);
    }
    {
        value_type v{{"key", 3.14}};
@@ -99,6 +159,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)

        toml::find<toml::floating>(v, "key") = 2.71;
        BOOST_TEST(toml::floating(2.71) == toml::find<toml::floating>(v, "key"));
+
+        const auto moved = toml::find<toml::floating>(std::move(v), "key");
+        BOOST_TEST(toml::floating(2.71) == moved);
    }
    {
        value_type v{{"key", "foo"}};
@@ -108,6 +171,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        toml::find<toml::string>(v, "key").str += "bar";
        BOOST_TEST(toml::string("foobar", toml::string_t::basic) ==
                          toml::find<toml::string>(v, "key"));
+
+        const auto moved = toml::find<toml::string>(std::move(v), "key");
+        BOOST_TEST(toml::string("foobar", toml::string_t::basic) == moved);
    }
    {
        value_type v{{"key", value_type("foo", toml::string_t::literal)}};
@@ -117,6 +183,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        toml::find<toml::string>(v, "key").str += "bar";
        BOOST_TEST(toml::string("foobar", toml::string_t::literal) ==
                          toml::find<toml::string>(v, "key"));
+
+        const auto moved = toml::find<toml::string>(std::move(v), "key");
+        BOOST_TEST(toml::string("foobar", toml::string_t::literal) == moved);
    }
    {
        toml::local_date d(2018, toml::month_t::Apr, 22);
@@ -126,6 +195,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        toml::find<toml::local_date>(v, "key").year = 2017;
        d.year = 2017;
        BOOST_CHECK(d == toml::find<toml::local_date>(v, "key"));
+
+        const auto moved = toml::find<toml::local_date>(std::move(v), "key");
+        BOOST_CHECK(d == moved);
    }
    {
        toml::local_time t(12, 30, 45);
@@ -135,6 +207,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        toml::find<toml::local_time>(v, "key").hour = 9;
        t.hour = 9;
        BOOST_CHECK(t == toml::find<toml::local_time>(v, "key"));
+
+        const auto moved = toml::find<toml::local_time>(std::move(v), "key");
+        BOOST_CHECK(t == moved);
    }
    {
        toml::local_datetime dt(toml::local_date(2018, toml::month_t::Apr, 22),
@@ -145,6 +220,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        toml::find<toml::local_datetime>(v, "key").date.year = 2017;
        dt.date.year = 2017;
        BOOST_CHECK(dt == toml::find<toml::local_datetime>(v, "key"));
+
+        const auto moved = toml::find<toml::local_datetime>(std::move(v), "key");
+        BOOST_CHECK(dt == moved);
    }
    {
        toml::offset_datetime dt(toml::local_datetime(
@@ -156,6 +234,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        toml::find<toml::offset_datetime>(v, "key").date.year = 2017;
        dt.date.year = 2017;
        BOOST_CHECK(dt == toml::find<toml::offset_datetime>(v, "key"));
+
+        const auto moved = toml::find<toml::offset_datetime>(std::move(v), "key");
+        BOOST_CHECK(dt == moved);
    }
    {
        typename value_type::array_type vec;
@@ -171,6 +252,10 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)

        const bool result2 = (vec == toml::find<typename value_type::array_type>(v, "key"));
        BOOST_CHECK(result2);
+
+        const auto moved = toml::find<typename value_type::array_type>(std::move(v), "key");
+        const bool result3 = (vec == moved);
+        BOOST_CHECK(result3);
    }
    {
        typename value_type::table_type tab;
@@ -184,6 +269,10 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        tab["key3"] = value_type(123);
        const bool result2 = (tab == toml::find<typename value_type::table_type>(v, "key"));
        BOOST_CHECK(result2);
+
+        const auto moved = toml::find<typename value_type::table_type>(std::move(v), "key");
+        const bool result3 = (tab == moved);
+        BOOST_CHECK(result3);
    }
    {
        value_type v1(42);
@@ -193,6 +282,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_exact, value_type, test_value_types)
        value_type v2(54);
        toml::find(v, "key") = v2;
        BOOST_CHECK(v2 == toml::find(v, "key"));
+
+        const auto moved = toml::find(std::move(v), "key");
+        BOOST_CHECK(v2 == moved);
    }
 }

@@ -200,15 +292,16 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_integer_type, value_type, test_value_typ
 {
    {
        value_type v{{"key", 42}};
-        BOOST_TEST(int(42) ==           toml::find<int          >(v, "key"));
-        BOOST_TEST(short(42) ==         toml::find<short        >(v, "key"));
-        BOOST_TEST(char(42) ==          toml::find<char         >(v, "key"));
-        BOOST_TEST(unsigned(42) ==      toml::find<unsigned     >(v, "key"));
-        BOOST_TEST(long(42) ==          toml::find<long         >(v, "key"));
-        BOOST_TEST(std::int64_t(42) ==  toml::find<std::int64_t >(v, "key"));
+        BOOST_TEST(int(42)           == toml::find<int          >(v, "key"));
+        BOOST_TEST(short(42)         == toml::find<short        >(v, "key"));
+        BOOST_TEST(char(42)          == toml::find<char         >(v, "key"));
+        BOOST_TEST(unsigned(42)      == toml::find<unsigned     >(v, "key"));
+        BOOST_TEST(long(42)          == toml::find<long         >(v, "key"));
+        BOOST_TEST(std::int64_t(42)  == toml::find<std::int64_t >(v, "key"));
        BOOST_TEST(std::uint64_t(42) == toml::find<std::uint64_t>(v, "key"));
-        BOOST_TEST(std::int16_t(42) ==  toml::find<std::int16_t >(v, "key"));
+        BOOST_TEST(std::int16_t(42)  == toml::find<std::int16_t >(v, "key"));
        BOOST_TEST(std::uint16_t(42) == toml::find<std::uint16_t>(v, "key"));
+        BOOST_TEST(std::uint16_t(42) == toml::find<std::uint16_t>(std::move(v), "key"));
    }
 }

@@ -219,6 +312,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_floating_type, value_type, test_value_ty
        BOOST_TEST(static_cast<float      >(3.14) == toml::find<float      >(v, "key"));
        BOOST_TEST(static_cast<double     >(3.14) == toml::find<double     >(v, "key"));
        BOOST_TEST(static_cast<long double>(3.14) == toml::find<long double>(v, "key"));
+        BOOST_TEST(static_cast<float      >(3.14) == toml::find<float      >(std::move(v), "key"));
    }
 }

@@ -236,6 +330,11 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_string_type, value_type, test_value_type
        toml::find<std::string>(v, "key") += "bar";
        BOOST_TEST("foobar" == toml::find<std::string>(v, "key"));
    }
+    {
+        value_type v{{"key", toml::string("foo", toml::string_t::literal)}};
+        const auto moved = toml::find<std::string>(std::move(v), "key");
+        BOOST_TEST("foo" == moved);
+    }

 #if __cplusplus >= 201703L
    {
@@ -292,6 +391,53 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_array, value_type, test_value_types
    BOOST_TEST(2.71 == pr.second);
 }

+BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_move_toml_array, value_type, test_value_types)
+{
+    value_type v1{{"key", {42, 54, 69, 72}}};
+    value_type v2{{"key", {42, 54, 69, 72}}};
+    value_type v3{{"key", {42, 54, 69, 72}}};
+    value_type v4{{"key", {42, 54, 69, 72}}};
+    value_type v5{{"key", {42, 54, 69, 72}}};
+
+    const std::vector<int>         vec = toml::find<std::vector<int>>(std::move(v1), "key");
+    const std::list<short>         lst = toml::find<std::list<short>>(std::move(v2), "key");
+    const std::deque<std::int64_t> deq = toml::find<std::deque<std::int64_t>>(std::move(v3), "key");
+
+    BOOST_TEST(42 == vec.at(0));
+    BOOST_TEST(54 == vec.at(1));
+    BOOST_TEST(69 == vec.at(2));
+    BOOST_TEST(72 == vec.at(3));
+
+    std::list<short>::const_iterator iter = lst.begin();
+    BOOST_TEST(static_cast<short>(42) == *(iter++));
+    BOOST_TEST(static_cast<short>(54) == *(iter++));
+    BOOST_TEST(static_cast<short>(69) == *(iter++));
+    BOOST_TEST(static_cast<short>(72) == *(iter++));
+
+    BOOST_TEST(static_cast<std::int64_t>(42) == deq.at(0));
+    BOOST_TEST(static_cast<std::int64_t>(54) == deq.at(1));
+    BOOST_TEST(static_cast<std::int64_t>(69) == deq.at(2));
+    BOOST_TEST(static_cast<std::int64_t>(72) == deq.at(3));
+
+    std::array<int, 4> ary = toml::find<std::array<int, 4>>(std::move(v4), "key");
+    BOOST_TEST(static_cast<int>(42) == ary.at(0));
+    BOOST_TEST(static_cast<int>(54) == ary.at(1));
+    BOOST_TEST(static_cast<int>(69) == ary.at(2));
+    BOOST_TEST(static_cast<int>(72) == ary.at(3));
+
+    std::tuple<int, short, unsigned, long> tpl =
+        toml::find<std::tuple<int, short, unsigned, long>>(std::move(v5), "key");
+    BOOST_TEST(static_cast<int     >(42) == std::get<0>(tpl));
+    BOOST_TEST(static_cast<short   >(54) == std::get<1>(tpl));
+    BOOST_TEST(static_cast<unsigned>(69) == std::get<2>(tpl));
+    BOOST_TEST(static_cast<long    >(72) == std::get<3>(tpl));
+
+    value_type p{{"key", {3.14, 2.71}}};
+    std::pair<double, double> pr = toml::find<std::pair<double, double> >(std::move(p), "key");
+    BOOST_TEST(3.14 == pr.first);
+    BOOST_TEST(2.71 == pr.second);
+}
+
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_array_of_array, value_type, test_value_types)
 {
    value_type v1{42, 54, 69, 72};
@@ -323,62 +469,153 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_array_of_array, value_type, test_va
    BOOST_TEST(std::get<1>(t).at(2) == "baz");
 }

+BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_move_toml_array_of_array, value_type, test_value_types)
+{
+    value_type a1{42, 54, 69, 72};
+    value_type a2{"foo", "bar", "baz"};
+    value_type v1{{"key", {a1, a2}}};
+    value_type v2{{"key", {a1, a2}}};
+
+    std::pair<std::vector<int>, std::vector<std::string>> p =
+        toml::find<std::pair<std::vector<int>, std::vector<std::string>>>(std::move(v1), "key");
+
+    BOOST_TEST(p.first.at(0) == 42);
+    BOOST_TEST(p.first.at(1) == 54);
+    BOOST_TEST(p.first.at(2) == 69);
+    BOOST_TEST(p.first.at(3) == 72);
+
+    BOOST_TEST(p.second.at(0) == "foo");
+    BOOST_TEST(p.second.at(1) == "bar");
+    BOOST_TEST(p.second.at(2) == "baz");
+
+    std::tuple<std::vector<int>, std::vector<std::string>> t =
+        toml::find<std::tuple<std::vector<int>, std::vector<std::string>>>(std::move(v2), "key");
+
+    BOOST_TEST(std::get<0>(t).at(0) == 42);
+    BOOST_TEST(std::get<0>(t).at(1) == 54);
+    BOOST_TEST(std::get<0>(t).at(2) == 69);
+    BOOST_TEST(std::get<0>(t).at(3) == 72);
+
+    BOOST_TEST(std::get<1>(t).at(0) == "foo");
+    BOOST_TEST(std::get<1>(t).at(1) == "bar");
+    BOOST_TEST(std::get<1>(t).at(2) == "baz");
+}
+
+
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_table, value_type, test_value_types)
 {
-    value_type v1{{"key", {
-            {"key1", 1}, {"key2", 2}, {"key3", 3}, {"key4", 4}
-        }}};
-    const auto v = toml::find<std::map<std::string, int>>(v1, "key");
-    BOOST_TEST(v.at("key1") == 1);
-    BOOST_TEST(v.at("key2") == 2);
-    BOOST_TEST(v.at("key3") == 3);
-    BOOST_TEST(v.at("key4") == 4);
+    {
+        value_type v1{{"key", {
+                {"key1", 1}, {"key2", 2}, {"key3", 3}, {"key4", 4}
+            }}};
+        const auto v = toml::find<std::map<std::string, int>>(v1, "key");
+        BOOST_TEST(v.at("key1") == 1);
+        BOOST_TEST(v.at("key2") == 2);
+        BOOST_TEST(v.at("key3") == 3);
+        BOOST_TEST(v.at("key4") == 4);
+    }
+    {
+        value_type v1{{"key", {
+                {"key1", 1}, {"key2", 2}, {"key3", 3}, {"key4", 4}
+            }}};
+        const auto v = toml::find<std::map<std::string, int>>(std::move(v1), "key");
+        BOOST_TEST(v.at("key1") == 1);
+        BOOST_TEST(v.at("key2") == 2);
+        BOOST_TEST(v.at("key3") == 3);
+        BOOST_TEST(v.at("key4") == 4);
+    }
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_local_date, value_type, test_value_types)
 {
-    value_type v1{{"key", toml::local_date{2018, toml::month_t::Apr, 1}}};
-    const auto date = std::chrono::system_clock::to_time_t(
-            toml::find<std::chrono::system_clock::time_point>(v1, "key"));
+    {
+        value_type v1{{"key", toml::local_date{2018, toml::month_t::Apr, 1}}};
+        const auto date = std::chrono::system_clock::to_time_t(
+                toml::find<std::chrono::system_clock::time_point>(v1, "key"));

-    std::tm t;
-    t.tm_year = 2018 - 1900;
-    t.tm_mon  = 4    - 1;
-    t.tm_mday = 1;
-    t.tm_hour = 0;
-    t.tm_min  = 0;
-    t.tm_sec  = 0;
-    t.tm_isdst = -1;
-    const auto c = std::mktime(&t);
-    BOOST_TEST(c == date);
+        std::tm t;
+        t.tm_year = 2018 - 1900;
+        t.tm_mon  = 4    - 1;
+        t.tm_mday = 1;
+        t.tm_hour = 0;
+        t.tm_min  = 0;
+        t.tm_sec  = 0;
+        t.tm_isdst = -1;
+        const auto c = std::mktime(&t);
+        BOOST_TEST(c == date);
+    }
+    {
+        value_type v1{{"key", toml::local_date{2018, toml::month_t::Apr, 1}}};
+        const auto date = std::chrono::system_clock::to_time_t(
+                toml::find<std::chrono::system_clock::time_point>(std::move(v1), "key"));
+
+        std::tm t;
+        t.tm_year = 2018 - 1900;
+        t.tm_mon  = 4    - 1;
+        t.tm_mday = 1;
+        t.tm_hour = 0;
+        t.tm_min  = 0;
+        t.tm_sec  = 0;
+        t.tm_isdst = -1;
+        const auto c = std::mktime(&t);
+        BOOST_TEST(c == date);
+    }
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_local_time, value_type, test_value_types)
 {
-    value_type v1{{"key", toml::local_time{12, 30, 45}}};
-    const auto time = toml::find<std::chrono::seconds>(v1, "key");
-    BOOST_CHECK(time == std::chrono::hours(12) +
-                        std::chrono::minutes(30) + std::chrono::seconds(45));
+    {
+        value_type v1{{"key", toml::local_time{12, 30, 45}}};
+        const auto time = toml::find<std::chrono::seconds>(v1, "key");
+        BOOST_CHECK(time == std::chrono::hours(12) +
+                            std::chrono::minutes(30) + std::chrono::seconds(45));
+    }
+    {
+        value_type v1{{"key", toml::local_time{12, 30, 45}}};
+        const auto time = toml::find<std::chrono::seconds>(std::move(v1), "key");
+        BOOST_CHECK(time == std::chrono::hours(12) +
+                            std::chrono::minutes(30) + std::chrono::seconds(45));
+    }
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_toml_local_datetime, value_type, test_value_types)
 {
-    value_type v1{{"key", toml::local_datetime(
-                toml::local_date{2018, toml::month_t::Apr, 1},
-                toml::local_time{12, 30, 45})}};
+    {
+        value_type v1{{"key", toml::local_datetime(
+                    toml::local_date{2018, toml::month_t::Apr, 1},
+                    toml::local_time{12, 30, 45})}};

-    const auto date = std::chrono::system_clock::to_time_t(
-            toml::find<std::chrono::system_clock::time_point>(v1, "key"));
-    std::tm t;
-    t.tm_year = 2018 - 1900;
-    t.tm_mon  = 4    - 1;
-    t.tm_mday = 1;
-    t.tm_hour = 12;
-    t.tm_min  = 30;
-    t.tm_sec  = 45;
-    t.tm_isdst = -1;
-    const auto c = std::mktime(&t);
-    BOOST_TEST(c == date);
+        const auto date = std::chrono::system_clock::to_time_t(
+                toml::find<std::chrono::system_clock::time_point>(v1, "key"));
+        std::tm t;
+        t.tm_year = 2018 - 1900;
+        t.tm_mon  = 4    - 1;
+        t.tm_mday = 1;
+        t.tm_hour = 12;
+        t.tm_min  = 30;
+        t.tm_sec  = 45;
+        t.tm_isdst = -1;
+        const auto c = std::mktime(&t);
+        BOOST_TEST(c == date);
+    }
+    {
+        value_type v1{{"key", toml::local_datetime(
+                    toml::local_date{2018, toml::month_t::Apr, 1},
+                    toml::local_time{12, 30, 45})}};
+
+        const auto date = std::chrono::system_clock::to_time_t(
+                toml::find<std::chrono::system_clock::time_point>(std::move(v1), "key"));
+        std::tm t;
+        t.tm_year = 2018 - 1900;
+        t.tm_mon  = 4    - 1;
+        t.tm_mday = 1;
+        t.tm_hour = 12;
+        t.tm_min  = 30;
+        t.tm_sec  = 45;
+        t.tm_isdst = -1;
+        const auto c = std::mktime(&t);
+        BOOST_TEST(c == date);
+    }
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_offset_datetime, value_type, test_value_types)
@@ -428,5 +665,28 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_offset_datetime, value_type, test_va
        BOOST_TEST(tm.tm_min ==           30);
        BOOST_TEST(tm.tm_sec ==            0);
    }
+
+    {
+        value_type v1{{"key", toml::offset_datetime(
+                    toml::local_date{2018, toml::month_t::Apr, 1},
+                    toml::local_time{12, 30, 0},
+                    toml::time_offset{-8, 0})}};
+        //    2018-04-01T12:30:00-08:00
+        // == 2018-04-01T20:30:00Z
+
+        const auto date = toml::find<std::chrono::system_clock::time_point>(std::move(v1), "key");
+        const auto timet = std::chrono::system_clock::to_time_t(date);
+
+        // get time_t as gmtime (2018-04-01T03:30:00Z)
+        const auto tmp = std::gmtime(std::addressof(timet)); // XXX not threadsafe!
+        BOOST_CHECK(tmp);
+        const auto tm = *tmp;
+        BOOST_TEST(tm.tm_year + 1900 == 2018);
+        BOOST_TEST(tm.tm_mon  + 1 ==       4);
+        BOOST_TEST(tm.tm_mday ==           1);
+        BOOST_TEST(tm.tm_hour ==          20);
+        BOOST_TEST(tm.tm_min ==           30);
+        BOOST_TEST(tm.tm_sec ==            0);
+    }
 }

--- a/tests/test_find_or.cpp
+++ b/tests/test_find_or.cpp
@@ -121,6 +121,55 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_or_exact, value_type, test_value_types)
 }
 #undef TOML11_TEST_FIND_OR_EXACT

+#define TOML11_TEST_FIND_OR_MOVE(toml_type, init_expr, opt_expr)   \
+    {                                                              \
+        using namespace test;                                      \
+        const toml::toml_type init init_expr ;                     \
+        toml::toml_type opt  opt_expr ;                            \
+        value_type v{{"key", init}};                               \
+        BOOST_TEST(init != opt);                                   \
+        const auto moved = toml::find_or(std::move(v), "key", std::move(opt));\
+        BOOST_TEST(init == moved);                                 \
+    }                                                              \
+    /**/
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_or_move, value_type, test_value_types)
+{
+    TOML11_TEST_FIND_OR_MOVE(boolean,         ( true), (false))
+    TOML11_TEST_FIND_OR_MOVE(integer,         (   42), (   54))
+    TOML11_TEST_FIND_OR_MOVE(floating,        ( 3.14), ( 2.71))
+    TOML11_TEST_FIND_OR_MOVE(string,          ("foo"), ("bar"))
+    TOML11_TEST_FIND_OR_MOVE(local_time,      (12, 30, 45), (6, 0, 30))
+    TOML11_TEST_FIND_OR_MOVE(local_date,      (2019, toml::month_t::Apr, 1),
+                                              (1999, toml::month_t::Jan, 2))
+    TOML11_TEST_FIND_OR_MOVE(local_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30))
+            )
+    TOML11_TEST_FIND_OR_MOVE(offset_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45), toml::time_offset( 9, 0)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30), toml::time_offset(-3, 0))
+            )
+    {
+        typename value_type::array_type init{1,2,3,4,5};
+        typename value_type::array_type opt {6,7,8,9,10};
+        value_type v{{"key", init}};
+        BOOST_TEST(init != opt);
+        const auto moved = toml::find_or(std::move(v), "key", std::move(opt));
+        BOOST_TEST(init == moved);
+    }
+    {
+        typename value_type::table_type init{{"key1", 42}, {"key2", "foo"}};
+        typename value_type::table_type opt {{"key1", 54}, {"key2", "bar"}};
+        value_type v{{"key", init}};
+        BOOST_TEST(init != opt);
+        const auto moved = toml::find_or(std::move(v), "key", std::move(opt));
+        BOOST_TEST(init == moved);
+    }
+}
+#undef TOML11_TEST_FIND_OR_MOVE
+
+
 #define TOML11_TEST_FIND_OR_MODIFY(toml_type, init_expr, opt_expr)\
    {                                                             \
        using namespace test;                                     \
@@ -304,10 +353,20 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_find_or_fallback, value_type, test_value_type
 BOOST_AUTO_TEST_CASE(test_find_or_integer)
 {
    {
-        toml::value v = toml::table{{"num", 42}};
+        toml::value v{{"num", 42}};
        BOOST_TEST(42u == toml::find_or(v, "num", 0u));
        BOOST_TEST(0u ==  toml::find_or(v, "foo", 0u));
    }
+    {
+        toml::value v{{"num", 42}};
+        const auto moved = toml::find_or(std::move(v), "num", 0u);
+        BOOST_TEST(42u == moved);
+    }
+    {
+        toml::value v{{"num", 42}};
+        const auto moved = toml::find_or(std::move(v), "foo", 0u);
+        BOOST_TEST(0u ==  moved);
+    }
 }

 BOOST_AUTO_TEST_CASE(test_find_or_floating)
@@ -318,6 +377,14 @@ BOOST_AUTO_TEST_CASE(test_find_or_floating)
        BOOST_TEST(2.71f == toml::find_or(v1, "key", 2.71f));
        BOOST_TEST(static_cast<float>(double(3.14)) == toml::find_or(v2, "key", 2.71f));
    }
+    {
+        toml::value v1{{"key", 42}};
+        toml::value v2{{"key", 3.14}};
+        const auto moved1 = toml::find_or(std::move(v1), "key", 2.71f);
+        const auto moved2 = toml::find_or(std::move(v2), "key", 2.71f);
+        BOOST_TEST(2.71f == moved1);
+        BOOST_TEST(static_cast<float>(double(3.14)) == moved2);
+    }
 }

 BOOST_AUTO_TEST_CASE(test_find_or_string)
@@ -345,6 +412,32 @@ BOOST_AUTO_TEST_CASE(test_find_or_string)
        s1 = "bazqux"; // restoring moved value
        BOOST_TEST("bazqux" == toml::find_or(std::move(v2), "key", std::move(s1)));
    }
+    {
+        toml::value v1 = toml::table{{"key", "foobar"}};
+        toml::value v2 = toml::table{{"key", 42}};
+
+        std::string s1("bazqux");
+
+        const auto moved1 = toml::find_or(std::move(v1), "key", s1);
+        const auto moved2 = toml::find_or(std::move(v2), "key", s1);
+
+        BOOST_TEST("foobar" == moved1);
+        BOOST_TEST("bazqux" == moved2);
+    }
+    {
+        toml::value v1 = toml::table{{"key", "foobar"}};
+        toml::value v2 = toml::table{{"key", 42}};
+
+        std::string s1("bazqux");
+        std::string s2("bazqux");
+
+        const auto moved1 = toml::find_or(std::move(v1), "key", std::move(s1));
+        const auto moved2 = toml::find_or(std::move(v2), "key", std::move(s2));
+
+        BOOST_TEST("foobar" == moved1);
+        BOOST_TEST("bazqux" == moved2);
+    }
+
    // string literal
    {
        toml::value v1 = toml::table{{"key", "foobar"}};
@@ -357,4 +450,90 @@ BOOST_AUTO_TEST_CASE(test_find_or_string)
        BOOST_TEST("foobar" == toml::find_or(v1, "key", lit));
        BOOST_TEST("bazqux" == toml::find_or(v2, "key", lit));
    }
+    {
+        toml::value v1 = toml::table{{"key", "foobar"}};
+        toml::value v2 = toml::table{{"key",42}};
+
+        const auto moved1 = toml::find_or(std::move(v1), "key", "bazqux");
+        const auto moved2 = toml::find_or(std::move(v2), "key", "bazqux");
+
+        BOOST_TEST("foobar" == moved1);
+        BOOST_TEST("bazqux" == moved2);
+    }
+    {
+        toml::value v1 = toml::table{{"key", "foobar"}};
+        toml::value v2 = toml::table{{"key",42}};
+
+        const char* lit = "bazqux";
+        const auto moved1 = toml::find_or(std::move(v1), "key", lit);
+        const auto moved2 = toml::find_or(std::move(v2), "key", lit);
+
+        BOOST_TEST("foobar" == moved1);
+        BOOST_TEST("bazqux" == moved2);
+    }
+
+}
+
+BOOST_AUTO_TEST_CASE(test_find_or_map)
+{
+    using map_type = std::map<std::string, std::string>;
+    {
+        const toml::value v1{
+            {"key", {{"key", "value"}}}
+        };
+
+        const auto key  = toml::find_or(v1, "key",  map_type{});
+        const auto key2 = toml::find_or(v1, "key2", map_type{});
+
+        BOOST_TEST(!key.empty());
+        BOOST_TEST(key2.empty());
+
+        BOOST_TEST(key.size()    == 1u);
+        BOOST_TEST(key.at("key") == "value");
+    }
+    {
+        toml::value v1{
+            {"key", {{"key", "value"}}}
+        };
+
+        const auto key  = toml::find_or<map_type>(v1, "key",  map_type{});
+        const auto key2 = toml::find_or<map_type>(v1, "key2", map_type{});
+
+        BOOST_TEST(!key.empty());
+        BOOST_TEST(key2.empty());
+
+        BOOST_TEST(key.size()    == 1u);
+        BOOST_TEST(key.at("key") == "value");
+    }
+
+    {
+        toml::value v1{
+            {"key", {{"key", "value"}}}
+        };
+        toml::value v2(v1);
+
+        const auto key  = toml::find_or(std::move(v1), "key",  map_type{});
+        const auto key2 = toml::find_or(std::move(v2), "key2", map_type{});
+
+        BOOST_TEST(!key.empty());
+        BOOST_TEST(key2.empty());
+
+        BOOST_TEST(key.size()    == 1u);
+        BOOST_TEST(key.at("key") == "value");
+    }
+    {
+        toml::value v1{
+            {"key", {{"key", "value"}}}
+        };
+        toml::value v2(v1);
+
+        const auto key  = toml::find_or<map_type>(std::move(v1), "key",  map_type{});
+        const auto key2 = toml::find_or<map_type>(std::move(v2), "key2", map_type{});
+
+        BOOST_TEST(!key.empty());
+        BOOST_TEST(key2.empty());
+
+        BOOST_TEST(key.size()    == 1u);
+        BOOST_TEST(key.at("key") == "value");
+    }
 }
--- a/tests/test_format_error.cpp
+++ b/tests/test_format_error.cpp
@@ -6,6 +6,7 @@
 #include <boost/test/included/unit_test.hpp>
 #endif
 #include <toml.hpp>
+#include <iostream>

 // to check it successfully compiles. it does not check the formatted string.

--- a/tests/test_get.cpp
+++ b/tests/test_get.cpp
@@ -31,6 +31,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)

        toml::get<toml::boolean>(v) = false;
        BOOST_TEST(false == toml::get<toml::boolean>(v));
+
+        toml::boolean x = toml::get<toml::boolean>(std::move(v));
+        BOOST_TEST(false == x);
    }
    {
        value_type v(42);
@@ -38,6 +41,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)

        toml::get<toml::integer>(v) = 54;
        BOOST_TEST(toml::integer(54) == toml::get<toml::integer>(v));
+
+        toml::integer x = toml::get<toml::integer>(std::move(v));
+        BOOST_TEST(toml::integer(54) == x);
    }
    {
        value_type v(3.14);
@@ -45,6 +51,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)

        toml::get<toml::floating>(v) = 2.71;
        BOOST_TEST(toml::floating(2.71) == toml::get<toml::floating>(v));
+
+        toml::floating x = toml::get<toml::floating>(std::move(v));
+        BOOST_TEST(toml::floating(2.71) == x);
    }
    {
        value_type v("foo");
@@ -54,6 +63,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<toml::string>(v).str += "bar";
        BOOST_TEST(toml::string("foobar", toml::string_t::basic) ==
                          toml::get<toml::string>(v));
+
+        toml::string x = toml::get<toml::string>(std::move(v));
+        BOOST_TEST(toml::string("foobar") == x);
    }
    {
        value_type v("foo", toml::string_t::literal);
@@ -63,6 +75,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<toml::string>(v).str += "bar";
        BOOST_TEST(toml::string("foobar", toml::string_t::literal) ==
                          toml::get<toml::string>(v));
+
+        toml::string x = toml::get<toml::string>(std::move(v));
+        BOOST_TEST(toml::string("foobar", toml::string_t::literal) == x);
    }
    {
        toml::local_date d(2018, toml::month_t::Apr, 22);
@@ -72,6 +87,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<toml::local_date>(v).year = 2017;
        d.year = 2017;
        BOOST_TEST(d == toml::get<toml::local_date>(v));
+
+        toml::local_date x = toml::get<toml::local_date>(std::move(v));
+        BOOST_TEST(d == x);
    }
    {
        toml::local_time t(12, 30, 45);
@@ -81,6 +99,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<toml::local_time>(v).hour = 9;
        t.hour = 9;
        BOOST_TEST(t == toml::get<toml::local_time>(v));
+
+        toml::local_time x = toml::get<toml::local_time>(std::move(v));
+        BOOST_TEST(t == x);
    }
    {
        toml::local_datetime dt(toml::local_date(2018, toml::month_t::Apr, 22),
@@ -91,6 +112,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<toml::local_datetime>(v).date.year = 2017;
        dt.date.year = 2017;
        BOOST_TEST(dt == toml::get<toml::local_datetime>(v));
+
+        toml::local_datetime x = toml::get<toml::local_datetime>(std::move(v));
+        BOOST_TEST(dt == x);
    }
    {
        toml::offset_datetime dt(toml::local_datetime(
@@ -102,6 +126,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<toml::offset_datetime>(v).date.year = 2017;
        dt.date.year = 2017;
        BOOST_TEST(dt == toml::get<toml::offset_datetime>(v));
+
+        toml::offset_datetime x = toml::get<toml::offset_datetime>(std::move(v));
+        BOOST_TEST(dt == x);
    }
    {
        using array_type = typename value_type::array_type;
@@ -114,6 +141,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<array_type>(v).push_back(value_type(123));
        vec.push_back(value_type(123));
        BOOST_TEST(vec == toml::get<array_type>(v));
+
+        array_type x = toml::get<array_type>(std::move(v));
+        BOOST_TEST(vec == x);
    }
    {
        using table_type = typename value_type::table_type;
@@ -126,6 +156,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        toml::get<table_type>(v)["key3"] = value_type(123);
        tab["key3"] = value_type(123);
        BOOST_TEST(tab == toml::get<table_type>(v));
+
+        table_type x = toml::get<table_type>(std::move(v));
+        BOOST_TEST(tab == x);
    }
    {
        value_type v1(42);
@@ -134,6 +167,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_exact, value_type, test_value_types)
        value_type v2(54);
        toml::get<value_type>(v1) = v2;
        BOOST_TEST(v2 == toml::get<value_type>(v1));
+
+        value_type x = toml::get<value_type>(std::move(v1));
+        BOOST_TEST(v2 == x);
    }
 }

@@ -150,6 +186,8 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_integer_type, value_type, test_value_type
        BOOST_TEST(std::uint64_t(42) == toml::get<std::uint64_t>(v));
        BOOST_TEST(std::int16_t(42) ==  toml::get<std::int16_t >(v));
        BOOST_TEST(std::uint16_t(42) == toml::get<std::uint16_t>(v));
+
+        BOOST_TEST(std::uint16_t(42) == toml::get<std::uint16_t>(std::move(v)));
    }
 }

@@ -160,6 +198,8 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_floating_type, value_type, test_value_typ
        BOOST_TEST(static_cast<float      >(3.14) == toml::get<float      >(v));
        BOOST_TEST(static_cast<double     >(3.14) == toml::get<double     >(v));
        BOOST_TEST(static_cast<long double>(3.14) == toml::get<long double>(v));
+
+        BOOST_TEST(3.14f == toml::get<float>(std::move(v)));
    }
 }

@@ -170,12 +210,18 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_string_type, value_type, test_value_types
        BOOST_TEST("foo" == toml::get<std::string>(v));
        toml::get<std::string>(v) += "bar";
        BOOST_TEST("foobar" == toml::get<std::string>(v));
+
+        const auto x = toml::get<std::string>(std::move(v));
+        BOOST_TEST("foobar" == x);
    }
    {
        value_type v("foo", toml::string_t::literal);
        BOOST_TEST("foo" == toml::get<std::string>(v));
        toml::get<std::string>(v) += "bar";
        BOOST_TEST("foobar" == toml::get<std::string>(v));
+
+        const auto x = toml::get<std::string>(std::move(v));
+        BOOST_TEST("foobar" == x);
    }

 #if __cplusplus >= 201703L
@@ -192,92 +238,176 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_string_type, value_type, test_value_types

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_array, value_type, test_value_types)
 {
-    const value_type v{42, 54, 69, 72};
+    {
+        const value_type v{42, 54, 69, 72};

-    const std::vector<int>         vec = toml::get<std::vector<int>>(v);
-    const std::list<short>         lst = toml::get<std::list<short>>(v);
-    const std::deque<std::int64_t> deq = toml::get<std::deque<std::int64_t>>(v);
+        const std::vector<int>         vec = toml::get<std::vector<int>>(v);
+        const std::list<short>         lst = toml::get<std::list<short>>(v);
+        const std::deque<std::int64_t> deq = toml::get<std::deque<std::int64_t>>(v);

-    BOOST_TEST(42 == vec.at(0));
-    BOOST_TEST(54 == vec.at(1));
-    BOOST_TEST(69 == vec.at(2));
-    BOOST_TEST(72 == vec.at(3));
+        BOOST_TEST(42 == vec.at(0));
+        BOOST_TEST(54 == vec.at(1));
+        BOOST_TEST(69 == vec.at(2));
+        BOOST_TEST(72 == vec.at(3));

-    std::list<short>::const_iterator iter = lst.begin();
-    BOOST_TEST(static_cast<short>(42) == *(iter++));
-    BOOST_TEST(static_cast<short>(54) == *(iter++));
-    BOOST_TEST(static_cast<short>(69) == *(iter++));
-    BOOST_TEST(static_cast<short>(72) == *(iter++));
+        std::list<short>::const_iterator iter = lst.begin();
+        BOOST_TEST(static_cast<short>(42) == *(iter++));
+        BOOST_TEST(static_cast<short>(54) == *(iter++));
+        BOOST_TEST(static_cast<short>(69) == *(iter++));
+        BOOST_TEST(static_cast<short>(72) == *(iter++));

-    BOOST_TEST(static_cast<std::int64_t>(42) == deq.at(0));
-    BOOST_TEST(static_cast<std::int64_t>(54) == deq.at(1));
-    BOOST_TEST(static_cast<std::int64_t>(69) == deq.at(2));
-    BOOST_TEST(static_cast<std::int64_t>(72) == deq.at(3));
+        BOOST_TEST(static_cast<std::int64_t>(42) == deq.at(0));
+        BOOST_TEST(static_cast<std::int64_t>(54) == deq.at(1));
+        BOOST_TEST(static_cast<std::int64_t>(69) == deq.at(2));
+        BOOST_TEST(static_cast<std::int64_t>(72) == deq.at(3));

-    std::array<int, 4> ary = toml::get<std::array<int, 4>>(v);
-    BOOST_TEST(static_cast<int>(42) == ary.at(0));
-    BOOST_TEST(static_cast<int>(54) == ary.at(1));
-    BOOST_TEST(static_cast<int>(69) == ary.at(2));
-    BOOST_TEST(static_cast<int>(72) == ary.at(3));
+        std::array<int, 4> ary = toml::get<std::array<int, 4>>(v);
+        BOOST_TEST(static_cast<int>(42) == ary.at(0));
+        BOOST_TEST(static_cast<int>(54) == ary.at(1));
+        BOOST_TEST(static_cast<int>(69) == ary.at(2));
+        BOOST_TEST(static_cast<int>(72) == ary.at(3));

-    std::tuple<int, short, unsigned, long> tpl =
-        toml::get<std::tuple<int, short, unsigned, long>>(v);
-    BOOST_TEST(static_cast<int     >(42) == std::get<0>(tpl));
-    BOOST_TEST(static_cast<short   >(54) == std::get<1>(tpl));
-    BOOST_TEST(static_cast<unsigned>(69) == std::get<2>(tpl));
-    BOOST_TEST(static_cast<long    >(72) == std::get<3>(tpl));
+        std::tuple<int, short, unsigned, long> tpl =
+            toml::get<std::tuple<int, short, unsigned, long>>(v);
+        BOOST_TEST(static_cast<int     >(42) == std::get<0>(tpl));
+        BOOST_TEST(static_cast<short   >(54) == std::get<1>(tpl));
+        BOOST_TEST(static_cast<unsigned>(69) == std::get<2>(tpl));
+        BOOST_TEST(static_cast<long    >(72) == std::get<3>(tpl));

-    const value_type p{3.14, 2.71};
-    std::pair<double, double> pr = toml::get<std::pair<double, double> >(p);
-    BOOST_TEST(3.14 == pr.first);
-    BOOST_TEST(2.71 == pr.second);
+        const value_type p{3.14, 2.71};
+        std::pair<double, double> pr = toml::get<std::pair<double, double> >(p);
+        BOOST_TEST(3.14 == pr.first);
+        BOOST_TEST(2.71 == pr.second);
+    }
+
+    {
+        value_type v{42, 54, 69, 72};
+        const std::vector<int> vec = toml::get<std::vector<int>>(std::move(v));
+        BOOST_TEST(42 == vec.at(0));
+        BOOST_TEST(54 == vec.at(1));
+        BOOST_TEST(69 == vec.at(2));
+        BOOST_TEST(72 == vec.at(3));
+    }
+    {
+        value_type v{42, 54, 69, 72};
+        const std::deque<int> deq = toml::get<std::deque<int>>(std::move(v));
+        BOOST_TEST(42 == deq.at(0));
+        BOOST_TEST(54 == deq.at(1));
+        BOOST_TEST(69 == deq.at(2));
+        BOOST_TEST(72 == deq.at(3));
+    }
+    {
+        value_type v{42, 54, 69, 72};
+        const std::list<int> lst = toml::get<std::list<int>>(std::move(v));
+        std::list<int>::const_iterator iter = lst.begin();
+        BOOST_TEST(42 == *(iter++));
+        BOOST_TEST(54 == *(iter++));
+        BOOST_TEST(69 == *(iter++));
+        BOOST_TEST(72 == *(iter++));
+    }
+    {
+        value_type v{42, 54, 69, 72};
+        std::array<int, 4> ary = toml::get<std::array<int, 4>>(std::move(v));
+        BOOST_TEST(static_cast<int>(42) == ary.at(0));
+        BOOST_TEST(static_cast<int>(54) == ary.at(1));
+        BOOST_TEST(static_cast<int>(69) == ary.at(2));
+        BOOST_TEST(static_cast<int>(72) == ary.at(3));
+    }
+    {
+        value_type v{42, 54, 69, 72};
+        std::tuple<int, short, unsigned, long> tpl =
+            toml::get<std::tuple<int, short, unsigned, long>>(std::move(v));
+        BOOST_TEST(static_cast<int     >(42) == std::get<0>(tpl));
+        BOOST_TEST(static_cast<short   >(54) == std::get<1>(tpl));
+        BOOST_TEST(static_cast<unsigned>(69) == std::get<2>(tpl));
+        BOOST_TEST(static_cast<long    >(72) == std::get<3>(tpl));
+    }
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_array_of_array, value_type, test_value_types)
 {
-    const value_type v1{42, 54, 69, 72};
-    const value_type v2{"foo", "bar", "baz"};
-    const value_type v{v1, v2};
+    {
+        const value_type v1{42, 54, 69, 72};
+        const value_type v2{"foo", "bar", "baz"};
+        const value_type v{v1, v2};

-    std::pair<std::vector<int>, std::vector<std::string>> p =
-        toml::get<std::pair<std::vector<int>, std::vector<std::string>>>(v);
+        std::pair<std::vector<int>, std::vector<std::string>> p =
+            toml::get<std::pair<std::vector<int>, std::vector<std::string>>>(v);

-    BOOST_TEST(p.first.at(0) == 42);
-    BOOST_TEST(p.first.at(1) == 54);
-    BOOST_TEST(p.first.at(2) == 69);
-    BOOST_TEST(p.first.at(3) == 72);
+        BOOST_TEST(p.first.size() == 4u);
+        BOOST_TEST(p.first.at(0) == 42);
+        BOOST_TEST(p.first.at(1) == 54);
+        BOOST_TEST(p.first.at(2) == 69);
+        BOOST_TEST(p.first.at(3) == 72);

-    BOOST_TEST(p.second.at(0) == "foo");
-    BOOST_TEST(p.second.at(1) == "bar");
-    BOOST_TEST(p.second.at(2) == "baz");
+        BOOST_TEST(p.second.size() == 3u);
+        BOOST_TEST(p.second.at(0) == "foo");
+        BOOST_TEST(p.second.at(1) == "bar");
+        BOOST_TEST(p.second.at(2) == "baz");

-    std::tuple<std::vector<int>, std::vector<std::string>> t =
-        toml::get<std::tuple<std::vector<int>, std::vector<std::string>>>(v);
+        std::tuple<std::vector<int>, std::vector<std::string>> t =
+            toml::get<std::tuple<std::vector<int>, std::vector<std::string>>>(v);

-    BOOST_TEST(std::get<0>(t).at(0) == 42);
-    BOOST_TEST(std::get<0>(t).at(1) == 54);
-    BOOST_TEST(std::get<0>(t).at(2) == 69);
-    BOOST_TEST(std::get<0>(t).at(3) == 72);
+        BOOST_TEST(std::get<0>(t).at(0) == 42);
+        BOOST_TEST(std::get<0>(t).at(1) == 54);
+        BOOST_TEST(std::get<0>(t).at(2) == 69);
+        BOOST_TEST(std::get<0>(t).at(3) == 72);

-    BOOST_TEST(std::get<1>(t).at(0) == "foo");
-    BOOST_TEST(std::get<1>(t).at(1) == "bar");
-    BOOST_TEST(std::get<1>(t).at(2) == "baz");
+        BOOST_TEST(std::get<1>(t).at(0) == "foo");
+        BOOST_TEST(std::get<1>(t).at(1) == "bar");
+        BOOST_TEST(std::get<1>(t).at(2) == "baz");
+    }
+    {
+        const value_type v1{42, 54, 69, 72};
+        const value_type v2{"foo", "bar", "baz"};
+        value_type v{v1, v2};
+
+        std::pair<std::vector<int>, std::vector<std::string>> p =
+            toml::get<std::pair<std::vector<int>, std::vector<std::string>>>(std::move(v));
+
+        BOOST_TEST(p.first.size() == 4u);
+        BOOST_TEST(p.first.at(0) == 42);
+        BOOST_TEST(p.first.at(1) == 54);
+        BOOST_TEST(p.first.at(2) == 69);
+        BOOST_TEST(p.first.at(3) == 72);
+
+        BOOST_TEST(p.second.size() == 3u);
+        BOOST_TEST(p.second.at(0) == "foo");
+        BOOST_TEST(p.second.at(1) == "bar");
+        BOOST_TEST(p.second.at(2) == "baz");
+    }
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_table, value_type, test_value_types)
 {
-    const value_type v1{
-            {"key1", 1},
-            {"key2", 2},
-            {"key3", 3},
-            {"key4", 4}
-        };
+    {
+        const value_type v1{
+                {"key1", 1},
+                {"key2", 2},
+                {"key3", 3},
+                {"key4", 4}
+            };
+
+        const auto v = toml::get<std::map<std::string, int>>(v1);
+        BOOST_TEST(v.at("key1") == 1);
+        BOOST_TEST(v.at("key2") == 2);
+        BOOST_TEST(v.at("key3") == 3);
+        BOOST_TEST(v.at("key4") == 4);
+    }
+    {
+        value_type v1{
+                {"key1", 1},
+                {"key2", 2},
+                {"key3", 3},
+                {"key4", 4}
+            };
+        const auto v = toml::get<std::map<std::string, int>>(std::move(v1));
+        BOOST_TEST(v.at("key1") == 1);
+        BOOST_TEST(v.at("key2") == 2);
+        BOOST_TEST(v.at("key3") == 3);
+        BOOST_TEST(v.at("key4") == 4);
+    }

-    const auto v = toml::get<std::map<std::string, int>>(v1);
-    BOOST_TEST(v.at("key1") == 1);
-    BOOST_TEST(v.at("key2") == 2);
-    BOOST_TEST(v.at("key3") == 3);
-    BOOST_TEST(v.at("key4") == 4);
 }

 BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_toml_local_date, value_type, test_value_types)
--- a/tests/test_get_or.cpp
+++ b/tests/test_get_or.cpp
@@ -25,6 +25,11 @@ using test_value_types = std::tuple<

 namespace test
 {
+// to compare result values in BOOST_TEST().
+//
+// BOOST_TEST outputs the expected and actual values. Thus it includes the
+// output stream operator inside. To compile it, we need operator<<s for
+// containers to compare.
 template<typename charT, typename traits, typename T, typename Alloc>
 std::basic_ostream<charT, traits>&
 operator<<(std::basic_ostream<charT, traits>& os, const std::vector<T, Alloc>& v)
@@ -121,6 +126,55 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_or_exact, value_type, test_value_types)
 }
 #undef TOML11_TEST_GET_OR_EXACT

+#define TOML11_TEST_GET_OR_MOVE_EXACT(toml_type, init_expr, opt_expr)\
+    {                                                                \
+        using namespace test;                                        \
+        const toml::toml_type init init_expr ;                       \
+        toml::toml_type       opt  opt_expr ;                        \
+        value_type v(init);                                          \
+        BOOST_TEST(init != opt);                                     \
+        const auto opt_ = toml::get_or(std::move(v), std::move(opt));\
+        BOOST_TEST(init == opt_);                                    \
+    }                                                                \
+    /**/
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_get_or_move, value_type, test_value_types)
+{
+    TOML11_TEST_GET_OR_MOVE_EXACT(boolean,         ( true), (false))
+    TOML11_TEST_GET_OR_MOVE_EXACT(integer,         (   42), (   54))
+    TOML11_TEST_GET_OR_MOVE_EXACT(floating,        ( 3.14), ( 2.71))
+    TOML11_TEST_GET_OR_MOVE_EXACT(string,          ("foo"), ("bar"))
+    TOML11_TEST_GET_OR_MOVE_EXACT(local_time,      (12, 30, 45), (6, 0, 30))
+    TOML11_TEST_GET_OR_MOVE_EXACT(local_date,      (2019, toml::month_t::Apr, 1),
+                                                   (1999, toml::month_t::Jan, 2))
+    TOML11_TEST_GET_OR_MOVE_EXACT(local_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30))
+            )
+    TOML11_TEST_GET_OR_MOVE_EXACT(offset_datetime,
+            (toml::local_date(2019, toml::month_t::Apr, 1), toml::local_time(12, 30, 45), toml::time_offset( 9, 0)),
+            (toml::local_date(1999, toml::month_t::Jan, 2), toml::local_time( 6,  0, 30), toml::time_offset(-3, 0))
+            )
+    {
+        const typename value_type::array_type init{1,2,3,4,5};
+        typename value_type::array_type opt {6,7,8,9,10};
+        value_type v(init);
+        BOOST_TEST(init != opt);
+        const auto opt_ = toml::get_or(std::move(v), std::move(opt));
+        BOOST_TEST(init == opt_);
+    }
+    {
+        const typename value_type::table_type init{{"key1", 42}, {"key2", "foo"}};
+        typename value_type::table_type opt {{"key1", 54}, {"key2", "bar"}};
+        value_type v(init);
+        BOOST_TEST(init != opt);
+        const auto opt_ = toml::get_or(std::move(v), std::move(opt));
+        BOOST_TEST(init == opt_);
+    }
+}
+#undef TOML11_TEST_GET_OR_MOVE_EXACT
+
+
 #define TOML11_TEST_GET_OR_MODIFY(toml_type, init_expr, opt_expr)\
    {                                                            \
        using namespace test;                                    \
@@ -309,6 +363,13 @@ BOOST_AUTO_TEST_CASE(test_get_or_integer)
        BOOST_TEST(42u == toml::get_or(v1, 0u));
        BOOST_TEST(0u ==  toml::get_or(v2, 0u));
    }
+    {
+        toml::value v1(42);
+        toml::value v2(3.14);
+        BOOST_TEST(42u == toml::get_or(std::move(v1), 0u));
+        BOOST_TEST(0u ==  toml::get_or(std::move(v2), 0u));
+    }
+
 }

 BOOST_AUTO_TEST_CASE(test_get_or_floating)
@@ -319,6 +380,12 @@ BOOST_AUTO_TEST_CASE(test_get_or_floating)
        BOOST_TEST(2.71f == toml::get_or(v1, 2.71f));
        BOOST_TEST(static_cast<float>(v2.as_floating()) == toml::get_or(v2, 2.71f));
    }
+    {
+        toml::value v1(42);
+        toml::value v2(3.14);
+        BOOST_TEST(2.71f                    == toml::get_or(std::move(v1), 2.71f));
+        BOOST_TEST(static_cast<float>(3.14) == toml::get_or(std::move(v2), 2.71f));
+    }
 }

 BOOST_AUTO_TEST_CASE(test_get_or_string)
@@ -345,7 +412,16 @@ BOOST_AUTO_TEST_CASE(test_get_or_string)
        BOOST_TEST("foobar" == toml::get_or(v1, std::move(s1)));
        BOOST_TEST("bazqux" == toml::get_or(v2, std::move(s1)));
    }
+    {
+        toml::value v1("foobar");
+        toml::value v2(42);

+        std::string       s1("bazqux");
+        const std::string s2("bazqux");
+
+        BOOST_TEST("foobar" == toml::get_or(std::move(v1), s1));
+        BOOST_TEST("bazqux" == toml::get_or(std::move(v2), s1));
+    }
    {
        toml::value v1("foobar");
        toml::value v2(42);
@@ -357,4 +433,20 @@ BOOST_AUTO_TEST_CASE(test_get_or_string)
        BOOST_TEST("foobar" == toml::get_or(v1, lit));
        BOOST_TEST("bazqux" == toml::get_or(v2, lit));
    }
+    {
+        toml::value v1("foobar");
+        toml::value v2(42);
+
+        BOOST_TEST("foobar" == toml::get_or(std::move(v1), "bazqux"));
+        BOOST_TEST("bazqux" == toml::get_or(std::move(v2), "bazqux"));
+    }
+    {
+        toml::value v1("foobar");
+        toml::value v2(42);
+
+        const char* lit = "bazqux";
+        BOOST_TEST("foobar" == toml::get_or(v1, lit));
+        BOOST_TEST("bazqux" == toml::get_or(v2, lit));
+    }
+
 }
--- a/tests/test_lex_floating.cpp
+++ b/tests/test_lex_floating.cpp
@@ -35,27 +35,35 @@ BOOST_AUTO_TEST_CASE(test_fractional_invalid)

 BOOST_AUTO_TEST_CASE(test_exponential_valid)
 {
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1e10",       "1e10");      
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1e+10",      "1e+10");     
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1e-10",      "1e-10");     
-    TOML11_TEST_LEX_ACCEPT(lex_float, "+1e10",      "+1e10");     
-    TOML11_TEST_LEX_ACCEPT(lex_float, "+1e+10",     "+1e+10");    
-    TOML11_TEST_LEX_ACCEPT(lex_float, "+1e-10",     "+1e-10");    
-    TOML11_TEST_LEX_ACCEPT(lex_float, "-1e10",      "-1e10");     
-    TOML11_TEST_LEX_ACCEPT(lex_float, "-1e+10",     "-1e+10");    
-    TOML11_TEST_LEX_ACCEPT(lex_float, "-1e-10",     "-1e-10");    
-    TOML11_TEST_LEX_ACCEPT(lex_float, "123e-10",    "123e-10");   
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1E10",       "1E10");      
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1E+10",      "1E+10");     
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1E-10",      "1E-10");     
-    TOML11_TEST_LEX_ACCEPT(lex_float, "123E-10",    "123E-10");   
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1_2_3E-10",  "1_2_3E-10"); 
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1e10",       "1e10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1e+10",      "1e+10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1e-10",      "1e-10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "+1e10",      "+1e10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "+1e+10",     "+1e+10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "+1e-10",     "+1e-10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "-1e10",      "-1e10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "-1e+10",     "-1e+10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "-1e-10",     "-1e-10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "123e-10",    "123e-10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1E10",       "1E10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1E+10",      "1E+10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1E-10",      "1E-10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "123E-10",    "123E-10");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1_2_3E-10",  "1_2_3E-10");
    TOML11_TEST_LEX_ACCEPT(lex_float, "1_2_3E-1_0", "1_2_3E-1_0");
+
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("testing an unreleased toml feature: leading zeroes in float exponent part");
+    // toml-lang/toml master permits leading 0s in exp part (unreleased)
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1_2_3E-01",  "1_2_3E-01");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1_2_3E-0_1", "1_2_3E-0_1");
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_exponential_invalid)
 {
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1e1E0", "1e1"); 
+    // accept partially
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1e1E0", "1e1");
    TOML11_TEST_LEX_ACCEPT(lex_float, "1E1e0", "1E1");
 }

@@ -64,12 +72,26 @@ BOOST_AUTO_TEST_CASE(test_both_valid)
    TOML11_TEST_LEX_ACCEPT(lex_float, "6.02e23",          "6.02e23");
    TOML11_TEST_LEX_ACCEPT(lex_float, "6.02e+23",         "6.02e+23");
    TOML11_TEST_LEX_ACCEPT(lex_float, "1.112_650_06e-17", "1.112_650_06e-17");
+
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("testing an unreleased toml feature: leading zeroes in float exponent part");
+    // toml-lang/toml master permits leading 0s in exp part (unreleased)
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1.0e-07",          "1.0e-07");
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_both_invalid)
 {
-    TOML11_TEST_LEX_ACCEPT(lex_float, "1e1.0",  "1e1");
    TOML11_TEST_LEX_REJECT(lex_float, "01e1.0");
+    // accept partially
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1e1.0",  "1e1");
+
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("testing an unreleased toml feature: leading zeroes in float exponent part");
+    // toml-lang/toml master permits leading 0s in exp part (unreleased)
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1.0e_01",  "1.0");
+    TOML11_TEST_LEX_ACCEPT(lex_float, "1.0e0__1", "1.0e0");
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_special_floating_point)
--- a/tests/test_literals.cpp
+++ b/tests/test_literals.cpp
@@ -45,6 +45,16 @@ BOOST_AUTO_TEST_CASE(test_file_as_literal)
            b = "baz"
        )"_toml;

+        BOOST_TEST(r == v);
+    }
+    {
+        const toml::value r{
+            {"array_of_tables", toml::array{toml::table{}}}
+        };
+        const toml::value v = u8R"(
+            [[array_of_tables]]
+        )"_toml;
+
        BOOST_TEST(r == v);
    }
 }
--- a/tests/test_parse_floating.cpp
+++ b/tests/test_parse_floating.cpp
@@ -68,6 +68,13 @@ BOOST_AUTO_TEST_CASE(test_exponential)
    TOML11_TEST_PARSE_EQUAL(parse_floating, "1_2_3E-1_0", 123e-10);
    TOML11_TEST_PARSE_EQUAL(parse_floating, "+0e0",        0.0);
    TOML11_TEST_PARSE_EQUAL(parse_floating, "-0e0",       -0.0);
+
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("testing an unreleased toml feature: leading zeroes in float exponent part");
+    // toml-lang/toml master permits leading 0s in exp part (unreleased)
+    TOML11_TEST_PARSE_EQUAL(parse_floating, "1_2_3E-01",  123e-1);
+    TOML11_TEST_PARSE_EQUAL(parse_floating, "1_2_3E-0_1", 123e-1);
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_exponential_value)
@@ -90,6 +97,13 @@ BOOST_AUTO_TEST_CASE(test_exponential_value)
    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "1_2_3E-1_0", value(123e-10));
    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "+0e0",       value( 0.0));
    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "-0e0",       value(-0.0));
+
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("testing an unreleased toml feature: leading zeroes in float exponent part");
+    // toml-lang/toml master permits leading 0s in exp part (unreleased)
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "1_2_3E-01",  value(123e-1));
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "1_2_3E-0_1", value(123e-1));
+#endif
 }
 BOOST_AUTO_TEST_CASE(test_fe)
 {
@@ -102,6 +116,12 @@ BOOST_AUTO_TEST_CASE(test_fe_vaule)
    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "6.02e23",          value(6.02e23));
    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "6.02e+23",         value(6.02e23));
    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "1.112_650_06e-17", value(1.11265006e-17));
+
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+    BOOST_TEST_MESSAGE("testing an unreleased toml feature: leading zeroes in float exponent part");
+    // toml-lang/toml master permits leading 0s in exp part (unreleased)
+    TOML11_TEST_PARSE_EQUAL_VALUE(parse_value<toml::value>, "3.141_5e-01",      value(3.1415e-1));
+#endif
 }

 BOOST_AUTO_TEST_CASE(test_inf)
--- a/tests/test_serialize_file.cpp
+++ b/tests/test_serialize_file.cpp
@@ -11,6 +11,39 @@
 #include <iostream>
 #include <fstream>

+template<typename Comment,
+         template<typename ...> class Table,
+         template<typename ...> class Array>
+bool has_comment_inside(const toml::basic_value<Comment, Table, Array>& v)
+{
+    if(!v.comments().empty())
+    {
+        return false;
+    }
+    // v itself does not have a comment.
+    if(v.is_array())
+    {
+        for(const auto& x : v.as_array())
+        {
+            if(has_comment_inside(x))
+            {
+                return false;
+            }
+        }
+    }
+    if(v.is_table())
+    {
+        for(const auto& x : v.as_table())
+        {
+            if(has_comment_inside(x.second))
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 BOOST_AUTO_TEST_CASE(test_example)
 {
    const auto data = toml::parse("toml/tests/example.toml");
@@ -37,12 +70,12 @@ BOOST_AUTO_TEST_CASE(test_example_map_dq)
    const auto data = toml::parse<toml::discard_comments, std::map, std::deque>(
            "toml/tests/example.toml");
    {
-        std::ofstream ofs("tmp1.toml");
+        std::ofstream ofs("tmp1_map_dq.toml");
        ofs << std::setw(80) << data;
    }

    auto serialized = toml::parse<toml::discard_comments, std::map, std::deque>(
-            "tmp1.toml");
+            "tmp1_map_dq.toml");
    {
        auto& owner = toml::find(serialized, "owner");
        auto& bio   = toml::find<std::string>(owner, "bio");
@@ -80,17 +113,46 @@ BOOST_AUTO_TEST_CASE(test_example_with_comment)
    }
 }

+BOOST_AUTO_TEST_CASE(test_example_with_comment_nocomment)
+{
+    {
+        const auto data = toml::parse<toml::preserve_comments>("toml/tests/example.toml");
+        {
+            std::ofstream ofs("tmp1_com_nocomment.toml");
+            ofs << std::setw(80) << toml::nocomment << data;
+        }
+        const auto serialized = toml::parse<toml::preserve_comments>("tmp1_com_nocomment.toml");
+        // check no comment exist
+        BOOST_TEST(!has_comment_inside(serialized));
+    }
+    {
+        const auto data_nocomment = toml::parse("toml/tests/example.toml");
+        auto serialized = toml::parse("tmp1_com_nocomment.toml");
+        {
+            auto& owner = toml::find(serialized, "owner");
+            auto& bio   = toml::find<std::string>(owner, "bio");
+            const auto CR = std::find(bio.begin(), bio.end(), '\r');
+            if(CR != bio.end())
+            {
+                bio.erase(CR);
+            }
+        }
+        // check collectly serialized
+        BOOST_TEST(data_nocomment == serialized);
+    }
+}
+
 BOOST_AUTO_TEST_CASE(test_example_with_comment_map_dq)
 {
    const auto data = toml::parse<toml::preserve_comments, std::map, std::deque>(
            "toml/tests/example.toml");
    {
-        std::ofstream ofs("tmp1_com.toml");
+        std::ofstream ofs("tmp1_com_map_dq.toml");
        ofs << std::setw(80) << data;
    }

    auto serialized = toml::parse<toml::preserve_comments, std::map, std::deque>(
-            "tmp1_com.toml");
+            "tmp1_com_map_dq.toml");
    {
        auto& owner = toml::find(serialized, "owner");
        auto& bio   = toml::find<std::string>(owner, "bio");
@@ -102,11 +164,38 @@ BOOST_AUTO_TEST_CASE(test_example_with_comment_map_dq)
    }
    BOOST_TEST(data == serialized);
    {
-        std::ofstream ofs("tmp1_com1.toml");
+        std::ofstream ofs("tmp1_com1_map_dq.toml");
        ofs << std::setw(80) << serialized;
    }
 }

+BOOST_AUTO_TEST_CASE(test_example_with_comment_map_dq_nocomment)
+{
+    {
+        const auto data = toml::parse<toml::preserve_comments, std::map, std::deque>("toml/tests/example.toml");
+        {
+            std::ofstream ofs("tmp1_com_map_dq_nocomment.toml");
+            ofs << std::setw(80) << toml::nocomment << data;
+        }
+        const auto serialized = toml::parse<toml::preserve_comments, std::map, std::deque>("tmp1_com_map_dq_nocomment.toml");
+        BOOST_TEST(!has_comment_inside(serialized));
+    }
+    {
+        const auto data_nocomment = toml::parse("toml/tests/example.toml");
+        auto serialized = toml::parse("tmp1_com_map_dq_nocomment.toml");
+        {
+            auto& owner = toml::find(serialized, "owner");
+            auto& bio   = toml::find<std::string>(owner, "bio");
+            const auto CR = std::find(bio.begin(), bio.end(), '\r');
+            if(CR != bio.end())
+            {
+                bio.erase(CR);
+            }
+        }
+        BOOST_TEST(data_nocomment == serialized);
+    }
+}
+
 BOOST_AUTO_TEST_CASE(test_fruit)
 {
    const auto data = toml::parse("toml/tests/fruit.toml");
@@ -194,3 +283,23 @@ BOOST_AUTO_TEST_CASE(test_hard_example_with_comment)
    }
    BOOST_TEST(data == serialized);
 }
+
+BOOST_AUTO_TEST_CASE(test_format_key)
+{
+    {
+        const toml::key key("normal_bare-key");
+        BOOST_TEST("normal_bare-key" == toml::format_key(key));
+    }
+    {
+        const toml::key key("key.include.dots");
+        BOOST_TEST("\"key.include.dots\"" == toml::format_key(key));
+    }
+    {
+        const toml::key key("key-include-unicode-\xE3\x81\x82");
+        BOOST_TEST("\"key-include-unicode-\xE3\x81\x82\"" == toml::format_key(key));
+    }
+    {
+        const toml::key key("special-chars-\\-\"-\b-\f-\r-\n-\t");
+        BOOST_TEST("\"special-chars-\\\\-\\\"-\\b-\\f-\\r-\\n-\\t\"" == toml::format_key(key));
+    }
+}
--- a/tests/test_string.cpp
+++ b/tests/test_string.cpp
@@ -0,0 +1,113 @@
+#define BOOST_TEST_MODULE "test_string"
+#include <boost/test/unit_test.hpp>
+#include <toml.hpp>
+
+BOOST_AUTO_TEST_CASE(test_basic_string)
+{
+    {
+        const toml::string str("basic string");
+        std::ostringstream oss;
+        oss << str;
+        BOOST_TEST(oss.str() == "\"basic string\"");
+    }
+    {
+        const std::string  s1 ("basic string");
+        const toml::string str(s1);
+        std::ostringstream oss;
+        oss << str;
+        BOOST_TEST(oss.str() == "\"basic string\"");
+    }
+    {
+        const toml::string str("basic string", toml::string_t::basic);
+        std::ostringstream oss;
+        oss << str;
+        BOOST_TEST(oss.str() == "\"basic string\"");
+    }
+    {
+        const std::string  s1 ("basic string");
+        const toml::string str(s1, toml::string_t::basic);
+        std::ostringstream oss;
+        oss << str;
+        BOOST_TEST(oss.str() == "\"basic string\"");
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_basic_ml_string)
+{
+    {
+        const toml::string str("basic\nstring");
+        std::ostringstream oss1;
+        oss1 << str;
+        std::ostringstream oss2;
+        oss2 << "\"\"\"\nbasic\nstring\\\n\"\"\"";
+        BOOST_TEST(oss1.str() == oss2.str());
+    }
+    {
+        const std::string  s1 ("basic\nstring");
+        const toml::string str(s1);
+        std::ostringstream oss1;
+        oss1 << str;
+        std::ostringstream oss2;
+        oss2 << "\"\"\"\nbasic\nstring\\\n\"\"\"";
+        BOOST_TEST(oss1.str() == oss2.str());
+    }
+    {
+        const toml::string str("basic\nstring", toml::string_t::basic);
+        std::ostringstream oss1;
+        oss1 << str;
+        std::ostringstream oss2;
+        oss2 << "\"\"\"\nbasic\nstring\\\n\"\"\"";
+        BOOST_TEST(oss1.str() == oss2.str());
+
+    }
+    {
+        const std::string  s1 ("basic\nstring");
+        const toml::string str(s1, toml::string_t::basic);
+        std::ostringstream oss1;
+        oss1 << str;
+        std::ostringstream oss2;
+        oss2 << "\"\"\"\nbasic\nstring\\\n\"\"\"";
+        BOOST_TEST(oss1.str() == oss2.str());
+    }
+}
+
+
+BOOST_AUTO_TEST_CASE(test_literal_string)
+{
+    {
+        const toml::string str("literal string", toml::string_t::literal);
+        std::ostringstream oss;
+        oss << str;
+        BOOST_TEST(oss.str() == "'literal string'");
+    }
+    {
+        const std::string  s1 ("literal string");
+        const toml::string str(s1, toml::string_t::literal);
+        std::ostringstream oss;
+        oss << str;
+        BOOST_TEST(oss.str() == "'literal string'");
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_literal_ml_string)
+{
+    {
+        const toml::string str("literal\nstring", toml::string_t::literal);
+        std::ostringstream oss1;
+        oss1 << str;
+        std::ostringstream oss2;
+        oss2 << "'''\nliteral\nstring'''";
+        BOOST_TEST(oss1.str() == oss2.str());
+
+    }
+    {
+        const std::string  s1 ("literal\nstring");
+        const toml::string str(s1, toml::string_t::literal);
+        std::ostringstream oss1;
+        oss1 << str;
+        std::ostringstream oss2;
+        oss2 << "'''\nliteral\nstring'''";
+        BOOST_TEST(oss1.str() == oss2.str());
+    }
+}
+
--- a/tests/test_value.cpp
+++ b/tests/test_value.cpp
@@ -905,3 +905,32 @@ BOOST_AUTO_TEST_CASE(test_value_empty)
    BOOST_CHECK_THROW(v1.as_array(),           toml::type_error);
    BOOST_CHECK_THROW(v1.as_table(),           toml::type_error);
 }
+
+
+BOOST_AUTO_TEST_CASE(test_value_at)
+{
+    {
+        toml::value v1{{"foo", 42}, {"bar", 3.14}, {"baz", "qux"}};
+
+        BOOST_TEST(v1.at("foo").as_integer()  == 42);
+        BOOST_TEST(v1.at("bar").as_floating() == 3.14);
+        BOOST_TEST(v1.at("baz").as_string()   == "qux");
+
+        BOOST_CHECK_THROW(v1.at(0), toml::type_error);
+        BOOST_CHECK_THROW(v1.at("quux"), std::out_of_range);
+    }
+
+
+    {
+        toml::value v1{1,2,3,4,5};
+
+        BOOST_TEST(v1.at(0).as_integer() == 1);
+        BOOST_TEST(v1.at(1).as_integer() == 2);
+        BOOST_TEST(v1.at(2).as_integer() == 3);
+        BOOST_TEST(v1.at(3).as_integer() == 4);
+        BOOST_TEST(v1.at(4).as_integer() == 5);
+
+        BOOST_CHECK_THROW(v1.at("foo"), toml::type_error);
+        BOOST_CHECK_THROW(v1.at(5),     std::out_of_range);
+    }
+}
--- a/toml/comments.hpp
+++ b/toml/comments.hpp
@@ -162,12 +162,15 @@ struct preserve_comments
    const_reverse_iterator crbegin() const noexcept {return comments.crbegin();}
    const_reverse_iterator crend()   const noexcept {return comments.crend();}

-    friend bool operator==(const preserve_comments& lhs, const preserve_comments& rhs);
-    friend bool operator!=(const preserve_comments& lhs, const preserve_comments& rhs);
-    friend bool operator< (const preserve_comments& lhs, const preserve_comments& rhs);
-    friend bool operator<=(const preserve_comments& lhs, const preserve_comments& rhs);
-    friend bool operator> (const preserve_comments& lhs, const preserve_comments& rhs);
-    friend bool operator>=(const preserve_comments& lhs, const preserve_comments& rhs);
+    friend bool operator==(const preserve_comments&, const preserve_comments&);
+    friend bool operator!=(const preserve_comments&, const preserve_comments&);
+    friend bool operator< (const preserve_comments&, const preserve_comments&);
+    friend bool operator<=(const preserve_comments&, const preserve_comments&);
+    friend bool operator> (const preserve_comments&, const preserve_comments&);
+    friend bool operator>=(const preserve_comments&, const preserve_comments&);
+
+    friend void swap(preserve_comments&, std::vector<std::string>&);
+    friend void swap(std::vector<std::string>&, preserve_comments&);

  private:

@@ -186,6 +189,27 @@ inline void swap(preserve_comments& lhs, preserve_comments& rhs)
    lhs.swap(rhs);
    return;
 }
+inline void swap(preserve_comments& lhs, std::vector<std::string>& rhs)
+{
+    lhs.comments.swap(rhs);
+    return;
+}
+inline void swap(std::vector<std::string>& lhs, preserve_comments& rhs)
+{
+    lhs.swap(rhs.comments);
+    return;
+}
+
+template<typename charT, typename traits>
+std::basic_ostream<charT, traits>&
+operator<<(std::basic_ostream<charT, traits>& os, const preserve_comments& com)
+{
+    for(const auto& c : com)
+    {
+        os << '#' << c << '\n';
+    }
+    return os;
+}

 namespace detail
 {
@@ -381,5 +405,12 @@ inline bool operator>=(const discard_comments&, const discard_comments&) noexcep

 inline void swap(const discard_comments&, const discard_comments&) noexcept {return;}

+template<typename charT, typename traits>
+std::basic_ostream<charT, traits>&
+operator<<(std::basic_ostream<charT, traits>& os, const discard_comments&)
+{
+    return os;
+}
+
 } // toml11
 #endif// TOML11_COMMENTS_HPP
--- a/toml/get.hpp
+++ b/toml/get.hpp
@@ -31,10 +31,10 @@ get(const basic_value<C, M, V>& v)

 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
-detail::enable_if_t<detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T> &&
+detail::enable_if_t<detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T>
 get(basic_value<C, M, V>&& v)
 {
-    return std::move(v).template cast<detail::type_to_enum<T, basic_value<C, M, V>>::value>();
+    return T(std::move(v).template cast<detail::type_to_enum<T, basic_value<C, M, V>>::value>());
 }

 // ============================================================================
@@ -58,10 +58,10 @@ get(const basic_value<C, M, V>& v)

 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
-inline detail::enable_if_t<std::is_same<T, basic_value<C, M, V>>::value, T> &&
+inline detail::enable_if_t<std::is_same<T, basic_value<C, M, V>>::value, T>
 get(basic_value<C, M, V>&& v)
 {
-    return std::move(v);
+    return basic_value<C, M, V>(std::move(v));
 }

 // ============================================================================
@@ -90,7 +90,7 @@ inline detail::enable_if_t<detail::conjunction<
    >::value, T>
 get(const basic_value<C, M, V>& v)
 {
-    return static_cast<T>(v.template cast<value_t::integer>());
+    return static_cast<T>(v.as_integer());
 }

 // ============================================================================
@@ -105,7 +105,7 @@ inline detail::enable_if_t<detail::conjunction<
    >::value, T>
 get(const basic_value<C, M, V>& v)
 {
-    return static_cast<T>(v.template cast<value_t::floating>());
+    return static_cast<T>(v.as_floating());
 }

 // ============================================================================
@@ -117,7 +117,7 @@ template<typename T, typename C,
 inline detail::enable_if_t<std::is_same<T, std::string>::value, std::string>&
 get(basic_value<C, M, V>& v)
 {
-    return v.template cast<value_t::string>().str;
+    return v.as_string().str;
 }

 template<typename T, typename C,
@@ -125,15 +125,15 @@ template<typename T, typename C,
 inline detail::enable_if_t<std::is_same<T, std::string>::value, std::string> const&
 get(const basic_value<C, M, V>& v)
 {
-    return v.template cast<value_t::string>().str;
+    return v.as_string().str;
 }

 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
-inline detail::enable_if_t<std::is_same<T, std::string>::value, std::string> const&
+inline detail::enable_if_t<std::is_same<T, std::string>::value, std::string>
 get(basic_value<C, M, V>&& v)
 {
-    return std::move(v.template cast<value_t::string>().str);
+    return std::string(std::move(v.as_string().str));
 }

 // ============================================================================
@@ -145,7 +145,7 @@ template<typename T, typename C,
 inline detail::enable_if_t<std::is_same<T, std::string_view>::value, std::string_view>
 get(const basic_value<C, M, V>& v)
 {
-    return std::string_view(v.template cast<value_t::string>().str);
+    return std::string_view(v.as_string().str);
 }
 #endif

@@ -158,7 +158,7 @@ inline detail::enable_if_t<detail::is_chrono_duration<T>::value, T>
 get(const basic_value<C, M, V>& v)
 {
    return std::chrono::duration_cast<T>(
-            std::chrono::nanoseconds(v.template cast<value_t::local_time>()));
+            std::chrono::nanoseconds(v.as_local_time()));
 }

 // ============================================================================
@@ -174,18 +174,15 @@ get(const basic_value<C, M, V>& v)
    {
        case value_t::local_date:
        {
-            return std::chrono::system_clock::time_point(
-                    v.template cast<value_t::local_date>());
+            return std::chrono::system_clock::time_point(v.as_local_date());
        }
        case value_t::local_datetime:
        {
-            return std::chrono::system_clock::time_point(
-                    v.template cast<value_t::local_datetime>());
+            return std::chrono::system_clock::time_point(v.as_local_datetime());
        }
        case value_t::offset_datetime:
        {
-            return std::chrono::system_clock::time_point(
-                    v.template cast<value_t::offset_datetime>());
+            return std::chrono::system_clock::time_point(v.as_offset_datetime());
        }
        default:
        {
@@ -259,7 +256,7 @@ get(const basic_value<C, M, V>&);
 // toml::from<T>::from_toml(v)
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V,
-         std::size_t S = sizeof(::toml::into<T>)>
+         std::size_t S = sizeof(::toml::from<T>)>
 T get(const basic_value<C, M, V>&);

 // ============================================================================
@@ -276,7 +273,7 @@ detail::enable_if_t<detail::conjunction<
 get(const basic_value<C, M, V>& v)
 {
    using value_type = typename T::value_type;
-    const auto& ar = v.template cast<value_t::array>();
+    const auto& ar = v.as_array();
    T container;
    container.resize(ar.size());
    std::transform(ar.cbegin(), ar.cend(), container.begin(),
@@ -298,7 +295,7 @@ detail::enable_if_t<detail::conjunction<
 get(const basic_value<C, M, V>& v)
 {
    using value_type = typename T::value_type;
-    const auto& ar = v.template cast<value_t::array>();
+    const auto& ar = v.as_array();

    T container;
    if(ar.size() != container.size())
@@ -325,7 +322,7 @@ get(const basic_value<C, M, V>& v)
    using first_type  = typename T::first_type;
    using second_type = typename T::second_type;

-    const auto& ar = v.template cast<value_t::array>();
+    const auto& ar = v.as_array();
    if(ar.size() != 2)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
@@ -356,7 +353,7 @@ template<typename T, typename C,
 detail::enable_if_t<detail::is_std_tuple<T>::value, T>
 get(const basic_value<C, M, V>& v)
 {
-    const auto& ar = v.template cast<value_t::array>();
+    const auto& ar = v.as_array();
    if(ar.size() != std::tuple_size<T>::value)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
@@ -388,7 +385,7 @@ get(const basic_value<C, M, V>& v)
                  "toml::get only supports map type of which key_type is "
                  "convertible from std::string.");
    T map;
-    for(const auto& kv : v.template cast<value_t::table>())
+    for(const auto& kv : v.as_table())
    {
        map[key_type(kv.first)] = ::toml::get<mapped_type>(kv.second);
    }
@@ -421,7 +418,7 @@ T get(const basic_value<C, M, V>& v)
 }

 // ============================================================================
-// find and get
+// find

 // ----------------------------------------------------------------------------
 // these overloads do not require to set T. and returns value itself.
@@ -429,7 +426,7 @@ template<typename C,
         template<typename ...> class M, template<typename ...> class V>
 basic_value<C, M, V> const& find(const basic_value<C, M, V>& v, const key& ky)
 {
-    const auto& tab = v.template cast<value_t::table>();
+    const auto& tab = v.as_table();
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
@@ -443,7 +440,7 @@ template<typename C,
         template<typename ...> class M, template<typename ...> class V>
 basic_value<C, M, V>& find(basic_value<C, M, V>& v, const key& ky)
 {
-    auto& tab = v.template cast<value_t::table>();
+    auto& tab = v.as_table();
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
@@ -455,9 +452,9 @@ basic_value<C, M, V>& find(basic_value<C, M, V>& v, const key& ky)
 }
 template<typename C,
         template<typename ...> class M, template<typename ...> class V>
-basic_value<C, M, V>&& find(basic_value<C, M, V>&& v, const key& ky)
+basic_value<C, M, V> find(basic_value<C, M, V>&& v, const key& ky)
 {
-    auto& tab = v.template cast<value_t::table>();
+    typename basic_value<C, M, V>::table_type tab = std::move(v).as_table();
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
@@ -465,7 +462,7 @@ basic_value<C, M, V>&& find(basic_value<C, M, V>&& v, const key& ky)
                {std::addressof(detail::get_region(v)), "in this table"}
            }));
    }
-    return std::move(tab.at(ky));
+    return basic_value<C, M, V>(std::move(tab.at(ky)));
 }

 // ----------------------------------------------------------------------------
@@ -476,7 +473,7 @@ template<typename T, typename C,
 decltype(::toml::get<T>(std::declval<basic_value<C, M, V> const&>()))
 find(const basic_value<C, M, V>& v, const key& ky)
 {
-    const auto& tab = v.template cast<value_t::table>();
+    const auto& tab = v.as_table();
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
@@ -492,7 +489,7 @@ template<typename T, typename C,
 decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&>()))
 find(basic_value<C, M, V>& v, const key& ky)
 {
-    auto& tab = v.template cast<value_t::table>();
+    auto& tab = v.as_table();
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
@@ -508,7 +505,7 @@ template<typename T, typename C,
 decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&&>()))
 find(basic_value<C, M, V>&& v, const key& ky)
 {
-    auto& tab = v.template cast<value_t::table>();
+    typename basic_value<C, M, V>::table_type tab = std::move(v).as_table();
    if(tab.count(ky) == 0)
    {
        throw std::out_of_range(detail::format_underline(concat_to_string(
@@ -541,7 +538,7 @@ find(basic_value<C, M, V>& v, const ::toml::key& ky, Ts&& ... keys)
 template<typename C,
         template<typename ...> class M, template<typename ...> class V,
         typename ... Ts>
-basic_value<C, M, V>&&
+basic_value<C, M, V>
 find(basic_value<C, M, V>&& v, const ::toml::key& ky, Ts&& ... keys)
 {
    return ::toml::find(::toml::find(std::move(v), ky), std::forward<Ts>(keys)...);
@@ -575,6 +572,28 @@ find(basic_value<C, M, V>&& v, const ::toml::key& ky, Ts&& ... keys)
 // ============================================================================
 // get_or(value, fallback)

+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V> const&
+get_or(const basic_value<C, M, V>& v, const basic_value<C, M, V>&)
+{
+    return v;
+}
+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V>&
+get_or(basic_value<C, M, V>& v, basic_value<C, M, V>&)
+{
+    return v;
+}
+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V>
+get_or(basic_value<C, M, V>&& v, basic_value<C, M, V>&&)
+{
+    return v;
+}
+
 // ----------------------------------------------------------------------------
 // specialization for the exact toml types (return type becomes lvalue ref)

@@ -586,8 +605,7 @@ get_or(const basic_value<C, M, V>& v, const T& opt)
 {
    try
    {
-        return get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(v);
+        return get<detail::remove_cvref_t<T>>(v);
    }
    catch(...)
    {
@@ -602,8 +620,7 @@ get_or(basic_value<C, M, V>& v, T& opt)
 {
    try
    {
-        return get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(v);
+        return get<detail::remove_cvref_t<T>>(v);
    }
    catch(...)
    {
@@ -612,18 +629,17 @@ get_or(basic_value<C, M, V>& v, T& opt)
 }
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
-detail::enable_if_t<
-    detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T>&&
+detail::enable_if_t<detail::is_exact_toml_type<detail::remove_cvref_t<T>,
+    basic_value<C, M, V>>::value, detail::remove_cvref_t<T>>
 get_or(basic_value<C, M, V>&& v, T&& opt)
 {
    try
    {
-        return get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(v);
+        return get<detail::remove_cvref_t<T>>(std::move(v));
    }
    catch(...)
    {
-        return opt;
+        return detail::remove_cvref_t<T>(std::forward<T>(opt));
    }
 }

@@ -632,14 +648,13 @@ get_or(basic_value<C, M, V>&& v, T&& opt)

 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
-detail::enable_if_t<std::is_same<
-    typename std::remove_cv<typename std::remove_reference<T>::type>::type,
-    std::string>::value, std::string> const&
-get_or(const basic_value<C, M, V>& v, T&& opt)
+detail::enable_if_t<std::is_same<detail::remove_cvref_t<T>, std::string>::value,
+    std::string> const&
+get_or(const basic_value<C, M, V>& v, const T& opt)
 {
    try
    {
-        return v.template cast<value_t::string>().str;
+        return v.as_string().str;
    }
    catch(...)
    {
@@ -653,7 +668,7 @@ get_or(basic_value<C, M, V>& v, T& opt)
 {
    try
    {
-        return v.template cast<value_t::string>().str;
+        return v.as_string().str;
    }
    catch(...)
    {
@@ -662,18 +677,17 @@ get_or(basic_value<C, M, V>& v, T& opt)
 }
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
-detail::enable_if_t<std::is_same<
-    typename std::remove_cv<typename std::remove_reference<T>::type>::type,
-    std::string>::value, std::string>
+detail::enable_if_t<
+    std::is_same<detail::remove_cvref_t<T>, std::string>::value, std::string>
 get_or(basic_value<C, M, V>&& v, T&& opt)
 {
    try
    {
-        return std::move(v.template cast<value_t::string>().str);
+        return std::move(v.as_string().str);
    }
    catch(...)
    {
-        return std::forward<T>(opt);
+        return std::string(std::forward<T>(opt));
    }
 }

@@ -688,11 +702,11 @@ get_or(const basic_value<C, M, V>& v, T&& opt)
 {
    try
    {
-        return std::move(v.template cast<value_t::string>().str);
+        return std::move(v.as_string().str);
    }
    catch(...)
    {
-        return std::string(opt);
+        return std::string(std::forward<T>(opt));
    }
 }

@@ -702,30 +716,61 @@ get_or(const basic_value<C, M, V>& v, T&& opt)
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
 detail::enable_if_t<detail::conjunction<
-    detail::negation<detail::is_exact_toml_type<
-        typename std::remove_cv<typename std::remove_reference<T>::type>::type,
+    detail::negation<detail::is_exact_toml_type<detail::remove_cvref_t<T>,
        basic_value<C, M, V>>>,
-    detail::negation<std::is_same<std::string,
-        typename std::remove_cv<typename std::remove_reference<T>::type>::type>>,
+    detail::negation<std::is_same<std::string, detail::remove_cvref_t<T>>>,
    detail::negation<detail::is_string_literal<
        typename std::remove_reference<T>::type>>
-    >::value, typename std::remove_reference<T>::type>
+    >::value, detail::remove_cvref_t<T>>
 get_or(const basic_value<C, M, V>& v, T&& opt)
 {
    try
    {
-        return get<typename std::remove_cv<
-            typename std::remove_reference<T>::type>::type>(v);
+        return get<detail::remove_cvref_t<T>>(v);
    }
    catch(...)
    {
-        return std::forward<T>(opt);
+        return detail::remove_cvref_t<T>(std::forward<T>(opt));
    }
 }

 // ===========================================================================
 // find_or(value, key, fallback)

+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V> const&
+find_or(const basic_value<C, M, V>& v, const key& ky,
+        const basic_value<C, M, V>& opt)
+{
+    if(!v.is_table()) {return opt;}
+    const auto& tab = v.as_table();
+    if(tab.count(ky) == 0) {return opt;}
+    return tab.at(ky);
+}
+
+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V>&
+find_or(basic_value<C, M, V>& v, const toml::key& ky, basic_value<C, M, V>& opt)
+{
+    if(!v.is_table()) {return opt;}
+    auto& tab = v.as_table();
+    if(tab.count(ky) == 0) {return opt;}
+    return tab.at(ky);
+}
+
+template<typename C,
+         template<typename ...> class M, template<typename ...> class V>
+basic_value<C, M, V>
+find_or(basic_value<C, M, V>&& v, const toml::key& ky, basic_value<C, M, V>&& opt)
+{
+    if(!v.is_table()) {return opt;}
+    auto tab = std::move(v).as_table();
+    if(tab.count(ky) == 0) {return opt;}
+    return basic_value<C, M, V>(std::move(tab.at(ky)));
+}
+
 // ---------------------------------------------------------------------------
 // exact types (return type can be a reference)
 template<typename T, typename C,
@@ -749,19 +794,20 @@ find_or(basic_value<C, M, V>& v, const toml::key& ky, T& opt)
    if(!v.is_table()) {return opt;}
    auto& tab = v.as_table();
    if(tab.count(ky) == 0) {return opt;}
-    return get_or(tab[ky], opt);
+    return get_or(tab.at(ky), opt);
 }

 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
 detail::enable_if_t<
-    detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T>&&
+    detail::is_exact_toml_type<T, basic_value<C, M, V>>::value,
+    detail::remove_cvref_t<T>>
 find_or(basic_value<C, M, V>&& v, const toml::key& ky, T&& opt)
 {
-    if(!v.is_table()) {return opt;}
+    if(!v.is_table()) {return std::forward<T>(opt);}
    auto tab = std::move(v).as_table();
-    if(tab.count(ky) == 0) {return opt;}
-    return get_or(std::move(tab[ky]), std::forward<T>(opt));
+    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
+    return get_or(std::move(tab.at(ky)), std::forward<T>(opt));
 }

 // ---------------------------------------------------------------------------
@@ -807,7 +853,7 @@ detail::enable_if_t<
    std::string>
 find_or(const basic_value<C, M, V>& v, const toml::key& ky, T&& opt)
 {
-    if(!v.is_table()) {return opt;}
+    if(!v.is_table()) {return std::string(opt);}
    const auto& tab = v.as_table();
    if(tab.count(ky) == 0) {return std::string(opt);}
    return get_or(tab.at(ky), std::forward<T>(opt));
@@ -818,19 +864,20 @@ find_or(const basic_value<C, M, V>& v, const toml::key& ky, T&& opt)
 template<typename T, typename C,
         template<typename ...> class M, template<typename ...> class V>
 detail::enable_if_t<detail::conjunction<
+    // T is not an exact toml type
    detail::negation<detail::is_exact_toml_type<
-        typename std::remove_cv<typename std::remove_reference<T>::type>::type,
-        basic_value<C, M, V>>>,
-    detail::negation<std::is_same<std::string,
-        typename std::remove_cv<typename std::remove_reference<T>::type>::type>>,
+        detail::remove_cvref_t<T>, basic_value<C, M, V>>>,
+    // T is not std::string
+    detail::negation<std::is_same<std::string, detail::remove_cvref_t<T>>>,
+    // T is not a string literal
    detail::negation<detail::is_string_literal<
        typename std::remove_reference<T>::type>>
-    >::value, T>
+    >::value, detail::remove_cvref_t<T>>
 find_or(const basic_value<C, M, V>& v, const toml::key& ky, T&& opt)
 {
-    if(!v.is_table()) {return opt;}
+    if(!v.is_table()) {return std::forward<T>(opt);}
    const auto& tab = v.as_table();
-    if(tab.count(ky) == 0) {return opt;}
+    if(tab.count(ky) == 0) {return std::forward<T>(opt);}
    return get_or(tab.at(ky), std::forward<T>(opt));
 }

@@ -864,21 +911,6 @@ expect(const basic_value<C, M, V>& v, const toml::key& k) noexcept
        return err(e.what());
    }
 }
-template<typename T, typename Table>
-detail::enable_if_t<detail::conjunction<
-    detail::is_map<Table>, detail::is_basic_value<typename Table::mapped_type>
-    >::value, result<T, std::string>>
-expect(const Table& t, const toml::key& k,
-       std::string tablename = "unknown table") noexcept
-{
-    try
-    {
-        return ok(find<T>(t, k, std::move(tablename)));
-    }
-    catch(const std::exception& e)
-    {
-        return err(e.what());
-    }
-}
+
 } // toml
 #endif// TOML11_GET
--- a/toml/lexer.hpp
+++ b/toml/lexer.hpp
@@ -63,12 +63,22 @@ using lex_integer = either<lex_bin_int, lex_oct_int, lex_hex_int, lex_dec_int>;
 using lex_inf = sequence<character<'i'>, character<'n'>, character<'f'>>;
 using lex_nan = sequence<character<'n'>, character<'a'>, character<'n'>>;
 using lex_special_float = sequence<maybe<lex_sign>, either<lex_inf, lex_nan>>;
-using lex_exponent_part = sequence<either<character<'e'>, character<'E'>>, lex_dec_int>;

 using lex_zero_prefixable_int = sequence<lex_digit, repeat<either<lex_digit,
-      sequence<lex_underscore, lex_digit>>, unlimited>>;
+    sequence<lex_underscore, lex_digit>>, unlimited>>;
+
 using lex_fractional_part = sequence<character<'.'>, lex_zero_prefixable_int>;

+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+// use toml-lang/toml HEAD
+using lex_exponent_part   = sequence<either<character<'e'>, character<'E'>>,
+        maybe<lex_sign>, lex_zero_prefixable_int>;
+#else
+// strictly TOML v0.5.0
+using lex_exponent_part = sequence<either<character<'e'>, character<'E'>>,
+        lex_dec_int>;
+#endif
+
 using lex_float = either<lex_special_float,
      sequence<lex_dec_int, either<lex_exponent_part,
      sequence<lex_fractional_part, maybe<lex_exponent_part>>>>>;
@@ -115,9 +125,17 @@ using lex_local_time       = lex_partial_time;
 // ===========================================================================

 using lex_quotation_mark  = character<'"'>;
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+using lex_basic_unescaped = exclude<either<in_range<0x00, 0x08>, // 0x09 (tab)
+                                           in_range<0x0a, 0x1F>, // is allowed
+                                           character<0x22>, character<0x5C>,
+                                           character<0x7F>>>;
+#else
 using lex_basic_unescaped = exclude<either<in_range<0x00, 0x1F>,
                                           character<0x22>, character<0x5C>,
                                           character<0x7F>>>;
+
+#endif
 using lex_escape          = character<'\\'>;
 using lex_escape_unicode_short = sequence<character<'u'>,
                                          repeat<lex_hex_dig, exactly<4>>>;
@@ -137,10 +155,18 @@ using lex_basic_string = sequence<lex_quotation_mark,
                                  lex_quotation_mark>;

 using lex_ml_basic_string_delim = repeat<lex_quotation_mark, exactly<3>>;
-using lex_ml_basic_unescaped    = exclude<either<in_range<0x00, 0x1F>,
+#ifdef TOML11_USE_UNRELEASED_TOML_FEATURES
+using lex_ml_basic_unescaped    = exclude<either<in_range<0x00, 0x08>, // 0x09
+                                                 in_range<0x0a, 0x1F>, // is tab
                                                 character<0x5C>,
                                                 character<0x7F>,
                                                 lex_ml_basic_string_delim>>;
+#else // TOML v0.5.0
+using lex_ml_basic_unescaped    = exclude<either<in_range<0x00,0x1F>,
+                                                 character<0x5C>,
+                                                 character<0x7F>,
+                                                 lex_ml_basic_string_delim>>;
+#endif

 using lex_ml_basic_escaped_newline = sequence<
        lex_escape, maybe<lex_ws>, lex_newline,
--- a/toml/parser.hpp
+++ b/toml/parser.hpp
@@ -8,7 +8,8 @@
 #include "lexer.hpp"
 #include "types.hpp"
 #include "value.hpp"
-#include <iostream>
+#include <fstream>
+#include <sstream>
 #include <cstring>

 namespace toml
@@ -1750,6 +1751,7 @@ parse_ml_table(location<Container>& loc)
    using skip_line = repeat<
        sequence<maybe<lex_ws>, maybe<lex_comment>, lex_newline>, at_least<1>>;
    skip_line::invoke(loc);
+    lex_ws::invoke(loc);

    table_type tab;
    while(loc.iter() != loc.end())
@@ -1973,7 +1975,7 @@ parse(std::istream& is, const std::string& fname = "unknown file")
 template<typename                     Comment = ::toml::discard_comments,
         template<typename ...> class Table   = std::unordered_map,
         template<typename ...> class Array   = std::vector>
-inline basic_value<Comment, Table, Array> parse(const std::string& fname)
+basic_value<Comment, Table, Array> parse(const std::string& fname)
 {
    std::ifstream ifs(fname.c_str(), std::ios_base::binary);
    if(!ifs.good())
--- a/toml/serializer.hpp
+++ b/toml/serializer.hpp
@@ -10,6 +10,45 @@
 namespace toml
 {

+// This function serialize a key. It checks a string is a bare key and
+// escapes special characters if the string is not compatible to a bare key.
+// ```cpp
+// std::string k("non.bare.key"); // the key itself includes `.`s.
+// std::string formatted = toml::format_key(k);
+// assert(formatted == "\"non.bare.key\"");
+// ```
+//
+// This function is exposed to make it easy to write a user-defined serializer.
+// Since toml restricts characters available in a bare key, generally a string
+// should be escaped. But checking whether a string needs to be surrounded by
+// a `"` and escaping some special character is boring.
+inline std::string format_key(const toml::key& key)
+{
+    detail::location<toml::key> loc(key, key);
+    detail::lex_unquoted_key::invoke(loc);
+    if(loc.iter() == loc.end())
+    {
+        return key; // all the tokens are consumed. the key is unquoted-key.
+    }
+    std::string token("\"");
+    for(const char c : key)
+    {
+        switch(c)
+        {
+            case '\\': {token += "\\\\"; break;}
+            case '\"': {token += "\\\""; break;}
+            case '\b': {token += "\\b";  break;}
+            case '\t': {token += "\\t";  break;}
+            case '\f': {token += "\\f";  break;}
+            case '\n': {token += "\\n";  break;}
+            case '\r': {token += "\\r";  break;}
+            default  : {token += c;      break;}
+        }
+    }
+    token += "\"";
+    return token;
+}
+
 template<typename Comment,
         template<typename ...> class Table,
         template<typename ...> class Array>
@@ -32,9 +71,10 @@ struct serializer
    serializer(const std::size_t w              = 80u,
               const int         float_prec     = std::numeric_limits<toml::floating>::max_digits10,
               const bool        can_be_inlined = false,
+               const bool        no_comment     = false,
               std::vector<toml::key> ks        = {})
-        : can_be_inlined_(can_be_inlined), float_prec_(float_prec), width_(w),
-          keys_(std::move(ks))
+        : can_be_inlined_(can_be_inlined), no_comment_(no_comment),
+          float_prec_(float_prec), width_(w), keys_(std::move(ks))
    {}
    ~serializer() = default;

@@ -217,11 +257,14 @@ struct serializer
                        failed = true;
                        break;
                    }
-                    for(const auto& c : item.comments())
+                    if(!no_comment_)
                    {
-                        token += '#';
-                        token += c;
-                        token += '\n';
+                        for(const auto& c : item.comments())
+                        {
+                            token += '#';
+                            token += c;
+                            token += '\n';
+                        }
                    }

                    const auto t = this->make_inline_table(item.as_table());
@@ -246,11 +289,14 @@ struct serializer
            std::string token;
            for(const auto& item : v)
            {
-                for(const auto& c : item.comments())
+                if(!no_comment_)
                {
-                    token += '#';
-                    token += c;
-                    token += '\n';
+                    for(const auto& c : item.comments())
+                    {
+                        token += '#';
+                        token += c;
+                        token += '\n';
+                    }
                }
                token += "[[";
                token += this->serialize_dotted_key(keys_);
@@ -287,7 +333,7 @@ struct serializer
        token += "[\n";
        for(const auto& item : v)
        {
-            if(!item.comments().empty())
+            if(!item.comments().empty() && !no_comment_)
            {
                // if comment exists, the element must be the only element in the line.
                // e.g. the following is not allowed.
@@ -369,7 +415,8 @@ struct serializer
                token += " = ";
            }
            token += this->make_inline_table(v);
-            if(token.size() < this->width_)
+            if(token.size() < this->width_ &&
+               token.end() == std::find(token.begin(), token.end(), '\n'))
            {
                return token;
            }
@@ -390,16 +437,7 @@ struct serializer

    std::string serialize_key(const toml::key& key) const
    {
-        detail::location<toml::key> loc(key, key);
-        detail::lex_unquoted_key::invoke(loc);
-        if(loc.iter() == loc.end())
-        {
-            return key; // all the tokens are consumed. the key is unquoted-key.
-        }
-        std::string token("\"");
-        token += this->escape_basic_string(key);
-        token += "\"";
-        return token;
+        return ::toml::format_key(key);
    }

    std::string serialize_dotted_key(const std::vector<toml::key>& keys) const
@@ -472,6 +510,9 @@ struct serializer
    // if an element of a table or an array has a comment, it cannot be inlined.
    bool has_comment_inside(const array_type& a) const noexcept
    {
+        // if no_comment is set, comments would not be written.
+        if(this->no_comment_) {return false;}
+
        for(const auto& v : a)
        {
            if(!v.comments().empty()) {return true;}
@@ -480,6 +521,9 @@ struct serializer
    }
    bool has_comment_inside(const table_type& t) const noexcept
    {
+        // if no_comment is set, comments would not be written.
+        if(this->no_comment_) {return false;}
+
        for(const auto& kv : t)
        {
            if(!kv.second.comments().empty()) {return true;}
@@ -536,7 +580,7 @@ struct serializer
                continue;
            }

-            if(!kv.second.comments().empty())
+            if(!kv.second.comments().empty() && !no_comment_)
            {
                for(const auto& c : kv.second.comments())
                {
@@ -575,8 +619,8 @@ struct serializer
            std::vector<toml::key> ks(this->keys_);
            ks.push_back(kv.first);

-            auto tmp = visit(serializer(
-                this->width_, this->float_prec_, !multiline_table_printed, ks),
+            auto tmp = visit(serializer(this->width_, this->float_prec_,
+                !multiline_table_printed, this->no_comment_, ks),
                kv.second);

            if((!multiline_table_printed) &&
@@ -590,7 +634,7 @@ struct serializer
                tmp += '\n';
            }

-            if(!kv.second.comments().empty())
+            if(!kv.second.comments().empty() && !no_comment_)
            {
                for(const auto& c : kv.second.comments())
                {
@@ -614,6 +658,7 @@ struct serializer
  private:

    bool        can_be_inlined_;
+    bool        no_comment_;
    int         float_prec_;
    std::size_t width_;
    std::vector<toml::key> keys_;
@@ -624,7 +669,7 @@ template<typename C,
 std::string
 format(const basic_value<C, M, V>& v, std::size_t w = 80u,
       int fprec = std::numeric_limits<toml::floating>::max_digits10,
-       bool force_inline = false)
+       bool no_comment = false, bool force_inline = false)
 {
    // if value is a table, it is considered to be a root object.
    // the root object can't be an inline table.
@@ -633,18 +678,43 @@ format(const basic_value<C, M, V>& v, std::size_t w = 80u,
        std::ostringstream oss;
        if(!v.comments().empty())
        {
-            for(const auto& c : v.comments())
-            {
-                oss << '#' << c << '\n';
-            }
-            oss << '\n';
+            oss << v.comments();
+            oss << '\n'; // to split the file comment from the first element
        }
-        oss << visit(serializer<C, M, V>(w, fprec, false), v);
+        oss << visit(serializer<C, M, V>(w, fprec, no_comment, false), v);
        return oss.str();
    }
    return visit(serializer<C, M, V>(w, fprec, force_inline), v);
 }

+namespace detail
+{
+template<typename charT, typename traits>
+int comment_index(std::basic_ostream<charT, traits>&)
+{
+    static const int index = std::ios_base::xalloc();
+    return index;
+}
+} // detail
+
+template<typename charT, typename traits>
+std::basic_ostream<charT, traits>&
+nocomment(std::basic_ostream<charT, traits>& os)
+{
+    // by default, it is zero. and by defalut, it shows comments.
+    os.iword(detail::comment_index(os)) = 1;
+    return os;
+}
+
+template<typename charT, typename traits>
+std::basic_ostream<charT, traits>&
+showcomment(std::basic_ostream<charT, traits>& os)
+{
+    // by default, it is zero. and by defalut, it shows comments.
+    os.iword(detail::comment_index(os)) = 0;
+    return os;
+}
+
 template<typename charT, typename traits, typename C,
         template<typename ...> class M, template<typename ...> class V>
 std::basic_ostream<charT, traits>&
@@ -655,16 +725,40 @@ operator<<(std::basic_ostream<charT, traits>& os, const basic_value<C, M, V>& v)
    const int  fprec = static_cast<int>(os.precision());
    os.width(0);

-    if(!v.comments().empty())
+    // by defualt, iword is initialized byl 0. And by default, toml11 outputs
+    // comments. So `0` means showcomment. 1 means nocommnet.
+    const bool no_comment = (1 == os.iword(detail::comment_index(os)));
+
+    if(!no_comment && v.is_table() && !v.comments().empty())
    {
-        for(const auto& c : v.comments())
-        {
-            os << '#' << c << '\n';
-        }
-        os << '\n';
+        os << v.comments();
+        os << '\n'; // to split the file comment from the first element
    }
    // the root object can't be an inline table. so pass `false`.
-    os << visit(serializer<C, M, V>(w, fprec, false), v);
+    os << visit(serializer<C, M, V>(w, fprec, false, no_comment), v);
+
+    // if v is a non-table value, and has only one comment, then
+    // put a comment just after a value. in the following way.
+    //
+    // ```toml
+    // key = "value" # comment.
+    // ```
+    //
+    // Since the top-level toml object is a table, one who want to put a
+    // non-table toml value must use this in a following way.
+    //
+    // ```cpp
+    // toml::value v;
+    // std::cout << "user-defined-key = " << v << std::endl;
+    // ```
+    //
+    // In this case, it is impossible to put comments before key-value pair.
+    // The only way to preserve comments is to put all of them after a value.
+    if(!no_comment && !v.is_table() && !v.comments().empty())
+    {
+        os << " #";
+        for(const auto& c : v.comments()) {os << c;}
+    }
    return os;
 }

--- a/toml/string.hpp
+++ b/toml/string.hpp
@@ -139,9 +139,74 @@ operator>=(const char* lhs, const string& rhs) {return std::string(lhs) >= rhs.s

 template<typename charT, typename traits>
 std::basic_ostream<charT, traits>&
-operator<<(std::basic_ostream<charT, traits>& os, const string& str)
+operator<<(std::basic_ostream<charT, traits>& os, const string& s)
 {
-    os << str.str;
+    if(s.kind == string_t::basic)
+    {
+        if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend())
+        {
+            // it contains newline. make it multiline string.
+            os << "\"\"\"\n";
+            for(auto i=s.str.cbegin(), e=s.str.cend(); i!=e; ++i)
+            {
+                switch(*i)
+                {
+                    case '\\': {os << "\\\\"; break;}
+                    case '\"': {os << "\\\""; break;}
+                    case '\b': {os << "\\b";  break;}
+                    case '\t': {os << "\\t";  break;}
+                    case '\f': {os << "\\f";  break;}
+                    case '\n': {os << '\n';   break;}
+                    case '\r':
+                    {
+                        // since it is a multiline string,
+                        // CRLF is not needed to be escaped.
+                        if(std::next(i) != e && *std::next(i) == '\n')
+                        {
+                            os << "\r\n";
+                            ++i;
+                        }
+                        else
+                        {
+                            os << "\\r";
+                        }
+                        break;
+                    }
+                    default: {os << *i; break;}
+                }
+            }
+            os << "\\\n\"\"\"";
+            return os;
+        }
+        // no newline. make it inline.
+        os << "\"";
+        for(const auto c : s.str)
+        {
+            switch(c)
+            {
+                case '\\': {os << "\\\\"; break;}
+                case '\"': {os << "\\\""; break;}
+                case '\b': {os << "\\b";  break;}
+                case '\t': {os << "\\t";  break;}
+                case '\f': {os << "\\f";  break;}
+                case '\n': {os << "\\n";  break;}
+                case '\r': {os << "\\r";  break;}
+                default  : {os << c;      break;}
+            }
+        }
+        os << "\"";
+        return os;
+    }
+    // the string `s` is literal-string.
+    if(std::find(s.str.cbegin(), s.str.cend(), '\n') != s.str.cend() ||
+       std::find(s.str.cbegin(), s.str.cend(), '\'') != s.str.cend() )
+    {
+        // contains newline or single quote. make it multiline.
+        os << "'''\n" << s.str << "'''";
+        return os;
+    }
+    // normal literal string
+    os << '\'' << s.str << '\'';
    return os;
 }

--- a/toml/traits.hpp
+++ b/toml/traits.hpp
@@ -240,6 +240,19 @@ disjunction<
        >
    >{};

+// ---------------------------------------------------------------------------
+// C++20 remove_cvref_t
+
+template<typename T>
+struct remove_cvref
+{
+    using type = typename std::remove_cv<
+        typename std::remove_reference<T>::type>::type;
+};
+
+template<typename T>
+using remove_cvref_t = typename remove_cvref<T>::type;
+
 }// detail
 }//toml
 #endif // TOML_TRAITS
--- a/toml/value.hpp
+++ b/toml/value.hpp
@@ -1567,9 +1567,31 @@ class basic_value
        return std::move(this->table_.value());
    }

+    // accessors =============================================================
+    //
+    // may throw type_error or out_of_range
+    //
+    value_type&       at(const key& k)
+    {
+        return this->as_table().at(k);
+    }
+    value_type const& at(const key& k) const
+    {
+        return this->as_table().at(k);
+    }
+
+    value_type&       at(const std::size_t idx)
+    {
+        return this->as_array().at(idx);
+    }
+    value_type const& at(const std::size_t idx) const
+    {
+        return this->as_array().at(idx);
+    }
+
    source_location location() const
    {
-        return source_location(this->region_info_);
+        return source_location(this->region_info_.get());
    }

    comment_type const& comments() const noexcept {return this->comments_;}
Author	SHA1	Message	Date
ToruNiina	e12fd4d944	doc: add contributors	2019-10-04 14:28:43 +09:00
ToruNiina	36af02cb3a	test: add test cases for one-way conversion	2019-10-04 13:01:15 +09:00
ToruNiina	488015df49	fix: toml -> T is required; related to #83	2019-10-04 13:00:34 +09:00
Toru Niina	1f951e49b1	Merge pull request #84 from jcmoyer/master Update documentation for toml::from and toml::into	2019-10-04 12:58:13 +09:00
J.C. Moyer	6a7dbb7875	Update documentation for toml::from and toml::into	2019-10-03 21:28:06 -04:00
ToruNiina	ad7eb56634	fix: avoid potential memory bugs related to move	2019-10-03 14:42:52 +09:00
ToruNiina	b01c5534ed	test: add test cases for const-ref version	2019-10-03 13:52:12 +09:00
ToruNiina	22dac3c9f2	Merge branch 'value-at'	2019-09-28 19:40:51 +09:00
ToruNiina	d5adfe8c7d	refactor: use as_xxx instead of cast<enum> because cast<enum>() requires `template` specifier inside a template function. it makes code long.	2019-09-28 17:01:45 +09:00
ToruNiina	4bb8045c84	doc: add `basic_value::at`.	2019-09-28 16:31:45 +09:00
ToruNiina	babb6ab3fe	test: add test case for basic_value::at	2019-09-28 16:22:01 +09:00
ToruNiina	d73bc6076c	feat: add basic_value::at(key) and at(idx)	2019-09-28 16:21:51 +09:00
ToruNiina	8d1da6e8b5	test: add test cases for find_or(&&) + conversion	2019-09-28 14:01:33 +09:00
ToruNiina	8276e12f06	test: add test cases for toml::find_or(value&&)	2019-09-28 13:38:59 +09:00
ToruNiina	f3d3f63ff9	fix: return values from find_or(value&&)	2019-09-28 13:38:26 +09:00
ToruNiina	d9689c878d	test: add test cases for toml::find(value&&, key)	2019-09-28 13:05:13 +09:00
ToruNiina	df097cb09a	test: add test cases of get_or(value&&, U)	2019-09-28 12:13:59 +09:00
ToruNiina	a425e3b7c6	test: add test cases of toml::get_or(value&&, T&&)	2019-09-28 12:08:14 +09:00
ToruNiina	e4b4503b81	style: add comment to test::operator<<	2019-09-28 12:07:53 +09:00
ToruNiina	b44fbad925	fix: remove needless ::type	2019-09-28 11:14:14 +09:00
ToruNiina	826c9444ac	refactor: use remove_cvref	2019-09-28 11:03:46 +09:00
ToruNiina	a1095f3e4c	refactor: use std::map::at instead of []	2019-09-28 11:03:14 +09:00
ToruNiina	483a39beb4	refactor: remove unsupported overload expect<T>(table, ...)	2019-09-28 11:00:35 +09:00
ToruNiina	1409114c96	refactor: add utility meta-func for internal use	2019-09-28 10:58:02 +09:00
ToruNiina	ecfc9d0c5a	fix: make return type rvalue when rvalue is passed	2019-09-28 10:31:10 +09:00
ToruNiina	94f76137a3	doc: add description of unreleased toml features	2019-09-05 14:31:05 +09:00
ToruNiina	c2e1aa9a3c	Merge branch 'master' into fp-exp-leading-zeroes	2019-09-05 13:50:58 +09:00
ToruNiina	5b5ece6c32	fix: add "unreleased" flag to raw-tab-in-string	2019-09-04 18:10:15 +09:00
ToruNiina	b696e327d7	ci: add options to test toml-head features	2019-09-04 13:37:08 +09:00
ToruNiina	757e5d60be	test: add flag for toml-head features to tests	2019-09-04 13:36:42 +09:00
ToruNiina	c02093de7f	chore: add an option to tests that enable/disable to use unreleased toml features	2019-09-04 13:34:28 +09:00
ToruNiina	4f8b62a7e9	feat: add TOML11_USE_UNRELEASED_TOML_FEATURES flag to choose to use unreleased toml feature	2019-09-04 13:32:05 +09:00
ToruNiina	d9b8582c47	test: add test for toml::get<T>(std::move(v))	2019-09-01 19:39:37 +09:00
ToruNiina	c9543d8d9e	test: add test of find_or with conversion	2019-08-31 13:05:05 +09:00
ToruNiina	15b68a89c6	fix: suppress warnings by forwarding argument	2019-08-31 13:04:25 +09:00
ToruNiina	64e7bdb835	test: add test for leading zeroes in fp exp	2019-08-28 17:49:12 +09:00
ToruNiina	1acf87679e	feat: permit leading 0s in exp parts of floats This is an unreleased feature of toml language, but is merged into toml-lang/toml:master.	2019-08-28 16:02:10 +09:00
ToruNiina	7a1b5bd64e	fix: skip whitespaces without newline	2019-08-26 18:16:09 +09:00
ToruNiina	e332e018db	feat: allow raw tab characters in basic strings This feature is planned to be incorporated in toml v1.0.0 but not released yet.	2019-08-21 11:19:47 +09:00
ToruNiina	b1ec6d87bd	chore: update patch version	2019-08-07 15:58:28 +09:00
ToruNiina	8dded288b4	Merge branch 'master' into find-or-value	2019-08-07 14:58:56 +09:00
ToruNiina	0f491c7f3a	fix: add overload for find_or with toml::value	2019-08-07 14:55:30 +09:00
ToruNiina	5edf43a1d2	test: add missing include file to test code	2019-07-23 22:32:32 +09:00
ToruNiina	cffc605505	fix: stop including iostream	2019-07-23 22:27:20 +09:00
ToruNiina	fb91936a1d	fix #76 : correct version description in CMakeLists	2019-07-21 13:16:48 +09:00
ToruNiina	8833292858	doc: rearrange toml::find section in README	2019-07-19 20:42:47 +09:00
ToruNiina	3fe04aff77	doc: fix sample script in README	2019-07-19 20:13:12 +09:00
ToruNiina	138f030b5d	doc: fix sample codes in README	2019-07-18 17:39:24 +09:00
ToruNiina	2eb2e0a753	doc: update README	2019-07-13 15:11:01 +09:00
ToruNiina	87e0ba201e	feat: enable to swap comment and strings	2019-07-13 14:33:14 +09:00
ToruNiina	24a05c7c93	doc: update serialization section #73	2019-07-10 09:12:38 +09:00
ToruNiina	c3653b85f1	doc: fix include directory #72	2019-07-10 08:45:09 +09:00
ToruNiina	00b05c63b9	doc: add explanation about os << toml::string	2019-07-07 21:24:33 +09:00
ToruNiina	35b7c79ebd	doc: update README	2019-07-03 17:33:24 +09:00
ToruNiina	9ef146d022	🔀 Merge branch 'v3'	2019-07-03 17:31:45 +09:00
ToruNiina	2c192af35d	test: add test for toml::string format	2019-06-29 20:20:31 +09:00
ToruNiina	c2435b0d56	feat:boom:: format toml::string as TOML format	2019-06-29 20:19:47 +09:00
ToruNiina	9b12b17d5e	ci: fix ci job script	2019-06-29 17:36:16 +09:00
ToruNiina	e61b38fac2	ci: add test_serialization to the jobs	2019-06-29 16:45:59 +09:00
ToruNiina	716f7bacba	ci: run serialization test to circleci	2019-06-29 16:43:11 +09:00
ToruNiina	299d1098e4	test: add serialization test for arbitrary file	2019-06-29 16:40:42 +09:00
ToruNiina	c272188060	fix: check inline table does not include LF	2019-06-29 16:39:54 +09:00
ToruNiina	0fc0967f6f	fix: remove CR before comparing to the reference	2019-06-29 15:38:28 +09:00
ToruNiina	df0d870c97	test: add test for serialization with nocomment	2019-06-29 15:00:00 +09:00
ToruNiina	d5299fef04	feat: add no_comment option to serializer	2019-06-29 14:59:18 +09:00
ToruNiina	937a3b4a2e	test: add test for nocomment/showcomment	2019-06-28 19:09:05 +09:00
ToruNiina	0502924d25	feat: add nocomment and showcomment	2019-06-28 19:08:48 +09:00
ToruNiina	6182f3ee9d	test: add test for operator<<(os, non-table-value)	2019-06-28 17:56:41 +09:00
ToruNiina	3624e4b690	fix: put comment just after non-table values When non-table value is passed to the `operator<<`, it assumes that the original C++ code looks like the following. ```cpp std::cout << "key = " << v << std::endl; ``` In this case, the comment associated to `v` should be put just after `v`, not before. ```toml key = # comment <= bad "value" key = "value" # comment <= good ``` So, if `v` is not a table it would put comments just after the value.	2019-06-28 17:53:19 +09:00
ToruNiina	37e96ed8dc	test: add test for format_key()	2019-06-28 17:47:42 +09:00
ToruNiina	79e7511871	feat: add format_key to help serialization	2019-06-28 17:47:19 +09:00
ToruNiina	284f122433	refactor: replace for-loop by comment output	2019-06-28 14:58:47 +09:00
ToruNiina	134475e292	test: check ostream op for comment containers	2019-06-28 14:58:16 +09:00
ToruNiina	28b3f7d6fb	feat: add ostream operator to comment containers	2019-06-28 14:57:45 +09:00
ToruNiina	6b5fd349aa	fix: initialize source_location correctly	2019-06-26 21:35:01 +09:00
ToruNiina	76e44a0c48	refactor: remove needless inline specifier	2019-06-26 21:34:36 +09:00
ToruNiina	b4bbd0a005	chore: update version string in CMakeLists	2019-06-26 21:31:35 +09:00
ToruNiina	f9ee645dc2	doc: add link to v3 branch	2019-06-23 21:00:59 +09:00