Yes, having more little functions is considered better practice. But the code still looks pretty much the same as my original code in terms of lines of code and structure of the code.  I think even with a separated more_code function, having a ternary operator can make constexpr code more like the way we wrote time code

template <typename T>
void f(T const& t){
  const auto obj = pred<T> constexpr? makeFoo() : makeBar();
  more_code(obj);
}

On Thu, Oct 21, 2021 at 2:06 PM Nikolay Mihaylov <nmmm@nmmm.nu> wrote:
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