ceph/src/boost/libs/hana/test/issues/github_221.cpp

   1 // Copyright Louis Dionne 2013-2016
   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)
   4
   5 #include <boost/hana/adjust_if.hpp>
   6 #include <boost/hana/all_of.hpp>
   7 #include <boost/hana/any_of.hpp>
   8 #include <boost/hana/assert.hpp>
   9 #include <boost/hana/count_if.hpp>
  10 #include <boost/hana/drop_while.hpp>
  11 #include <boost/hana/equal.hpp>
  12 #include <boost/hana/ext/std/tuple.hpp>
  13 #include <boost/hana/filter.hpp>
  14 #include <boost/hana/find_if.hpp>
  15 #include <boost/hana/functional/id.hpp>
  16 #include <boost/hana/functional/partial.hpp>
  17 #include <boost/hana/group.hpp>
  18 #include <boost/hana/integral_constant.hpp>
  19 #include <boost/hana/lexicographical_compare.hpp>
  20 #include <boost/hana/maximum.hpp>
  21 #include <boost/hana/minimum.hpp>
  22 #include <boost/hana/none_of.hpp>
  23 #include <boost/hana/optional.hpp>
  24 #include <boost/hana/partition.hpp>
  25 #include <boost/hana/plus.hpp>
  26 #include <boost/hana/remove_if.hpp>
  27 #include <boost/hana/replace_if.hpp>
  28 #include <boost/hana/sort.hpp>
  29 #include <boost/hana/span.hpp>
  30 #include <boost/hana/take_while.hpp>
  31 #include <boost/hana/tuple.hpp>
  32 #include <boost/hana/unique.hpp>
  33 #include <boost/hana/while.hpp>
  34 namespace hana = boost::hana;
  35
  36
  37 constexpr auto increment = hana::partial(hana::plus, hana::int_c<1>);
  38
  39 int main() {
  40
  41     // adjust_if
  42     {
  43         constexpr auto x = hana::adjust_if(hana::make_tuple(hana::int_c<0>), hana::id, increment);
  44         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::make_tuple(hana::int_c<0>)));
  45
  46         constexpr auto y = hana::adjust_if(hana::make_tuple(hana::int_c<1>), hana::id, increment);
  47         BOOST_HANA_CONSTANT_CHECK(hana::equal(y, hana::make_tuple(hana::int_c<2>)));
  48
  49         constexpr auto z = hana::adjust_if(hana::make_tuple(hana::int_c<3>), hana::id, increment);
  50         BOOST_HANA_CONSTANT_CHECK(hana::equal(z, hana::make_tuple(hana::int_c<4>)));
  51
  52         constexpr auto l = hana::adjust_if(hana::tuple_c<int, 3>, hana::id, increment);
  53         BOOST_HANA_CONSTANT_CHECK(hana::equal(l, hana::make_tuple(hana::int_c<4>)));
  54     }
  55     {
  56         // test with lvalue
  57         constexpr auto x = hana::adjust_if(hana::tuple_c<int, 3>, hana::id, increment);
  58         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::make_tuple(hana::int_c<4>)));
  59     }
  60
  61     // all_of
  62     {
  63         BOOST_HANA_CONSTANT_CHECK(!hana::all_of(hana::make_tuple(hana::int_c<0>), hana::id));
  64         BOOST_HANA_CONSTANT_CHECK(hana::all_of(hana::make_tuple(hana::int_c<1>), hana::id));
  65         BOOST_HANA_CONSTANT_CHECK(hana::all_of(hana::make_tuple(hana::int_c<3>), hana::id));
  66         // test with lvalue
  67         BOOST_HANA_CONSTANT_CHECK(hana::all_of(hana::tuple_c<int, 3>, hana::id));
  68     }
  69
  70     // any_of
  71     {
  72         BOOST_HANA_CONSTANT_CHECK(!hana::any_of(hana::make_tuple(hana::int_c<0>), hana::id));
  73         BOOST_HANA_CONSTANT_CHECK(hana::any_of(hana::make_tuple(hana::int_c<1>), hana::id));
  74         BOOST_HANA_CONSTANT_CHECK(hana::any_of(hana::make_tuple(hana::int_c<3>), hana::id));
  75         // test with lvalue
  76         BOOST_HANA_CONSTANT_CHECK(hana::any_of(hana::tuple_c<int, 3>, hana::id));
  77     }
  78
  79     // count_if
  80     {
  81         constexpr auto x = hana::count_if(hana::make_tuple(hana::int_c<0>), hana::id);
  82         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::size_c<0>));
  83
  84         constexpr auto y = hana::count_if(hana::make_tuple(hana::int_c<1>), hana::id);
  85         BOOST_HANA_CONSTANT_CHECK(hana::equal(y, hana::size_c<1>));
  86
  87         constexpr auto z = hana::count_if(hana::make_tuple(hana::int_c<3>), hana::id);
  88         BOOST_HANA_CONSTANT_CHECK(hana::equal(z, hana::size_c<1>));
  89     }
  90     {
  91         // test with lvalue
  92         constexpr auto x = hana::count_if(hana::tuple_c<int, 3>, hana::id);
  93         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::size_c<1>));
  94     }
  95
  96     // drop_while
  97     {
  98         constexpr auto x = hana::drop_while(
  99             hana::make_tuple(hana::int_c<0>), hana::id
 100         );
 101         BOOST_HANA_CONSTANT_CHECK(hana::equal(x,
 102                 hana::make_tuple(hana::int_c<0>)
 103             )
 104         );
 105         constexpr auto y = hana::drop_while(
 106             hana::make_tuple(hana::int_c<1>, hana::int_c<3>, hana::int_c<0>), hana::id
 107         );
 108         BOOST_HANA_CONSTANT_CHECK(hana::equal(y,
 109                 hana::make_tuple(hana::int_c<0>)
 110             )
 111         );
 112     }
 113     {
 114         // test with lvalue
 115         constexpr auto x = hana::drop_while(
 116             hana::tuple_c<int, 1, 3, 0>,  hana::id
 117         );
 118         BOOST_HANA_CONSTANT_CHECK(hana::equal(x,
 119                 hana::make_tuple(hana::int_c<0>)
 120             )
 121         );
 122     }
 123
 124     // filter
 125     {
 126         constexpr auto x = hana::filter(hana::make_tuple(hana::int_c<0>), hana::id);
 127         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::make_tuple()));
 128
 129         constexpr auto y = hana::filter(hana::make_tuple(hana::int_c<1>), hana::id);
 130         BOOST_HANA_CONSTANT_CHECK(hana::equal(y, hana::make_tuple(hana::int_c<1>)));
 131
 132         constexpr auto z = hana::filter(hana::make_tuple(hana::int_c<3>), hana::id);
 133         BOOST_HANA_CONSTANT_CHECK(hana::equal(z, hana::make_tuple(hana::int_c<3>)));
 134
 135     }
 136     {
 137         // test with lvalue
 138         constexpr auto x = hana::filter(hana::tuple_c<int, 3>, hana::id);
 139         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::make_tuple(hana::int_c<3>)));
 140     }
 141
 142     // find_if
 143     {
 144         constexpr auto x = hana::find_if(hana::make_tuple(hana::int_c<0>), hana::id);
 145         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::nothing));
 146
 147         constexpr auto y = hana::find_if(hana::make_tuple(hana::int_c<1>), hana::id);
 148         BOOST_HANA_CONSTANT_CHECK(hana::equal(y, hana::just(hana::int_c<1>)));
 149
 150         constexpr auto z = hana::find_if(hana::make_tuple(hana::int_c<3>), hana::id);
 151         BOOST_HANA_CONSTANT_CHECK(hana::equal(z, hana::just(hana::int_c<3>)));
 152     }
 153     {
 154         // test with lvalue
 155         constexpr auto z = hana::find_if(hana::tuple_c<int, 3>, hana::id);
 156         BOOST_HANA_CONSTANT_CHECK(hana::equal(z, hana::just(hana::int_c<3>)));
 157     }
 158     {
 159         // test with std::tuple (for default implementation of find_if)
 160         constexpr auto x = hana::find_if(std::make_tuple(hana::int_c<0>), hana::id);
 161         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::nothing));
 162
 163         constexpr auto y = hana::find_if(std::make_tuple(hana::int_c<1>), hana::id);
 164         BOOST_HANA_CONSTANT_CHECK(hana::equal(y, hana::just(hana::int_c<1>)));
 165
 166         constexpr auto z = hana::find_if(std::make_tuple(hana::int_c<3>), hana::id);
 167         BOOST_HANA_CONSTANT_CHECK(hana::equal(z, hana::just(hana::int_c<3>)));
 168     }
 169     {
 170         // test with lvalue
 171         constexpr auto seq = std::make_tuple(hana::int_c<3>);
 172         constexpr auto x = hana::find_if(seq, hana::id);
 173         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::just(hana::int_c<3>)));
 174     }
 175
 176     // group
 177     {
 178         constexpr auto x = hana::group(
 179             hana::make_tuple(
 180                 hana::int_c<0>,
 181                 hana::int_c<0>,
 182                 hana::int_c<1>,
 183                 hana::int_c<1>,
 184                 hana::int_c<2>
 185             ),
 186             hana::plus
 187         );
 188         BOOST_HANA_CONSTANT_CHECK(hana::equal(x,
 189                 hana::make_tuple(
 190                     hana::tuple_c<int, 0>,
 191                     hana::tuple_c<int, 0, 1, 1, 2>
 192                 )
 193             )
 194         );
 195     }
 196     {
 197         // test with lvalue
 198         constexpr auto x = hana::group(hana::tuple_c<int, 0, 0, 1, 1, 2>, hana::plus);
 199         BOOST_HANA_CONSTANT_CHECK(hana::equal(x,
 200                 hana::make_tuple(
 201                     hana::tuple_c<int, 0>,
 202                     hana::tuple_c<int, 0, 1, 1, 2>
 203                 )
 204             )
 205         );
 206     }
 207
 208     // lexicographical_compare
 209     {
 210         BOOST_HANA_CONSTANT_CHECK(
 211             hana::lexicographical_compare(
 212                 hana::make_tuple(hana::int_c<0>, hana::int_c<0>),
 213                 hana::make_tuple(hana::int_c<0>, hana::int_c<3>),
 214                 hana::plus
 215             )
 216         );
 217     }
 218     {
 219         // test with lvalue
 220         BOOST_HANA_CONSTANT_CHECK(
 221             hana::lexicographical_compare(
 222                 hana::tuple_c<int, 0, 0>,
 223                 hana::tuple_c<int, 0, 3>,
 224                 hana::plus
 225             )
 226         );
 227     }
 228
 229     // maximum
 230     {
 231         constexpr auto x = hana::maximum(
 232             hana::make_tuple(
 233                 hana::int_c<0>,
 234                 hana::int_c<0>,
 235                 hana::int_c<1>,
 236                 hana::int_c<3>,
 237                 hana::int_c<2>
 238             ),
 239             hana::plus
 240         );
 241         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::int_c<2>));
 242     }
 243     {
 244         // test with lvalue
 245         constexpr auto x = hana::maximum(hana::tuple_c<int, 0, 0, 1, 3, 2>, hana::plus);
 246         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::int_c<2>));
 247     }
 248
 249     // minimum
 250     {
 251         constexpr auto x = hana::minimum(
 252             hana::make_tuple(
 253                 hana::int_c<0>,
 254                 hana::int_c<0>,
 255                 hana::int_c<1>,
 256                 hana::int_c<3>,
 257                 hana::int_c<2>
 258             ),
 259             hana::plus
 260         );
 261         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::int_c<0>));
 262     }
 263     {
 264         // test with lvalue
 265         constexpr auto x = hana::minimum(hana::tuple_c<int, 0, 0, 1, 3, 2>, hana::plus);
 266         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::int_c<0>));
 267     }
 268
 269     // none_of
 270     {
 271         BOOST_HANA_CONSTANT_CHECK(hana::none_of(hana::make_tuple(hana::int_c<0>), hana::id));
 272         BOOST_HANA_CONSTANT_CHECK(!hana::none_of(hana::make_tuple(hana::int_c<1>), hana::id));
 273         BOOST_HANA_CONSTANT_CHECK(!hana::none_of(hana::make_tuple(hana::int_c<3>), hana::id));
 274     }
 275     {
 276         // test with lvalue
 277         BOOST_HANA_CONSTANT_CHECK(hana::none_of(hana::tuple_c<int, 0>, hana::id));
 278         BOOST_HANA_CONSTANT_CHECK(!hana::none_of(hana::tuple_c<int, 1>, hana::id));
 279         BOOST_HANA_CONSTANT_CHECK(!hana::none_of(hana::tuple_c<int, 3>, hana::id));
 280     }
 281
 282     // partition
 283     {
 284         constexpr auto x = hana::partition(
 285             hana::make_tuple(
 286                 hana::int_c<0>,
 287                 hana::int_c<1>,
 288                 hana::int_c<3>
 289             ),
 290             hana::id
 291         );
 292         BOOST_HANA_CONSTANT_CHECK(hana::equal(x,
 293                 hana::make_pair(
 294                     hana::tuple_c<int, 1, 3>,
 295                     hana::tuple_c<int, 0>
 296                 )
 297             )
 298         );
 299     }
 300     {
 301         // test with lvalue
 302         constexpr auto x = hana::partition(hana::tuple_c<int, 0, 1, 3>, hana::id);
 303         BOOST_HANA_CONSTANT_CHECK(hana::equal(x,
 304                 hana::make_pair(
 305                     hana::tuple_c<int, 1, 3>,
 306                     hana::tuple_c<int, 0>
 307                 )
 308             )
 309         );
 310     }
 311
 312     // remove_if
 313     {
 314         constexpr auto x = hana::remove_if(hana::make_tuple(hana::int_c<0>), hana::id);
 315         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::make_tuple(hana::int_c<0>)));
 316
 317         constexpr auto y = hana::remove_if(hana::make_tuple(hana::int_c<1>), hana::id);
 318         BOOST_HANA_CONSTANT_CHECK(hana::equal(y, hana::make_tuple()));
 319
 320         constexpr auto z = hana::remove_if(hana::make_tuple(hana::int_c<3>), hana::id);
 321         BOOST_HANA_CONSTANT_CHECK(hana::equal(z, hana::make_tuple()));
 322     }
 323     {
 324         // test with lvalue
 325         constexpr auto z = hana::remove_if(hana::tuple_c<int, 3>, hana::id);
 326         BOOST_HANA_CONSTANT_CHECK(hana::equal(z, hana::make_tuple()));
 327     }
 328
 329     // replace_if
 330     {
 331         constexpr auto x = hana::replace_if(
 332             hana::make_tuple(hana::int_c<0>),
 333             hana::id,
 334             hana::int_c<42>
 335         );
 336         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::make_tuple(hana::int_c<0>)));
 337
 338         constexpr auto y = hana::replace_if(
 339             hana::make_tuple(hana::int_c<1>),
 340             hana::id,
 341             hana::int_c<42>
 342         );
 343         BOOST_HANA_CONSTANT_CHECK(hana::equal(y, hana::make_tuple(hana::int_c<42>)));
 344
 345         constexpr auto z = hana::replace_if(
 346             hana::make_tuple(hana::int_c<3>),
 347             hana::id,
 348             hana::int_c<42>
 349         );
 350         BOOST_HANA_CONSTANT_CHECK(hana::equal(z, hana::make_tuple(hana::int_c<42>)));
 351     }
 352     {
 353         // test with lvalue
 354         constexpr auto z = hana::replace_if(
 355             hana::tuple_c<int, 3>,
 356             hana::id,
 357             hana::int_c<42>
 358         );
 359         BOOST_HANA_CONSTANT_CHECK(hana::equal(z, hana::make_tuple(hana::int_c<42>)));
 360     }
 361
 362     // sort
 363     {
 364         constexpr auto x = hana::sort(
 365             hana::make_tuple(
 366                 hana::int_c<0>,
 367                 hana::int_c<1>,
 368                 hana::int_c<2>
 369             ),
 370             hana::plus);
 371         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::tuple_c<int, 2, 1, 0>));
 372     }
 373     {
 374         // test with lvalue
 375         constexpr auto x = hana::sort(hana::tuple_c<int, 0, 1, 2>, hana::plus);
 376         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::tuple_c<int, 2, 1, 0>));
 377     }
 378     // span
 379     {
 380         constexpr auto x = hana::span(
 381             hana::make_tuple(
 382                 hana::int_c<2>,
 383                 hana::int_c<1>,
 384                 hana::int_c<0>
 385             ),
 386             hana::id
 387         );
 388         BOOST_HANA_CONSTANT_CHECK(
 389             hana::equal(x,
 390                 hana::make_pair(
 391                     hana::tuple_c<int, 2, 1>,
 392                     hana::tuple_c<int, 0>
 393                 )
 394             )
 395         );
 396     }
 397     {
 398         // test with an lvalue
 399         constexpr auto x = hana::span(hana::tuple_c<int, 2, 1, 0>, hana::id);
 400         BOOST_HANA_CONSTANT_CHECK(
 401             hana::equal(x,
 402                 hana::make_pair(
 403                     hana::tuple_c<int, 2, 1>,
 404                     hana::tuple_c<int, 0>
 405                 )
 406             )
 407         );
 408     }
 409
 410     // take_while
 411     {
 412         constexpr auto x = hana::take_while(
 413             hana::make_tuple(
 414                 hana::int_c<2>,
 415                 hana::int_c<1>,
 416                 hana::int_c<0>
 417             ),
 418             hana::id
 419         );
 420         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::tuple_c<int, 2, 1>));
 421     }
 422     {
 423         // test with lvalue
 424         constexpr auto x = hana::take_while(hana::tuple_c<int, 2, 1, 0>, hana::id);
 425         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::tuple_c<int, 2, 1>));
 426     }
 427
 428     // unique
 429     {
 430         constexpr auto x = hana::unique(
 431             hana::make_tuple(
 432                 hana::int_c<0>,
 433                 hana::int_c<0>,
 434                 hana::int_c<1>,
 435                 hana::int_c<2>
 436             ),
 437             hana::plus
 438         );
 439         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::tuple_c<int, 0, 0>));
 440     }
 441     {
 442         // test with lvalue
 443         constexpr auto x = hana::unique(hana::tuple_c<int, 0, 0, 1, 2>, hana::plus);
 444         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::tuple_c<int, 0, 0>));
 445     }
 446
 447     // while
 448     {
 449         constexpr auto x = hana::while_(hana::id, hana::int_c<-3>, increment);
 450         BOOST_HANA_CONSTANT_CHECK(hana::equal(x, hana::int_c<0>));
 451     }
 452 }