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