ceph/src/boost/libs/hana/test/_include/laws/monad_plus.hpp

   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)
   4
   5 #ifndef BOOST_HANA_TEST_LAWS_MONAD_PLUS_HPP
   6 #define BOOST_HANA_TEST_LAWS_MONAD_PLUS_HPP
   7
   8 #include <boost/hana/append.hpp>
   9 #include <boost/hana/assert.hpp>
  10 #include <boost/hana/bool.hpp>
  11 #include <boost/hana/chain.hpp>
  12 #include <boost/hana/concat.hpp>
  13 #include <boost/hana/concept/comparable.hpp>
  14 #include <boost/hana/concept/monad_plus.hpp>
  15 #include <boost/hana/concept/sequence.hpp>
  16 #include <boost/hana/core/make.hpp>
  17 #include <boost/hana/core/when.hpp>
  18 #include <boost/hana/cycle.hpp>
  19 #include <boost/hana/empty.hpp>
  20 #include <boost/hana/equal.hpp>
  21 #include <boost/hana/filter.hpp>
  22 #include <boost/hana/for_each.hpp>
  23 #include <boost/hana/functional/capture.hpp>
  24 #include <boost/hana/functional/compose.hpp>
  25 #include <boost/hana/integral_constant.hpp>
  26 #include <boost/hana/lift.hpp>
  27 #include <boost/hana/not.hpp>
  28 #include <boost/hana/not_equal.hpp>
  29 #include <boost/hana/prefix.hpp>
  30 #include <boost/hana/prepend.hpp>
  31 #include <boost/hana/remove.hpp>
  32 #include <boost/hana/remove_if.hpp>
  33 #include <boost/hana/replicate.hpp>
  34 #include <boost/hana/suffix.hpp>
  35
  36 #include <laws/base.hpp>
  37
  38
  39 namespace boost { namespace hana { namespace test {
  40     template <typename M, typename = when<true>>
  41     struct TestMonadPlus : TestMonadPlus<M, laws> {
  42         using TestMonadPlus<M, laws>::TestMonadPlus;
  43     };
  44
  45     template <typename M>
  46     struct TestMonadPlus<M, laws> {
  47         template <typename Xs, typename Predicates, typename Values>
  48         TestMonadPlus(Xs xs, Predicates predicates, Values values) {
  49 #ifdef BOOST_HANA_WORKAROUND_MSVC_DECLTYPEAUTO_RETURNTYPE_662735
  50             empty<M>(); // force adding empty<M>'s member function to pending temploid list
  51 #endif
  52
  53             hana::for_each(xs, [](auto a) {
  54                 static_assert(MonadPlus<decltype(a)>{}, "");
  55
  56                 // left identity
  57                 BOOST_HANA_CHECK(hana::equal(
  58                     hana::concat(hana::empty<M>(), a),
  59                     a
  60                 ));
  61
  62                 // right identity
  63                 BOOST_HANA_CHECK(hana::equal(
  64                     hana::concat(a, hana::empty<M>()),
  65                     a
  66                 ));
  67
  68                 // absorption
  69                 auto f = hana::compose(lift<M>, test::_injection<0>{});
  70                 BOOST_HANA_CHECK(hana::equal(
  71                     hana::chain(hana::empty<M>(), f),
  72                     hana::empty<M>()
  73                 ));
  74
  75                 BOOST_HANA_CHECK(hana::equal(
  76                     hana::chain(a, hana::always(hana::empty<M>())),
  77                     hana::empty<M>()
  78                 ));
  79
  80             });
  81
  82             // associativity
  83             foreach3(xs, [](auto a, auto b, auto c) {
  84                 BOOST_HANA_CHECK(hana::equal(
  85                     hana::concat(a, hana::concat(b, c)),
  86                     hana::concat(hana::concat(a, b), c)
  87                 ));
  88             });
  89
  90             // Default method definitions
  91             hana::for_each(xs, hana::capture(predicates, values)(
  92             [](auto predicates, auto values, auto x) {
  93
  94                 // remove_if(x, pred) == filter(x, negated pred)
  95                 hana::for_each(predicates, hana::capture(x)([](auto x, auto pred) {
  96                     BOOST_HANA_CHECK(hana::equal(
  97                         hana::remove_if(x, pred),
  98                         hana::filter(x, hana::compose(hana::not_, pred))
  99                     ));
 100                 }));
 101
 102                 // remove(x, value) == remove_if(x, equal.to(value))
 103                 hana::for_each(values, hana::capture(x)([](auto x, auto value) {
 104                     BOOST_HANA_CHECK(hana::equal(
 105                         hana::remove(x, value),
 106                         hana::remove_if(x, hana::equal.to(value))
 107                     ));
 108                 }));
 109             }));
 110         }
 111     };
 112
 113     template <typename S>
 114     struct TestMonadPlus<S, when<Sequence<S>::value>>
 115         : TestMonadPlus<S, laws>
 116     {
 117         template <int i>
 118         using eq = test::ct_eq<i>;
 119
 120         struct undefined { };
 121
 122         template <typename Xs, typename Predicates, typename Values>
 123         TestMonadPlus(Xs xs, Predicates predicates, Values values)
 124             : TestMonadPlus<S, laws>{xs, predicates, values}
 125         {
 126             auto z = eq<999>{};
 127             constexpr auto list = make<S>;
 128
 129             //////////////////////////////////////////////////////////////////
 130             // empty
 131             //////////////////////////////////////////////////////////////////
 132             BOOST_HANA_CONSTANT_CHECK(equal(
 133                 hana::empty<S>(), list()
 134             ));
 135
 136             //////////////////////////////////////////////////////////////////
 137             // concat
 138             //////////////////////////////////////////////////////////////////
 139             BOOST_HANA_CONSTANT_CHECK(equal(
 140                 concat(list(), list()),
 141                 list()
 142             ));
 143             BOOST_HANA_CONSTANT_CHECK(equal(
 144                 concat(list(), list(eq<0>{})),
 145                 list(eq<0>{})
 146             ));
 147             BOOST_HANA_CONSTANT_CHECK(equal(
 148                 concat(list(), list(eq<0>{}, eq<1>{})),
 149                 list(eq<0>{}, eq<1>{})
 150             ));
 151
 152             BOOST_HANA_CONSTANT_CHECK(equal(
 153                 concat(list(eq<0>{}), list()),
 154                 list(eq<0>{})
 155             ));
 156             BOOST_HANA_CONSTANT_CHECK(equal(
 157                 concat(list(eq<0>{}), list(eq<1>{})),
 158                 list(eq<0>{}, eq<1>{})
 159             ));
 160             BOOST_HANA_CONSTANT_CHECK(equal(
 161                 concat(list(eq<0>{}), list(eq<1>{}, eq<2>{})),
 162                 list(eq<0>{}, eq<1>{}, eq<2>{})
 163             ));
 164
 165             BOOST_HANA_CONSTANT_CHECK(equal(
 166                 concat(list(eq<0>{}, eq<1>{}), list()),
 167                 list(eq<0>{}, eq<1>{})
 168             ));
 169             BOOST_HANA_CONSTANT_CHECK(equal(
 170                 concat(list(eq<0>{}, eq<1>{}), list(eq<2>{})),
 171                 list(eq<0>{}, eq<1>{}, eq<2>{})
 172             ));
 173             BOOST_HANA_CONSTANT_CHECK(equal(
 174                 concat(list(eq<0>{}, eq<1>{}), list(eq<2>{}, eq<3>{})),
 175                 list(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{})
 176             ));
 177
 178
 179             BOOST_HANA_CONSTANT_CHECK(equal(
 180                 concat(list(), list()),
 181                 list()
 182             ));
 183             BOOST_HANA_CONSTEXPR_CHECK(equal(
 184                 concat(list(1), list()),
 185                 list(1)
 186             ));
 187             BOOST_HANA_CONSTEXPR_CHECK(equal(
 188                 concat(list(), list(1)),
 189                 list(1)
 190             ));
 191             BOOST_HANA_CONSTEXPR_CHECK(equal(
 192                 concat(list(1), list('2')),
 193                 list(1, '2')
 194             ));
 195             BOOST_HANA_CONSTEXPR_CHECK(equal(
 196                 concat(list(1, '2'), list(3.3)),
 197                 list(1, '2', 3.3)
 198             ));
 199
 200
 201             //////////////////////////////////////////////////////////////////
 202             // filter
 203             //////////////////////////////////////////////////////////////////
 204             BOOST_HANA_CONSTANT_CHECK(equal(
 205                 filter(list(), undefined{}),
 206                 list()
 207             ));
 208
 209             BOOST_HANA_CONSTANT_CHECK(equal(
 210                 filter(list(z), not_equal.to(z)),
 211                 list()
 212             ));
 213             BOOST_HANA_CONSTANT_CHECK(equal(
 214                 filter(list(eq<1>{}), not_equal.to(z)),
 215                 list(eq<1>{})
 216             ));
 217
 218             BOOST_HANA_CONSTANT_CHECK(equal(
 219                 filter(list(eq<1>{}, eq<2>{}), not_equal.to(z)),
 220                 list(eq<1>{}, eq<2>{})
 221             ));
 222             BOOST_HANA_CONSTANT_CHECK(equal(
 223                 filter(list(z, eq<2>{}), not_equal.to(z)),
 224                 list(eq<2>{})
 225             ));
 226             BOOST_HANA_CONSTANT_CHECK(equal(
 227                 filter(list(eq<1>{}, z), not_equal.to(z)),
 228                 list(eq<1>{})
 229             ));
 230
 231             BOOST_HANA_CONSTANT_CHECK(equal(
 232                 filter(list(z, eq<2>{}, eq<3>{}), not_equal.to(z)),
 233                 list(eq<2>{}, eq<3>{})
 234             ));
 235             BOOST_HANA_CONSTANT_CHECK(equal(
 236                 filter(list(eq<1>{}, z, eq<3>{}), not_equal.to(z)),
 237                 list(eq<1>{}, eq<3>{})
 238             ));
 239             BOOST_HANA_CONSTANT_CHECK(equal(
 240                 filter(list(eq<1>{}, eq<2>{}, z), not_equal.to(z)),
 241                 list(eq<1>{}, eq<2>{})
 242             ));
 243             BOOST_HANA_CONSTANT_CHECK(equal(
 244                 filter(list(eq<1>{}, z, z), not_equal.to(z)),
 245                 list(eq<1>{})
 246             ));
 247             BOOST_HANA_CONSTANT_CHECK(equal(
 248                 filter(list(z, eq<2>{}, z), not_equal.to(z)),
 249                 list(eq<2>{})
 250             ));
 251             BOOST_HANA_CONSTANT_CHECK(equal(
 252                 filter(list(z, z, eq<3>{}), not_equal.to(z)),
 253                 list(eq<3>{})
 254             ));
 255
 256             BOOST_HANA_CONSTANT_CHECK(equal(
 257                 filter(list(eq<1>{}, eq<2>{}, eq<3>{}, eq<4>{}, z), not_equal.to(z)),
 258                 list(eq<1>{}, eq<2>{}, eq<3>{}, eq<4>{})
 259             ));
 260
 261             //////////////////////////////////////////////////////////////////
 262             // prepend
 263             //////////////////////////////////////////////////////////////////
 264             BOOST_HANA_CONSTANT_CHECK(equal(
 265                 prepend(list(), eq<0>{}),
 266                 list(eq<0>{})
 267             ));
 268             BOOST_HANA_CONSTANT_CHECK(equal(
 269                 prepend(list(eq<1>{}), eq<0>{}),
 270                 list(eq<0>{}, eq<1>{})
 271             ));
 272             BOOST_HANA_CONSTANT_CHECK(equal(
 273                 prepend(list(eq<1>{}, eq<2>{}), eq<0>{}),
 274                 list(eq<0>{}, eq<1>{}, eq<2>{})
 275             ));
 276             BOOST_HANA_CONSTANT_CHECK(equal(
 277                 prepend(list(eq<1>{}, eq<2>{}, eq<3>{}), eq<0>{}),
 278                 list(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{})
 279             ));
 280
 281
 282             BOOST_HANA_CONSTEXPR_CHECK(equal(
 283                 prepend(list(), 1),
 284                 list(1)
 285             ));
 286             BOOST_HANA_CONSTEXPR_CHECK(equal(
 287                 prepend(list('2'), 1),
 288                 list(1, '2')
 289             ));
 290             BOOST_HANA_CONSTEXPR_CHECK(equal(
 291                 prepend(list('2', 3.3), 1),
 292                 list(1, '2', 3.3)
 293             ));
 294
 295             //////////////////////////////////////////////////////////////////
 296             // append
 297             //////////////////////////////////////////////////////////////////
 298             BOOST_HANA_CONSTANT_CHECK(equal(
 299                 append(list(), eq<0>{}),
 300                 list(eq<0>{})
 301             ));
 302             BOOST_HANA_CONSTANT_CHECK(equal(
 303                 append(list(eq<0>{}), eq<1>{}),
 304                 list(eq<0>{}, eq<1>{})
 305             ));
 306             BOOST_HANA_CONSTANT_CHECK(equal(
 307                 append(list(eq<0>{}, eq<1>{}), eq<2>{}),
 308                 list(eq<0>{}, eq<1>{}, eq<2>{})
 309             ));
 310
 311             BOOST_HANA_CONSTEXPR_CHECK(equal(
 312                 append(list(), 1), list(1)
 313             ));
 314             BOOST_HANA_CONSTEXPR_CHECK(equal(
 315                 append(list(1), '2'), list(1, '2')
 316             ));
 317             BOOST_HANA_CONSTEXPR_CHECK(equal(
 318                 append(list(1, '2'), 3.3), list(1, '2', 3.3)
 319             ));
 320
 321
 322             //////////////////////////////////////////////////////////////////
 323             // cycle
 324             //////////////////////////////////////////////////////////////////
 325             BOOST_HANA_CONSTANT_CHECK(equal(
 326                 cycle(list(), size_c<0>),
 327                 list()
 328             ));
 329             BOOST_HANA_CONSTANT_CHECK(equal(
 330                 cycle(list(), size_c<1>),
 331                 list()
 332             ));
 333             BOOST_HANA_CONSTANT_CHECK(equal(
 334                 cycle(list(), size_c<2>),
 335                 list()
 336             ));
 337             BOOST_HANA_CONSTANT_CHECK(equal(
 338                 cycle(list(), size_c<3>),
 339                 list()
 340             ));
 341
 342
 343             BOOST_HANA_CONSTANT_CHECK(equal(
 344                 cycle(list(eq<0>{}), size_c<0>),
 345                 list()
 346             ));
 347             BOOST_HANA_CONSTANT_CHECK(equal(
 348                 cycle(list(eq<0>{}), size_c<1>),
 349                 list(eq<0>{})
 350             ));
 351             BOOST_HANA_CONSTANT_CHECK(equal(
 352                 cycle(list(eq<0>{}), size_c<2>),
 353                 list(eq<0>{}, eq<0>{})
 354             ));
 355             BOOST_HANA_CONSTANT_CHECK(equal(
 356                 cycle(list(eq<0>{}), size_c<3>),
 357                 list(eq<0>{}, eq<0>{}, eq<0>{})
 358             ));
 359
 360
 361             BOOST_HANA_CONSTANT_CHECK(equal(
 362                 cycle(list(eq<0>{}, eq<1>{}), size_c<0>),
 363                 list()
 364             ));
 365             BOOST_HANA_CONSTANT_CHECK(equal(
 366                 cycle(list(eq<0>{}, eq<1>{}), size_c<1>),
 367                 list(eq<0>{}, eq<1>{})
 368             ));
 369             BOOST_HANA_CONSTANT_CHECK(equal(
 370                 cycle(list(eq<0>{}, eq<1>{}), size_c<2>),
 371                 list(eq<0>{}, eq<1>{}, eq<0>{}, eq<1>{})
 372             ));
 373             BOOST_HANA_CONSTANT_CHECK(equal(
 374                 cycle(list(eq<0>{}, eq<1>{}), size_c<3>),
 375                 list(eq<0>{}, eq<1>{}, eq<0>{}, eq<1>{}, eq<0>{}, eq<1>{})
 376             ));
 377
 378
 379             BOOST_HANA_CONSTANT_CHECK(equal(
 380                 cycle(list(eq<0>{}, eq<1>{}, eq<2>{}), size_c<0>),
 381                 list()
 382             ));
 383             BOOST_HANA_CONSTANT_CHECK(equal(
 384                 cycle(list(eq<0>{}, eq<1>{}, eq<2>{}), size_c<1>),
 385                 list(eq<0>{}, eq<1>{}, eq<2>{})
 386             ));
 387             BOOST_HANA_CONSTANT_CHECK(equal(
 388                 cycle(list(eq<0>{}, eq<1>{}, eq<2>{}), size_c<2>),
 389                 list(eq<0>{}, eq<1>{}, eq<2>{}, eq<0>{}, eq<1>{}, eq<2>{})
 390             ));
 391             BOOST_HANA_CONSTANT_CHECK(equal(
 392                 cycle(list(eq<0>{}, eq<1>{}, eq<2>{}), size_c<3>),
 393                 list(eq<0>{}, eq<1>{}, eq<2>{}, eq<0>{}, eq<1>{}, eq<2>{}, eq<0>{}, eq<1>{}, eq<2>{})
 394             ));
 395
 396             //////////////////////////////////////////////////////////////////
 397             // remove_if
 398             //////////////////////////////////////////////////////////////////
 399             BOOST_HANA_CONSTANT_CHECK(equal(
 400                 remove_if(list(), undefined{}),
 401                 list()
 402             ));
 403
 404             BOOST_HANA_CONSTANT_CHECK(equal(
 405                 remove_if(list(eq<0>{}), equal.to(z)),
 406                 list(eq<0>{})
 407             ));
 408             BOOST_HANA_CONSTANT_CHECK(equal(
 409                 remove_if(list(z), equal.to(z)),
 410                 list()
 411             ));
 412
 413             BOOST_HANA_CONSTANT_CHECK(equal(
 414                 remove_if(list(eq<0>{}, eq<1>{}), equal.to(z)),
 415                 list(eq<0>{}, eq<1>{})
 416             ));
 417             BOOST_HANA_CONSTANT_CHECK(equal(
 418                 remove_if(list(z, eq<1>{}), equal.to(z)),
 419                 list(eq<1>{})
 420             ));
 421             BOOST_HANA_CONSTANT_CHECK(equal(
 422                 remove_if(list(eq<0>{}, z), equal.to(z)),
 423                 list(eq<0>{})
 424             ));
 425             BOOST_HANA_CONSTANT_CHECK(equal(
 426                 remove_if(list(z, z), equal.to(z)),
 427                 list()
 428             ));
 429
 430             BOOST_HANA_CONSTANT_CHECK(equal(
 431                 remove_if(list(eq<0>{}, eq<1>{}, eq<2>{}), equal.to(z)),
 432                 list(eq<0>{}, eq<1>{}, eq<2>{})
 433             ));
 434             BOOST_HANA_CONSTANT_CHECK(equal(
 435                 remove_if(list(eq<0>{}, eq<1>{}, z), equal.to(z)),
 436                 list(eq<0>{}, eq<1>{})
 437             ));
 438             BOOST_HANA_CONSTANT_CHECK(equal(
 439                 remove_if(list(eq<0>{}, z, eq<2>{}), equal.to(z)),
 440                 list(eq<0>{}, eq<2>{})
 441             ));
 442             BOOST_HANA_CONSTANT_CHECK(equal(
 443                 remove_if(list(z, eq<1>{}, eq<2>{}), equal.to(z)),
 444                 list(eq<1>{}, eq<2>{})
 445             ));
 446             BOOST_HANA_CONSTANT_CHECK(equal(
 447                 remove_if(list(z, z, eq<2>{}), equal.to(z)),
 448                 list(eq<2>{})
 449             ));
 450             BOOST_HANA_CONSTANT_CHECK(equal(
 451                 remove_if(list(eq<0>{}, z, z), equal.to(z)),
 452                 list(eq<0>{})
 453             ));
 454             BOOST_HANA_CONSTANT_CHECK(equal(
 455                 remove_if(list(z, z, z), equal.to(z)),
 456                 list()
 457             ));
 458
 459             //////////////////////////////////////////////////////////////////
 460             // remove
 461             //////////////////////////////////////////////////////////////////
 462             BOOST_HANA_CONSTANT_CHECK(equal(
 463                 hana::remove(list(), undefined{}),
 464                 list()
 465             ));
 466
 467             BOOST_HANA_CONSTANT_CHECK(equal(
 468                 hana::remove(list(eq<0>{}), z),
 469                 list(eq<0>{})
 470             ));
 471             BOOST_HANA_CONSTANT_CHECK(equal(
 472                 hana::remove(list(z), z),
 473                 list()
 474             ));
 475
 476             BOOST_HANA_CONSTANT_CHECK(equal(
 477                 hana::remove(list(eq<0>{}, eq<1>{}), z),
 478                 list(eq<0>{}, eq<1>{})
 479             ));
 480             BOOST_HANA_CONSTANT_CHECK(equal(
 481                 hana::remove(list(z, eq<1>{}), z),
 482                 list(eq<1>{})
 483             ));
 484             BOOST_HANA_CONSTANT_CHECK(equal(
 485                 hana::remove(list(eq<0>{}, z), z),
 486                 list(eq<0>{})
 487             ));
 488             BOOST_HANA_CONSTANT_CHECK(equal(
 489                 hana::remove(list(z, z), z),
 490                 list()
 491             ));
 492
 493             BOOST_HANA_CONSTANT_CHECK(equal(
 494                 hana::remove(list(eq<0>{}, eq<1>{}, eq<2>{}), z),
 495                 list(eq<0>{}, eq<1>{}, eq<2>{})
 496             ));
 497             BOOST_HANA_CONSTANT_CHECK(equal(
 498                 hana::remove(list(eq<0>{}, eq<1>{}, z), z),
 499                 list(eq<0>{}, eq<1>{})
 500             ));
 501             BOOST_HANA_CONSTANT_CHECK(equal(
 502                 hana::remove(list(eq<0>{}, z, eq<2>{}), z),
 503                 list(eq<0>{}, eq<2>{})
 504             ));
 505             BOOST_HANA_CONSTANT_CHECK(equal(
 506                 hana::remove(list(z, eq<1>{}, eq<2>{}), z),
 507                 list(eq<1>{}, eq<2>{})
 508             ));
 509             BOOST_HANA_CONSTANT_CHECK(equal(
 510                 hana::remove(list(z, z, eq<2>{}), z),
 511                 list(eq<2>{})
 512             ));
 513             BOOST_HANA_CONSTANT_CHECK(equal(
 514                 hana::remove(list(eq<0>{}, z, z), z),
 515                 list(eq<0>{})
 516             ));
 517             BOOST_HANA_CONSTANT_CHECK(equal(
 518                 hana::remove(list(z, z, z), z),
 519                 list()
 520             ));
 521
 522             //////////////////////////////////////////////////////////////////
 523             // replicate
 524             //////////////////////////////////////////////////////////////////
 525             BOOST_HANA_CONSTANT_CHECK(equal(
 526                 replicate<S>(eq<0>{}, size_c<0>),
 527                 list()
 528             ));
 529
 530             BOOST_HANA_CONSTANT_CHECK(equal(
 531                 replicate<S>(eq<0>{}, size_c<1>),
 532                 list(eq<0>{})
 533             ));
 534
 535             BOOST_HANA_CONSTANT_CHECK(equal(
 536                 replicate<S>(eq<0>{}, size_c<2>),
 537                 list(eq<0>{}, eq<0>{})
 538             ));
 539
 540             BOOST_HANA_CONSTANT_CHECK(equal(
 541                 replicate<S>(eq<0>{}, size_c<3>),
 542                 list(eq<0>{}, eq<0>{}, eq<0>{})
 543             ));
 544
 545             BOOST_HANA_CONSTANT_CHECK(equal(
 546                 replicate<S>(eq<0>{}, size_c<4>),
 547                 list(eq<0>{}, eq<0>{}, eq<0>{}, eq<0>{})
 548             ));
 549
 550             BOOST_HANA_CONSTANT_CHECK(equal(
 551                 replicate<S>(eq<0>{}, size_c<5>),
 552                 list(eq<0>{}, eq<0>{}, eq<0>{}, eq<0>{}, eq<0>{})
 553             ));
 554
 555
 556             //////////////////////////////////////////////////////////////////
 557             // prefix
 558             //////////////////////////////////////////////////////////////////
 559             BOOST_HANA_CONSTANT_CHECK(equal(
 560                 prefix(list(), z),
 561                 list()
 562             ));
 563
 564             BOOST_HANA_CONSTANT_CHECK(equal(
 565                 prefix(list(eq<0>{}), z),
 566                 list(z, eq<0>{})
 567             ));
 568
 569             BOOST_HANA_CONSTANT_CHECK(equal(
 570                 prefix(list(eq<0>{}, eq<1>{}), z),
 571                 list(z, eq<0>{}, z, eq<1>{})
 572             ));
 573
 574             BOOST_HANA_CONSTANT_CHECK(equal(
 575                 prefix(list(eq<0>{}, eq<1>{}, eq<2>{}), z),
 576                 list(z, eq<0>{}, z, eq<1>{}, z, eq<2>{})
 577             ));
 578
 579             BOOST_HANA_CONSTANT_CHECK(equal(
 580                 prefix(list(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{}), z),
 581                 list(z, eq<0>{}, z, eq<1>{}, z, eq<2>{}, z, eq<3>{})
 582             ));
 583
 584
 585             //////////////////////////////////////////////////////////////////
 586             // suffix
 587             //////////////////////////////////////////////////////////////////
 588             BOOST_HANA_CONSTANT_CHECK(equal(
 589                 suffix(list(), z),
 590                 list()
 591             ));
 592
 593             BOOST_HANA_CONSTANT_CHECK(equal(
 594                 suffix(list(eq<0>{}), z),
 595                 list(eq<0>{}, z)
 596             ));
 597
 598             BOOST_HANA_CONSTANT_CHECK(equal(
 599                 suffix(list(eq<0>{}, eq<1>{}), z),
 600                 list(eq<0>{}, z, eq<1>{}, z)
 601             ));
 602
 603             BOOST_HANA_CONSTANT_CHECK(equal(
 604                 suffix(list(eq<0>{}, eq<1>{}, eq<2>{}), z),
 605                 list(eq<0>{}, z, eq<1>{}, z, eq<2>{}, z)
 606             ));
 607
 608             BOOST_HANA_CONSTANT_CHECK(equal(
 609                 suffix(list(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{}), z),
 610                 list(eq<0>{}, z, eq<1>{}, z, eq<2>{}, z, eq<3>{}, z)
 611             ));
 612         }
 613     };
 614 }}} // end namespace boost::hana::test
 615
 616 #endif // !BOOST_HANA_TEST_LAWS_MONAD_PLUS_HPP