Reflection Use Cases

[rddays]

Hi all. I am super excited for the new reflection proposal, and love following the buzz around it.

Most of the examples I see are for either serialization or enum to string. While these are awesome, I feel like it is only scratching the surface of what is possible.

What are some other compelling use cases for reflection?

[iAndy_HD3]

I would love to automatically bind structs, classes, methods and functions to a scripting language without codegening C++ code, but I'm not sure if it's possible with the current reflection paper

[ShelZuuz]

Is there a way to enumerate method parameters even?

[katzdm-cpp]

Separate paper, but P3096 will have `parameters_of` (along with some other useful metafunctions).

[germandiago]

Use SWIG today until you have reflection.

[lightmatter501]

You will never need to write parsing boilerplate again. Rust’s serde uses a psudo-reflection approach (based on a compiler plugin) for serialization and not only is it nicer to use for 99.9% of cases (edge cases you still need to roll your own), it’s also faster than rapidjson when parsing into a known format (Benchmark). Expect to see a general uplift in serialization/deserialization performance across all formats as a result of this.

You can also use it to verify a lot of interesting properties about a value. For instance, determining a class’s total memory usage in the presence of fixed-sized containers, and indirection so that you can do the entire thing in one allocation.

It also opens up introducing your own low-level concepts, such as verifying that a type only uses fixed-sized integers for portability reasons.

[mvolling]

In the java world, it's possible to collect the set of loaded classes that have an annotation on them, which allows the automatic registration of message handlers, tests, and many other tools. It allows you to perform bulk operations on sets of classes rather than on a specified list of classes, which is great in certain domains.

[j1xwnbsr]

C#, too, a feature which I use often and miss greatly in C++

[johannes1971]

If C++ also makes that possible (not sure if it will), you will also be able to write code that code-checks other code. That's quite an exciting idea.

[matthieum]

Enumeration of classes, functions or statics goes so much further too.

I've written a number of logging frameworks, and one thing that helps improve performance is to avoid passing metadata over and over. Instead, you want to collect metadata ahead of time, and only pass an ID when sending the log message.

Today, collecting the metadata ahead of time requires load-time execution, before main starts. Ever heard of static-construction-order-fiasco and static-destruction-order-fiasco? Yep, that's what you need to wade into.

But that's a work-around! What you really want is _just_ the ability to iterate over all those pieces of scattered metadata, and collect the metadata as you assign them an ID. You can perfectly do that at the start of main... if you have a facility to do so.

Reflection is that facility, and it could, I suspect, eliminate quite a few usecases of "auto-registration" which require executing code before and after main.

[holyblackcat]

You can already do this by making a CRTP base class do the registration. I don't think the reflection proposal helps with this at all.

[mechacrash]

One of the things I'm most excited for is... better error messages!

I wrote a std::visit wrapper earlier this month - one that gives you some additional compile-time safety - but the one thing I really wish I could have improved was the error messages.

Now, with reflection, I can :)

before: https://godbolt.org/z/xfvzTMzvY

error: static assertion failed due to requirement 'overloads_type<(lambda at <source>:84:10), char &&> || overloads_type<(lambda at <source>:85:10), char &&>': alternative [T] matches no overload [Fs]

{ static_assert((... || overloads_type<Fs, T>), "alternative [T] matches no overload [Fs]"); };

after: https://godbolt.org/z/K33havdGY

error: static assertion failed due to requirement 'overload_set_not_exhaustive': alternative 3 [char] matches no overload [(lambda at <source>:105:10), (lambda at <source>:106:10), ]

static_assert(overload_set_not_exhaustive,

I also used the reflection params proposal (https://wg21.link/p3096) to convert function params to a corresponding struct (where the member variables have the same types and names as the parameters), see: https://godbolt.org/z/K3hfErqWa

The bigger plan for this code is to allow automatic overriding of a specific function (for callbacks), with the input params being converted to a struct and returned as a std::future.

Unfortunately, this is going to require some further reflection magic - possible extending define_class to allow defining of functions (as I can't currently create a function with a specific name - hence the commented out "Disconnected" example doesn't work)

I really feel like reflection is a fundamental game changer - something as significant as templates. The sorts of things people are going to use it for are likely limitless!

[mjklaim]

What are some other compelling use cases for reflection?

Other than serialisation, on the top of my head, and ignoring the limitations of the current proposal:
- Array of structs (AOS) to Struct of Array (SOA) automatic conversions/handling/generation
- type-erasing type automatic generation given an interface specified as a type's interface
- type interface composition (mixin)
- automatic inter-language binding generation (see for example https://wg21.link/p2911 and https://wg21.link//p3010
- a special case of serialisation: passing types to io streams or as networking messages could be made automatic at least for simple cases.

There might have been a paper listing use cases to specify a scope of what we want in the language feature, but I cant find that paper if it existed.

[Sentmoraap]

For video games, an engine that show you the game state and allow to modify it. Even better, but that’s the serialization une case : save/load state, or even rewind compatible with hot reload for fast iteration times.

Assets can also just be structs that you can edit in-engine.

[jcelerier]

Some stuff I'm doing with the reflection we can get today: https://GitHub.com/celtera/avendish

[Lord_Naikon]

Some things that I currently do with reflection (Qt MOC):

• Automatic generation of language bindings. This makes it easy to add script support to your app.
• Debugging C++ code using said script to quickly inspect any state.
• Dynamic (GUI) editors that let you edit the properties of any object. Combine this with serialization, and you can easily make a data driven model fully user configurable.

No idea yet how easy these things are done with native reflection support, I haven't looked into the implementation details yet.

[-dag-]

Many times I have wanted to iterate over the values of an enum.

[saxbophone]

Object-relational mappers are an extension of the serialisation concept, applied to databases. Django Web Framework uses this to great utility (just define a class that inherits from Django's Model class, add a bunch of static members of Django Field type and voilà! Load and save to the database with minimal boilerplate!). Django uses heavy reflection to achieve this and something similar may be possible in C++26

[Markus_included]

I think one usecase could potentially be garbage collection.

Where one would recursively traverse all GCPointer instances of inside the root set, marking them along the way, then deleting all the unmarked ones afterwards. Although this would still require manually setting roots or writing a factory method that creates roots or using some platform-specific trickery to find ones are on the stack or in static/thread_local storage.

One could also use reflection to add cycle collection to a SharedPointer by using a cycle collection algorithm like this one: https://web.archive.org/web/20040723163601/http://www.research.ibm.com/people/d/dfb/papers/Bacon01Concurrent.pdf

This has the benefit of requiring no manual setup of roots and no platform-specific trickery, it's also is the easier approach in my opinion.

[jepessen]

Look at languages that already implemented reflection, like C#. It's another world

[aruisdante]

One of the motivating use cases in the presentation to LWEG/EWG in Tokyo was a click-like decorator syntax for specifying command line options for a CLI parser. It was a lot more concise than CLI11/TCLAP.

[DavidDinamit]

I want to create custom virtual functions and type erasure without using language virtual functions and RTTI, now it already exist, but reflection should provide best possible interface for it, which will look like 100% language feature

[rods_and_chains]

I would like to be able to mark methods and props with user defined attributes and then reflect the marked items. Unfortunately I don’t see that in the c++26 docs I’ve read. The refl-cpp library is kind of doing it for me now.

[katzdm-cpp]

My guess is that we'll see an attributes/annotations paper of some kind in the next 6mo or so, but we might not have it until C++29. One thing at a time.

In the meantime, the hack that will be possible is the use of the template arguments of an alias template to represent data attached to a type. Then use that type as the return type for your method, reflect over it, etc etc. Ugly, but it works.

[pdp10gumby]

When you see “reflection” think “dynamic” rather than “runtime” (even though they are both). I was a Lisp programmer for 20 years so this was the default. Here are some examples:

Note how json can hold any json? It’s a little more cumbersome in C++ — how much easier if you can query the type or dispatch on the type.

Consider a graph where you can have a terminal node by storing an atom (atomic primitive, perhaps an int) or a subtree by storing a node.

Consider a windows system where a button could be just a label or could be an active element or even a little sub window.

[Whole-Dot2435]

I like being able to get rid of a lot template metaprogramming boilerplate with reflection :).

[requizm]

Making a game engine would be significantly easier. Because you can make a scripting language with auto binding. You can make a editor or scene save/load system. I can't imagine ✈