Function matchPatterns

include/matchit.h:1865–1913

        template <typename Value, typename... PatternPairs>
        constexpr auto matchPatterns(Value &&value, PatternPairs const &...patterns)
        {
            using RetType = typename PatternPairsRetType<PatternPairs...>::RetType;
            using TypeTuple = decltype(std::tuple_cat(
                std::declval<typename PatternTraits<typename PatternPairs::PatternT>::
                                 template AppResultTuple<Value>>()...));

            // expression, has return value.
            if constexpr (!std::is_same_v<RetType, void>)
            {
                constexpr auto const func =
                    [](auto const &pattern, auto &&value, RetType &result) constexpr->bool
                {
                    auto context = typename ContextTrait<TypeTuple>::ContextT{};
                    if (pattern.matchValue(std::forward<Value>(value), context))
                    {
                        result = pattern.execute();
                        processId(pattern, 0, IdProcess::kCANCEL);
                        return true;
                    }
                    return false;
                };
                RetType result{};
                bool const matched = (func(patterns, value, result) || ...);
                if (!matched)
                {
                    throw std::logic_error{"Error: no patterns got matched!"};
                }
                static_cast<void>(matched);
                return result;
            }
            else
            // statement, no return value, mismatching all patterns is not an error.
            {
                auto const func = [](auto const &pattern, auto &&value) -> bool
                {
                    auto context = typename ContextTrait<TypeTuple>::ContextT{};
                    if (pattern.matchValue(std::forward<Value>(value), context))
                    {
                        pattern.execute();
                        processId(pattern, 0, IdProcess::kCANCEL);
                        return true;
                    }
                    return false;
                };
                bool const matched = (func(patterns, value) || ...);
                static_cast<void>(matched);
            }
        }

    } // namespace impl