From f0b72c0f14449693fcc5c9359df1d437b23848e0 Mon Sep 17 00:00:00 2001
From: Vitaly Fanaskov <vt4a2h@gmail.com>
Date: Fri, 10 Jan 2025 22:25:20 +0100
Subject: [PATCH] Small experimental matcher for variants

---
 src/include/fl/expected/expected.hpp     | 10 ++++
 src/include/fl/utils/callable_traits.hpp | 44 +++++++++++++++
 src/include/fl/utils/match.hpp           | 71 ++++++++++++++++++++++++
 test/CMakeLists.txt                      |  2 +
 test/test_match.cpp                      | 29 ++++++++++
 5 files changed, 156 insertions(+)
 create mode 100644 src/include/fl/utils/callable_traits.hpp
 create mode 100644 src/include/fl/utils/match.hpp
 create mode 100644 test/test_match.cpp

diff --git a/src/include/fl/expected/expected.hpp b/src/include/fl/expected/expected.hpp
index 06cd38c..1da5dcb 100644
--- a/src/include/fl/expected/expected.hpp
+++ b/src/include/fl/expected/expected.hpp
@@ -1,3 +1,13 @@
+//
+// MIT License
+//
+// Copyright (c) 2024-present Vitaly Fanaskov
+//
+// fl -- Functional tools for C++
+// Project home: https://github.com/vt4a2h/fl
+//
+// See LICENSE file for the further details.
+//
 #include <variant>
 
 namespace fl {
diff --git a/src/include/fl/utils/callable_traits.hpp b/src/include/fl/utils/callable_traits.hpp
new file mode 100644
index 0000000..33b35ce
--- /dev/null
+++ b/src/include/fl/utils/callable_traits.hpp
@@ -0,0 +1,44 @@
+//
+// MIT License
+//
+// Copyright (c) 2025-present Vitaly Fanaskov
+//
+// fl -- Functional tools for C++
+// Project home: https://github.com/vt4a2h/fl
+//
+// See LICENSE file for the further details.
+//
+#pragma once
+
+#include <tuple>
+
+namespace fl {
+
+template<class T>
+struct callable_traits;
+
+template<class T>
+struct callable_traits : public callable_traits<decltype(&T::operator())> {};
+
+template<class R, class ...Args>
+struct callable_traits<R (*)(Args...)>
+{
+    static constexpr std::size_t args_count = sizeof...(Args);
+
+    using result_type = R;
+
+    template <std::size_t index>
+        requires (index < args_count)
+    struct arg
+    {
+        using type = typename std::tuple_element<index, std::tuple<Args...>>::type;
+    };
+};
+
+template<class R, class C, class ...Args>
+struct callable_traits<R (C::*)(Args...) const> : public callable_traits<R (*)(Args...)>
+{
+    using class_type = C;
+};
+
+} // namespace fl
\ No newline at end of file
diff --git a/src/include/fl/utils/match.hpp b/src/include/fl/utils/match.hpp
new file mode 100644
index 0000000..80c7506
--- /dev/null
+++ b/src/include/fl/utils/match.hpp
@@ -0,0 +1,71 @@
+//
+// MIT License
+//
+// Copyright (c) 2025-present Vitaly Fanaskov
+//
+// fl -- Functional tools for C++
+// Project home: https://github.com/vt4a2h/fl
+//
+// See LICENSE file for the further details.
+//
+#pragma once
+
+#include <variant>
+#include <concepts>
+#include <type_traits>
+
+namespace fl {
+
+namespace details {
+
+template <class>
+constexpr bool is_variant = false;
+
+template <class ...Args>
+constexpr bool is_variant<std::variant<Args...>> = true;
+
+template <class Variant>
+concept IsVariant = is_variant<std::remove_cvref_t<Variant>>;
+
+template <class F, IsVariant Variant>
+constexpr bool invocable_with()
+{
+    return []<std::size_t... I>(std::index_sequence<I...>){
+        return (... || std::is_invocable_v<F, std::variant_alternative_t<I, Variant>>);
+    }(std::make_index_sequence<std::variant_size_v<Variant>>{});
+}
+
+template <class F, class Variant>
+concept InvocableWithAnyOf = invocable_with<std::remove_cvref_t<F>, std::remove_cvref_t<Variant>>();
+
+template <std::size_t Index, class Variant, class Value, class Callable>
+bool invokeIfCan(Value &valuePtr, Callable f)
+{
+    if constexpr (std::is_invocable_v<Callable, std::variant_alternative_t<Index, Variant>>) {
+        std::invoke(f, valuePtr);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <std::size_t Index, class Variant_t, details::IsVariant Variant, details::InvocableWithAnyOf<Variant> ...Callable>
+bool invokeIfHoldsCorrectAlternative(const Variant &variant, const Callable &...callable)
+{
+    auto *v = std::get_if<std::variant_alternative_t<Index, Variant_t>>(&variant);
+    return v && ((... || invokeIfCan<Index, Variant_t>(*v, callable)));
+}
+
+} // namespace details
+
+template <details::IsVariant Variant, details::InvocableWithAnyOf<Variant> ...Callable>
+void match(const Variant &variant, Callable ...callable)
+{
+    using Variant_t = std::remove_cvref_t<Variant>;
+
+    [&variant, &callable...]<std::size_t... I>(std::index_sequence<I...>){
+        (... || details::invokeIfHoldsCorrectAlternative<I, Variant_t>(variant, callable...));
+    }(std::make_index_sequence<std::variant_size_v<Variant_t>>{});
+}
+
+} // namespace fl
\ No newline at end of file
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index fb4e4f2..0e7d15e 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -29,6 +29,7 @@ target_sources(tests PRIVATE
     test_writer_move_copy.cpp
 #    test_utils_ap_optional.cpp
 #    test_applicative_optional.cpp
+    test_match.cpp
     expected/test_expected_create.cpp
     expected/test_expected_unexpected_create.cpp
     expected/test_expected_unexpected_access_error.cpp
@@ -57,6 +58,7 @@ if(MSVC)
     target_compile_options(tests
         PRIVATE
             "/wd4996;" # external warning in fmt
+            "/wd4244;" # convert int/double in tests
     )
 endif()
 
diff --git a/test/test_match.cpp b/test/test_match.cpp
new file mode 100644
index 0000000..fd33699
--- /dev/null
+++ b/test/test_match.cpp
@@ -0,0 +1,29 @@
+//
+// MIT License
+//
+// Copyright (c) 2025-present Vitaly Fanaskov
+//
+// fl -- Functional tools for C++
+// Project home: https://github.com/vt4a2h/fl
+//
+// See LICENSE file for the further details.
+//
+#include "catch.hpp"
+
+#include <fl/utils/match.hpp>
+
+#include <fmt/format.h>
+
+template<class... Ts>
+struct overloaded : Ts... { using Ts::operator()...; };
+
+TEST_CASE("Invoked for all alternatives")
+{
+    auto intHandler = [](int v){ fmt::println("int: {}", v); };
+    auto stringHandler = [](const std::string &v){ fmt::println("string: {}", v); };
+    auto doubleHandler = [](double v){ fmt::println("double: {}", v); };
+
+    std::variant<int, std::string, double> v = 42;
+
+    fl::match(v,  stringHandler, intHandler, doubleHandler);
+}
\ No newline at end of file