How to use union metafunction to replace variant member and member functions that call std::visit.

[gregmarr]

This came up in a C++ study group meeting today about ways to replace virtual functions in a class hierarchy that has a fixed set of member classes.

Here is a solution from today using std::variant and std::visit.

#include <variant>

class Circle {
  double _radius = 0;

public:
  double GetArea() const { return 3.1415 * _radius * _radius; }
};

class Rectangle {
  double _width = 0;
  double _height = 0;

public:
  double GetArea() const { return _width * _height; }
};

class Shape {
  std::variant<Circle, Rectangle> _data;

public:
  double GetArea() const {
    return std::visit([](auto x) { return x.GetArea(); }, _data);
  }
};

One of the discussion points was that it would be nice to be able to get rid of the std::visit boilerplate and be able to automatically generate a "call this function on the active member of the variant" member function.

Thinking about how we could do this in Cpp2 with the union metafunction, I was able to get this far:

Circle: type = {
  _radius : double = 0;

  GetArea: () 3.1415 * _radius * _radius;
}

Rectangle: type = {
  _width : double = 0;
  _height : double = 0;

  GetArea: () _width * _height;
}

Shape: @union type = {
  circle: Circle;
  rectangle: Rectangle;

  // We can add member functions, but we have to write the type handling manually.
  // This is how we have to do it now:
  GetArea: (this) -> double = {
    if is_circle() { return circle().GetArea(); }
    else if is_rectangle() { return rectangle().GetArea(); }
    else { throw std::bad_variant_access(); }
  }
}

This is even worse in terms of having to do the boilerplate function, as you have to individually name the function. You can't use std::visit because you don't have a variant, unless we make the union metafunction have all the hooks that visit uses from variant, which isn't out of the realm of possibility. That would still require us to write the std::visit boilerplate.

Looking at the syntax in P0707 Section 4.2.2 property metaclass function, I think we could do something like this:

  visitor GetArea : (this) = {};

and the metafunction handler would rewrite the body of the visitor function like the above, similar to how it generates the destructor now.

[AbhinavK00]

Maybe the more experienced people here can explain better but I think pattern matching is the right answer to this use case.

[JohelEGP]

This looks like something you would build on top of @union.
@union isn't necessarily about similar data structures.
There must be a better name for this behavior.
The theme is common, though, so it's a reasonable extension
(one I'd benefit from).

[AbhinavK00]

Its this https://lists.isocpp.org/std-proposals/2023/06/6894.php

I don't think the proposal is in the discussion itself but I was more curious if this can be implemented in cpp2 at all.

[JohelEGP]

I see, it seems to be something similar.
Even if Cpp2 metafunctions isn't capable,
there's Cpp1 reflection: https://www.reddit.com/r/cpp/comments/17q9dg4/abusing_the_c_preprocessor_for_declaring_rustlike/.

[gregmarr]

For closed sets, you can also use static polymorphism.

Yes, that's what this is about, implementing it within the union metatype instead of using a variant and writing boilerplate visitors.

[AbhinavK00]

there's Cpp1 reflection: https://www.reddit.com/r/cpp/comments/17q9dg4/abusing_the_c_preprocessor_for_declaring_rustlike/.

Wow, that's very cool. Can't wait for cpp2 to have something like this. Btw, since there are so many "experiments" dealing with polymorphism using rust-like "thing" for cpp2, do you think it's worth it to have something like traits in cpp2?
I remember there was something from Sy Brand too related to this.

[JohelEGP]

If you can write a library for it in Cpp1,
you probably should be able to in Cpp2.

[AbhinavK00]

This is regarding the original problem posted by @gregmarr, maybe the union metafunction can have an active_member member function so that the GetArea function in your example could be written as:

GetArea: (this) -> double = {
    return this.active_member().GetArea();
  }

Specifics about this can be discusssed.

[JohelEGP]

This seems recursive.
active_member() returns a structure with a GetArea(),
but that's what you're trying to implement here.

[AbhinavK00]

But the member of the union have their own GetArea() which has been implemented. So, I don't think it's recursive. The example in this reply

[JohelEGP]

The thing is that active_member().GetArea() implies a data structure
with a function with the same implementation we're trying to implement.
That's because active_member() would need to return a type erased reference.
But that's what the this (a @union) already is.

[AbhinavK00]

You're right, so this idea was just wrong.