int main() {
// Interoperation with hana::integral_constant
BOOST_HANA_CONSTANT_CHECK(mpl::integral_c<int, 1>{} == hana::int_c<1>);
BOOST_HANA_CONSTANT_CHECK(mpl::integral_c<int, 1>{} == hana::long_c<1>);
BOOST_HANA_CONSTANT_CHECK(mpl::integral_c<int, 2>{} != hana::int_c<3>);
}
int main() {
auto container = ::seq;
{
auto storage = container();
auto transformed = hana::experimental::transformed(storage, undefined<99>{});
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::length(transformed),
hana::size_c<0>
));
}{
auto storage = container(undefined<0>{});
auto transformed = hana::experimental::transformed(storage, undefined<99>{});
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::length(transformed),
hana::size_c<1>
));
}{
auto storage = container(undefined<0>{}, undefined<1>{});
auto transformed = hana::experimental::transformed(storage, undefined<99>{});
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::length(transformed),
hana::size_c<2>
));
}{
auto storage = container(undefined<0>{}, undefined<1>{}, undefined<2>{});
auto transformed = hana::experimental::transformed(storage, undefined<99>{});
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::length(transformed),
hana::size_c<3>
));
}
}
int main() {
BOOST_HANA_CONSTANT_CHECK(hana::length(hana::make_tuple()) == hana::size_c<0>);
BOOST_HANA_CONSTANT_CHECK(hana::length(hana::make_tuple(1, '2', 3.0)) == hana::size_c<3>);
BOOST_HANA_CONSTANT_CHECK(hana::length(hana::nothing) == hana::size_c<0>);
BOOST_HANA_CONSTANT_CHECK(hana::length(hana::just('x')) == hana::size_c<1>);
}
int main() {
// Conversion from any `Foldable` containing `type`s
auto foldable = ::seq;
auto to_list = hana::to<hana::ext::boost::mpl::list_tag>;
BOOST_HANA_CONSTANT_CHECK(hana::equal(
to_list(foldable()),
mpl::list<>{}
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
to_list(foldable(hana::type_c<t1>)),
mpl::list<t1>{}
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
to_list(foldable(hana::type_c<t1>, hana::type_c<t2>)),
mpl::list<t1, t2>{}
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
to_list(foldable(hana::type_c<t1>, hana::type_c<t2>, hana::type_c<t3>)),
mpl::list<t1, t2, t3>{}
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
to_list(foldable(hana::type_c<t1>, hana::type_c<t2>, hana::type_c<t3>, hana::type_c<t4>)),
mpl::list<t1, t2, t3, t4>{}
));
}
int main() {
auto container = ::seq;
{
auto storage1 = container();
auto storage2 = container();
auto joined = hana::experimental::joined(storage1, storage2);
BOOST_HANA_CONSTANT_CHECK(hana::is_empty(joined));
}
{
auto storage1 = container(undefined<0>{});
auto storage2 = container();
auto joined = hana::experimental::joined(storage1, storage2);
BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::is_empty(joined)));
}
{
auto storage1 = container(undefined<0>{});
auto storage2 = container(undefined<1>{});
auto joined = hana::experimental::joined(storage1, storage2);
BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::is_empty(joined)));
}
{
auto storage1 = container();
auto storage2 = container(undefined<0>{});
auto joined = hana::experimental::joined(storage1, storage2);
BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::is_empty(joined)));
}
}
int main() {
// works with elements whose `less` does not return a Constant
{
constexpr auto xs = hana::make_tuple(1, 2, 3, 4);
constexpr auto ys = hana::make_tuple(1, 6, 3, 4);
static_assert(hana::lexicographical_compare(xs, ys), "");
}
// and with those that do
{
auto xs = hana::make_tuple(hana::int_<1>, hana::int_<2>, hana::int_<3>);
auto ys = hana::make_tuple(hana::int_<1>, hana::int_<5>, hana::int_<3>);
BOOST_HANA_CONSTANT_CHECK(hana::lexicographical_compare(xs, ys));
}
// it also accepts a custom predicate
{
auto xs = hana::make_tuple(hana::type<int>, hana::type<char>, hana::type<void*>);
auto ys = hana::make_tuple(hana::type<int>, hana::type<long>, hana::type<void*>);
BOOST_HANA_CONSTANT_CHECK(
hana::lexicographical_compare(xs, ys, [](auto t, auto u) {
return hana::sizeof_(t) < hana::sizeof_(u);
})
);
}
}
int main() {
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::make<hana::type_tag>(T{}),
hana::decltype_(T{})
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::make<hana::type_tag>(hana::type_c<T>),
hana::decltype_(hana::type_c<T>)
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::make_type(T{}),
hana::make<hana::type_tag>(T{})
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::make_type(hana::type_c<T>),
hana::make<hana::type_tag>(hana::type_c<T>)
));
// make sure we don't read from non-constexpr variables
{
auto t = hana::type_c<T>;
auto x = 1;
constexpr auto r1 = hana::make<hana::type_tag>(t); (void)r1;
constexpr auto r2 = hana::make<hana::type_tag>(x); (void)r2;
}
}
int main() {
auto deref = [](auto x) { return *x; };
auto deref3 = hana::compose(deref, deref, deref);
BOOST_HANA_CONSTANT_CHECK(hana::equal(
*hana::type_c<char*>,
hana::type_c<char&>
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
deref(hana::type_c<int*>),
hana::type_c<int&>
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
deref3(hana::type_c<int***>),
hana::type_c<int&>
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::type_c<int> + hana::type_c<float>,
hana::type_c<float>
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
++hana::type_c<int&>,
hana::type_c<int&>
));
}
int main() {
hana::test::_injection<0> f{};
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::unpack(hana::make_range(hana::int_c<0>, hana::int_c<0>), f),
f()
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::unpack(hana::make_range(hana::int_c<0>, hana::int_c<1>), f),
f(hana::int_c<0>)
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::unpack(hana::make_range(hana::int_c<0>, hana::int_c<2>), f),
f(hana::int_c<0>, hana::int_c<1>)
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::unpack(hana::make_range(hana::int_c<0>, hana::int_c<3>), f),
f(hana::int_c<0>, hana::int_c<1>, hana::int_c<2>)
));
// Previously, we would only unpack with `std::size_t`s. Make
// sure this does not happen.
hana::unpack(hana::make_range(hana::int_c<0>, hana::int_c<1>), [](auto x) {
using T = hana::tag_of_t<decltype(x)>;
static_assert(std::is_same<typename T::value_type, int>{}, "");
});
}
int main() {
BOOST_HANA_CONSTANT_CHECK(hana::char_c<'c'> ^hana::in^ BOOST_HANA_STRING("abcde"));
BOOST_HANA_CONSTANT_CHECK(!(hana::char_c<'z'> ^hana::in^ BOOST_HANA_STRING("abcde")));
BOOST_HANA_CONSTANT_CHECK(
hana::find(BOOST_HANA_STRING("abcxefg"), hana::char_c<'x'>) == hana::just(hana::char_c<'x'>)
);
}
int main() {
BOOST_HANA_CONSTANT_CHECK(
hana::to<hana::tuple_tag>(hana::tuple_c<int, 0, 1, 2>)
==
hana::make_tuple(hana::int_c<0>, hana::int_c<1>, hana::int_c<2>)
);
BOOST_HANA_CONSTANT_CHECK(hana::front(hana::tuple_c<int, 0, 1, 2>) == hana::int_c<0>);
}
int main() {
constexpr auto ints = hana::tuple_c<int, 1, 2, 3, 2, 2, 4, 2>;
BOOST_HANA_CONSTANT_CHECK(hana::count(ints, hana::int_<2>) == hana::size_t<4>);
static_assert(hana::count(ints, 2) == 4, "");
constexpr auto types = hana::tuple_t<int, char, long, short, char, double>;
BOOST_HANA_CONSTANT_CHECK(hana::count(types, hana::type<char>) == hana::size_t<2>);
}
int main() {
constexpr auto x = hana::make<hana::optional_tag>();
BOOST_HANA_CONSTANT_CHECK(x == hana::make_optional());
BOOST_HANA_CONSTANT_CHECK(hana::is_nothing(x));
constexpr auto just_x = hana::make<hana::optional_tag>('x');
static_assert(just_x == hana::make_optional('x'), "");
BOOST_HANA_CONSTANT_CHECK(hana::is_just(just_x));
}
int main() {
static_assert(hana::to<hana::tuple_tag>(hana::just(1)) == hana::make_tuple(1), "");
BOOST_HANA_CONSTANT_CHECK(hana::to<hana::tuple_tag>(hana::nothing) == hana::make_tuple());
BOOST_HANA_CONSTANT_CHECK(
hana::to<hana::tuple_tag>(hana::make_range(hana::int_c<3>, hana::int_c<6>))
==
hana::tuple_c<int, 3, 4, 5>
);
}
int main() {
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::at_key(hana::make_map(p<0, 0>()), key<0>()),
val<0>()
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::at_key(hana::make_map(p<0, 0>(), p<1,1>()), key<0>()),
val<0>()
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::at_key(hana::make_map(p<0, 0>(), p<1,1>()), key<1>()),
val<1>()
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::at_key(hana::make_map(p<0, 0>(), p<1,1>(), p<2,2>()), key<0>()),
val<0>()
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::at_key(hana::make_map(p<0, 0>(), p<1,1>(), p<2,2>()), key<1>()),
val<1>()
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::at_key(hana::make_map(p<0, 0>(), p<1,1>(), p<2,2>()), key<2>()),
val<2>()
));
// check operators
auto m = hana::make_map(p<2, 2>(), p<1, 1>());
auto const const_m = hana::make_map(p<2, 2>(), p<1, 1>());
BOOST_HANA_CONSTANT_CHECK(hana::equal(m[key<1>()], val<1>()));
BOOST_HANA_CONSTANT_CHECK(hana::equal(const_m[key<1>()], val<1>()));
BOOST_HANA_CONSTANT_CHECK(hana::equal(std::move(m)[key<1>()], val<1>()));
}
int main() {
constexpr auto xs = hana::make_set(hana::int_c<0>, hana::int_c<1>, hana::int_c<2>);
BOOST_HANA_CONSTANT_CHECK(hana::find(xs, hana::int_c<0>) == hana::just(hana::int_c<0>));
BOOST_HANA_CONSTANT_CHECK(hana::find(xs, hana::int_c<3>) == hana::nothing);
// operator[] is equivalent to at_key
BOOST_HANA_CONSTANT_CHECK(xs[hana::int_c<2>] == hana::int_c<2>);
// long_c<0> == int_<0>, and therefore int_<0> is found
BOOST_HANA_CONSTANT_CHECK(xs[hana::long_c<0>] == hana::int_c<0>);
}
int main() {
BOOST_HANA_CONSTANT_CHECK(!hana::is_empty(BOOST_HANA_STRING("abcd")));
BOOST_HANA_CONSTANT_CHECK(hana::is_empty(BOOST_HANA_STRING("")));
BOOST_HANA_CONSTANT_CHECK(BOOST_HANA_STRING("abcd")[hana::size_c<2>] == hana::char_c<'c'>);
auto is_vowel = [](auto c) {
return c ^hana::in^ BOOST_HANA_STRING("aeiouy");
};
BOOST_HANA_CONSTANT_CHECK(
hana::drop_while(BOOST_HANA_STRING("aioubcd"), is_vowel) == BOOST_HANA_STRING("bcd")
);
}
int main() {
BOOST_HANA_CONSTANT_CHECK(
hana::make_set(hana::int_c<0>, hana::type_c<char>, hana::int_c<1>)
==
hana::make_set(hana::int_c<1>, hana::int_c<0>, hana::type_c<char>)
);
BOOST_HANA_CONSTANT_CHECK(
hana::make_set(hana::int_c<0>, hana::type_c<char>)
!=
hana::make_set(hana::int_c<1>)
);
}
int main() {
hana::test::_injection<0> f{};
hana::test::ct_eq<2> x{};
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::maybe(x, undefined{}, hana::nothing),
x
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::maybe(undefined{}, f, hana::just(x)),
f(x)
));
}
int main() {
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::minimum(hana::make_range(hana::int_c<3>, hana::int_c<4>)),
hana::int_c<3>
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::minimum(hana::make_range(hana::int_c<3>, hana::int_c<5>)),
hana::int_c<3>
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::minimum(hana::make_range(hana::int_c<-1>, hana::int_c<5>)),
hana::int_c<-1>
));
}
int main() {
hana::test::ct_eq<2> x{};
hana::test::ct_eq<3> s{};
hana::test::_injection<0> f{};
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::fold_left(hana::just(x), s, f),
f(s, x)
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::fold_left(hana::nothing, s, f),
s
));
}
int main() {
// with tuples
static_assert(
hana::ap(hana::make_tuple(std::plus<>{}), hana::make_tuple(1, 2),
hana::make_tuple(3, 4, 5))
==
hana::make_tuple(
1 + 3, 1 + 4, 1 + 5,
2 + 3, 2 + 4, 2 + 5
)
, "");
// with optional values
BOOST_HANA_CONSTEXPR_LAMBDA auto multiply = [](auto a, auto b, auto c) {
return a * b * c;
};
BOOST_HANA_CONSTEXPR_CHECK(
hana::ap(hana::just(multiply), hana::just(1),
hana::just(2),
hana::just(3))
==
hana::just(1 * 2 * 3)
);
BOOST_HANA_CONSTANT_CHECK(
hana::ap(hana::just(multiply), hana::just(1),
hana::nothing,
hana::just(3))
==
hana::nothing
);
}
int main() {
constexpr auto sequence = hana::test::seq;
// Use pointers to workaround a Clang ICE
hana::test::_injection<0> f{};
auto* fp = &f;
hana::test::ct_eq<999> state{};
auto* statep = &state;
auto check = [=](auto ...pairs) {
auto possible_results = hana::transform(hana::permutations(sequence(pairs...)),
[=](auto xs) {
return hana::fold_left(xs, *statep, *fp);
}
);
BOOST_HANA_CONSTANT_CHECK(hana::contains(
possible_results,
hana::fold_left(hana::make_map(pairs...), state, f)
));
};
check();
check(p<1, 1>());
check(p<1, 1>(), p<2, 2>());
check(p<1, 1>(), p<2, 2>(), p<3, 3>());
check(p<1, 1>(), p<2, 2>(), p<3, 3>(), p<4, 4>());
}
int main() {
static_assert(hana::equal(hana::make_tuple(1, 2), hana::make_tuple(1, 2)), "");
static_assert(!hana::equal('x', 'y'), "");
BOOST_HANA_CONSTANT_CHECK(!hana::equal(hana::make_tuple(1, 2), 'y'));
static_assert(hana::any_of(hana::make_tuple(1, 2, 3), hana::equal.to(2)), "");
}
int main() {
BOOST_HANA_CONSTANT_CHECK(hana::any_of(
BOOST_HANA_STRING("abcd"),
hana::equal.to(hana::char_c<'b'>)
));
BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any_of(
BOOST_HANA_STRING(""),
hana::always(hana::true_c)
)));
BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any_of(
BOOST_HANA_STRING("abcd"),
hana::equal.to(hana::char_c<'z'>)
)));
}
int main() {
static_assert(hana::just('x').value() == 'x', "");
BOOST_HANA_CONSTANT_CHECK(*hana::just(hana::type_c<int>) == hana::type_c<int>);
BOOST_HANA_RUNTIME_CHECK(hana::just(std::string{"abcd"})->size() == 4);
// hana::nothing.value(); // compile-time error
}
int main() {
// make sure to_tuple == to<tuple_tag>
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::to<hana::tuple_tag>(hana::tuple_t<int, char, void, int(float)>),
hana::to_tuple(hana::tuple_t<int, char, void, int(float)>)
));
}
int main() {
// make sure make<range_tag> works with arbitrary Constants
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::make<hana::range_tag>(hana::test::_constant<1>{}, hana::test::_constant<4>{}),
hana::make_range(hana::integral_c<int, 1>, hana::integral_c<int, 4>)
));
}
int main() {
static_assert(hana::not_equal(hana::make_tuple(1, 2), hana::make_tuple(3)), "");
static_assert(hana::not_equal('x', 'y'), "");
BOOST_HANA_CONSTANT_CHECK(hana::not_equal(hana::make_tuple(1, 2), 'y'));
static_assert(hana::all_of(hana::make_tuple(1, 2, 3), hana::not_equal.to(5)), "");
}
int main() {
BOOST_HANA_CONSTANT_CHECK(hana::less(
std::ratio<1>{},
std::ratio<3>{}
));
BOOST_HANA_CONSTANT_CHECK(hana::less(
std::ratio<4, 10>{},
std::ratio<3, 5>{}
));
BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::less(
std::ratio<3, 5>{},
std::ratio<4, 10>{}
)));
}
