effect.hpp

#ifndef HALCHECK_LIB_EFFECT_HPP
#define HALCHECK_LIB_EFFECT_HPP
 
#include <halcheck/lib/functional.hpp>
#include <halcheck/lib/optional.hpp>
#include <halcheck/lib/scope.hpp>
#include <halcheck/lib/tuple.hpp>
#include <halcheck/lib/type_traits.hpp>
#include <halcheck/lib/utility.hpp>
 
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <type_traits>
#include <vector>
 
namespace halcheck { namespace lib {
 
#ifdef HALCHECK_DOXYGEN
lib::effect_result_t<T> fallback(T args);
#endif
 
static const class {
private:
  template<typename T>
  using member_t = decltype(std::declval<const T &>().fallback());
 
  template<typename T>
  using free_t = decltype(fallback(std::declval<const T &>()));
 
public:
  template<typename T>
  member_t<T> operator()(T args) const {
    return std::move(args).fallback();
  }
 
  template<typename T, HALCHECK_REQUIRE(!lib::is_detected<member_t, T>())>
  free_t<T> operator()(T args) const {
    return fallback(std::move(args));
  }
} fallback;
 
template<typename T>
using effect_result_t = lib::invoke_result_t<decltype(lib::fallback), const T &>;
 
template<typename T>
struct is_effect : lib::is_detected<lib::effect_result_t, T> {};
 
class effect {
private:
  static std::size_t next();
 
  template<typename T>
  static std::size_t index() {
    static const std::size_t output = next();
    return output;
  }
 
  struct entry {
    void *func;
    const std::vector<lib::optional<entry>> *context;
  };
 
  using context = std::vector<lib::optional<entry>>;
 
  static const context empty;
  static thread_local const context *current;
 
  struct clone_effect {
    lib::move_only_function<lib::finally_t<>(bool)> fallback() const;
  };
 
  template<typename Effect>
  struct base {
    static_assert(lib::is_effect<Effect>(), "Effect must satisfy is_effect");
    virtual lib::effect_result_t<Effect> operator()(Effect args) = 0;
  };
 
public:
  template<typename T, HALCHECK_REQUIRE(lib::is_effect<T>())>
  static lib::effect_result_t<T> invoke(T args) {
    const std::size_t i = index<T>();
    if (i < current->size() && (*current)[i]) {
      auto &entry = *(*current)[i];
      assert(entry.func && "entry.func should not be null");
      assert(entry.context && "entry.context should not be null");
      auto old = lib::exchange(current, entry.context);
      auto _ = lib::finally([&] { current = old; });
      return (*reinterpret_cast<base<T> *>(entry.func))(std::move(args));
    } else {
      auto old = lib::exchange(current, &empty);
      auto _ = lib::finally([&] { current = old; });
      return lib::fallback(std::move(args));
    }
  }
 
  template<
      typename T,
      typename... Args,
      HALCHECK_REQUIRE(lib::is_effect<T>()),
      HALCHECK_REQUIRE(lib::is_brace_constructible<T, Args...>())>
  static lib::effect_result_t<T> invoke(Args &&...args) {
    return invoke(T{std::forward<Args>(args)...});
  }
 
  template<typename Self, typename... Effects>
  class handler : private base<clone_effect>, private base<Effects>... {
  private:
    class reset {
    private:
      friend class handler;
 
      context next;
      const context *old;
 
      explicit reset(handler *self) : next(self->install()), old(lib::exchange(current, &next)) {}
 
    public:
      reset(reset &&other) noexcept : next(std::move(other.next)), old(other.old) {
        assert(current == &other.next);
        current = &next;
      }
 
      reset(const reset &) = delete;
      reset &operator=(reset &&) = delete;
      reset &operator=(const reset &) = delete;
      ~reset() = default;
 
      void operator()() const { current = old; }
    };
 
    class owning_reset {
    private:
      friend class handler;
 
      Self self;
      context next;
      const context *old;
 
      explicit owning_reset(handler *self)
          : self(std::move(*static_cast<Self *>(self))), next(this->self.install()),
            old(lib::exchange(current, &next)) {}
 
    public:
      owning_reset(owning_reset &&other) noexcept(std::is_nothrow_move_constructible<Self>())
          : self(std::move(other.self)), next((current = other.old, self.install())),
            old(lib::exchange(current, &next)) {}
 
      owning_reset(const owning_reset &) = delete;
      owning_reset &operator=(owning_reset &&) = delete;
      owning_reset &operator=(const owning_reset &) = delete;
      ~owning_reset() = default;
 
      void operator()() const { current = old; }
    };
 
  public:
    using scope = lib::finally_t<reset>;
 
    using owning_scope = lib::finally_t<owning_reset>;
 
    scope handle() & { return lib::finally(reset(this)); }
 
    owning_scope handle() && { return lib::finally(owning_reset(this)); }
 
    template<
        typename F,
        typename... Args,
        HALCHECK_REQUIRE(lib::is_invocable<F, Args...>()),
        HALCHECK_REQUIRE(lib::conjunction<lib::is_effect<Effects>...>())>
    lib::invoke_result_t<F, Args...> handle(F func, Args &&...args) {
      auto _ = handle();
      return lib::invoke(std::move(func), std::forward<Args>(args)...);
    }
 
  private:
    context install() {
      auto output = *current;
      output.resize(std::max({output.size(), index<clone_effect>(), index<Effects>()...}) + 1);
      output[index<clone_effect>()] = entry{static_cast<base<clone_effect> *>(this), current};
      lib::ignore = {(output[index<Effects>()] = entry{static_cast<base<Effects> *>(this), current})...};
      return output;
    }
 
    lib::effect_result_t<clone_effect> operator()(clone_effect) final {
      using namespace std::placeholders;
      return std::bind(
          [](bool owning, lib::effect_result_t<clone_effect> &outer, handler &copy) -> lib::finally_t<> {
            auto handler1 = outer(owning);
            if (owning) {
              return std::move(handler1) + std::move(copy).handle();
            } else {
              return std::move(handler1) + copy.handle();
            }
          },
          _1,
          invoke<clone_effect>(),
          *static_cast<Self *>(this));
    }
  };
 
  class state {
  public:
    state() = default;
 
    explicit state(lib::in_place_t);
 
    lib::finally_t<> handle() &;
 
    lib::finally_t<> handle() &&;
 
    template<typename F, typename... Args, HALCHECK_REQUIRE(lib::is_invocable<F, Args...>())>
    lib::invoke_result_t<F, Args...> handle(F func, Args &&...args) {
      auto _ = handle();
      return lib::invoke(std::move(func), std::forward<Args>(args)...);
    }
 
  private:
    lib::move_only_function<lib::finally_t<>(bool)> _impl;
  };
 
  static state save() { return state(lib::in_place); }
};
 
}} // namespace halcheck::lib
 
#endif