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_at_[hidden]> 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_at_[hidden]
> https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals
>