container.hpp

#ifndef HALCHECK_GEN_CONTAINER_HPP
#define HALCHECK_GEN_CONTAINER_HPP
 
#include <halcheck/gen/label.hpp>
#include <halcheck/gen/range.hpp>
#include <halcheck/gen/sample.hpp>
#include <halcheck/gen/shrink.hpp>
#include <halcheck/gen/size.hpp>
#include <halcheck/lib/atom.hpp>
#include <halcheck/lib/effect.hpp>
#include <halcheck/lib/functional.hpp>
#include <halcheck/lib/iterator.hpp>
#include <halcheck/lib/optional.hpp>
#include <halcheck/lib/pp.hpp>
#include <halcheck/lib/scope.hpp>
#include <halcheck/lib/type_traits.hpp>
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <utility>
#include <vector>
 
namespace halcheck { namespace gen {
 
HALCHECK_INLINE_CONSTEXPR struct {
private:
  template<typename F>
  struct to_label {
    lib::invoke_result_t<const F &, lib::atom> operator()(std::uintmax_t i) const { return context.handle(func, i); }
    lib::effect::state context;
    F func;
  };
 
  struct if_noshrink {
    bool operator()(std::uintmax_t i) const { return !skip[skip.size() - i - 1]; }
    std::vector<bool> skip;
  };
 
  template<typename F>
  using view = lib::transform_view<lib::filter_view<lib::iota_view<std::uintmax_t>, if_noshrink>, to_label<F>>;
 
public:
  template<typename F, HALCHECK_REQUIRE(lib::is_invocable<const F &, lib::atom>())>
  view<F> operator()(lib::atom id, F gen) const {
    using namespace lib::literals;
 
    auto _ = gen::label(id);
    auto context = lib::effect::save();
 
    auto size = gen::sample("size"_s, gen::size());
 
    std::vector<bool> skip;
    {
      auto _ = gen::label("shrink"_s);
      for (std::uintmax_t i = 0; i < size; i++)
        skip.push_back(gen::shrink(i).has_value());
    }
 
    return lib::transform(
        lib::filter(lib::iota(size), if_noshrink{std::move(skip)}),
        to_label<F>{std::move(context), std::move(gen)});
  }
} view;
 
static const class {
private:
  struct to_label {
    lib::finally_t<> operator()(std::uintmax_t i) const {
      auto label1 = gen::label(id);
      auto label2 = gen::label(i);
      return std::move(label1) + std::move(label2);
    }
 
    lib::atom id;
  };
 
  struct if_noshrink {
    bool operator()(std::uintmax_t i) const { return !skip[skip.size() - i - 1]; }
    std::vector<bool> skip;
  };
 
  using view = lib::transform_view<lib::filter_view<lib::iota_view<std::uintmax_t>, if_noshrink>, to_label>;
 
public:
  view operator()(lib::atom id) const {
    using namespace lib::literals;
 
    auto _ = gen::label(id);
 
    auto size = gen::sample("size"_s, gen::size());
 
    std::vector<bool> skip;
    {
      auto _ = gen::label("shrink"_s);
      for (std::uintmax_t i = 0; i < size; i++)
        skip.push_back(gen::shrink(i).has_value());
    }
 
    return lib::transform(lib::filter(lib::iota(size), if_noshrink{std::move(skip)}), to_label{id});
  }
 
  template<typename F, HALCHECK_REQUIRE(lib::is_invocable<F, lib::atom>())>
  void operator()(lib::atom id, F func) const {
    using namespace lib::literals;
    for (auto _ : (*this)(id))
      lib::invoke(func, "func"_s);
  }
} repeat;
 
template<
    typename T,
    typename F,
    HALCHECK_REQUIRE(lib::is_insertable_range<T>()),
    HALCHECK_REQUIRE(lib::is_invocable_r<lib::range_value_t<T>, F, lib::atom>())>
T container(lib::atom id, F gen) {
  using namespace lib::literals;
  T output;
  auto it = lib::end(output);
  for (auto _ : gen::repeat(id))
    it = std::next(output.insert(it, lib::invoke(gen, "gen"_s)));
  return output;
}
 
template<
    typename T,
    typename F,
    HALCHECK_REQUIRE(lib::is_insertable_range<T>()),
    HALCHECK_REQUIRE(lib::is_invocable_r<lib::range_value_t<T>, F, lib::atom>())>
T container(lib::atom id, std::size_t size, F gen) {
  auto _ = gen::label(id);
 
  T output;
  auto it = lib::end(output);
  while (size-- > 0)
    it = std::next(output.insert(it, lib::invoke(gen, size)));
  return output;
}
 
template<typename I, HALCHECK_REQUIRE(lib::is_forward_iterator<I>())>
void shuffle(lib::atom id, I begin, I end) {
  auto _ = gen::label(id);
  for (auto it = begin; it != end; ++it)
    std::iter_swap(it, gen::range(it - begin, it, end));
}
 
template<typename Range, HALCHECK_REQUIRE(lib::is_forward_range<lib::decay_t<Range>>())>
void shuffle(lib::atom id, Range &&range) {
  gen::shuffle(id, lib::begin(range), lib::end(range));
}
 
}} // namespace halcheck::gen
 
#endif