1 // Copyright Louis Dionne 2013-2017
2 // Distributed under the Boost Software License, Version 1.0.
3 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
5 #ifndef BOOST_HANA_TEST_LAWS_ITERABLE_HPP
6 #define BOOST_HANA_TEST_LAWS_ITERABLE_HPP
8 #include <boost/hana/any_of.hpp>
9 #include <boost/hana/assert.hpp>
10 #include <boost/hana/at.hpp>
11 #include <boost/hana/back.hpp>
12 #include <boost/hana/bool.hpp>
13 #include <boost/hana/concept/comparable.hpp>
14 #include <boost/hana/concept/foldable.hpp>
15 #include <boost/hana/concept/sequence.hpp>
16 #include <boost/hana/core/make.hpp>
17 #include <boost/hana/core/to.hpp>
18 #include <boost/hana/core/when.hpp>
19 #include <boost/hana/drop_front.hpp>
20 #include <boost/hana/drop_front_exactly.hpp>
21 #include <boost/hana/equal.hpp>
22 #include <boost/hana/eval_if.hpp>
23 #include <boost/hana/find_if.hpp>
24 #include <boost/hana/for_each.hpp>
25 #include <boost/hana/front.hpp>
26 #include <boost/hana/functional/always.hpp>
27 #include <boost/hana/functional/capture.hpp>
28 #include <boost/hana/integral_constant.hpp>
29 #include <boost/hana/is_empty.hpp>
30 #include <boost/hana/lazy.hpp>
31 #include <boost/hana/length.hpp>
32 #include <boost/hana/minus.hpp>
33 #include <boost/hana/not.hpp>
34 #include <boost/hana/optional.hpp>
35 #include <boost/hana/range.hpp>
36 #include <boost/hana/tuple.hpp>
38 #include <laws/base.hpp>
41 namespace boost { namespace hana { namespace test {
42 template <typename It, typename = hana::when<true>>
43 struct TestIterable : TestIterable<It, laws> {
44 using TestIterable<It, laws>::TestIterable;
47 template <typename It>
48 struct TestIterable<It, laws> {
49 template <typename Xs>
51 hana::for_each(xs, [](auto xs) {
52 static_assert(Iterable<decltype(xs)>{}, "");
54 BOOST_HANA_CONSTANT_CHECK(
55 hana::is_empty(xs) ^iff^ hana::is_empty(hana::to<tuple_tag>(xs))
58 only_when_(hana::not_(hana::is_empty(xs)), hana::make_lazy([](auto xs) {
59 BOOST_HANA_CHECK(hana::equal(
61 hana::front(hana::to<tuple_tag>(xs))
64 BOOST_HANA_CHECK(hana::equal(
65 hana::to<tuple_tag>(hana::drop_front_exactly(xs)),
66 hana::drop_front_exactly(hana::to<tuple_tag>(xs))
70 // back(xs) == at(xs, length(xs)-1)
71 BOOST_HANA_CHECK(hana::equal(
73 hana::at(xs, hana::minus(hana::length(xs), hana::size_c<1>))
78 // drop_front(xs, 0) == xs
79 BOOST_HANA_CHECK(hana::equal(
80 hana::drop_front(xs, size_c<0>),
84 // at(xs, n) == front(drop_front(xs, n))
85 hana::for_each(hana::make_range(size_c<0>, hana::length(xs)),
86 hana::capture(xs)([](auto xs, auto n) {
87 BOOST_HANA_CHECK(hana::equal(
89 hana::front(hana::drop_front(xs, n))
94 hana::eval_if(hana::is_empty(xs),
95 hana::make_lazy([](auto xs) {
96 BOOST_HANA_CONSTANT_CHECK(
97 hana::not_(hana::any_of(xs, hana::always(true_c)))
100 BOOST_HANA_CONSTANT_CHECK(hana::equal(
101 hana::find_if(xs, hana::always(true_c)),
105 hana::make_lazy([](auto xs) {
107 hana::any_of(xs, hana::always(true_c))
110 hana::not_(hana::any_of(xs, hana::always(false_c)))
113 BOOST_HANA_CHECK(hana::equal(
114 hana::find_if(xs, hana::always(true_c)),
115 hana::just(hana::front(xs))
124 template <typename S>
125 struct TestIterable<S, when<Sequence<S>::value>>
126 : TestIterable<S, laws>
134 struct undefined { };
136 template <typename Xs>
137 TestIterable(Xs xs) : TestIterable<S, laws>{xs} {
138 constexpr auto list = make<S>;
140 //////////////////////////////////////////////////////////////////
142 //////////////////////////////////////////////////////////////////
143 BOOST_HANA_CONSTANT_CHECK(equal(
147 BOOST_HANA_CONSTANT_CHECK(equal(
148 front(list(x<0>{}, invalid<>{})),
151 BOOST_HANA_CONSTANT_CHECK(equal(
152 front(list(x<0>{}, invalid<1>{}, invalid<2>{})),
156 BOOST_HANA_CONSTEXPR_CHECK(equal(
159 BOOST_HANA_CONSTEXPR_CHECK(equal(
160 front(list(1, '2')), 1
162 BOOST_HANA_CONSTEXPR_CHECK(equal(
163 front(list(1, '2', 3.3)), 1
166 //////////////////////////////////////////////////////////////////
168 //////////////////////////////////////////////////////////////////
169 BOOST_HANA_CONSTANT_CHECK(equal(
173 BOOST_HANA_CONSTANT_CHECK(equal(
174 back(list(invalid<0>{}, x<1>{})),
177 BOOST_HANA_CONSTANT_CHECK(equal(
178 back(list(invalid<0>{}, invalid<1>{}, x<2>{})),
182 BOOST_HANA_CONSTEXPR_CHECK(equal(
185 BOOST_HANA_CONSTEXPR_CHECK(equal(
186 back(list(1, '2')), '2'
188 BOOST_HANA_CONSTEXPR_CHECK(equal(
189 back(list(1, '2', 3.3)), 3.3
193 }}} // end namespace boost::hana::test
195 #endif // !BOOST_HANA_TEST_LAWS_ITERABLE_HPP