自学教程：C++ BOOST_HANA_CONSTANT_CHECK函数代码示例

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() {    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() {    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>{}    )));}