builds.h

#pragma once
 
#include <tuple>
 
#include "hegel/core.h"
 
namespace hegel::generators {


    template <typename T, typename... Gens> Generator<T> builds(Gens... gens) {
        auto gen_tuple = std::make_tuple(std::move(gens)...);
 
        return compose([gen_tuple](const TestCase& tc) -> T {
            return std::apply([&tc](auto&... g) { return T(g.do_draw(tc)...); },
                              gen_tuple);
        });
    }

    template <auto MemberPtr, typename Gen> struct Field {
        static constexpr auto member_ptr = MemberPtr; 
        Gen generator; 
    };

    template <auto MemberPtr, typename Gen>
    Field<MemberPtr, Gen> field(Gen gen) {
        return Field<MemberPtr, Gen>{std::move(gen)};
    }

    template <typename T, typename... Fields>
    Generator<T> builds_agg(Fields... fields) {
        auto gen_tuple = std::make_tuple(std::move(fields)...);
 
        return compose([gen_tuple](const TestCase& tc) mutable -> T {
            T result{};
            std::apply(
                [&result, &tc](auto&... fs) {
                    ((result.*
                          (std::remove_reference_t<decltype(fs)>::member_ptr) =
                          fs.generator.do_draw(tc)),
                     ...);
                },
                gen_tuple);
            return result;
        });
    }

 
} // namespace hegel::generators