boost/hana
2
0
Fork 0
mirror of https://github.com/boostorg/hana.git synced 2026-01-28 07:12:15 +00:00
Code Issues Projects Releases Wiki Activity

[IntegralConstant] Suffix variable templates with _c, and clean up type names

Browse Source 
Along with PR #166, this closes #122 because names have now been
cleaned up and are now consistent basically everywhere.
This commit is contained in:
Louis Dionne
2015-09-01 09:31:22 -04:00
parent 05a57e562d
commit 08f66d47c1
227 changed files with 1328 additions and 1310 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@@ -49,7 +49,7 @@ int main() {
// 2. Unroll loops at compile-time without hassle.
std::string s;
hana::int_<10>.times([&]{ s += "x"; });
hana::int_c<10>.times([&]{ s += "x"; });
// equivalent to s += "x"; s += "x"; ... s += "x";
// 3. Easily check whether an expression is valid.

4
benchmark/count_if/compile.fusion.vector.erb.cpp
View File

@@ -19,13 +19,13 @@ Distributed under the Boost Software License, Version 1.0.
struct is_even {
template <typename N>
constexpr auto operator()(N n) const {
return n % boost::hana::int_<2> == boost::hana::int_<0>;
return n % boost::hana::int_c<2> == boost::hana::int_c<0>;
}
};
int main() {
auto vector = boost::fusion::make_vector(
<%= (1..input_size).map { |n| "boost::hana::int_<#{n}>" }.join(', ') %>
<%= (1..input_size).map { |n| "boost::hana::int_c<#{n}>" }.join(', ') %>
);
auto result = boost::fusion::count_if(vector, is_even{});
(void)result;

4
benchmark/count_if/compile.hana.tuple.erb.cpp
View File

@@ -14,13 +14,13 @@ Distributed under the Boost Software License, Version 1.0.
struct is_even {
template <typename N>
constexpr auto operator()(N n) const {
return n % boost::hana::int_<2> == boost::hana::int_<0>;
return n % boost::hana::int_c<2> == boost::hana::int_c<0>;
}
};
int main() {
constexpr auto tuple = boost::hana::make_tuple(
<%= (1..input_size).map { |n| "boost::hana::int_<#{n}>" }.join(', ') %>
<%= (1..input_size).map { |n| "boost::hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto result = boost::hana::count_if(tuple, is_even{});
(void)result;

4
benchmark/difference/compile.hana.set.erb.cpp
View File

@@ -12,11 +12,11 @@ namespace hana = boost::hana;
int main() {
constexpr auto xs = hana::make_set(
<%= (1..input_size).map { |n| "hana::int_<#{n}>" }.join(', ') %>
<%= (1..input_size).map { |n| "hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto ys = hana::make_set(
<%= (1..(input_size/2)).map { |n| "hana::int_<#{n}>" }.join(', ') %>
<%= (1..(input_size/2)).map { |n| "hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto result = hana::difference(xs, ys);

4
benchmark/filter/compile.hana.tuple.erb.cpp
View File

@@ -14,13 +14,13 @@ Distributed under the Boost Software License, Version 1.0.
struct is_even {
template <typename N>
constexpr auto operator()(N n) const {
return n % boost::hana::int_<2> == boost::hana::int_<0>;
return n % boost::hana::int_c<2> == boost::hana::int_c<0>;
}
};
int main() {
constexpr auto tuple = boost::hana::make_tuple(
<%= (1..input_size).map { |n| "boost::hana::int_<#{n}>" }.join(', ') %>
<%= (1..input_size).map { |n| "boost::hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto result = boost::hana::filter(tuple, is_even{});
(void)result;

4
benchmark/find_if/compile.hana.set.erb.cpp
View File

@@ -14,13 +14,13 @@ namespace hana = boost::hana;
struct is_last {
template <typename N>
constexpr auto operator()(N) const {
return hana::bool_<N::value == <%= input_size %>>;
return hana::bool_c<N::value == <%= input_size %>>;
}
};
int main() {
constexpr auto set = hana::make_set(
<%= (1..input_size).map { |n| "hana::int_<#{n}>" }.join(', ') %>
<%= (1..input_size).map { |n| "hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto result = hana::find_if(set, is_last{});
(void)result;

4
benchmark/find_if/compile.hana.tuple.erb.cpp
View File

@@ -13,13 +13,13 @@ Distributed under the Boost Software License, Version 1.0.
struct is_last {
template <typename N>
constexpr auto operator()(N) const {
return boost::hana::bool_<N::value == <%= input_size %>>;
return boost::hana::bool_c<N::value == <%= input_size %>>;
}
};
int main() {
constexpr auto tuple = boost::hana::make_tuple(
<%= (1..input_size).map { |n| "boost::hana::int_<#{n}>" }.join(', ') %>
<%= (1..input_size).map { |n| "boost::hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto result = boost::hana::find_if(tuple, is_last{});
(void)result;

4
benchmark/insert/compile.hana.map.erb.cpp
View File

@@ -14,10 +14,10 @@ namespace hana = boost::hana;
int main() {
constexpr auto map = hana::make_map(
<%= (1..input_size).map { |n|
"hana::make_pair(hana::int_<#{n}>, hana::int_<#{n}>)"
"hana::make_pair(hana::int_c<#{n}>, hana::int_c<#{n}>)"
}.join(', ') %>
);
constexpr auto next = hana::int_< <%= input_size+1 %> >;
constexpr auto next = hana::int_c< <%= input_size+1 %> >;
constexpr auto result = hana::insert(map, hana::make_pair(next, next));
(void)result;
}

4
benchmark/insert/compile.hana.set.erb.cpp
View File

@@ -12,9 +12,9 @@ namespace hana = boost::hana;
int main() {
constexpr auto set = hana::make_set(
<%= (1..input_size).map { |n| "hana::int_<#{n}>" }.join(', ') %>
<%= (1..input_size).map { |n| "hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto next = hana::int_< <%= input_size+1 %> >;
constexpr auto next = hana::int_c< <%= input_size+1 %> >;
constexpr auto result = hana::insert(set, next);
(void)result;
}

4
benchmark/intersection/compile.hana.set.erb.cpp
View File

@@ -13,11 +13,11 @@ namespace hana = boost::hana;
int main() {
<% half = input_size / 2 %>
constexpr auto xs = hana::make_set(
<%= (1..half).map { |n| "hana::int_<#{n}>" }.join(', ') %>
<%= (1..half).map { |n| "hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto ys = hana::make_set(
<%= (half..input_size).map { |n| "hana::int_<#{n}>" }.join(', ') %>
<%= (half..input_size).map { |n| "hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto result = hana::intersection(xs, ys);

4
benchmark/is_disjoint/compile.hana.map.erb.cpp
View File

@@ -14,12 +14,12 @@ namespace hana = boost::hana;
int main() {
constexpr auto even = hana::make_map(
<%= (1..input_size).map { |n|
"hana::make_pair(hana::int_<#{n*2}>, hana::int_<#{n*2}>)"
"hana::make_pair(hana::int_c<#{n*2}>, hana::int_c<#{n*2}>)"
}.join(', ') %>
);
constexpr auto odd = hana::make_map(
<%= (1..input_size).map { |n|
"hana::make_pair(hana::int_<#{n*2+1}>, hana::int_<#{n*2+1}>)"
"hana::make_pair(hana::int_c<#{n*2+1}>, hana::int_c<#{n*2+1}>)"
}.join(', ') %>
);
hana::is_disjoint(even, odd);

4
benchmark/is_disjoint/compile.hana.set.erb.cpp
View File

@@ -12,10 +12,10 @@ namespace hana = boost::hana;
int main() {
constexpr auto even = hana::make_set(
<%= (1..input_size).map { |n| "hana::int_<#{n*2}>" }.join(', ') %>
<%= (1..input_size).map { |n| "hana::int_c<#{n*2}>" }.join(', ') %>
);
constexpr auto odd = hana::make_set(
<%= (1..input_size).map { |n| "hana::int_<#{n*2+1}>" }.join(', ') %>
<%= (1..input_size).map { |n| "hana::int_c<#{n*2+1}>" }.join(', ') %>
);
hana::is_disjoint(even, odd);
}

4
benchmark/is_disjoint/compile.hana.tuple.erb.cpp
View File

@@ -12,10 +12,10 @@ namespace hana = boost::hana;
int main() {
constexpr auto even = hana::make_tuple(
<%= (1..input_size).map { |n| "hana::int_<#{n*2}>" }.join(', ') %>
<%= (1..input_size).map { |n| "hana::int_c<#{n*2}>" }.join(', ') %>
);
constexpr auto odd = hana::make_tuple(
<%= (1..input_size).map { |n| "hana::int_<#{n*2+1}>" }.join(', ') %>
<%= (1..input_size).map { |n| "hana::int_c<#{n*2+1}>" }.join(', ') %>
);
hana::is_disjoint(even, odd);
}

4
benchmark/is_subset/compile.hana.map.erb.cpp
View File

@@ -14,12 +14,12 @@ namespace hana = boost::hana;
int main() {
constexpr auto even = hana::make_map(
<%= (1..input_size).map { |n|
"hana::make_pair(hana::int_<#{n*2}>, hana::int_<#{n*2}>)"
"hana::make_pair(hana::int_c<#{n*2}>, hana::int_c<#{n*2}>)"
}.join(', ') %>
);
constexpr auto all = hana::make_map(
<%= (1..input_size*2).map { |n|
"hana::make_pair(hana::int_<#{n}>, hana::int_<#{n}>)"
"hana::make_pair(hana::int_c<#{n}>, hana::int_c<#{n}>)"
}.join(', ') %>
);
hana::is_subset(even, all);

4
benchmark/is_subset/compile.hana.set.erb.cpp
View File

@@ -12,10 +12,10 @@ namespace hana = boost::hana;
int main() {
constexpr auto even = hana::make_set(
<%= (1..input_size).map { |n| "hana::int_<#{n*2}>" }.join(', ') %>
<%= (1..input_size).map { |n| "hana::int_c<#{n*2}>" }.join(', ') %>
);
constexpr auto all = hana::make_set(
<%= (1..input_size*2).map { |n| "hana::int_<#{n}>" }.join(', ') %>
<%= (1..input_size*2).map { |n| "hana::int_c<#{n}>" }.join(', ') %>
);
hana::is_subset(even, all);
}

4
benchmark/is_subset/compile.hana.tuple.erb.cpp
View File

@@ -12,10 +12,10 @@ namespace hana = boost::hana;
int main() {
constexpr auto even = hana::make_tuple(
<%= (1..input_size).map { |n| "hana::int_<#{n*2}>" }.join(', ') %>
<%= (1..input_size).map { |n| "hana::int_c<#{n*2}>" }.join(', ') %>
);
constexpr auto all = hana::make_tuple(
<%= (1..input_size*2).map { |n| "hana::int_<#{n}>" }.join(', ') %>
<%= (1..input_size*2).map { |n| "hana::int_c<#{n}>" }.join(', ') %>
);
hana::is_subset(even, all);
}

2
benchmark/old/iterable/drop.cpp
View File

@@ -16,7 +16,7 @@ template <int i> struct x { };
int main() {
auto iterable = <%= iterable %>;
auto n = boost::hana::int_< <%= input_size / 2 %> >;
auto n = boost::hana::int_c< <%= input_size / 2 %> >;
boost::hana::benchmark::measure([=] {
boost::hana::drop(n, iterable);

2
benchmark/old/iterable/drop_until.cpp
View File

@@ -16,7 +16,7 @@ template <int i> struct x { };
int main() {
auto iterable = <%= iterable %>;
auto pred = [](auto&& x) { return boost::hana::false_; };
auto pred = [](auto&& x) { return boost::hana::false_c; };
boost::hana::benchmark::measure([=] {
boost::hana::drop_until(iterable, pred);

2
benchmark/old/iterable/drop_while.cpp
View File

@@ -16,7 +16,7 @@ template <int i> struct x { };
int main() {
auto iterable = <%= iterable %>;
auto pred = [](auto&& x) { return boost::hana::true_; };
auto pred = [](auto&& x) { return boost::hana::true_c; };
boost::hana::benchmark::measure([=] {
boost::hana::drop_while(iterable, pred);

2
benchmark/old/searchable/all_of.cpp
View File

@@ -16,7 +16,7 @@ template <int i> struct x { };
int main() {
auto searchable = <%= searchable %>;
auto pred = [](auto&& x) { return boost::hana::true_; };
auto pred = [](auto&& x) { return boost::hana::true_c; };
boost::hana::benchmark::measure([=] {
boost::hana::all_of(searchable, pred);

2
benchmark/old/searchable/any_of.cpp
View File

@@ -16,7 +16,7 @@ template <int i> struct x { };
int main() {
auto searchable = <%= searchable %>;
auto pred = [](auto&& x) { return boost::hana::false_; };
auto pred = [](auto&& x) { return boost::hana::false_c; };
boost::hana::benchmark::measure([=] {
boost::hana::any_of(searchable, pred);

2
benchmark/old/searchable/none_of.cpp
View File

@@ -16,7 +16,7 @@ template <int i> struct x { };
int main() {
auto searchable = <%= searchable %>;
auto pred = [](auto&& x) { return boost::hana::false_; };
auto pred = [](auto&& x) { return boost::hana::false_c; };
boost::hana::benchmark::measure([=] {
boost::hana::none_of(searchable, pred);

2
benchmark/old/sequence/group_by.cpp
View File

@@ -16,7 +16,7 @@ template <int i> struct x { };
struct decade {
template <int i, int j>
constexpr decltype(auto) operator()(x<i>, x<j>) const {
return boost::hana::bool_<i/10 == j/10>;
return boost::hana::bool_c<i/10 == j/10>;
}
};

2
benchmark/old/sequence/sort.cpp
View File

@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
int main() {
using L = <%= datatype %>;
auto list = boost::hana::make<L>(
<%= (1..input_size).to_a.map { |i| "boost::hana::int_<#{i}>" }.join(', ') %>
<%= (1..input_size).to_a.map { |i| "boost::hana::int_c<#{i}>" }.join(', ') %>
);
boost::hana::benchmark::measure([=] {

2
benchmark/old/sequence/take.cpp
View File

@@ -20,7 +20,7 @@ int main() {
<%= (1..input_size).to_a.map { |i| "x<#{i}>{}" }.join(', ') %>
);
auto n = boost::hana::int_< <%= input_size / 2 %> >;
auto n = boost::hana::int_c< <%= input_size / 2 %> >;
boost::hana::benchmark::measure([=] {
boost::hana::take(n, list);

2
benchmark/old/sequence/take_while.cpp
View File

@@ -16,7 +16,7 @@ template <int i> struct x { };
struct pred {
template <int i>
constexpr decltype(auto) operator()(x<i> const&) const {
return boost::hana::bool_<i == <%= input_size / 2 %> >;
return boost::hana::bool_c<i == <%= input_size / 2 %> >;
}
};

4
benchmark/partition/compile.hana.tuple.erb.cpp
View File

@@ -14,13 +14,13 @@ Distributed under the Boost Software License, Version 1.0.
struct is_even {
template <typename N>
constexpr auto operator()(N n) const {
return n % boost::hana::int_<2> == boost::hana::int_<0>;
return n % boost::hana::int_c<2> == boost::hana::int_c<0>;
}
};
int main() {
constexpr auto tuple = boost::hana::make_tuple(
<%= (1..input_size).map { |n| "boost::hana::int_<#{n}>" }.join(', ') %>
<%= (1..input_size).map { |n| "boost::hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto result = boost::hana::partition(tuple, is_even{});
(void)result;

2
benchmark/product/compile.hana.tuple.heterogeneous.erb.cpp
View File

@@ -11,7 +11,7 @@ Distributed under the Boost Software License, Version 1.0.
int main() {
constexpr auto tuple = boost::hana::make_tuple(<%=
(1..input_size).to_a.map{ |n| "boost::hana::ullong<#{n}>" }.join(', ')
(1..input_size).to_a.map{ |n| "boost::hana::ullong_c<#{n}>" }.join(', ')
%>);
constexpr auto result = boost::hana::product<
boost::hana::IntegralConstant<unsigned long long>

4
benchmark/symmetric_difference/compile.hana.set.erb.cpp
View File

@@ -13,11 +13,11 @@ namespace hana = boost::hana;
int main() {
<% half = input_size / 2 %>
constexpr auto xs = hana::make_set(
<%= (1..half).map { |n| "hana::int_<#{n}>" }.join(', ') %>
<%= (1..half).map { |n| "hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto ys = hana::make_set(
<%= (half..input_size).map { |n| "hana::int_<#{n}>" }.join(', ') %>
<%= (half..input_size).map { |n| "hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto result = hana::symmetric_difference(xs, ys);

4
benchmark/union/compile.hana.set.erb.cpp
View File

@@ -13,11 +13,11 @@ namespace hana = boost::hana;
int main() {
<% half = input_size / 2 %>
constexpr auto xs = hana::make_set(
<%= (1..half).map { |n| "hana::int_<#{n}>" }.join(', ') %>
<%= (1..half).map { |n| "hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto ys = hana::make_set(
<%= (half..input_size).map { |n| "hana::int_<#{n}>" }.join(', ') %>
<%= (half..input_size).map { |n| "hana::int_c<#{n}>" }.join(', ') %>
);
constexpr auto result = hana::union_(xs, ys);

27
doc/tutorial.md
View File

@@ -733,9 +733,9 @@ to simplify the creation of an `integral_constant`:
@code{cpp}
template <int i>
constexpr integral_constant<int, i> int_{};
constexpr integral_constant<int, i> int_c{};
auto three = int_<1> + int_<2>;
auto three = int_c<1> + int_c<2>;
@endcode
Now we're talking about a visible gain in expressiveness over the initial
@@ -753,14 +753,11 @@ auto three = 1_c + 3_c;
Hana provides its own `integral_constant`s, which define arithmetic operators
just like we showed above. Hana also provides variable templates to easily
create different kinds of `integral_constant`s: `int_`, `long_`, `bool_`,
etc... However, note that `integral_constant` in Hana is a variable template
instead of a type, so `integral_constant<int, 1>` is actually an object,
unlike `std::integral_constant<int, 1>`, which is a type. This allows you
to omit the trailing `{}` braces otherwise required to value-initialize
`integral_constant`s. Of course, the `_c` suffix is also provided; it is
part of the `boost::hana::literals` namespace, and you should import it
into your namespace before using it:
create different kinds of `integral_constant`s: `int_c`, `long_c`, `bool_c`,
etc... This allows you to omit the trailing `{}` braces otherwise required to
value-initialize these objects. Of course, the `_c` suffix is also provided;
it is part of the `hana::literals` namespace, and you must import it into
your namespace before using it:
@code{cpp}
using namespace hana::literals;
@@ -817,7 +814,7 @@ for loop unrolling:
__attribute__((noinline)) void f() { }
int main() {
hana::int_<10>.times(f);
hana::int_c<10>.times(f);
}
@endcode
@@ -917,11 +914,11 @@ constexpr basic_type<T*> add_pointer(basic_type<T> const&)
template <typename T>
constexpr auto is_pointer(basic_type<T> const&)
{ return hana::false_; }
{ return hana::bool_c<false>; }
template <typename T>
constexpr auto is_pointer(basic_type<T*> const&)
{ return hana::true_; }
{ return hana::bool_c<true>; }
@endcode
We've just written metafunctions that look like functions, just like we wrote
@@ -1939,7 +1936,7 @@ expanded into something like:
auto xs = hana::make_tuple("hello"s, 1.2, 3);
auto pred = [](auto x) { return std::is_integral<decltype(x)>{}; };
auto r = hana::bool_<
auto r = hana::bool_c<
pred(xs[0_c]) ? true :
pred(xs[1_c]) ? true :
pred(xs[2_c]) ? true :
@@ -3437,7 +3434,7 @@ Let me ask a tricky question. Is the following code valid?
template <typename X>
auto identity(X x) { return x; }
static_assert(value(identity(bool_<true>)), "");
static_assert(value(identity(bool_c<true>)), "");
@endcode
The answer is "no", but the reason might not be obvious at first. Even more

8
example/accessors.cpp
View File

@@ -27,15 +27,15 @@ struct Person {
int main() {
constexpr auto accessors = hana::accessors<Person>();
BOOST_HANA_CONSTANT_CHECK(
hana::first(accessors[hana::size_t<0>]) == BOOST_HANA_STRING("name")
hana::first(accessors[hana::size_c<0>]) == BOOST_HANA_STRING("name")
);
BOOST_HANA_CONSTANT_CHECK(
hana::first(accessors[hana::size_t<1>]) == BOOST_HANA_STRING("age")
hana::first(accessors[hana::size_c<1>]) == BOOST_HANA_STRING("age")
);
constexpr auto get_name = hana::second(accessors[hana::size_t<0>]);
constexpr auto get_age = hana::second(accessors[hana::size_t<1>]);
constexpr auto get_name = hana::second(accessors[hana::size_c<0>]);
constexpr auto get_age = hana::second(accessors[hana::size_c<1>]);
Person john{"John", 30};
BOOST_HANA_RUNTIME_CHECK(get_name(john) == "John");

4
example/all.cpp
View File

@@ -12,7 +12,7 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
static_assert(hana::all(hana::make_tuple(hana::true_, true, hana::true_)), "");
BOOST_HANA_CONSTANT_CHECK(!hana::all(hana::make_tuple(true, hana::false_, hana::true_)));
static_assert(hana::all(hana::make_tuple(hana::true_c, true, hana::true_c)), "");
BOOST_HANA_CONSTANT_CHECK(!hana::all(hana::make_tuple(true, hana::false_c, hana::true_c)));
int main() { }

4
example/and.cpp
View File

@@ -10,7 +10,7 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::and_(hana::true_, hana::true_, hana::true_, hana::true_));
static_assert(!hana::and_(hana::true_, false, hana::true_, hana::true_), "");
BOOST_HANA_CONSTANT_CHECK(hana::and_(hana::true_c, hana::true_c, hana::true_c, hana::true_c));
static_assert(!hana::and_(hana::true_c, false, hana::true_c, hana::true_c), "");
int main() { }

6
example/any.cpp
View File

@@ -11,8 +11,8 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::any(hana::make_tuple(false, hana::false_, hana::true_)));
static_assert(hana::any(hana::make_tuple(false, hana::false_, true)), "");
static_assert(!hana::any(hana::make_tuple(false, hana::false_, hana::false_)), "");
BOOST_HANA_CONSTANT_CHECK(hana::any(hana::make_tuple(false, hana::false_c, hana::true_c)));
static_assert(hana::any(hana::make_tuple(false, hana::false_c, true)), "");
static_assert(!hana::any(hana::make_tuple(false, hana::false_c, hana::false_c)), "");
int main() { }

6
example/at.cpp
View File

@@ -12,8 +12,8 @@ namespace hana = boost::hana;
constexpr auto xs = hana::make_tuple(0, '1', 2.0);
static_assert(hana::at(xs, hana::size_t<0>) == 0, "");
static_assert(hana::at(xs, hana::size_t<1>) == '1', "");
static_assert(hana::at(xs, hana::size_t<2>) == 2.0, "");
static_assert(hana::at(xs, hana::size_c<0>) == 0, "");
static_assert(hana::at(xs, hana::size_c<1>) == '1', "");
static_assert(hana::at(xs, hana::size_c<2>) == 2.0, "");
int main() { }

4
example/at_key.cpp
View File

@@ -18,12 +18,12 @@ namespace hana = boost::hana;
int main() {
auto m = hana::make_map(
hana::make_pair(hana::type_c<int>, std::string{"int"}),
hana::make_pair(hana::int_<3>, std::string{"3"})
hana::make_pair(hana::int_c<3>, std::string{"3"})
);
BOOST_HANA_RUNTIME_CHECK(hana::at_key(m, hana::type_c<int>) == "int");
// usage as operator[]
BOOST_HANA_RUNTIME_CHECK(m[hana::type_c<int>] == "int");
BOOST_HANA_RUNTIME_CHECK(m[hana::int_<3>] == "3");
BOOST_HANA_RUNTIME_CHECK(m[hana::int_c<3>] == "3");
}

6
example/contains.cpp
View File

@@ -13,13 +13,13 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::contains(hana::make_tuple(2, hana::int_<2>, hana::int_<3>, 'x'), hana::int_<3>));
BOOST_HANA_CONSTANT_CHECK(hana::contains(hana::make_tuple(2, hana::int_c<2>, hana::int_c<3>, 'x'), hana::int_c<3>));
BOOST_HANA_CONSTANT_CHECK(hana::contains(hana::make_set(hana::int_<3>, hana::type_c<void>), hana::type_c<void>));
BOOST_HANA_CONSTANT_CHECK(hana::contains(hana::make_set(hana::int_c<3>, hana::type_c<void>), hana::type_c<void>));
// contains can be applied in infix notation
BOOST_HANA_CONSTANT_CHECK(
hana::make_tuple(2, hana::int_<2>, hana::int_<3>, 'x') ^hana::contains^ hana::int_<2>
hana::make_tuple(2, hana::int_c<2>, hana::int_c<3>, 'x') ^hana::contains^ hana::int_c<2>
);
int main() { }

2
example/core/is_a.cpp
View File

@@ -13,6 +13,6 @@ namespace hana = boost::hana;
static_assert(hana::is_a<hana::Tuple, decltype(hana::make_tuple(1, '2', 3.3))>, "");
static_assert(!hana::is_a<hana::Tuple, void>, "");
static_assert(hana::is_an<hana::IntegralConstant<int>>(hana::int_<10>), "");
static_assert(hana::is_an<hana::IntegralConstant<int>>(hana::int_c<10>), "");
int main() { }

4
example/count.cpp
View File

@@ -15,10 +15,10 @@ namespace hana = boost::hana;
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>);
BOOST_HANA_CONSTANT_CHECK(hana::count(ints, hana::int_c<2>) == hana::size_c<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_c<char>) == hana::size_t<2>);
BOOST_HANA_CONSTANT_CHECK(hana::count(types, hana::type_c<char>) == hana::size_c<2>);
}

8
example/count_if.cpp
View File

@@ -25,10 +25,10 @@ auto is_odd = [](auto x) {
int main() {
constexpr auto ints = hana::tuple_c<int, 1, 2, 3>;
BOOST_HANA_CONSTANT_CHECK(hana::count_if(ints, is_odd) == hana::size_t<2>);
BOOST_HANA_CONSTANT_CHECK(hana::count_if(ints, is_odd) == hana::size_c<2>);
constexpr auto types = hana::tuple_t<int, char, long, short, char, double>;
BOOST_HANA_CONSTANT_CHECK(hana::count_if(types, hana::trait<std::is_floating_point>) == hana::size_t<1>);
BOOST_HANA_CONSTANT_CHECK(hana::count_if(types, hana::equal.to(hana::type_c<char>)) == hana::size_t<2>);
BOOST_HANA_CONSTANT_CHECK(hana::count_if(types, hana::equal.to(hana::type_c<void>)) == hana::size_t<0>);
BOOST_HANA_CONSTANT_CHECK(hana::count_if(types, hana::trait<std::is_floating_point>) == hana::size_c<1>);
BOOST_HANA_CONSTANT_CHECK(hana::count_if(types, hana::equal.to(hana::type_c<char>)) == hana::size_c<2>);
BOOST_HANA_CONSTANT_CHECK(hana::count_if(types, hana::equal.to(hana::type_c<void>)) == hana::size_c<0>);
}

14
example/cppcon_2014/functor.cpp
View File

@@ -18,17 +18,17 @@ int main() {
// transform
{
auto m = matrix(
row(1, hana::int_<2>, 3),
row(hana::int_<4>, 5, 6),
row(7, 8, hana::int_<9>)
row(1, hana::int_c<2>, 3),
row(hana::int_c<4>, 5, 6),
row(7, 8, hana::int_c<9>)
);
BOOST_HANA_CONSTEXPR_CHECK(hana::equal(
hana::transform(m, hana::_ + hana::int_<1>),
hana::transform(m, hana::_ + hana::int_c<1>),
matrix(
row(2, hana::int_<3>, 4),
row(hana::int_<5>, 6, 7),
row(8, 9, hana::int_<10>)
row(2, hana::int_c<3>, 4),
row(hana::int_c<5>, 6, 7),
row(8, 9, hana::int_c<10>)
)
));
}

26
example/cppcon_2014/matrix.cpp
View File

@@ -32,7 +32,7 @@ int main() {
// vector
{
auto v = vector(1, '2', hana::int_<3>, 4.2f);
auto v = vector(1, '2', hana::int_c<3>, 4.2f);
BOOST_HANA_CONSTEXPR_CHECK(v.size() == 4ul);
BOOST_HANA_CONSTEXPR_CHECK(v.nrows() == 4ul);
BOOST_HANA_CONSTEXPR_CHECK(v.ncolumns() == 1ul);
@@ -42,27 +42,27 @@ int main() {
{
auto m = matrix(
row(1, '2', 3),
row('4', hana::char_<'5'>, 6),
row(hana::int_<7>, '8', 9.3)
row('4', hana::char_c<'5'>, 6),
row(hana::int_c<7>, '8', 9.3)
);
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_<0>, hana::int_<0>) == 1);
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_<0>, hana::int_<1>) == '2');
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_<0>, hana::int_<2>) == 3);
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_c<0>, hana::int_c<0>) == 1);
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_c<0>, hana::int_c<1>) == '2');
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_c<0>, hana::int_c<2>) == 3);
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_<1>, hana::int_<0>) == '4');
BOOST_HANA_CONSTANT_CHECK(m.at(hana::int_<1>, hana::int_<1>) == hana::char_<'5'>);
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_<1>, hana::int_<2>) == 6);
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_c<1>, hana::int_c<0>) == '4');
BOOST_HANA_CONSTANT_CHECK(m.at(hana::int_c<1>, hana::int_c<1>) == hana::char_c<'5'>);
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_c<1>, hana::int_c<2>) == 6);
BOOST_HANA_CONSTANT_CHECK(m.at(hana::int_<2>, hana::int_<0>) == hana::int_<7>);
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_<2>, hana::int_<1>) == '8');
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_<2>, hana::int_<2>) == 9.3);
BOOST_HANA_CONSTANT_CHECK(m.at(hana::int_c<2>, hana::int_c<0>) == hana::int_c<7>);
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_c<2>, hana::int_c<1>) == '8');
BOOST_HANA_CONSTEXPR_CHECK(m.at(hana::int_c<2>, hana::int_c<2>) == 9.3);
}
// size, ncolumns, nrows
{
auto m = matrix(
row(1, '2', 3),
row('4', hana::char_<'5'>, 6)
row('4', hana::char_c<'5'>, 6)
);
BOOST_HANA_CONSTEXPR_CHECK(m.size() == 6ul);
BOOST_HANA_CONSTEXPR_CHECK(m.ncolumns() == 3ul);

4
example/cppcon_2014/matrix/comparable.hpp
View File

@@ -21,12 +21,12 @@ namespace boost { namespace hana {
struct equal_impl<cppcon::Matrix<R1, C1>, cppcon::Matrix<R2, C2>> {
template <typename M1, typename M2>
static constexpr auto apply(M1 const& m1, M2 const& m2) {
return eval_if(bool_<R1 == R2 && C1 == C2>,
return eval_if(bool_c<R1 == R2 && C1 == C2>,
[&](auto _) {
return all(zip_with(_(equal), cppcon::rows(m1),
cppcon::rows(m2)));
},
[] { return false_; }
[] { return false_c; }
);
}
};

10
example/cppcon_2014/matrix/det.hpp
View File

@@ -42,15 +42,15 @@ namespace cppcon {
};
auto cofactor = [=](auto&& m, auto i, auto j) {
return hana::power(hana::int_<-1>, hana::plus(i, j)) *
return hana::power(hana::int_c<-1>, hana::plus(i, j)) *
matrix_minor(std::forward<decltype(m)>(m), i, j);
};
return hana::eval_if(m.size() == hana::size_t<1>,
hana::always(m.at(hana::size_t<0>, hana::size_t<0>)),
return hana::eval_if(m.size() == hana::size_c<1>,
hana::always(m.at(hana::size_c<0>, hana::size_c<0>)),
[=](auto _) {
auto cofactors_1st_row = hana::unpack(_(hana::make_range)(hana::size_t<0>, m.ncolumns()),
hana::on(hana::make_tuple, hana::partial(cofactor, m, hana::size_t<0>))
auto cofactors_1st_row = hana::unpack(_(hana::make_range)(hana::size_c<0>, m.ncolumns()),
hana::on(hana::make_tuple, hana::partial(cofactor, m, hana::size_c<0>))
);
return detail::tuple_scalar_product(hana::front(rows(m)), cofactors_1st_row);
}

4
example/cppcon_2014/matrix/ring.hpp
View File

@@ -36,7 +36,7 @@ namespace boost { namespace hana {
transform(cppcon::rows(std::forward<M1>(m1)),
[&](auto&& row) -> decltype(auto) {
return zip_with(cppcon::detail::tuple_scalar_product,
repeat<Tuple>(std::forward<decltype(row)>(row), uint<R1>),
repeat<Tuple>(std::forward<decltype(row)>(row), uint_c<R1>),
cols
);
}
@@ -52,7 +52,7 @@ namespace boost { namespace hana {
return unpack(range_c<unsigned, 0, R>, [](auto ...n) {
return unpack(range_c<unsigned, 0, C>, [=](auto ...m) {
auto row = [=](auto n) {
return cppcon::row(if_(n == m, int_<1>, int_<0>)...);
return cppcon::row(if_(n == m, int_c<1>, int_c<0>)...);
};
return cppcon::matrix(row(n)...);
});

2
example/cycle.cpp
View File

@@ -11,6 +11,6 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
static_assert(hana::cycle(hana::make_tuple('x', 'y'), hana::size_t<2>) == hana::make_tuple('x', 'y', 'x', 'y'), "");
static_assert(hana::cycle(hana::make_tuple('x', 'y'), hana::size_c<2>) == hana::make_tuple('x', 'y', 'x', 'y'), "");
int main() { }

6
example/difference.cpp
View File

@@ -13,10 +13,10 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
constexpr auto xs = hana::make_set(hana::int_<1>, hana::int_<2>, hana::type_c<int>, hana::int_<3>);
constexpr auto ys = hana::make_set(hana::int_<3>, hana::type_c<void>, hana::type_c<int>);
constexpr auto xs = hana::make_set(hana::int_c<1>, hana::int_c<2>, hana::type_c<int>, hana::int_c<3>);
constexpr auto ys = hana::make_set(hana::int_c<3>, hana::type_c<void>, hana::type_c<int>);
BOOST_HANA_CONSTANT_CHECK(hana::difference(xs, ys) == hana::make_set(hana::int_<1>, hana::int_<2>));
BOOST_HANA_CONSTANT_CHECK(hana::difference(xs, ys) == hana::make_set(hana::int_c<1>, hana::int_c<2>));
BOOST_HANA_CONSTANT_CHECK(hana::difference(ys, xs) == hana::make_set(hana::type_c<void>));
int main() { }

10
example/drop_back.cpp
View File

@@ -14,11 +14,11 @@ namespace hana = boost::hana;
constexpr auto xs = hana::make_tuple(0, '1', 2.0);
static_assert(hana::drop_back(xs, hana::size_t<0>) == xs, "");
static_assert(hana::drop_back(xs, hana::size_t<1>) == hana::make_tuple(0, '1'), "");
static_assert(hana::drop_back(xs, hana::size_t<2>) == hana::make_tuple(0), "");
BOOST_HANA_CONSTANT_CHECK(hana::drop_back(xs, hana::size_t<3>) == hana::make_tuple());
BOOST_HANA_CONSTANT_CHECK(hana::drop_back(xs, hana::size_t<4>) == hana::make_tuple());
static_assert(hana::drop_back(xs, hana::size_c<0>) == xs, "");
static_assert(hana::drop_back(xs, hana::size_c<1>) == hana::make_tuple(0, '1'), "");
static_assert(hana::drop_back(xs, hana::size_c<2>) == hana::make_tuple(0), "");
BOOST_HANA_CONSTANT_CHECK(hana::drop_back(xs, hana::size_c<3>) == hana::make_tuple());
BOOST_HANA_CONSTANT_CHECK(hana::drop_back(xs, hana::size_c<4>) == hana::make_tuple());
static_assert(hana::drop_back(xs) == hana::make_tuple(0, '1'), "");

10
example/drop_front.cpp
View File

@@ -14,11 +14,11 @@ namespace hana = boost::hana;
constexpr auto xs = hana::make_tuple(0, '1', 2.0);
static_assert(hana::drop_front(xs, hana::size_t<0>) == xs, "");
static_assert(hana::drop_front(xs, hana::size_t<1>) == hana::make_tuple('1', 2.0), "");
static_assert(hana::drop_front(xs, hana::size_t<2>) == hana::make_tuple(2.0), "");
BOOST_HANA_CONSTANT_CHECK(hana::drop_front(xs, hana::size_t<3>) == hana::make_tuple());
BOOST_HANA_CONSTANT_CHECK(hana::drop_front(xs, hana::size_t<4>) == hana::make_tuple());
static_assert(hana::drop_front(xs, hana::size_c<0>) == xs, "");
static_assert(hana::drop_front(xs, hana::size_c<1>) == hana::make_tuple('1', 2.0), "");
static_assert(hana::drop_front(xs, hana::size_c<2>) == hana::make_tuple(2.0), "");
BOOST_HANA_CONSTANT_CHECK(hana::drop_front(xs, hana::size_c<3>) == hana::make_tuple());
BOOST_HANA_CONSTANT_CHECK(hana::drop_front(xs, hana::size_c<4>) == hana::make_tuple());
// drop_front(xs) is equivalent to drop_front(xs, size_t<1>)
static_assert(hana::drop_front(xs) == hana::make_tuple('1', 2.0), "");

6
example/drop_front_exactly.cpp
View File

@@ -14,9 +14,9 @@ namespace hana = boost::hana;
constexpr auto xs = hana::make_tuple(0, '1', 2.0);
static_assert(hana::drop_front_exactly(xs, hana::size_t<1>) == hana::make_tuple('1', 2.0), "");
static_assert(hana::drop_front_exactly(xs, hana::size_t<2>) == hana::make_tuple(2.0), "");
BOOST_HANA_CONSTANT_CHECK(hana::drop_front_exactly(xs, hana::size_t<3>) == hana::make_tuple());
static_assert(hana::drop_front_exactly(xs, hana::size_c<1>) == hana::make_tuple('1', 2.0), "");
static_assert(hana::drop_front_exactly(xs, hana::size_c<2>) == hana::make_tuple(2.0), "");
BOOST_HANA_CONSTANT_CHECK(hana::drop_front_exactly(xs, hana::size_c<3>) == hana::make_tuple());
// drop_front_exactly(xs) is equivalent to drop_front_exactly(xs, size_t<1>)
static_assert(hana::drop_front_exactly(xs) == hana::make_tuple('1', 2.0), "");

6
example/drop_while.cpp
View File

@@ -16,13 +16,13 @@ using namespace hana::literals;
auto negative = [](auto x) {
return x < hana::int_<0>;
return x < hana::int_c<0>;
};
BOOST_HANA_CONSTANT_CHECK(
hana::drop_while(hana::make_range(hana::int_<-3>, hana::int_<6>), negative)
hana::drop_while(hana::make_range(hana::int_c<-3>, hana::int_c<6>), negative)
==
hana::make_range(hana::int_<0>, hana::int_<6>)
hana::make_range(hana::int_c<0>, hana::int_c<6>)
);
BOOST_HANA_CONSTANT_CHECK(

6
example/ext/boost/mpl/vector.cpp
View File

@@ -46,14 +46,14 @@ BOOST_HANA_CONSTANT_CHECK(
//! [Foldable]
auto types = mpl::vector<long, float, short, float, long, long double>{};
auto number_of_floats = hana::fold_left(types, hana::int_<0>, [](auto count, auto t) {
auto number_of_floats = hana::fold_left(types, hana::int_c<0>, [](auto count, auto t) {
return hana::if_(hana::trait<std::is_floating_point>(t),
count + hana::int_<1>,
count + hana::int_c<1>,
count
);
});
BOOST_HANA_CONSTANT_CHECK(number_of_floats == hana::int_<3>);
BOOST_HANA_CONSTANT_CHECK(number_of_floats == hana::int_c<3>);
//! [Foldable]
}{

6
example/find.cpp
View File

@@ -17,14 +17,14 @@ namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(
hana::find(hana::make_tuple(hana::int_<1>, hana::type_c<int>, '3'), hana::type_c<int>) == hana::just(hana::type_c<int>)
hana::find(hana::make_tuple(hana::int_c<1>, hana::type_c<int>, '3'), hana::type_c<int>) == hana::just(hana::type_c<int>)
);
BOOST_HANA_CONSTANT_CHECK(
hana::find(hana::make_tuple(hana::int_<1>, hana::type_c<int>, '3'), hana::type_c<void>) == hana::nothing
hana::find(hana::make_tuple(hana::int_c<1>, hana::type_c<int>, '3'), hana::type_c<void>) == hana::nothing
);
constexpr auto m = hana::make_map(
hana::make_pair(hana::int_<2>, 2),
hana::make_pair(hana::int_c<2>, 2),
hana::make_pair(hana::type_c<float>, 3.3),
hana::make_pair(hana::type_c<char>, hana::type_c<int>)
);

2
example/foldable/to.cpp
View File

@@ -18,7 +18,7 @@ int main() {
BOOST_HANA_CONSTANT_CHECK(hana::to<hana::Tuple>(hana::nothing) == hana::make_tuple());
BOOST_HANA_CONSTANT_CHECK(
hana::to<hana::Tuple>(hana::make_range(hana::int_<3>, hana::int_<6>))
hana::to<hana::Tuple>(hana::make_range(hana::int_c<3>, hana::int_c<6>))
==
hana::tuple_c<int, 3, 4, 5>
);

12
example/functional/on.cpp
View File

@@ -18,15 +18,15 @@ namespace hana = boost::hana;
// infix application
constexpr auto sorted = hana::sort.by(hana::less ^hana::on^ hana::first, hana::make_tuple(
hana::make_pair(hana::int_<3>, 'x'),
hana::make_pair(hana::int_<1>, hana::type_c<void>),
hana::make_pair(hana::int_<2>, 9876)
hana::make_pair(hana::int_c<3>, 'x'),
hana::make_pair(hana::int_c<1>, hana::type_c<void>),
hana::make_pair(hana::int_c<2>, 9876)
));
static_assert(sorted == hana::make_tuple(
hana::make_pair(hana::int_<1>, hana::type_c<void>),
hana::make_pair(hana::int_<2>, 9876),
hana::make_pair(hana::int_<3>, 'x')
hana::make_pair(hana::int_c<1>, hana::type_c<void>),
hana::make_pair(hana::int_c<2>, 9876),
hana::make_pair(hana::int_c<3>, 'x')
), "");

2
example/greater.cpp
View File

@@ -11,6 +11,6 @@ namespace hana = boost::hana;
static_assert(hana::greater(4, 1), "");
BOOST_HANA_CONSTANT_CHECK(!hana::greater(hana::int_<1>, hana::int_<3>));
BOOST_HANA_CONSTANT_CHECK(!hana::greater(hana::int_c<1>, hana::int_c<3>));
int main() { }

2
example/greater_equal.cpp
View File

@@ -12,6 +12,6 @@ namespace hana = boost::hana;
static_assert(hana::greater_equal(4, 1), "");
static_assert(hana::greater_equal(1, 1), "");
BOOST_HANA_CONSTANT_CHECK(!hana::greater_equal(hana::int_<1>, hana::int_<2>));
BOOST_HANA_CONSTANT_CHECK(!hana::greater_equal(hana::int_c<1>, hana::int_c<2>));
int main() { }

6
example/group.cpp
View File

@@ -18,11 +18,11 @@ namespace hana = boost::hana;
// group without a predicate
BOOST_HANA_CONSTANT_CHECK(
hana::group(hana::make_tuple(hana::int_<1>, hana::long_<1>, hana::type_c<int>, hana::char_<'x'>, hana::char_<'x'>))
hana::group(hana::make_tuple(hana::int_c<1>, hana::long_c<1>, hana::type_c<int>, hana::char_c<'x'>, hana::char_c<'x'>))
== hana::make_tuple(
hana::make_tuple(hana::int_<1>, hana::long_<1>),
hana::make_tuple(hana::int_c<1>, hana::long_c<1>),
hana::make_tuple(hana::type_c<int>),
hana::make_tuple(hana::char_<'x'>, hana::char_<'x'>)
hana::make_tuple(hana::char_c<'x'>, hana::char_c<'x'>)
)
);

2
example/if.cpp
View File

@@ -15,7 +15,7 @@ static_assert(hana::if_(true, 1, 2) == 1, "");
static_assert(hana::if_(false, 1, 2) == 2, "");
static_assert(
hana::if_(hana::true_,
hana::if_(hana::true_c,
hana::make_tuple('t', 'r', 'u', 'e'),
hana::make_tuple('f', 'a', 'l', 's', 'e')
)

2
example/in.cpp
View File

@@ -11,6 +11,6 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::int_<2> ^hana::in^ hana::make_tuple(2, hana::int_<2>, hana::int_<3>, 'x'));
BOOST_HANA_CONSTANT_CHECK(hana::int_c<2> ^hana::in^ hana::make_tuple(2, hana::int_c<2>, hana::int_c<3>, 'x'));
int main() { }

24
example/integral_constant.cpp
View File

@@ -24,12 +24,12 @@ int main() {
{
//! [operators]
BOOST_HANA_CONSTANT_CHECK(hana::int_<1> + hana::int_<3> == hana::int_<4>);
BOOST_HANA_CONSTANT_CHECK(hana::int_c<1> + hana::int_c<3> == hana::int_c<4>);
// Mixed-type operations are supported, but only when it involves a
// promotion, and not a conversion that could be lossy.
BOOST_HANA_CONSTANT_CHECK(hana::size_t<3> * hana::ushort<5> == hana::size_t<15>);
BOOST_HANA_CONSTANT_CHECK(hana::llong<15> == hana::int_<15>);
BOOST_HANA_CONSTANT_CHECK(hana::size_c<3> * hana::ushort_c<5> == hana::size_c<15>);
BOOST_HANA_CONSTANT_CHECK(hana::llong_c<15> == hana::int_c<15>);
//! [operators]
}{
@@ -37,7 +37,7 @@ BOOST_HANA_CONSTANT_CHECK(hana::llong<15> == hana::int_<15>);
//! [times_loop_unrolling]
std::string s;
for (char c = 'x'; c <= 'z'; ++c)
hana::int_<5>.times([&] { s += c; });
hana::int_c<5>.times([&] { s += c; });
BOOST_HANA_RUNTIME_CHECK(s == "xxxxxyyyyyzzzzz");
//! [times_loop_unrolling]
@@ -47,7 +47,7 @@ BOOST_HANA_RUNTIME_CHECK(s == "xxxxxyyyyyzzzzz");
//! [as_static_member]
std::string s;
for (char c = 'x'; c <= 'z'; ++c)
decltype(hana::int_<5>)::times([&] { s += c; });
decltype(hana::int_c<5>)::times([&] { s += c; });
BOOST_HANA_RUNTIME_CHECK(s == "xxxxxyyyyyzzzzz");
//! [as_static_member]
@@ -61,7 +61,7 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto functions = hana::make_tuple(
[&] { s += "y"; },
[&] { s += "z"; }
);
hana::for_each(functions, hana::int_<5>.times);
hana::for_each(functions, hana::int_c<5>.times);
BOOST_HANA_RUNTIME_CHECK(s == "xxxxxyyyyyzzzzz");
//! [times_higher_order]
@@ -69,14 +69,14 @@ BOOST_HANA_RUNTIME_CHECK(s == "xxxxxyyyyyzzzzz");
//! [times_with_index_runtime]
std::vector<int> v;
hana::int_<5>.times.with_index([&](auto index) { v.push_back(index); });
hana::int_c<5>.times.with_index([&](auto index) { v.push_back(index); });
BOOST_HANA_RUNTIME_CHECK(v == std::vector<int>{0, 1, 2, 3, 4});
//! [times_with_index_runtime]
//! [times_with_index_compile_time]
constexpr auto xs = hana::tuple_c<int, 0, 1, 2>;
hana::int_<3>.times.with_index([xs](auto index) {
hana::int_c<3>.times.with_index([xs](auto index) {
BOOST_HANA_CONSTANT_CHECK(xs[index] == index);
});
//! [times_with_index_compile_time]
@@ -86,15 +86,15 @@ hana::int_<3>.times.with_index([xs](auto index) {
//! [literals]
using namespace hana::literals; // contains the _c suffix
BOOST_HANA_CONSTANT_CHECK(1234_c == hana::llong<1234>);
BOOST_HANA_CONSTANT_CHECK(-1234_c == hana::llong<-1234>);
BOOST_HANA_CONSTANT_CHECK(1_c + (3_c * 4_c) == hana::llong<1 + (3 * 4)>);
BOOST_HANA_CONSTANT_CHECK(1234_c == hana::llong_c<1234>);
BOOST_HANA_CONSTANT_CHECK(-1234_c == hana::llong_c<-1234>);
BOOST_HANA_CONSTANT_CHECK(1_c + (3_c * 4_c) == hana::llong_c<1 + (3 * 4)>);
//! [literals]
}{
//! [integral_c]
BOOST_HANA_CONSTANT_CHECK(hana::integral_c<int, 2> == hana::int_<2>);
BOOST_HANA_CONSTANT_CHECK(hana::integral_c<int, 2> == hana::int_c<2>);
static_assert(decltype(hana::integral_c<int, 2>)::value == 2, "");
//! [integral_c]

6
example/intersection.cpp
View File

@@ -13,9 +13,9 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
constexpr auto xs = hana::make_set(hana::int_<1>, hana::type_c<void>, hana::int_<2>);
constexpr auto ys = hana::make_set(hana::int_<2>, hana::type_c<int>, hana::int_<3>);
constexpr auto xs = hana::make_set(hana::int_c<1>, hana::type_c<void>, hana::int_c<2>);
constexpr auto ys = hana::make_set(hana::int_c<2>, hana::type_c<int>, hana::int_c<3>);
BOOST_HANA_CONSTANT_CHECK(hana::intersection(xs, ys) == hana::make_set(hana::int_<2>));
BOOST_HANA_CONSTANT_CHECK(hana::intersection(xs, ys) == hana::make_set(hana::int_c<2>));
int main() { }

20
example/is_disjoint.cpp
View File

@@ -19,27 +19,27 @@ using namespace std::literals;
int main() {
// Tuples
auto xs = hana::make_tuple(hana::int_<1>, "alfa"s, hana::type_c<int>);
auto ys = hana::make_tuple(hana::type_c<void>, hana::int_<3>, "bravo"s);
auto xs = hana::make_tuple(hana::int_c<1>, "alfa"s, hana::type_c<int>);
auto ys = hana::make_tuple(hana::type_c<void>, hana::int_c<3>, "bravo"s);
BOOST_HANA_RUNTIME_CHECK(hana::is_disjoint(xs, ys));
// Sets
auto s1 = hana::make_set(hana::int_<1>, hana::type_c<void>, hana::int_<2>);
auto s2 = hana::make_set(hana::type_c<char>, hana::type_c<int>, hana::int_<1>);
auto s1 = hana::make_set(hana::int_c<1>, hana::type_c<void>, hana::int_c<2>);
auto s2 = hana::make_set(hana::type_c<char>, hana::type_c<int>, hana::int_c<1>);
BOOST_HANA_CONSTANT_CHECK(!hana::is_disjoint(s1, s2));
// Maps
auto vowels = hana::make_map(
hana::make_pair(hana::char_<'a'>, "alfa"s),
hana::make_pair(hana::char_<'e'>, "echo"s),
hana::make_pair(hana::char_<'i'>, "india"s)
hana::make_pair(hana::char_c<'a'>, "alfa"s),
hana::make_pair(hana::char_c<'e'>, "echo"s),
hana::make_pair(hana::char_c<'i'>, "india"s)
// ...
);
auto consonants = hana::make_map(
hana::make_pair(hana::char_<'b'>, "bravo"s),
hana::make_pair(hana::char_<'c'>, "charlie"s),
hana::make_pair(hana::char_<'f'>, "foxtrot"s)
hana::make_pair(hana::char_c<'b'>, "bravo"s),
hana::make_pair(hana::char_c<'c'>, "charlie"s),
hana::make_pair(hana::char_c<'f'>, "foxtrot"s)
// ...
);

4
example/iterable/searchable.cpp
View File

@@ -31,13 +31,13 @@ BOOST_HANA_CONSTANT_CHECK(
);
BOOST_HANA_CONSTANT_CHECK(
hana::find(hana::make_tuple(hana::int_<1>, hana::char_<'c'>, hana::type_c<void>), hana::type_c<void>)
hana::find(hana::make_tuple(hana::int_c<1>, hana::char_c<'c'>, hana::type_c<void>), hana::type_c<void>)
==
hana::just(hana::type_c<void>)
);
BOOST_HANA_CONSTANT_CHECK(
hana::find(hana::make_tuple(hana::int_<1>, hana::char_<'c'>, hana::type_c<void>), hana::type_c<int>)
hana::find(hana::make_tuple(hana::int_c<1>, hana::char_c<'c'>, hana::type_c<void>), hana::type_c<int>)
==
hana::nothing
);

2
example/lazy/make.cpp
View File

@@ -22,5 +22,5 @@ int main() {
return x + 1;
});
BOOST_HANA_CONSTEXPR_CHECK(hana::eval(hana::if_(hana::false_, f(0), g(0))) == 0 + 1);
BOOST_HANA_CONSTEXPR_CHECK(hana::eval(hana::if_(hana::false_c, f(0), g(0))) == 0 + 1);
}

8
example/length.cpp
View File

@@ -14,9 +14,9 @@ namespace hana = boost::hana;
int main() {
BOOST_HANA_CONSTANT_CHECK(hana::length(hana::make_tuple()) == hana::size_t<0>);
BOOST_HANA_CONSTANT_CHECK(hana::length(hana::make_tuple(1, '2', 3.0)) == hana::size_t<3>);
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_t<0>);
BOOST_HANA_CONSTANT_CHECK(hana::length(hana::just('x')) == hana::size_t<1>);
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>);
}

4
example/less.cpp
View File

@@ -14,10 +14,10 @@ namespace hana = boost::hana;
static_assert(hana::less(1, 4), "");
BOOST_HANA_CONSTANT_CHECK(!hana::less(hana::int_<3>, hana::int_<2>));
BOOST_HANA_CONSTANT_CHECK(!hana::less(hana::int_c<3>, hana::int_c<2>));
// less.than is syntactic sugar
static_assert(hana::all_of(hana::tuple_c<int, 1, 2, 3, 4>, hana::less.than(5)), "");
BOOST_HANA_CONSTANT_CHECK(hana::all_of(hana::tuple_c<int, 1, 2, 3, 4>, hana::less_equal.than(hana::int_<4>)));
BOOST_HANA_CONSTANT_CHECK(hana::all_of(hana::tuple_c<int, 1, 2, 3, 4>, hana::less_equal.than(hana::int_c<4>)));
int main() { }

2
example/less_equal.cpp
View File

@@ -13,6 +13,6 @@ namespace hana = boost::hana;
static_assert(hana::less_equal(1, 4), "");
static_assert(hana::less_equal(1, 1), "");
BOOST_HANA_CONSTANT_CHECK(!hana::less_equal(hana::int_<3>, hana::int_<2>));
BOOST_HANA_CONSTANT_CHECK(!hana::less_equal(hana::int_c<3>, hana::int_c<2>));
int main() { }

4
example/lexicographical_compare.cpp
View File

@@ -23,8 +23,8 @@ int main() {
// 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>);
auto xs = hana::make_tuple(hana::int_c<1>, hana::int_c<2>, hana::int_c<3>);
auto ys = hana::make_tuple(hana::int_c<1>, hana::int_c<5>, hana::int_c<3>);
BOOST_HANA_CONSTANT_CHECK(hana::lexicographical_compare(xs, ys));
}

4
example/map/comparable.cpp
View File

@@ -18,13 +18,13 @@ using namespace std::literals;
int main() {
BOOST_HANA_RUNTIME_CHECK(
hana::make_map(
hana::make_pair(hana::char_<'a'>, "foobar"s),
hana::make_pair(hana::char_c<'a'>, "foobar"s),
hana::make_pair(hana::type_c<int&&>, nullptr)
)
==
hana::make_map(
hana::make_pair(hana::type_c<int&&>, (void*)0),
hana::make_pair(hana::char_<'a'>, "foobar"s)
hana::make_pair(hana::char_c<'a'>, "foobar"s)
)
);
}

12
example/map/foldable.cpp
View File

@@ -26,16 +26,16 @@ int main() {
};
auto m = hana::make_map(
hana::make_pair(hana::type_c<int>, hana::int_<1>),
hana::make_pair(hana::type_c<float>, hana::int_<2>),
hana::make_pair(hana::int_<3>, hana::type_c<void>)
hana::make_pair(hana::type_c<int>, hana::int_c<1>),
hana::make_pair(hana::type_c<float>, hana::int_c<2>),
hana::make_pair(hana::int_c<3>, hana::type_c<void>)
);
BOOST_HANA_CONSTANT_CHECK(invert(m) ==
hana::make_map(
hana::make_pair(hana::int_<1>, hana::type_c<int>),
hana::make_pair(hana::int_<2>, hana::type_c<float>),
hana::make_pair(hana::type_c<void>, hana::int_<3>)
hana::make_pair(hana::int_c<1>, hana::type_c<int>),
hana::make_pair(hana::int_c<2>, hana::type_c<float>),
hana::make_pair(hana::type_c<void>, hana::int_c<3>)
)
);
}

4
example/map/keys.cpp
View File

@@ -21,12 +21,12 @@ using namespace std::literals;
int main() {
auto m = hana::make_map(
hana::make_pair(hana::int_<1>, "foobar"s),
hana::make_pair(hana::int_c<1>, "foobar"s),
hana::make_pair(hana::type_c<void>, 1234)
);
// The order of the keys is unspecified.
BOOST_HANA_CONSTANT_CHECK(
hana::keys(m) ^hana::in^ hana::permutations(hana::make_tuple(hana::int_<1>, hana::type_c<void>))
hana::keys(m) ^hana::in^ hana::permutations(hana::make_tuple(hana::int_c<1>, hana::type_c<void>))
);
}

4
example/map/make.cpp
View File

@@ -19,12 +19,12 @@ using namespace std::literals;
int main() {
BOOST_HANA_RUNTIME_CHECK(
hana::make_map(
hana::make_pair(hana::int_<1>, "foobar"s),
hana::make_pair(hana::int_c<1>, "foobar"s),
hana::make_pair(hana::type_c<void>, 1234)
)
==
hana::make<hana::Map>(
hana::make_pair(hana::int_<1>, "foobar"s),
hana::make_pair(hana::int_c<1>, "foobar"s),
hana::make_pair(hana::type_c<void>, 1234)
)
);

2
example/map/searchable.cpp
View File

@@ -23,7 +23,7 @@ constexpr auto m = hana::make_map(
static_assert(hana::find(m, hana::type_c<int>) == hana::just('i'), "");
static_assert(hana::find(m, hana::type_c<float>) == hana::just('f'), "");
BOOST_HANA_CONSTANT_CHECK(hana::find(m, hana::type_c<void>) == hana::nothing);
BOOST_HANA_CONSTANT_CHECK(hana::find(m, hana::int_<3>) == hana::nothing);
BOOST_HANA_CONSTANT_CHECK(hana::find(m, hana::int_c<3>) == hana::nothing);
// operator[] is equivalent to at_key
static_assert(m[hana::type_c<int>] == 'i', "");

2
example/map/values.cpp
View File

@@ -20,7 +20,7 @@ using namespace std::literals;
int main() {
auto m = hana::make_map(
hana::make_pair(hana::int_<1>, "foobar"s),
hana::make_pair(hana::int_c<1>, "foobar"s),
hana::make_pair(hana::type_c<void>, 1234)
);

2
example/max.cpp
View File

@@ -12,6 +12,6 @@ namespace hana = boost::hana;
static_assert(hana::max(1, 4) == 4, "");
BOOST_HANA_CONSTANT_CHECK(hana::max(hana::int_<7>, hana::int_<5>) == hana::int_<7>);
BOOST_HANA_CONSTANT_CHECK(hana::max(hana::int_c<7>, hana::int_c<5>) == hana::int_c<7>);
int main() { }

4
example/maximum.cpp
View File

@@ -16,12 +16,12 @@ namespace hana = boost::hana;
int main() {
// without a predicate
BOOST_HANA_CONSTANT_CHECK(
hana::maximum(hana::tuple_c<int, -1, 0, 2, -4, 6, 9>) == hana::int_<9>
hana::maximum(hana::tuple_c<int, -1, 0, 2, -4, 6, 9>) == hana::int_c<9>
);
// with a predicate
auto smallest = hana::maximum(hana::tuple_c<int, -1, 0, 2, -4, 6, 9>, [](auto x, auto y) {
return x > y; // order is reversed!
});
BOOST_HANA_CONSTANT_CHECK(smallest == hana::int_<-4>);
BOOST_HANA_CONSTANT_CHECK(smallest == hana::int_c<-4>);
}

2
example/min.cpp
View File

@@ -12,6 +12,6 @@ namespace hana = boost::hana;
static_assert(hana::min(1, 4) == 1, "");
BOOST_HANA_CONSTANT_CHECK(hana::min(hana::int_<7>, hana::int_<5>) == hana::int_<5>);
BOOST_HANA_CONSTANT_CHECK(hana::min(hana::int_c<7>, hana::int_c<5>) == hana::int_c<5>);
int main() { }

4
example/minimum.cpp
View File

@@ -16,12 +16,12 @@ namespace hana = boost::hana;
int main() {
// without a predicate
BOOST_HANA_CONSTANT_CHECK(
hana::minimum(hana::tuple_c<int, -1, 0, 2, -4, 6, 9>) == hana::int_<-4>
hana::minimum(hana::tuple_c<int, -1, 0, 2, -4, 6, 9>) == hana::int_c<-4>
);
// with a predicate
auto largest = hana::minimum(hana::tuple_c<int, -1, 0, 2, -4, 6, 9>, [](auto x, auto y) {
return x > y; // order is reversed!
});
BOOST_HANA_CONSTANT_CHECK(largest == hana::int_<9>);
BOOST_HANA_CONSTANT_CHECK(largest == hana::int_c<9>);
}

2
example/minus.cpp
View File

@@ -12,6 +12,6 @@ namespace hana = boost::hana;
int main() {
BOOST_HANA_CONSTANT_CHECK(hana::minus(hana::int_<3>, hana::int_<5>) == hana::int_<-2>);
BOOST_HANA_CONSTANT_CHECK(hana::minus(hana::int_c<3>, hana::int_c<5>) == hana::int_c<-2>);
static_assert(hana::minus(1, 2) == -1, "");
}

6
example/misc/printable.cpp
View File

@@ -161,14 +161,14 @@ struct print_impl<hana::Type> {
int main() {
auto tuple = hana::make_tuple(1, '2', BOOST_HANA_STRING("3456"));
auto set = hana::make_set(hana::int_<1>, hana::int_<2>);
auto set = hana::make_set(hana::int_c<1>, hana::int_c<2>);
auto map = hana::make_map(
hana::make_pair(hana::int_<1>, hana::type_c<void>),
hana::make_pair(hana::int_c<1>, hana::type_c<void>),
hana::make_pair(hana::type_c<decltype(tuple)>, "int")
);
auto pair = hana::make_pair(1, hana::int_<1>);
auto pair = hana::make_pair(1, hana::int_c<1>);
std::cout << print(tuple) << std::endl
<< print(set) << std::endl

10
example/monadic_fold_right.cpp
View File

@@ -19,7 +19,7 @@ namespace hana = boost::hana;
int main() {
BOOST_HANA_CONSTEXPR_LAMBDA auto safe_div = [](auto x, auto y) {
return hana::eval_if(y == hana::int_<0>,
return hana::eval_if(y == hana::int_c<0>,
hana::make_lazy(hana::nothing),
[=](auto _) {
return hana::just(_(x) / y);
@@ -30,15 +30,15 @@ int main() {
// with an initial state
BOOST_HANA_CONSTANT_CHECK(
hana::monadic_fold_right<hana::Optional>(
hana::tuple_c<int, 1000, 8, 4>, hana::int_<2>, safe_div
hana::tuple_c<int, 1000, 8, 4>, hana::int_c<2>, safe_div
)
==
hana::just(hana::int_<1000> / (hana::int_<8> / (hana::int_<4> / hana::int_<2>)))
hana::just(hana::int_c<1000> / (hana::int_c<8> / (hana::int_c<4> / hana::int_c<2>)))
);
BOOST_HANA_CONSTANT_CHECK(
hana::monadic_fold_right<hana::Optional>(
hana::tuple_c<int, 1000, 8, 4>, hana::int_<0>, safe_div
hana::tuple_c<int, 1000, 8, 4>, hana::int_c<0>, safe_div
)
==
hana::nothing
@@ -50,7 +50,7 @@ int main() {
hana::tuple_c<int, 1000, 8, 4, 2>, safe_div
)
==
hana::just(hana::int_<1000> / (hana::int_<8> / (hana::int_<4> / hana::int_<2>)))
hana::just(hana::int_c<1000> / (hana::int_c<8> / (hana::int_c<4> / hana::int_c<2>)))
);
BOOST_HANA_CONSTANT_CHECK(

2
example/mult.cpp
View File

@@ -11,7 +11,7 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::mult(hana::int_<3>, hana::int_<5>) == hana::int_<15>);
BOOST_HANA_CONSTANT_CHECK(hana::mult(hana::int_c<3>, hana::int_c<5>) == hana::int_c<15>);
static_assert(hana::mult(4, 2) == 8, "");
int main() { }

2
example/negate.cpp
View File

@@ -12,6 +12,6 @@ namespace hana = boost::hana;
int main() {
BOOST_HANA_CONSTANT_CHECK(hana::negate(hana::int_<3>) == hana::int_<-3>);
BOOST_HANA_CONSTANT_CHECK(hana::negate(hana::int_c<3>) == hana::int_c<-3>);
static_assert(hana::negate(2) == -2, "");
}

6
example/none.cpp
View File

@@ -12,8 +12,8 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
static_assert(hana::none(hana::make_tuple(false, hana::false_, hana::false_)), "");
static_assert(!hana::none(hana::make_tuple(false, hana::false_, true)), "");
BOOST_HANA_CONSTANT_CHECK(!hana::none(hana::make_tuple(false, hana::false_, hana::true_)));
static_assert(hana::none(hana::make_tuple(false, hana::false_c, hana::false_c)), "");
static_assert(!hana::none(hana::make_tuple(false, hana::false_c, true)), "");
BOOST_HANA_CONSTANT_CHECK(!hana::none(hana::make_tuple(false, hana::false_c, hana::true_c)));
int main() { }

2
example/not.cpp
View File

@@ -11,7 +11,7 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::true_) == hana::false_);
BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::true_c) == hana::false_c);
static_assert(hana::not_(false) == true, "");
int main() { }

2
example/one.cpp
View File

@@ -11,7 +11,7 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::one<hana::IntegralConstant<int>>() == hana::int_<1>);
BOOST_HANA_CONSTANT_CHECK(hana::one<hana::IntegralConstant<int>>() == hana::int_c<1>);
static_assert(hana::one<long>() == 1l, "");
int main() { }

2
example/optional/applicative.complex.cpp
View File

@@ -31,7 +31,7 @@ BOOST_HANA_CONSTEXPR_LAMBDA auto function<'-'> = hana::just([](auto x, auto y) {
// and so on...
template <char n>
constexpr auto digit = hana::if_(hana::bool_<(n >= '0' && n <= '9')>,
constexpr auto digit = hana::if_(hana::bool_c<(n >= '0' && n <= '9')>,
hana::just(static_cast<int>(n - 48)),
hana::nothing
);

8
example/optional/only_when.cpp
View File

@@ -14,14 +14,14 @@ namespace hana = boost::hana;
auto even = [](auto x) {
return x % hana::int_<2> == hana::int_<0>;
return x % hana::int_c<2> == hana::int_c<0>;
};
auto half = [](auto x) {
return x / hana::int_<2>;
return x / hana::int_c<2>;
};
BOOST_HANA_CONSTANT_CHECK(hana::only_when(even, half, hana::int_<4>) == hana::just(hana::int_<2>));
BOOST_HANA_CONSTANT_CHECK(hana::only_when(even, half, hana::int_<3>) == hana::nothing);
BOOST_HANA_CONSTANT_CHECK(hana::only_when(even, half, hana::int_c<4>) == hana::just(hana::int_c<2>));
BOOST_HANA_CONSTANT_CHECK(hana::only_when(even, half, hana::int_c<3>) == hana::nothing);
int main() { }

8
example/optional/searchable.cpp
View File

@@ -16,14 +16,14 @@ namespace hana = boost::hana;
auto odd = [](auto x) {
return x % hana::int_<2> != hana::int_<0>;
return x % hana::int_c<2> != hana::int_c<0>;
};
BOOST_HANA_CONSTANT_CHECK(hana::find_if(hana::just(hana::int_<3>), odd) == hana::just(hana::int_<3>));
BOOST_HANA_CONSTANT_CHECK(hana::find_if(hana::just(hana::int_<2>), odd) == hana::nothing);
BOOST_HANA_CONSTANT_CHECK(hana::find_if(hana::just(hana::int_c<3>), odd) == hana::just(hana::int_c<3>));
BOOST_HANA_CONSTANT_CHECK(hana::find_if(hana::just(hana::int_c<2>), odd) == hana::nothing);
BOOST_HANA_CONSTANT_CHECK(hana::find_if(hana::nothing, odd) == hana::nothing);
BOOST_HANA_CONSTANT_CHECK(hana::all_of(hana::just(hana::int_<3>), odd));
BOOST_HANA_CONSTANT_CHECK(hana::all_of(hana::just(hana::int_c<3>), odd));
BOOST_HANA_CONSTANT_CHECK(hana::all_of(hana::nothing, odd));
int main() { }

4
example/or.cpp
View File

@@ -11,7 +11,7 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::or_(hana::false_, hana::false_, hana::true_));
BOOST_HANA_CONSTANT_CHECK(!hana::or_(hana::false_, hana::false_, hana::false_));
BOOST_HANA_CONSTANT_CHECK(hana::or_(hana::false_c, hana::false_c, hana::true_c));
BOOST_HANA_CONSTANT_CHECK(!hana::or_(hana::false_c, hana::false_c, hana::false_c));
int main() { }

2
example/overview.cpp
View File

@@ -51,7 +51,7 @@ int main() {
// 2. Unroll loops at compile-time without hassle.
std::string s;
hana::int_<10>.times([&]{ s += "x"; });
hana::int_c<10>.times([&]{ s += "x"; });
// equivalent to s += "x"; s += "x"; ... s += "x";
// 3. Easily check whether an expression is valid.

2
example/partition.cpp
View File

@@ -21,7 +21,7 @@ namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(
hana::partition(hana::tuple_c<int, 1, 2, 3, 4, 5, 6, 7>, [](auto x) {
return x % hana::int_<2> != hana::int_<0>;
return x % hana::int_c<2> != hana::int_c<0>;
})
==
hana::make_pair(

2
example/plus.cpp
View File

@@ -11,7 +11,7 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::plus(hana::int_<3>, hana::int_<5>) == hana::int_<8>);
BOOST_HANA_CONSTANT_CHECK(hana::plus(hana::int_c<3>, hana::int_c<5>) == hana::int_c<8>);
static_assert(hana::plus(1, 2) == 3, "");
static_assert(hana::plus(1.5f, 2.4) == 3.9, "");

4
example/power.cpp
View File

@@ -11,7 +11,7 @@ Distributed under the Boost Software License, Version 1.0.
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::power(hana::int_<3>, hana::int_<2>) == hana::int_<3 * 3>);
static_assert(hana::power(2, hana::int_<4>) == 16, "");
BOOST_HANA_CONSTANT_CHECK(hana::power(hana::int_c<3>, hana::int_c<2>) == hana::int_c<3 * 3>);
static_assert(hana::power(2, hana::int_c<4>) == 16, "");
int main() { }

2
example/pred.cpp
View File

@@ -12,6 +12,6 @@ namespace hana = boost::hana;
int main() {
BOOST_HANA_CONSTANT_CHECK(hana::pred(hana::int_<4>) == hana::int_<3>);
BOOST_HANA_CONSTANT_CHECK(hana::pred(hana::int_c<4>) == hana::int_c<3>);
static_assert(hana::pred(10) == 9, "");
}

4
example/product.cpp
View File

@@ -15,11 +15,11 @@ namespace hana = boost::hana;
int main() {
BOOST_HANA_CONSTANT_CHECK(
hana::product<>(hana::make_range(hana::int_<1>, hana::int_<6>)) == hana::int_<1 * 2 * 3 * 4 * 5>
hana::product<>(hana::make_range(hana::int_c<1>, hana::int_c<6>)) == hana::int_c<1 * 2 * 3 * 4 * 5>
);
BOOST_HANA_CONSTEXPR_CHECK(
hana::product<>(hana::make_tuple(1, hana::int_<3>, hana::long_<-5>, 9)) == 1 * 3 * -5 * 9
hana::product<>(hana::make_tuple(1, hana::int_c<3>, hana::long_c<-5>, 9)) == 1 * 3 * -5 * 9
);
BOOST_HANA_CONSTEXPR_CHECK(

4
example/quot.cpp
View File

@@ -12,8 +12,8 @@ namespace hana = boost::hana;
int main() {
BOOST_HANA_CONSTANT_CHECK(hana::quot(hana::int_<6>, hana::int_<3>) == hana::int_<2>);
BOOST_HANA_CONSTANT_CHECK(hana::quot(hana::int_<6>, hana::int_<4>) == hana::int_<1>);
BOOST_HANA_CONSTANT_CHECK(hana::quot(hana::int_c<6>, hana::int_c<3>) == hana::int_c<2>);
BOOST_HANA_CONSTANT_CHECK(hana::quot(hana::int_c<6>, hana::int_c<4>) == hana::int_c<1>);
static_assert(hana::quot(6, 3) == 2, "");
static_assert(hana::quot(6, 4) == 1, "");

6
example/range/comparable.cpp
View File

@@ -13,10 +13,10 @@ namespace hana = boost::hana;
// empty ranges are equal
BOOST_HANA_CONSTANT_CHECK(hana::make_range(hana::int_<6>, hana::int_<6>) == hana::make_range(hana::int_<0>, hana::int_<0>));
BOOST_HANA_CONSTANT_CHECK(hana::make_range(hana::int_c<6>, hana::int_c<6>) == hana::make_range(hana::int_c<0>, hana::int_c<0>));
// otherwise, ranges are equal if and only if they span the same interval
BOOST_HANA_CONSTANT_CHECK(hana::make_range(hana::int_<2>, hana::int_<5>) == hana::make_range(hana::int_<2>, hana::int_<5>));
BOOST_HANA_CONSTANT_CHECK(hana::make_range(hana::int_<0>, hana::int_<3>) != hana::make_range(hana::int_<-1>, hana::int_<3>));
BOOST_HANA_CONSTANT_CHECK(hana::make_range(hana::int_c<2>, hana::int_c<5>) == hana::make_range(hana::int_c<2>, hana::int_c<5>));
BOOST_HANA_CONSTANT_CHECK(hana::make_range(hana::int_c<0>, hana::int_c<3>) != hana::make_range(hana::int_c<-1>, hana::int_c<3>));
int main() { }

Some files were not shown because too many files have changed in this diff Show More