C++ (Cpp) BOOST_HANA_CONSTEXPR_CHECK示例

示例#1

文件： capture.cpp 项目： LocutusOfBorg/poedit

int main() {
    BOOST_HANA_CONSTEXPR_LAMBDA auto sum = [](auto x, auto y, auto z) {
        return x + y + z;
    };

    BOOST_HANA_CONSTEXPR_CHECK(hana::capture(1, 2, 3)(sum)() == 6);
    BOOST_HANA_CONSTEXPR_CHECK(hana::capture(1, 2)(sum)(3) == 6);
}

示例#2

文件： monad.cpp 项目： jinby/hana

int main() {
    BOOST_HANA_CONSTEXPR_LAMBDA auto inc = [](auto x) {
        return hana::just(x + 1);
    };

    BOOST_HANA_CONSTEXPR_CHECK(hana::chain(hana::just(1), inc) == hana::just(2));
    BOOST_HANA_CONSTANT_CHECK(hana::chain(hana::nothing, inc) == hana::nothing);

    BOOST_HANA_CONSTEXPR_CHECK(hana::flatten(hana::just(hana::just(2))) == hana::just(2));
}

示例#3

文件： ap.cpp 项目： huaxiufeng/hana

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

示例#4

文件： adjust_if.cpp 项目： LocutusOfBorg/poedit

int main() {
    BOOST_HANA_CONSTEXPR_CHECK(
        hana::adjust_if(hana::make_tuple(-3, -2, -1, 0, 1, 2, 3), negative, negate)
                ==
        hana::make_tuple(3, 2, 1, 0, 1, 2, 3)
    );
}

示例#5

文件： adjust.cpp 项目： Ding8222/abelkhan

int main() {
    BOOST_HANA_CONSTEXPR_CHECK(
        hana::adjust(hana::make_tuple(1, 4, 9, 2, 3, 4), 4, negate)
        ==
        hana::make_tuple(1, -4, 9, 2, 3, -4)
    );
}

示例#6

文件： curry.cpp 项目： LocutusOfBorg/poedit

int main() {
    BOOST_HANA_CONSTEXPR_LAMBDA auto add = [](auto x, auto y, auto z) {
        return x + y + z;
    };

    BOOST_HANA_CONSTEXPR_CHECK(hana::curry<3>(add)(1)(2)(3) == 1 + 2 + 3);
    BOOST_HANA_CONSTEXPR_CHECK(hana::curry<3>(add)(1)(2, 3) == hana::curry<3>(add)(1)(2)(3));
    BOOST_HANA_CONSTEXPR_CHECK(hana::curry<3>(add)(1, 2, 3) == hana::curry<3>(add)(1)(2)(3));

    // curry with a nullary function
    BOOST_HANA_CONSTEXPR_LAMBDA auto two = []() {
        return 2;
    };

    BOOST_HANA_CONSTEXPR_CHECK(hana::curry<0>(two)() == two());
}

示例#7

文件： libcxx_19616.cpp 项目： LocutusOfBorg/poedit

int main() {
    // Make sure we workaround the bug at:
    // http://llvm.org/bugs/show_bug.cgi?id=19616
    BOOST_HANA_CONSTEXPR_CHECK(hana::equal(
        hana::lift<hana::ext::std::tuple_tag>(std::make_tuple(1)),
        std::make_tuple(std::make_tuple(1))
    ));
}

示例#8

文件： sfinae.cpp 项目： LocutusOfBorg/poedit

int main() {
    BOOST_HANA_CONSTEXPR_LAMBDA auto incr = [](auto x) -> decltype(x + 1) {
        return x + 1;
    };

    BOOST_HANA_CONSTEXPR_CHECK(hana::sfinae(incr)(1) == hana::just(2));

    struct invalid { };
    BOOST_HANA_CONSTANT_CHECK(hana::sfinae(incr)(invalid{}) == hana::nothing);
}

示例#9

文件： make.cpp 项目： npk48/hana

int main() {
    BOOST_HANA_CONSTEXPR_LAMBDA auto f = hana::make<hana::lazy_tag>([](auto x) {
        return 1 / x;
    });

    BOOST_HANA_CONSTEXPR_LAMBDA auto g = hana::make_lazy([](auto x) {
        return x + 1;
    });

    BOOST_HANA_CONSTEXPR_CHECK(hana::eval(hana::if_(hana::false_c, f(0), g(0))) == 0 + 1);
}

示例#10

文件： permutations.cpp 项目： jinby/hana

int main() {
    BOOST_HANA_CONSTEXPR_CHECK(
        hana::all_of(
            hana::make_tuple(
                hana::make_tuple('1', 2, 3.0),
                hana::make_tuple('1', 3.0, 2),
                hana::make_tuple(2, '1', 3.0),
                hana::make_tuple(2, 3.0, '1'),
                hana::make_tuple(3.0, '1', 2),
                hana::make_tuple(3.0, 2, '1')
            ),
            is_permutation_of(hana::make_tuple('1', 2, 3.0))
        )
    );
}

示例#11

文件： interop.cpp 项目： LocutusOfBorg/poedit

int main() {
    static_assert(
        hana::to_tuple(std::make_tuple(1, '2', 3.3)) == hana::make_tuple(1, '2', 3.3)
    , "");

    BOOST_HANA_CONSTANT_CHECK(
        hana::to_tuple(hana::make_range(hana::int_c<1>, hana::int_c<4>))
            ==
        hana::make_tuple(hana::int_c<1>, hana::int_c<2>, hana::int_c<3>)
    );

    // std::array's operator[] is not constexpr, so we can't use static_assert
    BOOST_HANA_CONSTEXPR_CHECK(
        hana::to_tuple(std::array<int, 3>{{1, 2, 3}}) == hana::make_tuple(1, 2, 3)
    );
}

示例#12

文件： monadic_compose.cpp 项目： eriser/boost

int main() {
    BOOST_HANA_CONSTEXPR_LAMBDA auto block = [](auto ...types) {
        return [=](auto x) {
            return hana::if_(hana::contains(hana::make_tuple(types...), hana::typeid_(x)),
                hana::nothing,
                hana::just(x)
            );
        };
    };

    BOOST_HANA_CONSTEXPR_LAMBDA auto f = block(hana::type_c<double>);
    BOOST_HANA_CONSTEXPR_LAMBDA auto g = block(hana::type_c<int>);
    BOOST_HANA_CONSTEXPR_LAMBDA auto h = hana::monadic_compose(g, f);
    BOOST_HANA_CONSTANT_CHECK(h(1)    == hana::nothing); // fails inside g; 1 has type int
    BOOST_HANA_CONSTANT_CHECK(h(1.2)  == hana::nothing); // fails inside f; 1.2 has type double
    BOOST_HANA_CONSTEXPR_CHECK(h('x') == hana::just('x')); // ok; 'x' has type char
}

示例#13

文件： infinite_set.cpp 项目： Ding8222/abelkhan

int main() {
    auto f = [](auto n) { return n + hana::int_c<10>; };
    auto g = [](auto n) { return n + hana::int_c<100>; };

    // union_
    {
        BOOST_HANA_CONSTANT_CHECK(hana::equal(
            hana::union_(singleton(c<0>), singleton(c<0>)),
            singleton(c<0>)
        ));
        BOOST_HANA_CONSTANT_CHECK(hana::equal(
            hana::union_(singleton(c<0>), singleton(c<1>)),
            doubleton(c<0>, c<1>)
        ));
        BOOST_HANA_CONSTANT_CHECK(hana::equal(
            hana::union_(singleton(c<0>), doubleton(c<0>, c<1>)),
            doubleton(c<0>, c<1>)
        ));
    }

    // Comparable
    {
        // equal
        {
            BOOST_HANA_CONSTEXPR_CHECK(hana::equal(singleton(n<0>), singleton(n<0>)));
            BOOST_HANA_CONSTEXPR_CHECK(hana::not_(hana::equal(singleton(n<0>), singleton(n<1>))));

            BOOST_HANA_CONSTEXPR_CHECK(hana::equal(singleton(n<0>), doubleton(n<0>, n<0>)));
            BOOST_HANA_CONSTEXPR_CHECK(hana::not_(hana::equal(singleton(n<0>), doubleton(n<0>, n<1>))));
            BOOST_HANA_CONSTEXPR_CHECK(hana::not_(hana::equal(singleton(n<0>), doubleton(n<1>, n<1>))));

            BOOST_HANA_CONSTEXPR_CHECK(hana::equal(doubleton(n<0>, n<1>), doubleton(n<0>, n<1>)));
            BOOST_HANA_CONSTEXPR_CHECK(hana::equal(doubleton(n<0>, n<1>), doubleton(n<1>, n<0>)));
            BOOST_HANA_CONSTEXPR_CHECK(hana::not_(hana::equal(doubleton(n<0>, n<1>), doubleton(n<0>, n<0>))));
            BOOST_HANA_CONSTEXPR_CHECK(hana::not_(hana::equal(doubleton(n<0>, n<1>), doubleton(n<3>, n<4>))));
        }
    }

    // Functor
    {
        // transform
        {
            BOOST_HANA_CONSTEXPR_CHECK(hana::equal(
                hana::transform(singleton(n<0>), f),
                singleton(f(n<0>))
            ));
            BOOST_HANA_CONSTEXPR_CHECK(hana::equal(
                hana::transform(doubleton(n<0>, n<1>), f),
                doubleton(f(n<0>), f(n<1>))
            ));
            BOOST_HANA_CONSTEXPR_CHECK(hana::equal(
                hana::transform(doubleton(n<0>, n<0>), f),
                singleton(f(n<0>))
            ));
        }
    }

    // Applicative
    {
        // ap
        {
            BOOST_HANA_CONSTANT_CHECK(hana::equal(
                hana::ap(singleton(f), singleton(c<0>)),
                singleton(f(c<0>))
            ));
            BOOST_HANA_CONSTANT_CHECK(hana::equal(
                hana::ap(singleton(f), doubleton(c<0>, c<1>)),
                doubleton(f(c<0>), f(c<1>))
            ));

            BOOST_HANA_CONSTANT_CHECK(hana::equal(
                hana::ap(doubleton(f, g), singleton(c<0>)),
                doubleton(f(c<0>), g(c<0>))
            ));
            BOOST_HANA_CONSTANT_CHECK(hana::equal(
                hana::ap(doubleton(f, g), doubleton(c<0>, c<1>)),
                hana::union_(doubleton(f(c<0>), f(c<1>)),
                             doubleton(g(c<0>), g(c<1>)))
            ));
        }

        // lift
        {
            BOOST_HANA_CONSTANT_CHECK(hana::equal(
                hana::lift<infinite_set_tag>(c<0>),
                singleton(c<0>)
            ));
        }
    }

    // Monad
    {
        // flatten
        {
            BOOST_HANA_CONSTANT_CHECK(hana::equal(
                hana::flatten(singleton(singleton(c<0>))),
                singleton(c<0>)
            ));
            BOOST_HANA_CONSTANT_CHECK(hana::equal(
                hana::flatten(singleton(doubleton(c<0>, c<1>))),
                doubleton(c<0>, c<1>)
            ));

            BOOST_HANA_CONSTANT_CHECK(hana::equal(
                hana::flatten(doubleton(singleton(c<0>), singleton(c<1>))),
                doubleton(c<0>, c<1>)
            ));
            BOOST_HANA_CONSTANT_CHECK(hana::equal(
                hana::flatten(doubleton(doubleton(c<0>, c<1>), singleton(c<2>))),
                hana::union_(doubleton(c<0>, c<1>), singleton(c<2>))
            ));
            BOOST_HANA_CONSTANT_CHECK(hana::equal(
                hana::flatten(doubleton(singleton(c<0>), doubleton(c<1>, c<2>))),
                hana::union_(doubleton(c<0>, c<1>), singleton(c<2>))
            ));
            BOOST_HANA_CONSTANT_CHECK(hana::equal(
                hana::flatten(doubleton(doubleton(c<0>, c<1>), doubleton(c<2>, c<3>))),
                hana::union_(doubleton(c<0>, c<1>), doubleton(c<2>, c<3>))
            ));
        }
    }

    // Searchable
    {
        // any_of
        {
            BOOST_HANA_CONSTEXPR_CHECK(hana::any_of(singleton(n<0>), hana::equal.to(n<0>)));
            BOOST_HANA_CONSTEXPR_CHECK(hana::not_(hana::any_of(singleton(n<0>), hana::equal.to(n<1>))));
            BOOST_HANA_CONSTEXPR_CHECK(hana::any_of(doubleton(n<0>, n<1>), hana::equal.to(n<0>)));
            BOOST_HANA_CONSTEXPR_CHECK(hana::any_of(doubleton(n<0>, n<1>), hana::equal.to(n<1>)));
            BOOST_HANA_CONSTEXPR_CHECK(hana::not_(hana::any_of(doubleton(n<0>, n<1>), hana::equal.to(n<2>))));
        }

        // find_if
        {
            BOOST_HANA_CONSTANT_CHECK(hana::find_if(singleton(c<0>), hana::equal.to(c<0>)) == hana::just(c<0>));
            BOOST_HANA_CONSTANT_CHECK(hana::find_if(singleton(c<1>), hana::equal.to(c<0>)) == hana::nothing);

            BOOST_HANA_CONSTANT_CHECK(hana::find_if(doubleton(c<0>, c<1>), hana::equal.to(c<0>)) == hana::just(c<0>));
            BOOST_HANA_CONSTANT_CHECK(hana::find_if(doubleton(c<0>, c<1>), hana::equal.to(c<1>)) == hana::just(c<1>));
            BOOST_HANA_CONSTANT_CHECK(hana::find_if(doubleton(c<0>, c<1>), hana::equal.to(c<2>)) == hana::nothing);
        }

        // is_subset
        {
            BOOST_HANA_CONSTEXPR_CHECK(hana::is_subset(singleton(n<0>), singleton(n<0>)));
            BOOST_HANA_CONSTEXPR_CHECK(hana::not_(hana::is_subset(singleton(n<1>), singleton(n<0>))));

            BOOST_HANA_CONSTEXPR_CHECK(hana::is_subset(singleton(n<0>), doubleton(n<0>, n<1>)));
            BOOST_HANA_CONSTEXPR_CHECK(hana::is_subset(singleton(n<1>), doubleton(n<0>, n<1>)));
            BOOST_HANA_CONSTEXPR_CHECK(hana::not_(hana::is_subset(singleton(n<2>), doubleton(n<0>, n<1>))));

            BOOST_HANA_CONSTEXPR_CHECK(hana::is_subset(doubleton(n<0>, n<1>), doubleton(n<0>, n<1>)));
            BOOST_HANA_CONSTEXPR_CHECK(hana::not_(hana::is_subset(doubleton(n<0>, n<2>), doubleton(n<0>, n<1>))));
            BOOST_HANA_CONSTEXPR_CHECK(hana::not_(hana::is_subset(doubleton(n<2>, n<3>), doubleton(n<0>, n<1>))));
        }
    }
}

示例#14

文件： lazy_list.cpp 项目： BeiLuoShiMen/hana

int main() {
    BOOST_HANA_CONSTANT_CHECK(!hana::is_empty(repeat(1)));
    BOOST_HANA_CONSTEXPR_CHECK(hana::front(repeat(1)) == 1);
    BOOST_HANA_CONSTEXPR_CHECK(hana::at(repeat(1), hana::size_c<10>) == 1);
}

示例#15

文件： to.cpp 项目： npk48/hana

int main() {
    BOOST_HANA_CONSTEXPR_CHECK(
        hana::to<hana::tuple_tag>(triple(1, '2', 3.3)) == hana::make_tuple(1, '2', 3.3)
    );
}