templated lambda return type

I want to write a little bit of code that maps enums to specific members of a struct.

The trouble is the members of the struct have different types, if they didn't I've just used an std::array of references or pointers to do this.

So I thought to use a lambda instead since they now have template params

Here's something like what I have:

#include <type_traits>
#include <iostream>

struct foo
{
    int x;
    double y;
};

enum class keys
{
    x,
    y,
};

void print(foo f)
{
    auto get = [&f]<keys K, typename T>(std::integral_constant<keys, K>) -> T&
    {
        switch(K)
        {
            case keys::x: return f.x;
            case keys::y: return f.y;
        }
    };
    std::cout << get(std::integral_constant<keys, keys::x>{}) <<std::endl;
    std::cout << get(std::integral_constant<keys, keys::y>{}) <<std::endl;
}

int main(void)
{
    foo m{1,2.0};
    print(m);
    return 0;
}

Note, in my real code, I cannot modify the foo struct, and the types are much more complex than int or double.

But this code gives me errors like:

<source>: In function 'void print(foo)':
<source>:26:21: error: no match for call to '(print(foo)::<lambda(std::integral_constant<keys, K>)>) (std::integral_constant<keys, keys::x>)'
26 |     std::cout << get(std::integral_constant<keys, keys::x>{}) <<std::endl;
|                  ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<source>:18:16: note: candidate: 'template<keys K, class T> print(foo)::<lambda(std::integral_constant<keys, K>)>'
18 |     auto get = [&f]<keys K, typename T>(std::integral_constant<keys, K>) -> T&
|                ^
<source>:18:16: note:   template argument deduction/substitution failed:
<source>:26:21: note:   couldn't deduce template parameter 'T'
26 |     std::cout << get(std::integral_constant<keys, keys::x>{}) <<std::endl;
|                  ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<source>:27:21: error: no match for call to '(print(foo)::<lambda(std::integral_constant<keys, K>)>) (std::integral_constant<keys, keys::y>)'
27 |     std::cout << get(std::integral_constant<keys, keys::y>{}) <<std::endl;
|                  ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<source>:18:16: note: candidate: 'template<keys K, class T> print(foo)::<lambda(std::integral_constant<keys, K>)>'
18 |     auto get = [&f]<keys K, typename T>(std::integral_constant<keys, K>) -> T&
|                ^
<source>:18:16: note:   template argument deduction/substitution failed:
<source>:27:21: note:   couldn't deduce template parameter 'T'
27 |     std::cout << get(std::integral_constant<keys, keys::y>{}) <<std::endl;
|                  ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Compiler returned: 1

How can I work around this? I'm a little confused how the compiler fails to be able to deduce T&. One way I could work around this is via specializations but I was not able to figure out how to specialize a lambda function for specific template params.

You are not passing anything to the lambda that lets the compiler deduce what T should be. As @molbdnilo mentioned, your switch is not evaluated until runtime, and it returns different types for each value of K, so the compiler can't use that to deduce T at compile-time.

Just use auto instead for the return type, and then use if constexpr to let the compiler evaluate the conditions at compile-time and remove unused code, thus letting auto to deduce the type of whichever return is actually used.

For example:

#include <type_traits>
#include <iostream>
struct foo
{
int x;
double y;
};
enum class keys
{
x,
y,
};
// see https://devblogs.microsoft.com/oldnewthing/20200311-00/?p=103553
// for why this is needed below...
template<keys K>
inline constexpr bool always_false_v = false;
void print(const foo& f)
{
auto get = [&f]<keys K>() -> auto&
{
if constexpr (K == keys::x)
return f.x;
else if constexpr (K == keys::y)
return f.y;
else
static_assert(always_false_v<K>, "Invalid key");
};
std::cout << get.operator()<keys::x>() << std::endl;
std::cout << get.operator()<keys::y>() << std::endl;
}
int main(void)
{
foo m{1,2.0};
print(m);
return 0;
}

Online Demo

Alternatively, as @n.m. suggested, you can just get rid of the keys enum and use pointer-to-members instead, eg:

include <type_traits>
#include <iostream>
struct foo
{
int x;
double y;
};
void print(const foo& f)
{
auto get = [&f](auto member) -> auto&
{
return f.*member;
};
std::cout << get(&foo::x) << std::endl;
std::cout << get(&foo::y) << std::endl;
}
int main(void)
{
foo m{1,2.0};
print(m);
return 0;
}

Online Demo

You can use a class template for the mapping:

template <keys> struct key_to_foo_mem;
template <> struct key_to_foo_mem<keys::x> { auto& operator()(const foo& f){ return f.x; } };
template <> struct key_to_foo_mem<keys::y> { auto& operator()(const foo& f){ return f.y; } };
void print(foo f)
{
std::cout << key_to_foo_mem<keys::x>()(f) <<std::endl;
std::cout << key_to_foo_mem<keys::y>()(f) <<std::endl;
}

Your lambda approach has two issues: T is used but neither provided explicitly nor deduced. The return type is deduced inconsistently from the two cases, but a function can have only one return type. Moreover you use a trailing return of T& which does surpress the deduction of the return type by the compiler.

You can remove T and use constexpr if :

void print(foo f)
{
auto get = [&f]<keys K>(std::integral_constant<keys, K>)
{
if constexpr(K == keys::x) { return f.x; }
else { return f.x; }
};
std::cout << get(std::integral_constant<keys, keys::x>{}) <<std::endl;
std::cout << get(std::integral_constant<keys, keys::y>{}) <<std::endl;
}

> I'm a little confused how the compiler fails to be able to deduce
T&.

When you use trailing return type you are telling the compiler "this is the type" (ie you surpress the deduction) but -> T& as trailing return type makes no sense. Once you use constexpr if the compiler can deduce the return type itself (lambdas have implicit auto return type).

> One way I could work around this is via specializations but I was not able to figure out how to specialize a lambda function for specific template param

Its important to understand that for the above lambda expression it is the operator() that is templated, not the type of the lambda. How you can use specialization I have shown above (though it is specialization of a class template, not of a member template).