ericniebler / meta Goto Github PK

namespace details {

        template<typename List, std::size_t I>
        struct find_ind_state {
            using L = List;
            static const std::size_t Idx = I;
        };

        template<typename Type>
        struct find_indices {
            template<typename State, typename T>
            using invoke = find_ind_state<
                                              meta::if_< std::is_same<Type,T> ,
                                                          meta::push_back< typename State::L, meta::size_t<State::Idx> >,
                                                          typename State::L
                                              >,
                                              State::Idx+1
                                          >;
        };
    };

    /** Returns a list of all indices of types equal to \p T in list \p */
    template<typename T, typename List>
    using find_indices =  typename  meta::accumulate< List,
                                                      details::find_ind_state< meta::list<> , 0 >,
                                                      /* accumulate the index list and the current index of the element*/
                                                      details::find_indices<T>
                                                      >::L;

static_assert(std::is_same<meta::_t<meta::defer_trait<std::decay, int>>, int>::value, "");

using List = meta::list<int,double,float,double>;
std::size_t index = 2
meta::visit<List>(2, [](auto type){ std::cout << "called with type==double"; });

namespace meta
{
    namespace details
    {
        template<typename Func, typename Type>
        struct Wrapper
        {
            static void invoke(Func f) { f(Type{}); }
        };

        template<typename Func, typename List> struct visit;

        template<typename Func, typename... Types>
        struct visit<Func, meta::list<Types...>>
        {
            static constexpr auto makeMap()
            {
                using FuncPtr = decltype(&Wrapper<Func, void>::invoke);
                using Array   = std::array<FuncPtr, sizeof...(Types)>;
                // Build member function pointers.
                return Array{&Wrapper<Func, Types>::invoke...};
            }
        };
    }  // namespace details

    //! Apply the function `Func` with the type
    //! in the `List` at position `index`.
    template<typename List, typename Func>
    void visit(std::size_t index, Func&& f)
    {
        using F            = decltype(std::forward<Func>(f));  // Define either an lvalue, or rvalue;
        constexpr auto map = details::visit<F, List>::makeMap();
        if(index >= map.size()){ throw std::out_of_range();}
        map[index](std::forward<Func>(f));
    }

}  // namespace meta

MY_TEST(MetaProgramming, Test1)
{
    using List = meta::list<int, double, short>;
    int b      = -1;
    meta::visit<List>(2,
                      [&](auto type) {
                          using T = decltype(type);
                          if constexpr(std::is_same<T, short>{})
                          {
                              b = 2;
                          }
                      });
    ASSERT_EQ(b, 2) << "Meta Visit failed!";
}

#include <meta/meta.hpp>

struct is_positive {
    template<typename N>
    using invoke = meta::bool_<(N::type::value > 0)>;
};

using list = meta::list<
    meta::int_<1>,
    meta::int_<2>,
    meta::int_<3>,
    meta::int_<4>
>;

using result = meta::all_of<list, is_positive>;

using identity = quote_trait<id>;

int index = 2;
using A = meta::list<TraitA, TraitB , TraitC>;
meta::for_each(A{}, [](auto a){
     using Trait = decltype(a); 
     if (meta::find_index<A, Trait>  == index)
    {
          // do something ...
          return false; // abort iteration, not possible right now
    }
     return true; // true for continuation,  not possible right now
});

template <typename T>
using _t = typename T::type;

template <typename T>
constexpr typename T::type::value_type _v = T::type::value;

template<typename T>
struct is_vararg
  : std::false_type
{};

template<typename T>
struct is_vararg<vararg<T>>
  : std::true_type
{};

template<typename A, typename T, typename F, typename Ts>
struct subst1_
  : id<list<list<T>>>
{};
template<typename T, typename F, typename Ts>
struct subst1_<F, T, F, Ts>
  : id<list<>>
{};
template<typename A, typename T, typename F, typename Ts>
struct subst1_<vararg<A>, T, F, Ts>
  : id<list<eval<Ts>>>
{};

template<typename As, typename Ts>
using substitutions_ =
    push_back<join<transform<
        concat<As, repeat_n_c<size<Ts>{} + 2 - size<As>{}, back<As>>>,
        concat<Ts, list<back<As>, back<As>>>,
        compose<quote<eval>,
            bind_back<
                quote<subst1_>,
                back<As>,
                lazy::drop<Ts, minus<size<As>, meta::size_t<2>>>>>>>, list<back<As>>>;

template<typename As>
using is_variadic = is_vararg<at<push_front<As, void>, dec<size<As>>>>;

template<typename As, typename Ts>
using substitutions =
    eval<if_c<((is_variadic<As>::value && size<Ts>::value + 2 >= size<As>::value) ||
               (size<Ts>::value + 1 == size<As>::value)), defer<substitutions_, As, Ts>>>;

template<int, typename...As>
struct lambda2_
{
private:
    template<int N, typename...Us> friend struct lambda2_;
    using Tags = list<As...>; // Includes the lambda body as the last arg!
    template<typename T, typename Args> struct impl;
    template<typename Args>
    using eval_impl = compose<quote<eval>, bind_back<quote<impl>, Args>>;
    template<template<typename...> class C, typename Args, typename Ts>
    using subst_ = apply_list<quote<C>, join<transform<Ts, eval_impl<Args>>>>;
    template<typename, typename, typename = void>
    struct impl_
    {};
    template<template<typename...> class C, typename...Ts, typename Args>
    struct impl_<defer<C, Ts...>, Args, void_<subst_<C, Args, list<Ts...>>>>
    {
        using type = list<subst_<C, Args, list<Ts...>>>;
    };
    template<typename T, typename Args>
    struct impl
      : if_<in<Tags, T>, lazy::at<Args, reverse_find_index<Tags, T>>, id<list<T>>>
    {};
    template<template<typename...> class C, typename...Ts, typename Args>
    struct impl<defer<C, Ts...>, Args> : impl_<defer<C, Ts...>, Args>
    {};
    template<template<typename...> class C, typename...Ts, typename Args>
    struct impl<C<Ts...>, Args> : impl_<defer<C, Ts...>, Args>
    {};
    template<int N, typename...Bs, typename Args>
    struct impl<lambda2_<N, Bs...>, Args>
    {
        using type = list<compose<
            typename lambda2_<0, As..., Bs...>::thunk,
            bind_front<quote<concat>, Args>,
            curry<bind_front<quote<substitutions>, list<Bs...>>>>>;
    };
    struct thunk
    {
        template<typename S, typename R = eval<impl<back<Tags>, S>>>
        using apply = if_c<size<R>{} == 1, front<R>>;
    };
public:
    template<typename...Ts>
    using apply = meta::apply<thunk, substitutions<Tags, list<Ts...>>>;
};

template<typename...As>
using lambda2 = lambda2_<0, As...>;

template<class> concept Foo = false;
template<Foo T> struct X;
using U = X<int>; // ill-formed despite not instantiating X<int>

  template <class, R = void>
    struct is_callable; // not defined
  template <class Fn, class ...Args, class R>
    struct is_callable<Fn(Args...), R>;
  template <class Sig, R = void> 
    constexpr bool is_callable_v = is_callable <Sig, R>::value;

namespace meta_detail
{
    template<typename Ts, int = 0>
    struct lambda_rec_;

    template<typename ...Ts>
    struct lambda_rec_<list<Ts...>>
    {
        template<typename...Us>
        using apply = apply<let<var<_self, lambda_rec_>, lambda<Ts...>>, Us...>;
    };
}

////////////////////////////////////////////////////////////////////////////////////
// lambda_rec
/// For defining a self-recursive lambda. In the body of a lambda, the placeholder
/// `_self` refers to the nearest enclosing `lambda_rec`
///
/// \code
/// // Define a factorial template in terms of a recursive lambda
/// using factorial_ = lambda_rec<_a,
///     lazy::if_<lazy::greater<_a, meta::size_t<0>>,
///               lazy::multiplies<_a, lazy::apply<_self, lazy::dec<_a>>>,
///               meta::size_t<1>>>;
/// template<std::size_t N>
/// using factorial = apply<factorial_, meta::size_t<N>>;
///
/// static_assert(factorial<0>::value == 1, "");
/// static_assert(factorial<1>::value == 1, "");
/// static_assert(factorial<2>::value == 2, "");
/// static_assert(factorial<3>::value == 6, "");
/// static_assert(factorial<4>::value == 24, "");
/// \endcode
template<typename ...Ts>
using lambda_rec = meta_detail::lambda_rec_<list<Ts...>>;

struct HugeObj
    {
        HugeObj(){ std::cout << "Huge Obj CTOR";}
    };
meta::for_each(meta::list<HugeObj>{}, [](auto&&r){});

meta::for_each(meta::list<HugeObj>{}, [](auto*p){});

return (void)std::initializer_list<int>{((void)f.invoke<Args>()), 0)...}, f;

#include <meta/meta.hpp>
int main() {}