primitives.h

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


    Generator<bool> booleans();

    // Concrete IGenerator<T> subclass produced by just(). The schema's
    // "value" field is a placeholder — the server draws zero entropy for a
    // constant, so the client parser returns the locally captured value
    // regardless of what the server echoes back. This means just() works
    // for any T without requiring T to be JSON-serializable.
    template <typename T> class JustGenerator : public IGenerator<T> {
      public:
        explicit JustGenerator(T value) : value_(std::move(value)) {}
 
        std::optional<BasicGenerator<T>> as_basic() const override {
            T v = value_;
            return BasicGenerator<T>{
                {{"type", "constant"}, {"value", nullptr}},
                [v = std::move(v)](const hegel::internal::json::json_raw_ref&) {
                    return v;
                }};
        }
 
      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