what about restructuring like this:

template<typename T>
void more_code(T a);

template <typename T>
void f(T const& t){
           if constexpr (pred<T>){
                return more_code(makeFoo());
           } else {
                return more_code(makeBar());
           }
}


On Thu, Oct 21, 2021 at 3:49 PM Hui Xie via Std-Proposals <std-proposals@lists.isocpp.org> wrote:
Hi,

Sometimes I have this situation

template <typename T>
void f(T const& t){
    const auto obj = []{
           if constexpr (pred<T>){
                return makeFoo();
           } else {
                return makeBar();
           }
    }();
    
    const auto x = g(obj);   // different overload g for Foo and Bar
    // more code
}


What I really want to write is a ternary operator
const auto obj = pred<T> ? makeFoo() : makeBar();

But Foo and Bar are different types, so it won't work.

What about allowing us to write 
const auto obj = pred<T> constexpr? makeFoo() : makeBar();

Any ideas?

Thanks
Hui

--
Std-Proposals mailing list
Std-Proposals@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals