Static Reflection (C++26)

#include <meta>
#include <print>
#include <string_view>

struct Point { int x; int y; float z; };

consteval std::string_view field_name(std::meta::info m) {
    return std::meta::name_of(m);
}

int main() {
    // List all non-static data members  // C++26
    constexpr auto members = std::meta::nonstatic_data_members_of(^^Point);
    // members is a constexpr range of std::meta::info

    // Iterate at compile time (via template expansion)
    [:members...;] // expansion statement (P1306)
}

#include <meta>
#include <string>
#include <format>

template<typename T>
std::string to_json(const T& obj) {
    std::string result = "{";
    bool first = true;
    template for (constexpr auto member : std::meta::nonstatic_data_members_of(^^T)) {
        if (!first) result += ", ";
        first = false;
        result += std::format("\"{}\":{}", 
            std::meta::name_of(member),
            obj.[:member:]  // splice: access the actual field
        );
    }
    return result + "}";
}

struct Config { int port; std::string host; bool tls; };

// Usage
Config cfg{8080, "localhost", true};
// to_json(cfg) → {"port":8080, "host":"localhost", "tls":true}

#include <meta>

// Check if a type has a specific member
consteval bool has_member(std::meta::info type_info, std::string_view name) {
    for (auto m : std::meta::nonstatic_data_members_of(type_info)) {
        if (std::meta::name_of(m) == name) return true;
    }
    return false;
}

struct Foo { int x; };
struct Bar { float y; };

static_assert(has_member(^^Foo, "x"));
static_assert(!has_member(^^Bar, "x"));

#include <meta>
#include <string_view>
#include <optional>

enum class Color { Red, Green, Blue };

constexpr std::optional<std::string_view> enum_name(Color c) {
    template for (constexpr auto e : std::meta::enumerators_of(^^Color)) {
        if ([:e:] == c) return std::meta::name_of(e);
    }
    return std::nullopt;
}

// enum_name(Color::Green) == "Green"   (constexpr, zero overhead)

struct Vec3 { float x, y, z; };

// Access field by reflected info
constexpr auto x_info = ^^Vec3::x;
Vec3 v{1.f, 2.f, 3.f};
float val = v.[:x_info:];   // same as v.x — resolved at compile time

// Splice a type
using T = [:std::meta::type_of(x_info):];   // T == float

// Splice in template arguments
template<typename T> struct Box { T value; };
constexpr auto meta_float = ^^float;
Box<[:meta_float:]> b{3.14f};   // Box<float>

#include <meta>

// Generate a visit function for a variant from its types
template<typename Variant>
constexpr auto make_visitor(auto&&... lambdas) {
    struct Visitor : decltype(lambdas)... {
        using decltype(lambdas)::operator()...;
    };
    return Visitor{std::forward<decltype(lambdas)>(lambdas)...};
}

// C++26
int a = 5, b = 3;
int xor_result  = a ^ b;          // still XOR — single caret, two operands
auto r          = ^^int;          // reflection — double caret, one operand (a type)
auto r2         = ^^MyStruct;     // reflect a class type
auto r3         = ^^::;           // reflect the global namespace
auto r4         = ^^std;          // reflect the std namespace

// Both work together in the same expression without confusion:
bool same = (^^int == ^^int);     // true — info values are comparable

#include <meta>
#include <print>

struct Animal  { virtual ~Animal() = default; };
struct Flyable { void fly(); };
struct Bird : public Animal, public Flyable { int feathers; };

consteval void describe_bases() {
    // C++26
    template for (constexpr auto b : std::meta::base_classes_of(^^Bird)) {
        // Recover the base type as a usable type via splice
        using BaseType = [:std::meta::type_of(b):];

        std::print("base: {}  public: {}\n",
            std::meta::identifier_of(b),
            std::meta::is_public(b));
    }
}
// Output (compile-time):
//   base: Animal   public: true
//   base: Flyable  public: true

#include <meta>
#include <string>
#include <format>

int add(int lhs, int rhs);         // declaration is enough

// Build a compile-time signature string from reflection
consteval std::string signature_of(std::meta::info fn) {
    // C++26
    std::string sig;
    sig += std::meta::identifier_of(std::meta::return_type_of(fn));
    sig += " ";
    sig += std::meta::identifier_of(fn);
    sig += "(";
    bool first = true;
    for (auto p : std::meta::parameters_of(fn)) {
        if (!first) sig += ", ";
        first = false;
        sig += std::meta::identifier_of(std::meta::type_of(p));
        sig += " ";
        sig += std::meta::identifier_of(p);
    }
    sig += ")";
    return sig;
}

static_assert(signature_of(^^add) == "int add(int lhs, int rhs)");

#include <meta>
#include <vector>
#include <string_view>

// C++26 — experimental; subject to change before final standardization
//
// Given a list of (name, type-reflection) pairs, produce a struct with those fields.
// Example use case: a "parallel struct" that mirrors another struct's layout.

consteval std::meta::info make_parallel_struct(
    std::span<const std::pair<std::string_view, std::meta::info>> fields)
{
    std::vector<std::meta::data_member_spec> specs;
    specs.reserve(fields.size());
    for (auto [name, type_r] : fields) {
        specs.push_back(std::meta::data_member_spec{
            .name = name,
            .type = type_r,
        });
    }
    // define_aggregate returns the std::meta::info for the newly created type
    return std::meta::define_aggregate(specs);
}

// Build a struct equivalent to: struct MyPoint { float x; float y; };
constexpr std::pair<std::string_view, std::meta::info> point_fields[] = {
    {"x", ^^float},
    {"y", ^^float},
};
constexpr auto MyPoint_r = make_parallel_struct(point_fields);
using MyPoint = [:MyPoint_r:];   // splice it into a real type alias

MyPoint p;
p.x = 1.0f;
p.y = 2.0f;

#include <meta>
#include <string>
#include <format>

// C++26 — verify no two enumerators share the same value
template<typename E>
    requires std::is_enum_v<E>
consteval void assert_no_duplicate_enum_values() {
    constexpr auto enumerators = std::meta::enumerators_of(^^E);
    for (std::size_t i = 0; i < enumerators.size(); ++i) {
        for (std::size_t j = i + 1; j < enumerators.size(); ++j) {
            if ([:enumerators[i]:] == static_cast<E>([:enumerators[j]:])) {
                // Provide the names in the error message via identifier_of
                // (consteval context — this will be a compile error, not UB)
                throw std::logic_error(
                    std::format("duplicate values: {} and {}",
                        std::meta::identifier_of(enumerators[i]),
                        std::meta::identifier_of(enumerators[j])));
            }
        }
    }
}

// Verify that every non-static data member of a struct has a non-void type
template<typename T>
consteval void assert_no_void_members() {
    // C++26
    template for (constexpr auto m : std::meta::nonstatic_data_members_of(^^T)) {
        static_assert(
            !std::meta::is_void_type(std::meta::type_of(m)),
            "struct member has void type — reflection found a problem"
        );
    }
}

enum class Status { Ok = 0, Warn = 1, Error = 2 };
struct Response { int code; std::string body; };

// These fire at compile time if the invariants are violated:
constexpr auto _check_status  = (assert_no_duplicate_enum_values<Status>(), 0);
constexpr auto _check_response = (assert_no_void_members<Response>(), 0);

// Godbolt quick-start — paste this into the editor with clang-p2996
// Flags: -std=c++26 -freflection -freflection-new-syntax
#include <meta>
#include <print>

enum class Dir { North, South, East, West };

int main() {
    template for (constexpr auto e : std::meta::enumerators_of(^^Dir)) {
        std::print("{}\n", std::meta::identifier_of(e));
    }
}
// Output: North  South  East  West