123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611 |
- // Copyright Louis Dionne 2013-2017
- // Distributed under the Boost Software License, Version 1.0.
- // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
- #ifndef BOOST_HANA_TEST_LAWS_SEARCHABLE_HPP
- #define BOOST_HANA_TEST_LAWS_SEARCHABLE_HPP
- #include <boost/hana/all.hpp>
- #include <boost/hana/all_of.hpp>
- #include <boost/hana/any.hpp>
- #include <boost/hana/any_of.hpp>
- #include <boost/hana/assert.hpp>
- #include <boost/hana/at_key.hpp>
- #include <boost/hana/bool.hpp>
- #include <boost/hana/concat.hpp>
- #include <boost/hana/concept/comparable.hpp>
- #include <boost/hana/concept/searchable.hpp>
- #include <boost/hana/concept/sequence.hpp>
- #include <boost/hana/contains.hpp>
- #include <boost/hana/core/is_a.hpp>
- #include <boost/hana/core/when.hpp>
- #include <boost/hana/equal.hpp>
- #include <boost/hana/find.hpp>
- #include <boost/hana/find_if.hpp>
- #include <boost/hana/for_each.hpp>
- #include <boost/hana/functional/always.hpp>
- #include <boost/hana/functional/capture.hpp>
- #include <boost/hana/functional/compose.hpp>
- #include <boost/hana/functional/partial.hpp>
- #include <boost/hana/is_disjoint.hpp>
- #include <boost/hana/is_subset.hpp>
- #include <boost/hana/lazy.hpp>
- #include <boost/hana/none.hpp>
- #include <boost/hana/none_of.hpp>
- #include <boost/hana/not.hpp>
- #include <boost/hana/optional.hpp>
- #include <boost/hana/transform.hpp>
- #include <boost/hana/tuple.hpp>
- #include <laws/base.hpp>
- #include <support/numeric.hpp>
- namespace boost { namespace hana { namespace test {
- template <typename S, typename = when<true>>
- struct TestSearchable : TestSearchable<S, laws> {
- using TestSearchable<S, laws>::TestSearchable;
- };
- template <typename S>
- struct TestSearchable<S, laws> {
- template <typename Searchables, typename Keys>
- TestSearchable(Searchables searchables, Keys keys) {
- hana::for_each(searchables, [](auto xs) {
- static_assert(Searchable<decltype(xs)>{}, "");
- });
- auto predicates = hana::concat(
- hana::to_tuple(hana::transform(keys, equal.to)),
- hana::make_tuple(
- hana::always(false_c),
- hana::always(true_c)
- )
- );
- hana::for_each(searchables, hana::capture(searchables, keys, predicates)(
- [](auto searchables, auto keys, auto predicates, auto xs) {
- hana::for_each(predicates, hana::capture(xs)(
- [](auto xs, auto p) {
- // any_of(xs, p) <=> !all_of(xs, negated p)
- // <=> !none_of(xs, p)
- BOOST_HANA_CHECK(
- hana::any_of(xs, p) ^iff^
- hana::not_(hana::all_of(xs, hana::compose(not_, p)))
- );
- BOOST_HANA_CHECK(
- hana::any_of(xs, p) ^iff^
- hana::not_(hana::none_of(xs, p))
- );
- }));
- // any(xs) <=> any_of(xs, id)
- // all(xs) <=> all_of(xs, id)
- // none(xs) <=> none_of(xs, id)
- auto all_logicals = hana::all_of(xs, [](auto x) {
- return hana::bool_c<hana::Logical<decltype(x)>::value>;
- });
- only_when_(all_logicals, hana::make_lazy([](auto xs) {
- BOOST_HANA_CHECK(
- hana::any(xs) ^iff^ hana::any_of(xs, id)
- );
- BOOST_HANA_CHECK(
- hana::all(xs) ^iff^ hana::all_of(xs, hana::id)
- );
- BOOST_HANA_CHECK(
- hana::none(xs) ^iff^ hana::none_of(xs, hana::id)
- );
- })(xs));
- // find_if(xs, always(false_c)) == nothing
- BOOST_HANA_CONSTANT_CHECK(hana::equal(
- hana::find_if(xs, hana::always(hana::false_c)),
- hana::nothing
- ));
- hana::for_each(searchables, hana::capture(xs)([](auto xs, auto ys) {
- // is_subset(xs, ys) <=> all_of(xs, [](auto x) { return contains(ys, x); })
- BOOST_HANA_CHECK(
- hana::is_subset(xs, ys) ^iff^
- hana::all_of(xs, hana::partial(hana::contains, ys))
- );
- // is_disjoint(xs, ys) <=> none_of(xs, [](auto x) { return contains(ys, x); })
- BOOST_HANA_CHECK(
- hana::is_disjoint(xs, ys) ^iff^
- hana::none_of(xs, hana::partial(hana::contains, ys))
- );
- }));
- hana::for_each(keys, hana::capture(xs)([](auto xs, auto key) {
- // find(xs, x) == find_if(xs, [](auto y) { return y == x; })
- BOOST_HANA_CHECK(hana::equal(
- hana::find(xs, key),
- hana::find_if(xs, hana::equal.to(key))
- ));
- // contains(xs, x) <=> any_of(xs, [](auto y) { return y == x; })
- BOOST_HANA_CHECK(
- hana::contains(xs, key) ^iff^
- hana::any_of(xs, hana::equal.to(key))
- );
- only_when_(hana::contains(xs, key),
- hana::make_lazy([](auto xs, auto key) {
- // at_key(xs, key) == find(xs, key).value()
- BOOST_HANA_CHECK(hana::equal(
- hana::at_key(xs, key),
- hana::find(xs, key).value()
- ));
- })(xs, key)
- );
- }));
- }));
- }
- };
- template <typename S>
- struct TestSearchable<S, when<Sequence<S>::value>>
- : TestSearchable<S, laws>
- {
- template <int i>
- using x = _constant<i>;
- template <int = 0>
- struct invalid { };
- struct undefined { };
- template <typename Xs, typename Keys>
- TestSearchable(Xs xs, Keys keys)
- : TestSearchable<S, laws>{xs, keys}
- {
- constexpr auto list = make<S>;
- BOOST_HANA_CONSTEXPR_LAMBDA auto is_even = [](auto x) {
- return x % 2 == 0;
- };
- auto c = numeric; // a minimal comparable
- auto logical = numeric;
- //////////////////////////////////////////////////////////////////
- // any_of
- //////////////////////////////////////////////////////////////////
- BOOST_HANA_CONSTANT_CHECK(
- hana::not_(hana::any_of(list(), equal.to(x<9>{})))
- );
- BOOST_HANA_CONSTANT_CHECK(
- hana::not_(hana::any_of(list(x<0>{}), equal.to(x<9>{})))
- );
- BOOST_HANA_CONSTANT_CHECK(
- hana::any_of(list(x<0>{}), equal.to(x<0>{}))
- );
- BOOST_HANA_CONSTANT_CHECK(
- hana::any_of(list(x<0>{}, invalid<1>{}), equal.to(x<0>{}))
- );
- BOOST_HANA_CONSTANT_CHECK(
- hana::any_of(list(x<0>{}, invalid<1>{}, invalid<2>{}), equal.to(x<0>{}))
- );
- BOOST_HANA_CONSTANT_CHECK(
- hana::not_(hana::any_of(list(x<0>{}, x<1>{}), equal.to(x<9>{})))
- );
- BOOST_HANA_CONSTANT_CHECK(
- hana::any_of(list(x<0>{}, x<1>{}), equal.to(x<1>{}))
- );
- BOOST_HANA_CONSTANT_CHECK(
- hana::any_of(list(x<0>{}, x<1>{}, invalid<2>{}), equal.to(x<1>{}))
- );
- BOOST_HANA_CONSTANT_CHECK(
- hana::any_of(list(x<0>{}, x<1>{}, invalid<2>{}, invalid<3>{}), equal.to(x<1>{}))
- );
- BOOST_HANA_CONSTANT_CHECK(
- hana::not_(hana::any_of(list(x<0>{}, x<1>{}, x<2>{}), equal.to(x<9>{})))
- );
- BOOST_HANA_CONSTANT_CHECK(
- hana::any_of(list(x<0>{}, x<1>{}, x<2>{}), equal.to(x<2>{}))
- );
- BOOST_HANA_CONSTANT_CHECK(
- hana::any_of(list(x<0>{}, x<1>{}, x<2>{}, nothing), equal.to(x<2>{}))
- );
- BOOST_HANA_CONSTANT_CHECK(
- hana::any_of(list(x<0>{}, x<1>{}, x<2>{}, nothing, nothing), equal.to(x<2>{}))
- );
- BOOST_HANA_CONSTANT_CHECK(
- hana::not_(hana::any_of(list(), invalid<>{}))
- );
- BOOST_HANA_CONSTEXPR_CHECK(
- hana::any_of(list(c(0)), equal.to(c(0)))
- );
- BOOST_HANA_CONSTEXPR_CHECK(
- hana::not_(hana::any_of(list(c(0)), equal.to(c(1))))
- );
- BOOST_HANA_CONSTEXPR_CHECK(
- hana::not_(hana::any_of(list(1), is_even))
- );
- BOOST_HANA_CONSTEXPR_CHECK(
- hana::any_of(list(2), is_even)
- );
- BOOST_HANA_CONSTEXPR_CHECK(
- hana::any_of(list(1, 2), is_even)
- );
- BOOST_HANA_CONSTEXPR_CHECK(
- hana::not_(hana::any_of(list(1, 3), is_even))
- );
- BOOST_HANA_CONSTEXPR_CHECK(
- hana::any_of(list(1, 3, 4), is_even)
- );
- //////////////////////////////////////////////////////////////////
- // any
- //////////////////////////////////////////////////////////////////
- BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any(list())));
- BOOST_HANA_CONSTEXPR_CHECK(hana::any(list(logical(true))));
- BOOST_HANA_CONSTEXPR_CHECK(hana::not_(hana::any(list(logical(false)))));
- //////////////////////////////////////////////////////////////////
- // all_of
- //////////////////////////////////////////////////////////////////
- BOOST_HANA_CONSTANT_CHECK(
- all_of(list(), invalid<>{})
- );
- BOOST_HANA_CONSTEXPR_CHECK(
- all_of(list(c(0)), equal.to(c(0)))
- );
- BOOST_HANA_CONSTEXPR_CHECK(
- not_(all_of(list(c(0)), equal.to(c(1))))
- );
- BOOST_HANA_CONSTEXPR_CHECK(not_(
- all_of(list(c(0), c(1)), equal.to(c(0)))
- ));
- BOOST_HANA_CONSTEXPR_CHECK(
- all_of(list(c(0), c(0)), equal.to(c(0)))
- );
- BOOST_HANA_CONSTEXPR_CHECK(not_(all_of(list(1), is_even)));
- BOOST_HANA_CONSTEXPR_CHECK(all_of(list(2), is_even));
- BOOST_HANA_CONSTEXPR_CHECK(all_of(list(2, 4), is_even));
- BOOST_HANA_CONSTEXPR_CHECK(not_(all_of(list(1, 2), is_even)));
- BOOST_HANA_CONSTEXPR_CHECK(not_(all_of(list(1, 3), is_even)));
- BOOST_HANA_CONSTEXPR_CHECK(not_(all_of(list(1, 3, 4), is_even)));
- //////////////////////////////////////////////////////////////////
- // all
- //////////////////////////////////////////////////////////////////
- BOOST_HANA_CONSTANT_CHECK(all(list()));
- BOOST_HANA_CONSTEXPR_CHECK(all(list(logical(true))));
- BOOST_HANA_CONSTEXPR_CHECK(not_(all(list(logical(false)))));
- BOOST_HANA_CONSTEXPR_CHECK(all(list(logical(true), logical(true))));
- BOOST_HANA_CONSTEXPR_CHECK(not_(all(list(logical(true), logical(false)))));
- //////////////////////////////////////////////////////////////////
- // none_of
- //////////////////////////////////////////////////////////////////
- BOOST_HANA_CONSTANT_CHECK(none_of(list(), invalid<>{}));
- BOOST_HANA_CONSTEXPR_CHECK(none_of(list(c(0)), equal.to(c(1))));
- BOOST_HANA_CONSTEXPR_CHECK(not_(none_of(list(c(0)), equal.to(c(0)))));
- BOOST_HANA_CONSTEXPR_CHECK(none_of(list(1), is_even));
- BOOST_HANA_CONSTEXPR_CHECK(not_(none_of(list(2), is_even)));
- BOOST_HANA_CONSTEXPR_CHECK(not_(none_of(list(1, 2), is_even)));
- BOOST_HANA_CONSTEXPR_CHECK(none_of(list(1, 3), is_even));
- BOOST_HANA_CONSTEXPR_CHECK(not_(none_of(list(1, 3, 4), is_even)));
- //////////////////////////////////////////////////////////////////
- // none
- //////////////////////////////////////////////////////////////////
- BOOST_HANA_CONSTANT_CHECK(none(list()));
- BOOST_HANA_CONSTEXPR_CHECK(none(list(logical(false))));
- BOOST_HANA_CONSTEXPR_CHECK(not_(none(list(logical(true)))));
- //////////////////////////////////////////////////////////////////
- // find_if
- //////////////////////////////////////////////////////////////////
- {
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(list(), equal.to(x<9>{})),
- nothing
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(list(x<0>{}), equal.to(x<9>{})),
- nothing
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(list(x<0>{}), equal.to(x<0>{})),
- just(x<0>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(list(x<0>{}, invalid<1>{}), equal.to(x<0>{})),
- just(x<0>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(list(x<0>{}, invalid<1>{}, invalid<2>{}), equal.to(x<0>{})),
- just(x<0>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(list(x<0>{}, x<1>{}), equal.to(x<9>{})),
- nothing
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(list(x<0>{}, x<1>{}), equal.to(x<1>{})),
- just(x<1>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(list(x<0>{}, x<1>{}, invalid<2>{}), equal.to(x<1>{})),
- just(x<1>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(list(x<0>{}, x<1>{}, invalid<2>{}, invalid<3>{}), equal.to(x<1>{})),
- just(x<1>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(list(x<0>{}, x<1>{}, x<2>{}), equal.to(x<9>{})),
- nothing
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(list(x<0>{}, x<1>{}, x<2>{}), equal.to(x<2>{})),
- just(x<2>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(list(x<0>{}, x<1>{}, x<2>{}, nothing), equal.to(x<2>{})),
- just(x<2>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(list(x<0>{}, x<1>{}, x<2>{}, nothing, nothing), equal.to(x<2>{})),
- just(x<2>{})
- ));
- // Make sure find_if works with an lvalue sequence. hana::tuple
- // used to have a bug that broke this.
- auto const const_lvalue = list(x<0>{}, x<1>{}, x<2>{});
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(const_lvalue, equal.to(x<1>{})),
- just(x<1>{})
- ));
- auto lvalue = list(x<0>{}, x<1>{}, x<2>{});
- BOOST_HANA_CONSTANT_CHECK(equal(
- find_if(lvalue, equal.to(x<1>{})),
- just(x<1>{})
- ));
- }
- //////////////////////////////////////////////////////////////////
- // find
- //////////////////////////////////////////////////////////////////
- {
- BOOST_HANA_CONSTANT_CHECK(equal(
- find(list(), invalid<>{}),
- nothing
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find(list(x<0>{}), x<9>{}),
- nothing
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find(list(x<0>{}), x<0>{}),
- just(x<0>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find(list(x<0>{}, invalid<1>{}), x<0>{}),
- just(x<0>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find(list(x<0>{}, invalid<1>{}, invalid<2>{}), x<0>{}),
- just(x<0>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find(list(x<0>{}, x<1>{}), x<9>{}),
- nothing
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find(list(x<0>{}, x<1>{}), x<1>{}),
- just(x<1>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find(list(x<0>{}, x<1>{}, invalid<2>{}), x<1>{}),
- just(x<1>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find(list(x<0>{}, x<1>{}, invalid<2>{}, invalid<3>{}), x<1>{}),
- just(x<1>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find(list(x<0>{}, x<1>{}, x<2>{}), x<9>{}),
- nothing
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find(list(x<0>{}, x<1>{}, x<2>{}), x<2>{}),
- just(x<2>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find(list(x<0>{}, x<1>{}, x<2>{}, nothing), x<2>{}),
- just(x<2>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- find(list(x<0>{}, x<1>{}, x<2>{}, nothing, nothing), x<2>{}),
- just(x<2>{})
- ));
- }
- //////////////////////////////////////////////////////////////////
- // at_key
- //////////////////////////////////////////////////////////////////
- {
- BOOST_HANA_CONSTANT_CHECK(equal(
- at_key(list(x<0>{}), x<0>{}),
- x<0>{}
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- at_key(list(x<0>{}, x<1>{}), x<0>{}),
- x<0>{}
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- at_key(list(x<0>{}, x<1>{}), x<1>{}),
- x<1>{}
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- at_key(list(x<0>{}, x<1>{}, x<2>{}), x<0>{}),
- x<0>{}
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- at_key(list(x<0>{}, x<1>{}, x<2>{}), x<1>{}),
- x<1>{}
- ));
- BOOST_HANA_CONSTANT_CHECK(equal(
- at_key(list(x<0>{}, x<1>{}, x<2>{}), x<2>{}),
- x<2>{}
- ));
- }
- //////////////////////////////////////////////////////////////////
- // contains
- //////////////////////////////////////////////////////////////////
- {
- BOOST_HANA_CONSTANT_CHECK(not_(
- contains(list(), undefined{})
- ));
- BOOST_HANA_CONSTANT_CHECK(not_(
- contains(list(x<0>{}), x<999>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(
- contains(list(x<0>{}), x<0>{})
- );
- BOOST_HANA_CONSTANT_CHECK(
- contains(list(x<0>{}, x<1>{}), x<1>{})
- );
- BOOST_HANA_CONSTANT_CHECK(
- contains(list(x<0>{}, x<1>{}, x<3>{}), x<3>{})
- );
- BOOST_HANA_CONSTEXPR_CHECK(contains(list(c(0)), c(0)));
- BOOST_HANA_CONSTEXPR_CHECK(not_(contains(list(c(0)), c(1))));
- // infix application
- BOOST_HANA_CONSTANT_CHECK(
- list(x<0>{}, x<1>{}) ^contains^ x<1>{}
- );
- }
- //////////////////////////////////////////////////////////////////
- // in
- //////////////////////////////////////////////////////////////////
- BOOST_HANA_CONSTEXPR_CHECK(c(0) ^in^ list(c(0)));
- BOOST_HANA_CONSTEXPR_CHECK(not_(c(1) ^in^ list(c(0))));
- //////////////////////////////////////////////////////////////////
- // is_subset
- //////////////////////////////////////////////////////////////////
- {
- BOOST_HANA_CONSTANT_CHECK(is_subset(
- list(), list(undefined{})
- ));
- BOOST_HANA_CONSTANT_CHECK(not_(is_subset(
- list(undefined{}), list()
- )));
- BOOST_HANA_CONSTEXPR_CHECK(is_subset(
- list(c(0)), list(c(0))
- ));
- BOOST_HANA_CONSTEXPR_CHECK(is_subset(
- list(c(0)), list(c(0), c(1))
- ));
- BOOST_HANA_CONSTEXPR_CHECK(not_(is_subset(
- list(c(0)), list(c(1))
- )));
- // infix application
- BOOST_HANA_CONSTANT_CHECK(
- list(x<0>{}) ^is_subset^ list(x<1>{}, x<0>{})
- );
- BOOST_HANA_CONSTANT_CHECK(
- list(x<0>{}, x<1>{}) ^is_subset^ list(x<1>{}, x<0>{})
- );
- }
- //////////////////////////////////////////////////////////////////
- // is_disjoint
- //////////////////////////////////////////////////////////////////
- {
- BOOST_HANA_CONSTANT_CHECK(is_disjoint(
- list(),
- list()
- ));
- BOOST_HANA_CONSTANT_CHECK(is_disjoint(
- list(),
- list(undefined{})
- ));
- BOOST_HANA_CONSTANT_CHECK(is_disjoint(
- list(undefined{}),
- list()
- ));
- BOOST_HANA_CONSTANT_CHECK(is_disjoint(
- list(x<0>{}),
- list(x<1>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(is_disjoint(
- list(x<1>{}),
- list(x<0>{})
- ));
- BOOST_HANA_CONSTANT_CHECK(not_(is_disjoint(
- list(x<0>{}),
- list(x<0>{})
- )));
- BOOST_HANA_CONSTANT_CHECK(not_(is_disjoint(
- list(x<0>{}, x<1>{}),
- list(x<0>{})
- )));
- BOOST_HANA_CONSTANT_CHECK(not_(is_disjoint(
- list(x<0>{}),
- list(x<0>{}, x<1>{})
- )));
- BOOST_HANA_CONSTANT_CHECK(not_(is_disjoint(
- list(x<1>{}, x<0>{}),
- list(x<0>{}, x<1>{})
- )));
- BOOST_HANA_CONSTANT_CHECK(not_(is_disjoint(
- list(x<0>{}, x<1>{}),
- list(x<1>{}, x<2>{})
- )));
- BOOST_HANA_CONSTANT_CHECK(is_disjoint(
- list(x<0>{}, x<1>{}),
- list(x<2>{}, x<3>{})
- ));
- }
- }
- };
- }}} // end namespace boost::hana::test
- #endif // !BOOST_HANA_TEST_LAWS_SEARCHABLE_HPP
|