fix try_next and try_object when returning false, update unit tests

README.md

@@ -395,3 +395,4 @@ p.try_next<int>()
     .or_object<x, double>()
     .on_error([] { /* int and x (all) conversions failed */ });
 ```
+*See unit tests for more examples.*

include/ss/parser.hpp

@@ -134,26 +134,27 @@ public:
         composite<Ts..., T> composite_with(T&& new_value) {
             auto merged_values =
                 std::tuple_cat(std::move(values_),
-                               std::tuple{std::forward<T>(new_value)});
+                               std::tuple{parser_.valid()
+                                              ? std::forward<T>(new_value)
+                                              : std::nullopt});
             return {std::move(merged_values), parser_};
         }
 
         template <typename U, typename... Us, typename Fun = none>
         void try_convert_and_invoke(std::optional<U>& value, Fun&& fun) {
             if (!parser_.valid()) {
-                std::optional<U> new_value;
                 auto tuple_output = try_same<Us...>();
+                if (!parser_.valid()) {
+                    return;
+                }
                 if constexpr (!std::is_same_v<U, decltype(tuple_output)>) {
-                    new_value = to_object<U>(std::move(tuple_output));
+                    value = to_object<U>(std::move(tuple_output));
                 } else {
-                    new_value = std::move(tuple_output);
+                    value = std::move(tuple_output);
                 }
-                if (parser_.valid()) {
-                    value = std::move(new_value);
                 parser_.try_invoke(*value, std::forward<Fun>(fun));
             }
         }
-        }
 
         template <typename U, typename... Us>
         no_void_validator_tup_t<U, Us...> try_same() {
@@ -175,26 +176,17 @@ public:
     template <typename... Ts, typename Fun = none>
     composite<std::optional<no_void_validator_tup_t<Ts...>>> try_next(
         Fun&& fun = none{}) {
-        std::optional<no_void_validator_tup_t<Ts...>> value;
+        using Ret = no_void_validator_tup_t<Ts...>;
-        auto new_value = get_next<Ts...>();
+        return try_invoke_and_make_composite<
-        if (valid()) {
+            std::optional<Ret>>(get_next<Ts...>(), std::forward<Fun>(fun));
-            value = std::move(new_value);
-            try_invoke(*value, std::forward<Fun>(fun));
-        }
-        return {std::move(value), *this};
     };
 
     // identical to try_next but returns composite with object instead of a
     // tuple
     template <typename T, typename... Ts, typename Fun = none>
     composite<std::optional<T>> try_object(Fun&& fun = none{}) {
-        std::optional<T> value;
+        return try_invoke_and_make_composite<
-        auto new_value = get_object<T, Ts...>();
+            std::optional<T>>(get_object<T, Ts...>(), std::forward<Fun>(fun));
-        if (valid()) {
-            value = std::move(new_value);
-            try_invoke(*value, std::forward<Fun>(fun));
-        }
-        return {std::move(value), *this};
     };
 
 private:
@@ -243,6 +235,14 @@ private:
         }
     }
 
+    template <typename T, typename Fun = none>
+    composite<T> try_invoke_and_make_composite(T&& value, Fun&& fun) {
+        if (valid()) {
+            try_invoke(*value, std::forward<Fun>(fun));
+        }
+        return {valid() ? std::move(value) : std::nullopt, *this};
+    }
+
     ////////////////
     // line reading
     ////////////////

test/test_parser.cpp

@@ -181,7 +181,7 @@ TEST_CASE("testing composite conversion") {
         std::ofstream out{f.name};
         for (auto& i :
              {"10,a,11.1", "10,20,11.1", "junk", "10,11.1", "1,11.1,a", "junk",
-              "10,junk", "11,junk", "10,11.1,c"}) {
+              "10,junk", "11,junk", "10,11.1,c", "10,20", "10,22.2,f"}) {
             out << i << std::endl;
         }
     }
@@ -348,6 +348,42 @@ TEST_CASE("testing composite conversion") {
         CHECK(d1->tied() == std::tuple{10, 11.1, 'c'});
     }
 
+    {
+        REQUIRE(!p.eof());
+
+        auto [d1, d2, d3, d4] =
+            p.try_next<int, int>([] { return false; })
+                .or_else<int, double>([](auto&) { return false; })
+                .or_else<int, int>()
+                .or_else<int, int>(fail)
+                .values();
+
+        REQUIRE(p.valid());
+        REQUIRE(!d1);
+        REQUIRE(!d2);
+        REQUIRE(d3);
+        REQUIRE(!d4);
+        CHECK(d3.value() == std::tuple{10, 20});
+    }
+
+    {
+        REQUIRE(!p.eof());
+
+        auto [d1, d2, d3, d4] =
+            p.try_object<test_struct, int, double, char>([] { return false; })
+                .or_else<int, double>([](auto&) { return false; })
+                .or_object<test_struct, int, double, char>()
+                .or_else<int, int>(fail)
+                .values();
+
+        REQUIRE(p.valid());
+        REQUIRE(!d1);
+        REQUIRE(!d2);
+        REQUIRE(d3);
+        REQUIRE(!d4);
+        CHECK(d3->tied() == std::tuple{10, 22.2, 'f'});
+    }
+
     CHECK(p.eof());
 }