From 01e279f2517d5c174f0579499615cf0af371a13b Mon Sep 17 00:00:00 2001
From: Nathan Hourt <nathan@followmyvote.com>
Date: Wed, 17 Jun 2020 20:31:49 -0500
Subject: [PATCH] Add typelist::any and typelist::wrapped

typelist::any determines whether any type in the list passes a predicate.

typelist::wrapped wraps an uninstantiated template in a type so it can be handled within a typelist.
---
 include/fc/reflect/typelist.hpp | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/include/fc/reflect/typelist.hpp b/include/fc/reflect/typelist.hpp
index d1d3e0d7a..f7f67bc43 100644
--- a/include/fc/reflect/typelist.hpp
+++ b/include/fc/reflect/typelist.hpp
@@ -128,6 +128,20 @@ struct zip<list<A, As...>, list<B, Bs...>> {
    using type = typename concat<list<list<A, B>>, typename zip<list<As...>, list<Bs...>>::type>::type;
 };
 
+template<typename, template<typename> class> struct any;
+template<template<typename> class Predicate>
+struct any<list<>, Predicate> {
+   constexpr static bool value = false;
+};
+template<typename T, template<typename> class Predicate>
+struct any<list<T>, Predicate> {
+   constexpr static bool value = Predicate<T>::value;
+};
+template<typename T1, typename T2, typename... Ts, template<typename> class Predicate>
+struct any<list<T1, T2, Ts...>, Predicate> {
+   constexpr static bool value = Predicate<T1>::value || any<list<T2, Ts...>, Predicate>::value;
+};
+
 template<typename Callable, typename Ret, typename T>
 Ret dispatch_helper(Callable& c) { return c(T()); }
 
@@ -224,6 +238,17 @@ using zip = typename impl::zip<ListA, ListB>::type;
 template<typename List>
 using index = typename impl::zip<typename impl::make_sequence<length<List>()>::type, List>::type;
 
+/// Determine whether any type in list passes predicate
+template<typename List, template<typename> class Predicate>
+constexpr static bool any = impl::any<List, Predicate>::value;
+
+/// A wrapper which wraps an uninstantiated template in a type so it can be handled in a typelist
+template<template<typename...> class Template>
+struct wrapped {
+   template<typename... Ts>
+   using unwrap = Template<Ts...>;
+};
+
 /// This namespace contains some utilities that provide runtime operations on typelists
 namespace runtime {
 /// Type wrapper object allowing arbitrary types to be passed to functions as information rather than data