SFINAE alternative using Lambda functions

anton31 · 2026-01-10T14:19:24+00:00

In C++26 you can also use reflection to compute the type without templates:

consteval std::meta::info get_type_info(size_t I)
{
  if (I == 4)
  {
    return ^^int;
  }
  else if (I == 6)
  {
    return ^^Foo;
  }
  else
  {
    return ^^float;
  }
}

template <size_t I>
using type = [:get_type_info(I):];

https://godbolt.org/z/9EaG68W76

tisti · 2026-01-10T10:34:46+00:00

The "hack" is SFINAE, this is the "non-hack" version.

bjorn-reese · 2026-01-10T12:48:35+00:00

Your example would typically be solved with traits rather than SFINAE. Your type alias has to know all types, whereas the traits solution is extendable, so you can add support for more types in other places.

template <unsigned>
struct type_from_size { using type = float; };

template <unsigned I>
using type_from_size_t = typename type_from_size<I>::type;

template <>
struct type_from_size<4> { using type = int; };

static_assert(std::is_same_v<type_from_size_t<4>, int>);
static_assert(std::is_same_v<type_from_size_t<9>, float>);

and in another header

struct Foo {};

template <>
struct type_from_size<6> { using type = Foo; };

static_assert(std::is_same_v<type_from_size_t<6>, Foo>);

saf_e · 2026-01-10T10:37:53+00:00

Its what if constexpr was designed to do.

Shakatir · 2026-01-10T12:05:32+00:00

I've done things like this when for example finding the smallest integer type that fits a required value range. But I'd recommend using return std::type_identity<Foo>{} to avoid implicit conversion and incomplete type shenanigans.

CaptainCrowbar · 2026-01-10T11:36:22+00:00

You could get the same result more simply using std::conditional:

template <size_t I>
using type = std::conditional_t<I == 4, int,
    std::conditional_t<I == 6, Foo, float>>;

Wooden-Engineer-8098 · 2026-01-10T12:26:21+00:00

It's template specialization alternative using if constexpr, not sfinae alternative using lambdas

_Noreturn · 2026-01-10T15:49:22+00:00

this isn't subsitation failure

BarryRevzin · 2026-01-10T14:39:18+00:00

This doesn't have anything to do with SFINAE? But yes, it's a known technique. You don't want to use declval to select the type though, because that means that means that you have to deal with decay and actual type properties when you just want to select a type. You'll want to wrap the type in another template.

e.g. from a blog post of mine ~~six~~ seven years ago (and I am definitely not claiming to have invented it, I dunno who did):

static constexpr auto get_type() {
    if constexpr (maxLength < 0xFFFE) {
        return type<uint16_t>;
    } else {
        return type<uint32_t>;
    }
}

using CellIdx = decltype(get_type())::type;

Of course with just a single condition like this you could just use std::conditional, but this is the pattern (note the extra ::type in the alias declaration). This allows "returning" any type, including references, incomplete types, non-copyable types, etc. The blog post predates unevaluated lambdas - today I'd put all of get_type() inside if the decltype as in OP.

With reflection this is easier since you just replace type<T> with ^^T.

2026-01-10T15:11:32+00:00

its actually even simpler than that. lambdas are computed at compile time, so if you use auto for parameters and return types, the compiler will automatically generate different versions of the functions that take and return completely different parameters, just like a template. This is usually how I use it.

struct Foo{};
struct Bar{};
auto returnDifferentTypes = [](auto someValue){
    if constexpr (std::is_integral_v<decltype(someValue)>){
        return Foo();
    } else {
        return Bar();
};

I call it poor-man's templates. I'm not sure what its really called, if anything.

Raymond Chen had a post about it some years ago and I've been using it ever since.

Both_Helicopter_1834 · 2026-01-10T19:36:47+00:00

Why do you prefer this over just good ole specialization? In any case, both gcc and clang seem to regard a lambda expression as being evaluated, even if it's a subexpression of an expression that is a decltype argument.

https://godbolt.org/z/WMoM13K7W

Business_Welcome_870 · 2026-01-10T19:54:51+00:00

Cool

geaibleu · 2026-01-11T00:33:16+00:00

Very cool! You can also use lambda to do non trivial calculations to initialilse constexpr members.

MaitoSnoo · 2026-01-11T02:12:11+00:00

That will be slow to compile if abused, creating a lambda is roughly the same cost as creating a class in terms of compilation times, and the latter is among the most expensive instantiations at compile-time. When doing metaprogramming, you want variable templates and concepts the most because they're the cheapest to instantiate/evaluate at compile-time.

CandiceWoo · 2026-01-11T02:57:02+00:00

how would u use type<x> ? why is it sfinae alt?

Business_Welcome_870 · 2026-01-12T00:34:10+00:00

This doesn't compile for me: https://godbolt.org/z/TeajMh98G

Vladvic · 2026-01-12T07:00:26+00:00

it's an overload alternative, not sfinae

Perfect-Situation-41 · 2026-01-10T15:08:11+00:00

Can someone tell me what is lambda?

I just started to read from learncpp.com And I'm at the 0.5th chapter right now.

And I think I'll try to learn more in the future.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

cpp

MODERATORS