描述

Searchable 概念表示可以搜索的结构。

直观地说，Searchable 是任何结构，有限或无限，包含可以使用谓词搜索的元素。有时，Searchable 会将键与值关联；可以使用谓词搜索键，并返回与其关联的值。这产生了类似映射的数据结构。其他时候，搜索的结构元素（即应用谓词的元素）与返回的元素相同，这产生了类似集合的数据结构。一般来说，我们将 Searchable 结构的键称为用于搜索的元素，并将 Searchable 的值称为搜索成功时返回的元素。如前所述，这两个概念没有必要不同，并且键和值重合通常很有用（例如 std::set）。

一些方法，如 any_of、all_of 和 none_of，允许对结构的键执行简单的查询，而其他方法，如 find 和 find_if，则可以找到与键关联的值。如果关心性能，则应始终使用最具体的方法，因为通常可以在更具体的方法中执行大量的优化。例如，作为哈希表实现的关联数据结构使用 find 访问的速度将比使用 find_if 快得多，因为在第二种情况下，它必须对所有条目进行线性搜索。类似地，使用 contains 可能比使用具有等效谓词的 any_of 快得多。

见解
在惰性求值上下文中，任何 Foldable 也可以成为 Searchable 的模型，因为我们可以使用 fold_right 对结构进行惰性搜索。但是，在 C++ 的上下文中，某些 Searchable 无法折叠；例如，考虑一个无限集合。

最小完整定义

find_if 和 any_of

当提供 find_if 和 any_of 时，其他函数将根据下面解释的规则实现。

注意: 我们可以通过检查 find_if(xs, pred) 是否为空 optional 来实现 any_of(xs, pred)，然后将最小完整定义减少到 find_if。但是，这样做是因为该实现要求 any_of 的谓词返回编译时 Logical，这比我们现在拥有的更具限制性。

规则

为了使方法的语义一致，Searchable 概念的任何模型都必须满足某些属性。严格来说，对于任何 Searchables xs 和 ys 以及任何谓词 p，以下规则应满足

any_of(xs, p) <=> !all_of(xs, negated p)
<=> !none_of(xs, p)
 
contains(xs, x) <=> any_of(xs, equal.to(x))
 
find(xs, x) == find_if(xs, equal.to(x))
find_if(xs, always(false_)) == nothing
 
is_subset(xs, ys) <=> all_of(xs, [](auto x) { return contains(ys, x); })
is_disjoint(xs, ys) <=> none_of(xs, [](auto x) { return contains(ys, x); })

此外，如果 Searchable 的所有键都是 Logical，则应满足以下规则

any(xs) <=> any_of(xs, id)
all(xs) <=> all_of(xs, id)
none(xs) <=> none_of(xs, id)

具体模型

hana::map、hana::optional、hana::range、hana::set、hana::string、hana::tuple

内置数组的自由模型

已知大小的内置数组可以像同构元组一样进行搜索。但是，由于数组只能保存单一类型的对象，并且 find_if 的谓词必须返回编译时 Logical，因此 find_if 方法相当无用。出于类似的原因，find 方法也相当无用。提供此模型主要是为了 any_of 方法及其朋友，它们既有用又编译时高效。

保持结构的函数

给定两个 Searchables S1 和 S2，函数 \( f : S_1(X) \to S_2(X) \) 被认为保留了 Searchable 结构，如果对于所有数据类型为 S1(X) 的 xs 和谓词 \( \mathtt{pred} : X \to Bool \)（对于 Logical Bool），

any_of(xs, pred) 当且仅当 any_of(f(xs), pred)

find_if(xs, pred) == find_if(f(xs), pred)

这实际上只是以下更直观的要件的推广。对于所有数据类型为 S1(X) 的 xs 和数据类型为 X 的 x，

x ^in^ xs 当且仅当 x ^in^ f(xs)

find(xs, x) == find(f(xs), x)

boost::hana::in

constexpr auto in

返回键是否出现在结构中。

定义：contains.hpp:70

这些要件可以理解为 f 不会更改 xs 的内容，尽管它可能会重新排序元素。像往常一样，如果这种保持结构的转换也是单射的，即如果它是无损转换，则称其为嵌入。

变量
constexpr auto	boost::hana::all
	返回结构的所有键是否都为真值。更多...

constexpr auto	boost::hana::all_of
	返回结构的所有键是否都满足`predicate`。更多...

constexpr auto	boost::hana::any
	返回结构的任何键是否为真值。更多...

constexpr auto	boost::hana::any_of
	返回结构的任何键是否满足`predicate`。更多...

constexpr auto	boost::hana::at_key
	返回与结构中给定键关联的值，或失败。更多...

constexpr auto	boost::hana::contains
	返回键是否出现在结构中。更多...

constexpr auto	boost::hana::in = hana::infix(hana::flip(hana::contains))
	返回键是否出现在结构中。更多...

constexpr auto	boost::hana::find
	在结构中查找与给定键关联的值。更多...

constexpr auto	boost::hana::find_if
	查找与满足谓词的第一个键关联的值。更多...

constexpr auto	boost::hana::is_disjoint
	返回两个`Searchable`是否不相交。更多...

constexpr auto	boost::hana::is_subset
	返回一个结构是否包含另一个结构键的子集。更多...

constexpr auto	boost::hana::none
	返回结构的所有键是否都为假值。更多...

constexpr auto	boost::hana::none_of
	返回结构体中是否没有键满足`predicate`。更多...

变量文档

◆ all

constexpr auto boost::hana::all

constexpr

#include <boost/hana/fwd/all.hpp>

初始值

= [](auto&& xs) {
        return tag-dispatched;
    }

返回结构的所有键是否都为真值。

结构体的键必须是Logical类型。如果结构体不是有限的，则必须在有限的“索引”处出现一个假值键，以便此方法完成。

示例

// 版权所有 Louis Dionne 2013-2017
// 根据 Boost 软件许可证 1.0 版发布。
// （请参阅随附文件 LICENSE.md 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）
 
#include <boost/hana/all.hpp>
#include <boost/hana/assert.hpp>
#include <boost/hana/bool.hpp>
#include <boost/hana/not.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
 
 
static_assert(hana::all(hana::make_tuple(hana::true_c, true, hana::true_c)), "");
BOOST_HANA_CONSTANT_CHECK(!hana::all(hana::make_tuple(true, hana::false_c, hana::true_c)));
 
int main() { }

◆ all_of

constexpr auto boost::hana::all_of

constexpr

#include <boost/hana/fwd/all_of.hpp>

初始值

= [](auto&& xs, auto&& predicate) {
        return tag-dispatched;
    }

返回结构体中所有键是否都满足predicate。

如果结构体不是有限的，则predicate必须在查看有限数量的键后返回一个假值Logical，以便此方法完成。

参数

xs	要搜索的结构体。
predicate	一个函数，调用方式为`predicate(k)`，其中`k`是结构体的键，并返回一个`Logical`。

示例

// 版权所有 Louis Dionne 2013-2017
// 根据 Boost 软件许可证 1.0 版发布。
// （请参阅随附文件 LICENSE.md 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）
 
#include <boost/hana/all_of.hpp>
#include <boost/hana/assert.hpp>
#include <boost/hana/config.hpp>
#include <boost/hana/ext/std/integral_constant.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/mod.hpp>
#include <boost/hana/not.hpp>
#include <boost/hana/not_equal.hpp>
#include <boost/hana/traits.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
 
#include <type_traits>
namespace hana = boost::hana;
using namespace hana::literals;
 
 
BOOST_HANA_CONSTEXPR_LAMBDA auto is_odd = [](auto x) {
    return x % 2_c != 0_c;
};
 
int main() {
    BOOST_HANA_CONSTEXPR_CHECK(hana::all_of(hana::make_tuple(1, 3), is_odd));
    BOOST_HANA_CONSTANT_CHECK(!hana::all_of(hana::make_tuple(3_c, 4_c), is_odd));
 
    BOOST_HANA_CONSTANT_CHECK(
!hana::all_of(hana::make_tuple(hana::type<void>{}, hana::type<char&>{}),
hana::traits::is_void)
    );
 
    BOOST_HANA_CONSTANT_CHECK(
      hana::all_of(hana::make_tuple(hana::type_c<int>, hana::type_c<char>),
hana::traits::is_integral)
    );
}

◆ any

constexpr auto boost::hana::any

constexpr

#include <boost/hana/fwd/any.hpp>

初始值

= [](auto&& xs) {
        return tag-dispatched;
    }

返回结构的任何键是否为真值。

结构体的键必须是Logical类型。如果结构体不是有限的，则必须在有限的“索引”处出现一个真值键，以便此方法完成。

示例

// 版权所有 Louis Dionne 2013-2017
// 根据 Boost 软件许可证 1.0 版发布。
// （请参阅随附文件 LICENSE.md 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）
 
#include <boost/hana/any.hpp>
#include <boost/hana/assert.hpp>
#include <boost/hana/bool.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
 
 
BOOST_HANA_CONSTANT_CHECK(hana::any(hana::make_tuple(false, hana::false_c, hana::true_c)));
static_assert(hana::any(hana::make_tuple(false, hana::false_c, true)), "");
static_assert(!hana::any(hana::make_tuple(false, hana::false_c, hana::false_c)), "");
 
int main() { }

◆ any_of

constexpr auto boost::hana::any_of

constexpr

#include <boost/hana/fwd/any_of.hpp>

初始值

= [](auto&& xs, auto&& predicate) {
        return tag-dispatched;
    }

返回结构体中是否有任何键满足predicate。

如果结构体不是有限的，则必须在查看有限数量的键后满足predicate，以便此方法完成。

参数

xs	要搜索的结构体。
predicate	一个函数，调用方式为`predicate(k)`，其中`k`是结构体的键，并返回一个`Logical`。

示例

// 版权所有 Louis Dionne 2013-2017
// 根据 Boost 软件许可证 1.0 版发布。
// （请参阅随附文件 LICENSE.md 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）
 
#include <boost/hana/any_of.hpp>
#include <boost/hana/assert.hpp>
#include <boost/hana/config.hpp>
#include <boost/hana/ext/std/integral_constant.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/mod.hpp>
#include <boost/hana/not.hpp>
#include <boost/hana/not_equal.hpp>
#include <boost/hana/traits.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
 
#include <type_traits>
namespace hana = boost::hana;
using namespace hana::literals;
 
 
BOOST_HANA_CONSTEXPR_LAMBDA auto is_odd = [](auto x) {
    return x % 2_c != 0_c;
};
 
int main() {
    BOOST_HANA_CONSTEXPR_CHECK(hana::any_of(hana::make_tuple(1, 2), is_odd));
    BOOST_HANA_CONSTANT_CHECK(!hana::any_of(hana::make_tuple(2_c, 4_c), is_odd));
 
    BOOST_HANA_CONSTANT_CHECK(
      hana::any_of(hana::make_tuple(hana::type<void>{}, hana::type<char&>{}),
hana::traits::is_void)
    );
 
    BOOST_HANA_CONSTANT_CHECK(
!hana::any_of(hana::make_tuple(hana::type<void>{}, hana::type<char&>{}),
hana::traits::is_integral)
    );
}

◆ at_key

constexpr auto boost::hana::at_key

constexpr

#include <boost/hana/fwd/at_key.hpp>

初始值

= [](auto&& xs, auto const& key) -> decltype(auto) {
        return tag-dispatched;
    }

返回与结构体中给定键关联的值，或失败。

给定一个key和一个Searchable结构体，at_key返回第一个键等于给定key的值，如果不存在这样的键，则在编译时失败。这要求key是编译时Comparable，就像find一样。at_key满足以下条件

at_key(xs, key) == find(xs, key).value()

boost::hana::at_key

constexpr auto at_key

返回与结构体中给定键关联的值，或失败。

定义： at_key.hpp:51

如果Searchable实际上存储了它包含的元素，则at_key需要返回左值引用、const 的左值引用或找到的值的右值引用，其中引用的类型必须与传递给at_key的结构体的类型匹配。如果Searchable不存储它包含的元素（即它按需生成它们），则此要求将被放弃。

参数

xs	要搜索的结构体。
key	要在结构体中搜索的键。该键必须与结构体的其他键具有`Comparable`关系。在库的当前版本中，`key`与结构体任何其他键的比较必须返回编译时`Logical`。

示例

// 版权所有 Louis Dionne 2013-2017
// 根据 Boost 软件许可证 1.0 版发布。
// （请参阅随附文件 LICENSE.md 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）
 
#include <boost/hana/assert.hpp>
#include <boost/hana/at_key.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/type.hpp>
 
#include <string>
namespace hana = boost::hana;
 
 
int main() {
    auto m = hana::make_map(
hana::make_pair(hana::type<int>{}, std::string{"int"}),
hana::make_pair(hana::int_<3>{}, std::string{"3"})
    );
 
    BOOST_HANA_RUNTIME_CHECK(hana::at_key(m, hana::type<int>{}) == "int");
 
    // 用作运算符[]
    BOOST_HANA_RUNTIME_CHECK(m[hana::type<int>{}] == "int");
    BOOST_HANA_RUNTIME_CHECK(m[hana::int_<3>{}] == "3");
}

◆ contains

constexpr auto boost::hana::contains

constexpr

#include <boost/hana/fwd/contains.hpp>

初始值

= [](auto&& xs, auto&& key) {
        return tag-dispatched;
    }

返回键是否出现在结构中。

给定一个Searchable结构体xs和一个key，contains返回结构体中是否有任何键等于给定的key。如果结构体不是有限的，则必须在结构体的有限位置出现一个相等的键，以便此方法完成。为方便起见，contains也可以应用于中缀表示法。

参数

xs	要搜索的结构体。
key	要在结构体中搜索的键。该键必须与结构体的其他键具有`Comparable`关系。

示例

// 版权所有 Louis Dionne 2013-2017
// 根据 Boost 软件许可证 1.0 版发布。
// （请参阅随附文件 LICENSE.md 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）
 
#include <boost/hana/assert.hpp>
#include <boost/hana/contains.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/set.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
 
 
BOOST_HANA_CONSTANT_CHECK(hana::contains(hana::make_tuple(2, hana::int_c<2>, hana::int_c<3>, 'x'), hana::int_c<3>));
 
BOOST_HANA_CONSTANT_CHECK(hana::contains(hana::make_set(hana::int_c<3>, hana::type_c<void>), hana::type_c<void>));
 
// contains 可以使用中缀表示法
BOOST_HANA_CONSTANT_CHECK(
hana::make_tuple(2, hana::int_c<2>, hana::int_c<3>, 'x') ^hana::contains^ hana::int_c<2>
);
 
int main() { }

◆ in

constexpr auto boost::hana::in = hana::infix(hana::flip(hana::contains))

constexpr

#include <boost/hana/fwd/contains.hpp>

返回键是否出现在结构中。

具体来说，这等价于 contains，除了 in 以相反的顺序获取其参数。与 contains 一样，in 也可以使用中缀表示法应用于提高表达力。此函数不是可以覆盖的方法；它只是概念提供的便捷函数。

示例

// 版权所有 Louis Dionne 2013-2017
// 根据 Boost 软件许可证 1.0 版发布。
// （请参阅随附文件 LICENSE.md 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）
 
#include <boost/hana/assert.hpp>
#include <boost/hana/contains.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
 
 
BOOST_HANA_CONSTANT_CHECK(hana::int_c<2> ^hana::in^ hana::make_tuple(2, hana::int_c<2>, hana::int_c<3>, 'x'));
 
int main() { }

◆ find

constexpr auto boost::hana::find

constexpr

#include <boost/hana/fwd/find.hpp>

初始值

= [](auto&& xs, auto const& key) {
        return tag-dispatched;
    }

在结构中查找与给定键关联的值。

给定一个 key 和一个 Searchable 结构，find 返回第一个键等于给定 key 的值的 just，如果不存在这样的键，则返回 nothing。比较使用 equal 完成。find 满足以下条件

find(xs, key) == find_if(xs, equal.to(key))

参数

xs	要搜索的结构体。
key	要在结构体中搜索的键。该键必须与结构体的其他键具有`Comparable`关系。在库的当前版本中，`key`与结构体任何其他键的比较必须返回编译时`Logical`。

示例

// 版权所有 Louis Dionne 2013-2017
// 根据 Boost 软件许可证 1.0 版发布。
// （请参阅随附文件 LICENSE.md 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）
 
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/find.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/optional.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
 
 
BOOST_HANA_CONSTANT_CHECK(
    hana::find(hana::make_tuple(hana::int_c<1>, hana::type_c<int>, '3'), hana::type_c<int>) == hana::just(hana::type_c<int>)
);
BOOST_HANA_CONSTANT_CHECK(
    hana::find(hana::make_tuple(hana::int_c<1>, hana::type_c<int>, '3'), hana::type_c<void>) == hana::nothing
);
 
constexpr auto m = hana::make_map(
hana::make_pair(hana::int_c<2>, 2),
hana::make_pair(hana::type_c<float>, 3.3),
hana::make_pair(hana::type_c<char>, hana::type_c<int>)
);
static_assert(hana::find(m, hana::type_c<float>) == hana::just(3.3), "");
 
int main() { }

◆ find_if

constexpr auto boost::hana::find_if

constexpr

#include <boost/hana/fwd/find_if.hpp>

初始值

= [](auto&& xs, auto&& predicate) {
        return tag-dispatched;
    }

查找与满足谓词的第一个键关联的值。

给定一个 Searchable 结构 xs 和一个谓词 pred，find_if(xs, pred) 返回第一个键满足谓词的元素的 just，如果不存在这样的元素，则返回 nothing。

参数

xs	要搜索的结构体。
predicate	一个称为 `predicate(k)` 的函数，其中 `k` 是结构的键，并返回 `k` 是否是正在搜索的元素的键。在库的当前版本中，谓词必须返回一个 `IntegralConstant`，其中包含一个可以转换为 `bool` 的值。

示例

// 版权所有 Louis Dionne 2013-2017
// 根据 Boost 软件许可证 1.0 版发布。
// （请参阅随附文件 LICENSE.md 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）
 
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/ext/std/integral_constant.hpp>
#include <boost/hana/find_if.hpp>
#include <boost/hana/functional/compose.hpp>
#include <boost/hana/optional.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
 
#include <type_traits>
namespace hana = boost::hana;
 
 
// 首先获取对象的类型，然后在其上调用特征。
constexpr auto is_integral = hana::compose(hana::trait<std::is_integral>, hana::typeid_);
constexpr auto is_class = hana::compose(hana::trait<std::is_class>, hana::typeid_);
 
static_assert(
    hana::find_if(hana::make_tuple(1.0, 2, '3'), is_integral) == hana::just(2)
, "");
 
BOOST_HANA_CONSTANT_CHECK(
    hana::find_if(hana::make_tuple(1.0, 2, '3'), is_class) == hana::nothing
);
 
constexpr auto types = hana::tuple_t<char, int, unsigned, long, unsigned long>;
BOOST_HANA_CONSTANT_CHECK(
    hana::find_if(types, hana::equal.to(hana::type_c<unsigned>)) == hana::just(hana::type_c<unsigned>)
);
BOOST_HANA_CONSTANT_CHECK(
    hana::find_if(types, hana::equal.to(hana::type_c<void>)) == hana::nothing
);
 
int main() { }

◆ is_disjoint

constexpr auto boost::hana::is_disjoint

constexpr

#include <boost/hana/fwd/is_disjoint.hpp>

初始值

= [](auto const& xs, auto const& ys) {
        return tag-dispatched;
    }

返回两个 Searchable 是否不相交。

给定两个 Searchable xs 和 ys，is_disjoint 返回一个 Logical，表示 xs 中的键是否与 ys 中的键不相交，即两个结构是否没有公共键。

参数

xs,ys 要测试是否不相交的两个 Searchable。

示例

// 版权所有 Louis Dionne 2013-2017
// 根据 Boost 软件许可证 1.0 版发布。
// （请参阅随附文件 LICENSE.md 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）
 
#include <boost/hana/assert.hpp>
#include <boost/hana/is_disjoint.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/not.hpp>
#include <boost/hana/set.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
 
#include <string>
namespace hana = boost::hana;
using namespace std::literals;
 
 
int main() {
    // 元组
    auto xs = hana::make_tuple(hana::int_c<1>, "alfa"s, hana::type_c<int>);
    auto ys = hana::make_tuple(hana::type_c<void>, hana::int_c<3>, "bravo"s);
    BOOST_HANA_RUNTIME_CHECK(hana::is_disjoint(xs, ys));
 
    // 集合
    auto s1 = hana::make_set(hana::int_c<1>, hana::type_c<void>, hana::int_c<2>);
    auto s2 = hana::make_set(hana::type_c<char>, hana::type_c<int>, hana::int_c<1>);
    BOOST_HANA_CONSTANT_CHECK(!hana::is_disjoint(s1, s2));
 
    // 映射
    auto vowels = hana::make_map(
hana::make_pair(hana::char_c<'a'>, "alfa"s),
hana::make_pair(hana::char_c<'e'>, "echo"s),
hana::make_pair(hana::char_c<'i'>, "india"s)
        // ...
    );
 
    auto consonants = hana::make_map(
hana::make_pair(hana::char_c<'b'>, "bravo"s),
hana::make_pair(hana::char_c<'c'>, "charlie"s),
hana::make_pair(hana::char_c<'f'>, "foxtrot"s)
        // ...
    );
 
    BOOST_HANA_CONSTANT_CHECK(hana::is_disjoint(vowels, consonants));
}

◆ is_subset

constexpr auto boost::hana::is_subset

constexpr

#include <boost/hana/fwd/is_subset.hpp>

初始值

= [](auto&& xs, auto&& ys) {
        return tag-dispatched;
    }

返回一个结构是否包含另一个结构键的子集。

给定两个 Searchable xs 和 ys，is_subset 返回一个 Logical，表示 xs 是否是 ys 的子集。换句话说，它返回 xs 的所有键是否也存在于 ys 中。此方法不返回 xs 是否是 ys 的严格子集；如果 xs 和 ys 相等，则 xs 的所有键也存在于 ys 中，并且 is_subset 返回 true。

注意: 为了方便起见，is_subset 也可以使用中缀表示法应用。

方法的跨类型版本

此方法使用两个参数的标签进行标签分派。它可以用任何两个共享公共 Searchable 嵌入的 Searchable 调用，如 Searchable 概念的主要文档中所定义。当具有两个不同标签但共享公共嵌入的 Searchable 发送到 is_subset 时，它们首先转换为这个公共 Searchable，然后使用公共嵌入的 is_subset 方法。当然，可以为自定义 Searchable 覆盖此方法以提高效率。

注意: 虽然支持 is_subset 的跨类型分派，但库目前未使用它，因为没有具有公共嵌入的 Searchable 模型。

参数

xs	要检查它是否是 `ys` 的子集的结构。
ys	要检查它是否是 `xs` 的超集的结构。

示例

// 版权所有 Louis Dionne 2013-2017
// 根据 Boost 软件许可证 1.0 版发布。
// （请参阅随附文件 LICENSE.md 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）
 
#include <boost/hana/is_subset.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
 
 
static_assert(
    hana::is_subset(hana::make_tuple(1, '2', 3.3), hana::make_tuple(3.3, 1, '2', nullptr))
, "");
 
// is_subset 可以使用中缀表示法应用
static_assert(
hana::make_tuple(1, '2', 3.3) ^hana::is_subset^ hana::make_tuple(3.3, 1, '2', nullptr)
, "");
 
int main() { }

◆ none

constexpr auto boost::hana::none

constexpr

#include <boost/hana/fwd/none.hpp>

初始值

= [](auto&& xs) -> decltype(auto) {
        return tag-dispatched;
    }

返回结构的所有键是否都为假值。

结构体的键必须是Logical类型。如果结构体不是有限的，则必须在有限的“索引”处出现一个真值键，以便此方法完成。

示例

// 版权所有 Louis Dionne 2013-2017
// 根据 Boost 软件许可证 1.0 版发布。
// （请参阅随附文件 LICENSE.md 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）
 
#include <boost/hana/assert.hpp>
#include <boost/hana/bool.hpp>
#include <boost/hana/none.hpp>
#include <boost/hana/not.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
 
 
static_assert(hana::none(hana::make_tuple(false, hana::false_c, hana::false_c)), "");
static_assert(!hana::none(hana::make_tuple(false, hana::false_c, true)), "");
BOOST_HANA_CONSTANT_CHECK(!hana::none(hana::make_tuple(false, hana::false_c, hana::true_c)));
 
int main() { }

◆ none_of

constexpr auto boost::hana::none_of

constexpr

#include <boost/hana/fwd/none_of.hpp>

初始值

= [](auto&& xs, auto&& predicate) {
        return tag-dispatched;
    }

返回结构的键中是否没有一个满足 predicate。

如果结构不是有限的，则此方法需要在查看有限数量的键后，predicate 必须返回一个真值的 Logical 才能完成。

参数

xs	要搜索的结构体。
predicate	一个函数，调用方式为`predicate(k)`，其中`k`是结构体的键，并返回一个`Logical`。

示例

// 版权所有 Louis Dionne 2013-2017
// 根据 Boost 软件许可证 1.0 版发布。
// （请参阅随附文件 LICENSE.md 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）
 
#include <boost/hana/assert.hpp>
#include <boost/hana/config.hpp>
#include <boost/hana/ext/std/integral_constant.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/mod.hpp>
#include <boost/hana/none_of.hpp>
#include <boost/hana/not.hpp>
#include <boost/hana/not_equal.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
 
#include <type_traits>
namespace hana = boost::hana;
using namespace hana::literals;
 
 
BOOST_HANA_CONSTEXPR_LAMBDA auto is_odd = [](auto x) {
    return x % 2_c != 0_c;
};
 
int main() {
    BOOST_HANA_CONSTANT_CHECK(hana::none_of(hana::make_tuple(2_c, 4_c), is_odd));
    BOOST_HANA_CONSTEXPR_CHECK(!hana::none_of(hana::make_tuple(1, 2), is_odd));
 
    BOOST_HANA_CONSTANT_CHECK(
!hana::none_of(hana::make_tuple(hana::type_c<void>, hana::type_c<char&>), hana::trait<std::is_void>)
    );
    BOOST_HANA_CONSTANT_CHECK(
        hana::none_of(hana::make_tuple(hana::type_c<void>, hana::type_c<char&>), hana::trait<std::is_integral>)
    );
}