boost::hana::always 除了 "always return its first argument" 还有什么作用？

Question

在 doc page of boost::hana::always 我读到了

always(x) is a function such that
always(x)(y...) == x
for any y....

这让我认为它的行为应该与以下 lambda 没有任何不同：[](auto const&...){ return false; }.

但是确实如此。例如，以下代码打印 11，但如果我将第三个 lambda 更改为 hana::always(false)，则它会打印 00，表明 always 正在吞没任何参数。

#include <boost/hana/functional/always.hpp>
#include <boost/hana/functional/overload.hpp>
#include <iostream>

auto fun = boost::hana::overload(
        [](int){ return true; },
        [](double){ return true; },
        [](auto const&...){ return false; }
        );

int main() {
    std::cout << fun(1) << fun(1.0) << std::endl;
}

这是预期的吗？
如果是，为什么？
是否符合预期，是什么导致了这种行为？

顺便说一下，我刚刚发现 boost::hana::overload_linearly，在这种情况下，它不是 boost::hana::overload 的替代方案（因为 always 不会得到所有调用，这将是 [](int){ return true; } 贪婪），但很高兴知道它。

Answer 1

事实上，always 有不同的重载（因为它将引用处理为 return 值）。

所以，简化版：

template <typename T>
struct my_always
{
     T res;

     template <typename ...&& Ts>
     T& operator ()(Ts&&...) /* mutable */ { return res; } // #1

     template <typename ...&& Ts>
     const T& operator ()(Ts&&...) const { return res; } // #2
};

然后

auto fun = boost::hana::overload(
        my_always<bool>{ false }, // #1 & #2
        [](int){ return true; }   // #3
        );

std::cout << fun(1);

可能的重载是：

bool& my_always<bool>::operator ()(int&&)#1
const bool& my_always<bool>::operator ()(int&&) const#2
bool lambda::operator() (int) const#3

都是viable here, but #1 is the best match（因为fun不是const（而且int并不比int&&好））。

对于 const fun，#3 将是最佳匹配（#1 不可行，#2 和 #3 之间的决胜局是模板状态）。

boost::hana::always 除了 "always return its first argument" 还有什么作用？

What does boost::hana::always do more than just "always return its first argument"?

c++

c++14

overload-resolution

boost-hana

referential-transparency