#include <boost/yap/expression.hpp>
#include <boost/yap/print.hpp>
#include <boost/yap/yap.hpp>
#include <boost/hana/sum.hpp>

struct sum_int {
//    template<typename IntType, typename = std::enable_if_t<std::is_integral_v<IntType>, int>>
//    auto operator()(boost::yap::expr_tag<boost::yap::expr_kind::terminal>, IntType i) {
//        return i;
//    }

    auto operator()(boost::yap::expr_tag<boost::yap::expr_kind::terminal>, int i) {
        return i;
    }

    template<int I>
    auto operator()(boost::yap::expr_tag<boost::yap::expr_kind::terminal>, boost::hana::integral_constant<int, I> i) {
        return i;
    }

    template<typename T>
    auto operator()(boost::yap::expr_tag<boost::yap::expr_kind::terminal>, T &&) {
        return boost::hana::int_c<0>;
    }

    template<boost::yap::expr_kind Kind, typename ... Args>
    auto operator()(boost::yap::expr_tag<Kind> expr_tag, Args &&... args) {
        return boost::hana::sum<>(
                boost::hana::make_tuple(
                        boost::yap::transform(
                                boost::yap::as_expr(std::forward<Args>(args)),
                                sum_int{})...
                        ));
    }
};


int main() {
    auto expr1 = boost::yap::make_terminal(boost::hana::int_c<7>);
    auto expr2 = boost::yap::make_terminal(19);
    auto expr3 = boost::yap::make_terminal(true);
    using value_type = boost::hana::integral_constant<int, 7>::value_type;

    auto expr = expr1 + expr1 + expr3;

    boost::yap::print(std::cout, expr);
    auto expr_t = boost::yap::transform(expr, sum_int{});

    boost::yap::print(std::cout, boost::yap::make_terminal(expr_t));
    std::cout << expr_t << std::endl;

    return 0;
}