Some experiments with applicative for std::optional

src/include/fl/utils/ap_optional.hpp

@@ -0,0 +1,69 @@
+//
+// MIT License
+//
+// Copyright (c) 2023-present Vitaly Fanaskov
+//
+// fl -- Writer "monad" for C++
+// Project home: https://github.com/vt4a2h/fl
+//
+// See LICENSE file for the further details.
+//
+#pragma once
+
+#include <optional>
+#include <type_traits>
+#include <concepts>
+
+namespace fl {
+
+namespace details {
+
+template<typename>
+constexpr bool is_optional = false;
+
+template<typename T>
+constexpr bool is_optional<std::optional<T>> = true;
+
+template<class T>
+concept IsOptional = is_optional<std::remove_cvref_t<T>>;
+
+template<class V>
+constexpr auto pure(V &&v)
+{
+    if constexpr (IsOptional<V>) {
+        return std::forward<V>(v);
+    }
+    else {
+        return std::make_optional(std::forward<V>(v));
+    }
+}
+
+} // namespace details
+
+template <class F, class ...Args>
+constexpr auto ap(F &&f, Args &&...args) noexcept(noexcept(std::invoke(std::forward<F>(f), std::forward<Args>(args)...)))
+    requires (std::is_invocable_v<F, Args...>)
+{
+    return std::make_optional(std::invoke(std::forward<F>(f), std::forward<Args>(args)...));
+}
+
+template <class F, details::IsOptional ...Args>
+constexpr auto ap(F &&f, Args &&...args) noexcept(noexcept(ap(std::forward<F>(f), *std::forward<Args>(args)...)))
+    -> decltype(ap(std::forward<F>(f), *std::forward<Args>(args)...))
+    requires (!std::is_invocable_v<F, Args...>)
+{
+    if ((... && args)) {
+        return ap(std::forward<F>(f), *std::forward<Args>(args)...);
+    } else {
+        return {};
+    }
+}
+
+template <class F, class ...Args>
+constexpr auto ap(F &&f, Args &&...args) noexcept(noexcept(ap(std::forward<F>(f), *details::pure(args)...)))
+    requires (!std::is_invocable_v<F, Args...> && !(... && details::IsOptional<Args>))
+{
+    return ap(std::forward<F>(f), *details::pure(args)...);
+}
+
+} // namespace fl

test/CMakeLists.txt

@@ -22,6 +22,7 @@ target_sources(tests PRIVATE
     writer_default_types.hpp
     writer_utility_types.hpp
     test_writer_move_copy.cpp
+    test_utils_ap_optional.cpp
 )
 
 target_compile_features(tests PRIVATE cxx_std_23)

test/test_utils_ap_optional.cpp

@@ -0,0 +1,48 @@
+//
+// MIT License
+//
+// Copyright (c) 2023-present Vitaly Fanaskov
+//
+// fl -- Writer "monad" for C++
+// Project home: https://github.com/vt4a2h/fl
+//
+// See LICENSE file for the further details.
+//
+#include "catch.hpp"
+
+#include <fl/utils/ap_optional.hpp>
+
+TEST_CASE("Applicative for optional")
+{
+    SECTION("Regular args and function") {
+        const auto add = [](int a, int b) { return a + b; };
+        const int a = 1;
+        const int b = 2;
+
+        REQUIRE(fl::ap(add, a, b) == 3);
+    }
+
+    SECTION("Optional non-invocable") {
+        const auto add = [](int a, const std::string &b) { return a + std::stoi(b); };
+        const auto a = std::make_optional<int>(1);
+        const auto b = std::make_optional<std::string>("2");
+
+        REQUIRE(fl::ap(add, a, b) == 3);
+    }
+
+    SECTION("Optional invocable") {
+        const auto add = [](std::optional<int> a, const std::optional<std::string> &b) { return *a + std::stoi(*b); };
+        const auto a = std::make_optional<int>(1);
+        const auto b = std::make_optional<std::string>("2");
+
+        REQUIRE(fl::ap(add, a, b) == 3);
+    }
+
+    SECTION("Optional partial ap") {
+        const auto add = [](int a, const std::string &b) { return a + std::stoi(b); };
+        const auto a = std::make_optional<int>(1);
+        const auto b = std::string{"2"};
+
+        REQUIRE(fl::ap(add, a, b) == 3);
+    }
+}