You have two overloads of g(). One requires A<T> for each element in a pack, the other requires C<T> — where C is a stricter concept that subsumes A. Both apply to the types you’re passing. The compiler should pick the more constrained version. But instead it complains about an ambiguous call. This is a limitation of how C++20 and 23 handle constraints that use fold expressions — fixed in C++26.

Sandor Dargo's blog provides practical insights into software development, Agile methodologies, and personal productivity. Readers can explore articles on topics such as Scrum, Kanban, and Agile project management, as well as techniques for improving coding skills and software design. Additionally, they can learn about tools, frameworks, and strategies for enhancing their effectiveness as software developers and team members.

Sandor Dargo

C++20 and C++23 have a limitation where fold expressions in constraints are treated as opaque atomic constraints, preventing the compiler from recognizing subsumption relationships between overloads. For example, if concept C subsumes A, the compiler cannot determine that (C<T> && ...) is more constrained than (A<T> && ...) and reports an ambiguous call. C++26 fixes this via proposal P2963R3, which introduces 'fold expanded constraints' as a new constraint category. Subsumption is extended so that (P<Ts> && ...) subsumes (Q<Ts> && ...) when both expand the same pack, use the same fold operator, and P<T> subsumes Q<T> for a single type. Fold operators must match for subsumption to apply. Clang 19 already supports this feature.

C++26: Ordering of constraints involving fold expressions

The problem: fold expressions are opaque to subsumption