是否存在无法避免 lambda 中尾随 return 类型语法的情况？

Question

关于上一个问题（Is it possible to return an object of type T by reference from a lambda without using trailing return type syntax?），我想知道是否还有其他重要的案例或例子，其中 trailing-return-type 语法，当使用 lambdas 时，可以 not 避免。

Answer 1

我想另一种情况是不同类型之间存在类型不一致 returns。

一个愚蠢的例子

std::function<long(int)> f 
    = [](int v) -> long { if ( v ) return v; else return 0L; };

显然，如果你避免不一致，你就可以避免它，所以我不知道它是否重要。

Answer 2

在 C++14 中，一个有点人为的例子是将 sfinae 与通用 lambda 结合使用：

[](auto &&arg)
-> decltype(arg.f(), void())
{ /* do whatever you want */ }

无论如何，有人可能会争辩说 static_assert 就足够了：

[](auto &&arg) {
    static_assert(has_metod_f<std::decay_t<decltype(arg)>>::value, "!");
    /* do whatever you want */
}

其中 has_method_f 是常用检测器惯用语。
无论如何，想象一下你想要从一堆 lambda 开始构造一个组合仿函数的情况：

#include<utility>
#include<iostream>

template<typename...>
struct Base;

template<typename Func, typename... Others>
struct Base<Func, Others...>: Func, Base<Others...> {
    Base(Func func, Others... others)
    : Func{std::move(func)}, Base<Others...>{std::move(others)...}
    {}

    template<typename... Args>
    auto operator()(int, Args&&... args)
    -> decltype(Func::operator()(std::forward<Args>(args)...)) {
        Func::operator()(std::forward<Args>(args)...);
    }

    template<typename... Args>
    auto operator()(char, Args&&... args) {
        Base<Others...>::operator()(0, std::forward<Args>(args)...);
    }
};

template<>
struct Base<> {
    template<typename... Args>
    auto operator()(Args&&...) {
        std::cout << "fallback" << std::endl;
    }
};

template<typename... Ops>
struct Mixin: Base<Ops...> {
    Mixin(Ops... ops)
        : Base<Ops...>{std::move(ops)...}
    {}

    template<typename... Args>
    auto operator()(Args&&... args) {
        return Base<Ops...>::operator()(0, std::forward<Args>(args)...);
    }
};

struct T { void f() {} };
struct U {};

int main() {
    auto l1 = [](auto &&arg) -> decltype(arg.f(), void()) {
        std::cout << "accept T" << std::endl;
    };

    auto l2 = [](U) {
        std::cout << "accept U" << std::endl;
    };

    Mixin<decltype(l1), decltype(l2)> mixin{std::move(l1), std::move(l2)};
    mixin(T{});
    mixin(U{});
    mixin(0);
}

在这种情况下，static_assert 会阻止编译，这不是预期的结果。
另一方面，尾随 return 类型可用于在包装器的帮助下直接在 lambda 上启用 sfinae。

是否存在无法避免 lambda 中尾随 return 类型语法的情况？

Are there cases in which trailing-return-type syntax in lambda cannot be avoided?

c++

lambda

c++11

trailing-return-type

c++14