Result

class pandas::Result

pandas C++ class.

Example

#include <pandas/pandas.h>
using namespace pandas;

// Use Result
Result obj;
// ... operations ...

Constructors

Signature	Location	Example
Result() = default	pd_result.h:128	View
Result(Result&&) noexcept = default	pd_result.h:129	View
Result(const Result&) = delete	pd_result.h:131	View

Type Checking

Signature	Return Type	Location	Example
bool is_empty() const noexcept	bool	pd_result.h:254	View
bool is_frame() const noexcept	bool	pd_result.h:281	View
bool is_index() const noexcept	bool	pd_result.h:284	View
bool is_ndarray() const noexcept	bool	pd_result.h:287	View
bool is_scalar() const noexcept	bool	pd_result.h:257	View
bool is_series() const noexcept	bool	pd_result.h:262	View

Other Methods

Signature	Return Type	Location	Example
static Result of_frame(std::unique_ptr<DataFrame> f)	static Result	pd_result.h:231
static Result of_index(std::unique_ptr<IndexBase> ix)	static Result	pd_result.h:236
static Result of_ndarray(std::unique_ptr<numpy::NDArray<double>> a)	static Result	pd_result.h:241
static Result of_ndarray(std::unique_ptr<numpy::NDArray<std::int64_t>> a)	static Result	pd_result.h:246
static Result of_scalar(double v)	static Result	pd_result.h:136	View
static Result of_scalar(std::int64_t v)	static Result	pd_result.h:141	View
static Result of_scalar(std::string v)	static Result	pd_result.h:146	View
static Result of_series(std::unique_ptr<Series<numpy::float64>> s)	static Result	pd_result.h:154	View
static Result of_series(std::unique_ptr<Series<std::int64_t>> s)	static Result	pd_result.h:159	View
static Result of_series(std::unique_ptr<Series<std::string>> s)	static Result	pd_result.h:164	View
static Result of_series(std::unique_ptr<Series<std::complex<double>>> s)	static Result	pd_result.h:169	View
static Result of_series(std::unique_ptr<Series<std::int32_t>> s)	static Result	pd_result.h:175	View
static Result of_series(std::unique_ptr<Series<numpy::float32>> s)	static Result	pd_result.h:180	View
static Result of_series(std::unique_ptr<Series<numpy::bool_>> s)	static Result	pd_result.h:185	View
static Result of_series(std::unique_ptr<Series<numpy::datetime64>> s)	static Result	pd_result.h:190	View
static Result of_series(std::unique_ptr<Series<numpy::timedelta64>> s)	static Result	pd_result.h:195	View
static Result of_series(std::unique_ptr<Series<numpy::object_>> s)	static Result	pd_result.h:201	View
static Result of_series(std::unique_ptr<Series<numpy::uint8>> s)	static Result	pd_result.h:208	View
static Result of_series(std::unique_ptr<Series<numpy::uint16>> s)	static Result	pd_result.h:213	View
static Result of_series(std::unique_ptr<Series<numpy::uint32>> s)	static Result	pd_result.h:218	View
static Result of_series(std::unique_ptr<Series<numpy::uint64>> s)	static Result	pd_result.h:223	View

Code Examples

The following examples are extracted from the test suite.

Result (pd_test_5_all.cpp:141161)

    if (!got) return;
    auto& sp = std::get<std::unique_ptr<pandas::Series<numpy::float64>>>(r.value);
    bool ok = (sp->size() == 1) && (*sp)[0] == 5.0;
    pandas_tests::check(ok, "case_H4.value_max_5", local_fail);
}

static void f_series_apply_dispatch_804133_case_H5_dispatcher_none_arm(int& local_fail) {
    std::cout << "-- case_H5_dispatcher_none_arm\n";
    pandas::Series<numpy::float64> s({1.0, 2.0}, "v");
    pandas::Result r = s.apply_dispatch(pandas::FuncArg::none());
    // None_ -> empty Result (monostate)
    bool is_mono = std::holds_alternative<std::monostate>(r.value);
    pandas_tests::check(is_mono, "case_H5.none_returns_monostate", local_fail);
}

void f_series_apply_dispatch_804133_case_1_apply_id_Int64(int& local_fail) {
    std::cout << "-- case_1_apply_id_Int64\n";
    pandas::Series<std::int64_t> s({1, 2, 3});
    s.set_dtype_override("Int64");
    auto r = s.apply([](std::int64_t x) { return x; });
    pandas::DataFrame df = r.to_frame(std::optional<std::string>("v"));

Result (pd_test_5_all.cpp:141161)

    if (!got) return;
    auto& sp = std::get<std::unique_ptr<pandas::Series<numpy::float64>>>(r.value);
    bool ok = (sp->size() == 1) && (*sp)[0] == 5.0;
    pandas_tests::check(ok, "case_H4.value_max_5", local_fail);
}

static void f_series_apply_dispatch_804133_case_H5_dispatcher_none_arm(int& local_fail) {
    std::cout << "-- case_H5_dispatcher_none_arm\n";
    pandas::Series<numpy::float64> s({1.0, 2.0}, "v");
    pandas::Result r = s.apply_dispatch(pandas::FuncArg::none());
    // None_ -> empty Result (monostate)
    bool is_mono = std::holds_alternative<std::monostate>(r.value);
    pandas_tests::check(is_mono, "case_H5.none_returns_monostate", local_fail);
}

void f_series_apply_dispatch_804133_case_1_apply_id_Int64(int& local_fail) {
    std::cout << "-- case_1_apply_id_Int64\n";
    pandas::Series<std::int64_t> s({1, 2, 3});
    s.set_dtype_override("Int64");
    auto r = s.apply([](std::int64_t x) { return x; });
    pandas::DataFrame df = r.to_frame(std::optional<std::string>("v"));

Result (pd_test_5_all.cpp:141161)

    if (!got) return;
    auto& sp = std::get<std::unique_ptr<pandas::Series<numpy::float64>>>(r.value);
    bool ok = (sp->size() == 1) && (*sp)[0] == 5.0;
    pandas_tests::check(ok, "case_H4.value_max_5", local_fail);
}

static void f_series_apply_dispatch_804133_case_H5_dispatcher_none_arm(int& local_fail) {
    std::cout << "-- case_H5_dispatcher_none_arm\n";
    pandas::Series<numpy::float64> s({1.0, 2.0}, "v");
    pandas::Result r = s.apply_dispatch(pandas::FuncArg::none());
    // None_ -> empty Result (monostate)
    bool is_mono = std::holds_alternative<std::monostate>(r.value);
    pandas_tests::check(is_mono, "case_H5.none_returns_monostate", local_fail);
}

void f_series_apply_dispatch_804133_case_1_apply_id_Int64(int& local_fail) {
    std::cout << "-- case_1_apply_id_Int64\n";
    pandas::Series<std::int64_t> s({1, 2, 3});
    s.set_dtype_override("Int64");
    auto r = s.apply([](std::int64_t x) { return x; });
    pandas::DataFrame df = r.to_frame(std::optional<std::string>("v"));

is_empty (pd_test_1_all.cpp:2164)

    // Test with right-closed intervals (a, b]
    std::vector<std::pair<numpy::float64, numpy::float64>> tuples = {
        {0.0, 1.0},   // Not empty
        {1.0, 1.0},   // Empty (1, 1] has no points
        {2.0, 2.0},   // Empty
        {2.0, 3.0}    // Not empty
    };

    auto arr_right = pandas::IntervalArrayFloat64::from_tuples(tuples, pandas::IntervalClosed::Right);
    auto empty_right = arr_right.is_empty();

    if (empty_right[0].value_or(true) != false ||
        empty_right[1].value_or(false) != true ||
        empty_right[2].value_or(false) != true ||
        empty_right[3].value_or(true) != false) {
        std::cout << "[FAIL] : in test_is_empty() : right-closed" << std::endl;
        return;
    }

    // Test with both-closed intervals [a, b] - [1, 1] is NOT empty

is_frame (pd_test_5_all.cpp:50614)

}

void case_1_dict_axis1(int& local_fail) {
    std::cout << "-- case_1_dict_axis1\n";
    auto df = make_flat_frame();
    pandas::RenameSpec spec;
    spec.kind = pandas::RenameSpec::Kind::Dict;
    spec.dict_mapper["a"] = "A";
    spec.dict_mapper["b"] = "B";
    auto r = df.rename_result(spec, /*axis=*/1, /*inplace=*/false, /*errors_raise=*/false);
    pandas_tests::check(r.is_frame(), "case_1.is_frame", local_fail);
    if (!r.is_frame()) return;
    auto& f = *std::get<std::unique_ptr<pandas::DataFrame>>(r.value);
    pandas_tests::check(f.columns().get_value_str(0) == "A", "case_1.col0_A", local_fail);
    pandas_tests::check(f.columns().get_value_str(1) == "B", "case_1.col1_B", local_fail);
}

void case_2_dict_axis0(int& local_fail) {
    std::cout << "-- case_2_dict_axis0\n";
    auto df = make_flat_frame();
    df.set_index(std::make_unique<pandas::Index<std::string>>(

is_index (pd_test_5_all.cpp:100525)

    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),
        "C_26m_case_2_object_is_introspection_contract()_not_empty", local_fail);
    pandas_tests::check(!r.is_scalar(),
        "C_26m_case_2_object_is_introspection_contract()_not_scalar", local_fail);
    pandas_tests::check(r.is_series(),
        "C_26m_case_2_object_is_introspection_contract()_is_series", local_fail);
    pandas_tests::check(!r.is_frame(),
        "C_26m_case_2_object_is_introspection_contract()_not_frame", local_fail);
    pandas_tests::check(!r.is_index(),
        "C_26m_case_2_object_is_introspection_contract()_not_index", local_fail);
    pandas_tests::check(!r.is_ndarray(),
        "C_26m_case_2_object_is_introspection_contract()_not_ndarray", local_fail);
}

void case_3_object_fillna_nan_no_missing(int& local_fail) {
    std::cout << "-- case_3_object_fillna_nan_no_missing\n";
    pandas::Series<numpy::object_> s(
        std::vector<numpy::object_>{
            numpy::object_(std::string("a")),

is_ndarray (pd_test_5_all.cpp:100527)

    pandas_tests::check(!r.is_empty(),
        "C_26m_case_2_object_is_introspection_contract()_not_empty", local_fail);
    pandas_tests::check(!r.is_scalar(),
        "C_26m_case_2_object_is_introspection_contract()_not_scalar", local_fail);
    pandas_tests::check(r.is_series(),
        "C_26m_case_2_object_is_introspection_contract()_is_series", local_fail);
    pandas_tests::check(!r.is_frame(),
        "C_26m_case_2_object_is_introspection_contract()_not_frame", local_fail);
    pandas_tests::check(!r.is_index(),
        "C_26m_case_2_object_is_introspection_contract()_not_index", local_fail);
    pandas_tests::check(!r.is_ndarray(),
        "C_26m_case_2_object_is_introspection_contract()_not_ndarray", local_fail);
}

void case_3_object_fillna_nan_no_missing(int& local_fail) {
    std::cout << "-- case_3_object_fillna_nan_no_missing\n";
    pandas::Series<numpy::object_> s(
        std::vector<numpy::object_>{
            numpy::object_(std::string("a")),
            numpy::object_(std::string("b")),
            numpy::object_(std::string("c"))},

is_scalar (pd_test_5_all.cpp:100519)

        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),
        "C_26m_case_2_object_is_introspection_contract()_not_empty", local_fail);
    pandas_tests::check(!r.is_scalar(),
        "C_26m_case_2_object_is_introspection_contract()_not_scalar", local_fail);
    pandas_tests::check(r.is_series(),
        "C_26m_case_2_object_is_introspection_contract()_is_series", local_fail);
    pandas_tests::check(!r.is_frame(),
        "C_26m_case_2_object_is_introspection_contract()_not_frame", local_fail);
    pandas_tests::check(!r.is_index(),
        "C_26m_case_2_object_is_introspection_contract()_not_index", local_fail);
    pandas_tests::check(!r.is_ndarray(),
        "C_26m_case_2_object_is_introspection_contract()_not_ndarray", local_fail);
}

is_series (pd_test_5_all.cpp:100508)

    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),
        "C_26m_case_2_object_is_introspection_contract()_not_empty", local_fail);

of_scalar (pd_test_func_dispatch_5.cpp:109)

    sum_fs.name = "sum";
    dict_specs["a"].push_back(std::move(sum_fs));
    auto fa5 = pandas::FuncArg::from_dict_spec(std::move(dict_specs));
    pandas_tests::check(fa5.kind == pandas::FuncArgKind::DictSpec,
                        "from_dict_spec -> DictSpec", fail);
}

static void test_dispatcher_arms(int& fail) {
    pandas::FuncDispatcher disp;
    disp.on_string([](const std::string& name) {
        return pandas::Result::of_scalar(static_cast<std::int64_t>(name.size()));
    });
    disp.on_string_list([](const std::vector<std::string>& names) {
        return pandas::Result::of_scalar(static_cast<std::int64_t>(names.size()));
    });
    disp.on_callable([](const pandas::CallableHandle& h) {
        pandas::MapCellInput in;
        in.kind = pandas::MapCellInput::Float;
        in.f = 0.0;
        auto cell = h->invoke_cell(in);
        return pandas::Result::of_scalar(cell.f);

of_scalar (pd_test_func_dispatch_5.cpp:109)

    sum_fs.name = "sum";
    dict_specs["a"].push_back(std::move(sum_fs));
    auto fa5 = pandas::FuncArg::from_dict_spec(std::move(dict_specs));
    pandas_tests::check(fa5.kind == pandas::FuncArgKind::DictSpec,
                        "from_dict_spec -> DictSpec", fail);
}

static void test_dispatcher_arms(int& fail) {
    pandas::FuncDispatcher disp;
    disp.on_string([](const std::string& name) {
        return pandas::Result::of_scalar(static_cast<std::int64_t>(name.size()));
    });
    disp.on_string_list([](const std::vector<std::string>& names) {
        return pandas::Result::of_scalar(static_cast<std::int64_t>(names.size()));
    });
    disp.on_callable([](const pandas::CallableHandle& h) {
        pandas::MapCellInput in;
        in.kind = pandas::MapCellInput::Float;
        in.f = 0.0;
        auto cell = h->invoke_cell(in);
        return pandas::Result::of_scalar(cell.f);

of_scalar (pd_test_func_dispatch_5.cpp:109)

    sum_fs.name = "sum";
    dict_specs["a"].push_back(std::move(sum_fs));
    auto fa5 = pandas::FuncArg::from_dict_spec(std::move(dict_specs));
    pandas_tests::check(fa5.kind == pandas::FuncArgKind::DictSpec,
                        "from_dict_spec -> DictSpec", fail);
}

static void test_dispatcher_arms(int& fail) {
    pandas::FuncDispatcher disp;
    disp.on_string([](const std::string& name) {
        return pandas::Result::of_scalar(static_cast<std::int64_t>(name.size()));
    });
    disp.on_string_list([](const std::vector<std::string>& names) {
        return pandas::Result::of_scalar(static_cast<std::int64_t>(names.size()));
    });
    disp.on_callable([](const pandas::CallableHandle& h) {
        pandas::MapCellInput in;
        in.kind = pandas::MapCellInput::Float;
        in.f = 0.0;
        auto cell = h->invoke_cell(in);
        return pandas::Result::of_scalar(cell.f);

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),

of_series (pd_test_5_all.cpp:100507)

        return sp->dtype_name_full();
    }
    return "<not-object-series>";
}

void case_1_object_of_series_compiles_and_is_series(int& local_fail) {
    std::cout << "-- case_1_object_of_series_compiles_and_is_series\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    // The line below is the INSTANTIATION PROOF — it fails to compile
    // against pre-fix HEAD (no matching Result::of_series overload).
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(r.is_series(),
        "C_26m_case_1_object_of_series_compiles_and_is_series()_is_series",
        local_fail);
}

void case_2_object_is_introspection_contract(int& local_fail) {
    std::cout << "-- case_2_object_is_introspection_contract\n";
    auto sp = mk_obj3_strings("a", "b", "c");
    pandas::Result r = pandas::Result::of_series(std::move(sp));
    pandas_tests::check(!r.is_empty(),