Best practices are unknown for avoiding recursive instantiation in mutually recursive user-defined types

[saki7]

Although rvariant's unit tests correctly handle basic "truly recursive" types, I have found that properly constraining user-defined types is very challenging in practice.

For instance, inadvertently applying std::is_constructible to a user-defined class's generic constructor can effectively introduce type-level left recursion, resulting in the well-known error: "satisfaction of constraint depends on itself".

We should document strategies to avoid such pitfalls, and perhaps provide a tutorial on constructing legitimate recursive types.

We definitely need minimal reproducible example for this. I have just encountered such error in medium-sized codebase, and I'm having a hard time reducing the code.

related: #39 and #45

[saki7]

Boost.Variant never had this problem because it didn’t use any form of "constraining." But recursive variants need proper constraints (of course) and we should avoid unconstrained generic constructor MyClass(T const& unconstrained_value) at all costs. That was a key motivation for creating rvariant.

[saki7]

For below model:

template<class Expr>
struct SubExpr
{
    Expr expr;

    constexpr SubExpr() = default;
    constexpr SubExpr(SubExpr const&) = default;
    constexpr SubExpr(SubExpr&&) noexcept = default;

    constexpr SubExpr& operator=(SubExpr const&) = default;
    constexpr SubExpr& operator=(SubExpr&&) noexcept = default;
};

This works:

template<class T = Expr>
    requires
        (!std::is_same_v<std::remove_cvref_t<T>, SubExpr>) &&
        std::is_constructible_v<Expr, T>
constexpr explicit SubExpr(T&& expr)
    : expr(std::forward<T>(expr))
{}

This works:

// metafunction pattern
template<class T = Expr>
    requires
        (!std::is_same_v<std::remove_cvref_t<T>, SubExpr>) &&
        std::is_constructible_v<Expr, T>
constexpr explicit SubExpr(T&& expr) noexcept(std::is_nothrow_constructible_v<Expr, T>)
    : expr(std::forward<T>(expr))
{}

// noexcept-expression pattern
template<class T = Expr>
    requires
        (!std::is_same_v<std::remove_cvref_t<T>, SubExpr>) &&
        std::is_constructible_v<Expr, T>
constexpr explicit SubExpr(T&& expr) noexcept(noexcept(expr(std::forward<T>(expr))))
    : expr(std::forward<T>(expr))
{}

This leads to infinite recursion:

template<class T = Expr>
    requires
        (!std::is_same_v<std::remove_cvref_t<T>, SubExpr>) &&
        std::is_constructible_v<Expr, T>
constexpr explicit(!std::is_convertible_v<T, Expr>) SubExpr(T&& expr)
    : expr(std::forward<T>(expr))
{}