Is there any way to iterate data members with STL algorithms using the C++26 reflection?

There are really two questions here.

Is there anyway to iterate data members with STL algorithms using the C++26 reflection?

This is straightforwardly yes. std::meta::info is just a scalar type, so if you get a std::vector<std::meta::info> from some reflection operation, that is just a regular range, and so all of the standard library algorithms just work. There are many examples in the reflection papers demonstrating this, and indeed it's pretty fundamental to the design of value-based reflection that generic code Just Works.

The simplest (if perhaps quite boring) example is:

constexpr std::array types = {^^int, ^^float, ^^double};
constexpr std::array sizes = []{
  std::array<std::size_t, types.size()> r;
  std::ranges::transform(types, r.begin(), std::meta::size_of);
  return r;
}();

types is a range of reflections, std::meta::size_of is a consteval function, all of this just works.

But the second question is about:

std::ranges::for_each(members, [&foo](auto member) {
    std::cout << identifier_of(member) << ": " << foo.[:member:] << std::endl;
}));

Because here, you're not just trying to iterate over the members — you also need them to be constants in the body. identifier_of(member) needs to be a constant expression, and in order for foo.[: member :] to work, member needs to be a constant expression.

This isn't any different from trying to iterate over a vector<int> using ranges::for_each and trying to make differently sized arrays from each int. That doesn't work, because you need the ints to be constant, and they're not. Except maybe it's just more obvious that that doesn't work since we're all very familiar with vector<int> and Reflection is much, much newer.

So situations like this will require template for, or some other mechanism to pass through member as a constant. You can still manipulate the range of reflections with ranges algorithms.

One wacky approach, demonstrating that you can still use ranges algorithms, is to convert each non-static data member into a function pointer that prints it. In order to print it, we need the member as a constant, so something like this:

template <std::meta::info R>
void PrintMember(const Foo& foo) {
  std::cout << identifier_of(R) << ": " << foo.[:R:] << std::endl;
}

Note that every specialization of PrintMember has the same signature: void(const Foo&). The template parameter doesn't participate.

That means we can then write this (demo):

void PrintFoo(const Foo& foo) {
    constexpr auto fs = 
        define_static_array(
            nonstatic_data_members_of(^^Foo, std::meta::access_context::current())
            | std::views::transform([](auto member){
                auto f = substitute(^^PrintMember, {std::meta::reflect_constant(member)});
                return extract<void(*)(const Foo&)>(f);
            })
        );

    std::ranges::for_each(fs, [&foo](auto f) {
        f(foo);
    });
}

We're turning every member into a void(*)(const Foo&) — and at that point we can just loop over all of them and call them. We've already stashed away the constant. This also demonstrates that define_static_array can take any range and can be used for any [structural] type too — it's not just for making std::span<std::meta::info const>.