primitives.h

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


    Generator<bool> booleans();

    // Concrete IGenerator<T> subclass produced by just(). A constant draws
    // zero entropy, so it returns the captured value without touching the
    // engine at all.
    template <typename T> class JustGenerator : public IGenerator<T> {
      public:
        explicit JustGenerator(T value) : value_(std::move(value)) {}
 
        T do_draw(const TestCase&) const override { return value_; }
 
      private:
        T value_;
    };

    template <typename T> Generator<T> just(T value) {
        return Generator<T>(new JustGenerator<T>(std::move(value)));
    }

    inline Generator<std::string> just(const char* value) {
        return just(std::string(value));
    }

 
} // namespace hegel::generators