ceph/src/boost/libs/fusion/doc/algorithm.qbk

   1 [/==============================================================================
   2     Copyright (C) 2001-2011 Joel de Guzman
   3     Copyright (C) 2006 Dan Marsden
   4     Copyright (C) 2010 Christopher Schmidt
   5
   6     Use, modification and distribution is subject to the Boost Software
   7     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   8     http://www.boost.org/LICENSE_1_0.txt)
   9 ===============================================================================/]
  10 [section Algorithm]
  11
  12 [heading Lazy Evaluation]
  13
  14 Unlike __mpl__, Fusion algorithms are lazy[footnote Except for some
  15 special cases such as __for_each__ and __copy__ which are inherently
  16 imperative algorithms.] and non sequence-type preserving [footnote What
  17 does that mean? It means that when you operate on a sequence through a
  18 Fusion algorithm that returns a sequence, the sequence returned may not
  19 be of the same class as the original]. This is by design. Runtime
  20 efficiency is given a high priority. Like __mpl__, and unlike __stl__,
  21 fusion algorithms are mostly functional in nature such that algorithms
  22 are non mutating (no side effects). However, due to the high cost of
  23 returning full sequences such as vectors and lists, /Views/ are returned
  24 from Fusion algorithms instead. For example, the __transform__ algorithm
  25 does not actually return a transformed version of the original sequence.
  26 __transform__ returns a __transform_view__. This view holds a reference
  27 to the original sequence plus the transform function. Iteration over the
  28 __transform_view__ will apply the transform function over the sequence
  29 elements on demand. This /lazy/ evaluation scheme allows us to chain as
  30 many algorithms as we want without incurring a high runtime penalty.
  31
  32 [heading Sequence Extension]
  33
  34 The /lazy/ evaluation scheme where __algorithms__ return __views__ also
  35 allows operations such as __push_back__ to be totally generic. In Fusion,
  36 __push_back__ is actually a generic algorithm that works on all sequences.
  37 Given an input sequence `s` and a value `x`, Fusion's __push_back__
  38 algorithm simply returns a __joint_view__: a view that holds a reference to
  39 the original sequence `s` and the value `x`. Functions that were once
  40 sequence specific and need to be implemented N times over N different
  41 sequences are now implemented only once. That is to say that Fusion
  42 sequences are cheaply extensible.
  43
  44 To regain the original sequence, __conversion__ functions are provided. You
  45 may use one of the __conversion__ functions to convert back to the original
  46 sequence type.
  47
  48 [heading Header]
  49
  50     #include <boost/fusion/algorithm.hpp>
  51     #include <boost/fusion/include/algorithm.hpp>
  52
  53 [section Auxiliary]
  54
  55 The auxiliary algorithms provide the utility algorithms for sequences.
  56
  57 [heading Header]
  58
  59     #include <boost/fusion/algorithm/auxiliary.hpp>
  60     #include <boost/fusion/include/auxiliary.hpp>
  61
  62 [section Functions]
  63
  64 [section copy]
  65
  66 [heading Description]
  67 Copy a sequence `src` to a sequence `dest`.
  68 It is also used to convert sequence into other.
  69
  70 [heading Synopsis]
  71     template <typename Seq1, typename Seq2>
  72     typename __result_of_copy__<Seq1, Seq2>::type copy(Seq1 const& src, Seq2& dest);
  73
  74 [table Parameters
  75     [[Parameter][Requirement][Description]]
  76     [[`src`][A model of __forward_sequence__, all elements contained in the `src` sequence should be convertible into the element contained in the `dest` sequence.][Operation's argument]]
  77     [[`dest`][A model of __forward_sequence__, `e2 = e1` is valid expression for each pair of elements `e1` of `src` and `e2` of `dest`.][Operation's argument]]
  78 ]
  79
  80 [heading Expression Semantics]
  81     __copy__(src, dest);
  82
  83 [*Return type]: `void`
  84
  85 [*Semantics]: `e2 = e1` for each element `e1` in `src` and `e2` in `dest`.
  86
  87 [heading Complexity]
  88 Linear, exactly `__result_of_size__<Sequence>::value`.
  89
  90 [heading Header]
  91
  92     #include <boost/fusion/algorithm/auxiliary/copy.hpp>
  93     #include <boost/fusion/include/copy.hpp>
  94
  95 [heading Example]
  96     __vector__<int,int> vec(1,2);
  97     __list__<int,int> ls;
  98     __copy__(vec, ls);
  99     assert(ls == __make_list__(1,2));
 100
 101 [endsect]
 102
 103 [section move]
 104
 105 [heading Description]
 106 move a sequence `src` to a sequence `dest`.
 107 It is also used to convert sequence into other.
 108
 109 [heading Synopsis]
 110     template <typename Seq1, typename Seq2>
 111     typename __result_of_move__<Seq1, Seq2>::type move(Seq1&& src, Seq2& dest);
 112
 113 [table Parameters
 114     [[Parameter][Requirement][Description]]
 115     [[`src`][A model of __forward_sequence__, all elements contained in the `src` sequence should be convertible into the element contained in the `dest` sequence.][Operation's argument]]
 116     [[`dest`][A model of __forward_sequence__, `e2 = std::move(e1)` is valid expression for each pair of elements `e1` of `src` and `e2` of `dest`.][Operation's argument]]
 117 ]
 118
 119 [heading Expression Semantics]
 120     __move__(src, dest);
 121
 122 [*Return type]: `void`
 123
 124 [*Semantics]: `e2 = std::move(e1)` for each element `e1` in `src` and `e2` in `dest`.
 125
 126 [heading Complexity]
 127 Linear, exactly `__result_of_size__<Sequence>::value`.
 128
 129 [heading Header]
 130
 131     #include <boost/fusion/algorithm/auxiliary/move.hpp>
 132     #include <boost/fusion/include/move.hpp>
 133
 134 [heading Example]
 135     __vector__<int,int> vec(1,2);
 136     __list__<int,int> ls;
 137     __move__(std::move(vec), ls);
 138     assert(ls == __make_list__(1,2));
 139
 140 [endsect]
 141
 142 [endsect]
 143
 144 [section Metafunctions]
 145
 146 [section copy]
 147
 148 [heading Description]
 149 A metafunction returning the result type of applying __copy__, which is always `void`.
 150
 151 [heading Synopsis]
 152     template <typename Seq1, typename Seq2>
 153     struct copy
 154     {
 155         typedef void type;
 156     };
 157
 158 [table Parameters
 159     [[Parameter] [Requirement] [Description]]
 160     [[`Seq1`] [A model of __forward_sequence__] [Operation's argument]]
 161     [[`Seq2`] [A model of __forward_sequence__] [Operation's argument]]
 162 ]
 163
 164 [heading Expression Semantics]
 165     result_of::copy<Seq1, Seq2>::type
 166
 167 [*Return type]: `void` iff both of `Seq1` and `Seq2` are sequence.
 168 Otherwise, none.
 169
 170 [*Semantics]: Returns the return type of __copy__ for 2 sequences of types `Seq1` and `Seq2`.
 171
 172 [heading Complexity]
 173 Constant.
 174
 175 [heading Header]
 176
 177     #include <boost/fusion/algorithm/auxiliary/copy.hpp>
 178     #include <boost/fusion/include/copy.hpp>
 179
 180 [endsect]
 181
 182 [section move]
 183
 184 [heading Description]
 185 A metafunction returning the result type of applying __move__, which is always `void`.
 186
 187 [heading Synopsis]
 188     template <typename Seq1, typename Seq2>
 189     struct move
 190     {
 191         typedef void type;
 192     };
 193
 194 [table Parameters
 195     [[Parameter] [Requirement] [Description]]
 196     [[`Seq1`] [A model of __forward_sequence__] [Operation's argument]]
 197     [[`Seq2`] [A model of __forward_sequence__] [Operation's argument]]
 198 ]
 199
 200 [heading Expression Semantics]
 201     result_of::move<Seq1, Seq2>::type
 202
 203 [*Return type]: `void` iff both of `Seq1` and `Seq2` are sequence.
 204 Otherwise, none.
 205
 206 [*Semantics]: Returns the return type of __move__ for 2 sequences of types `Seq1` and `Seq2`.
 207
 208 [heading Complexity]
 209 Constant.
 210
 211 [heading Header]
 212
 213     #include <boost/fusion/algorithm/auxiliary/move.hpp>
 214     #include <boost/fusion/include/move.hpp>
 215
 216 [endsect]
 217
 218 [endsect]
 219
 220 [endsect]
 221
 222
 223 [section Iteration]
 224
 225 The iteration algorithms provide the fundamental algorithms for traversing
 226 a sequence repeatedly applying an operation to its elements.
 227
 228 [heading Header]
 229
 230     #include <boost/fusion/algorithm/iteration.hpp>
 231     #include <boost/fusion/include/iteration.hpp>
 232
 233 [section Functions]
 234
 235 [template fold_desc[name result_of_name arg_desc seq_concept arg_id arg_type_id invoke_desc semantics_elements_desc example_arg_transform example_result I0 I1 IN]
 236 [heading Description]
 237 For a sequence `seq`, initial state `initial_state`, and binary function object
 238 or function pointer `f`, [^[name]] returns the result of the repeated application of
 239 binary `f` to the result of the previous `f` invocation (`inital_state` if it is
 240 the first call) and [arg_desc] of `seq`.
 241
 242 [def name_macro [name]]
 243 [def result_of_name_macro [result_of_name]]
 244 [heading Synopsis]
 245     template<
 246         typename Sequence,
 247         typename State,
 248         typename F
 249         >
 250     typename result_of_name_macro<Sequence, State const, F>::type name_macro(
 251         Sequence& seq, State const& initial_state, F f);
 252
 253     template<
 254         typename Sequence,
 255         typename State,
 256         typename F
 257         >
 258     typename result_of_name_macro<Sequence const, State const, F>::type name_macro(
 259         Sequence const& seq, State const& initial_state, F f);
 260
 261     template<
 262         typename Sequence,
 263         typename State,
 264         typename F
 265         >
 266     typename result_of_name_macro<Sequence, State, F>::type name_macro(
 267         Sequence& seq, State& initial_state, F f);
 268
 269     template<
 270         typename Sequence,
 271         typename State,
 272         typename F
 273         >
 274     typename result_of_name_macro<Sequence const, State, F>::type name_macro(
 275         Sequence const& seq, State& initial_state, F f);
 276
 277 [def seq_concept_macro [seq_concept]]
 278 [def arg_type_id_macro [arg_type_id]]
 279 [def arg_id_macro [arg_id]]
 280 [def invoke_desc_macro [invoke_desc]]
 281 [table Parameters
 282     [[Parameter][Requirement][Description]]
 283     [[`seq`][A model of seq_concept_macro][Operation's argument]]
 284     [[`initial_state`][Any type][Initial state]]
 285     [[`f`][`f(s,arg_id_macro)` with return type `__boost_result_of_call__<F(S,arg_type_id_macro)>::type` for current state `s` of type `S`, and for each invoke_desc_macro][Operation's argument]]
 286 ]
 287
 288 [heading Expression Semantics]
 289     name_macro(seq, initial_state, f);
 290
 291 [*Return type]: Any type
 292
 293 [*Semantics]: Equivalent to [^f(... f(f(initial_state,[arg_id][I0]),[arg_id][I1]) ...[arg_id][IN])] where [^[arg_id]1 ...[arg_id]N] are [semantics_elements_desc].
 294
 295 [heading Complexity]
 296 Linear, exactly `__result_of_size__<Sequence>::value` applications of `f`.
 297
 298 [heading Header]
 299
 300     #include <boost/fusion/algorithm/iteration/name_macro.hpp>
 301     #include <boost/fusion/include/name_macro.hpp>
 302
 303 [def example_result_macro [example_result]]
 304 [def example_arg_transform_macro [example_arg_transform]]
 305 [heading Example]
 306     struct make_string
 307     {
 308         typedef std::string result_type;
 309
 310         template<typename T>
 311         std::string operator()(const std::string& str, const T& t) const
 312         {
 313             return str + boost::lexical_cast<std::string>(example_arg_transform_macro);
 314         }
 315     };
 316     ...
 317     const __vector__<int,int> vec(1,2);
 318     assert(name_macro(vec,std::string(""), make_string()) == example_result_macro);
 319 ]
 320
 321 [section fold]
 322 [fold_desc fold..__result_of_fold__..each element..__forward_sequence__..e..E..element `e` of type `E` in `seq`..the consecutive elements of `seq`..t.."12"..1..2..N]
 323 [endsect]
 324
 325 [section reverse_fold]
 326 [fold_desc reverse_fold..__result_of_reverse_fold__..each element..__bidirectional_sequence__..e..E..element `e` of type `E` in `seq`..the consecutive elements of `seq`..t.."21"..N..N-1..1]
 327 [endsect]
 328
 329 [section iter_fold]
 330 [fold_desc iter_fold..__result_of_iter_fold__..iterators on each element..__forward_sequence__..it..It..iterator `it` of type `It` on an element of `seq`..consecutive iterators on the elements of `seq`..__deref__(t).."12"..1..2..N]
 331 [endsect]
 332
 333 [section reverse_iter_fold]
 334 [fold_desc reverse_iter_fold..__result_of_reverse_iter_fold__..iterators on each element..__bidirectional_sequence__..it..It..iterator `it` of type `It` on an element of `seq`..consecutive iterators on the elements of `seq`..__deref__(t).."21"..N..N-1..1]
 335 [endsect]
 336
 337 [section accumulate]
 338 [fold_desc accumulate..__result_of_accumulate__..each element..__forward_sequence__..e..E..element `e` of type `E` in `seq`..the consecutive elements of `seq`..t.."12"..1..2..N]
 339 [endsect]
 340
 341 [section for_each]
 342
 343 [heading Description]
 344 Applies a unary function object to each element of a sequence.
 345
 346 [heading Synopsis]
 347     template<
 348         typename Sequence,
 349         typename F
 350         >
 351     typename __result_of_for_each__<Sequence, F>::type for_each(
 352         Sequence& seq, F f);
 353
 354 [table Parameters
 355     [[Parameter][Requirement][Description]]
 356     [[`seq`][A model of __forward_sequence__, `f(e)` must be a valid expression for each element `e` in `seq`][Operation's argument]]
 357     [[`f`][A unary __reg_callable_obj__][Operation's argument]]
 358 ]
 359
 360 [heading Expression Semantics]
 361     __for_each__(seq, f);
 362
 363 [*Return type]: `void`
 364
 365 [*Semantics]: Calls `f(e)` for each element `e` in `seq`.
 366
 367 [heading Complexity]
 368 Linear, exactly `__result_of_size__<Sequence>::value` applications of `f`.
 369
 370 [heading Header]
 371
 372     #include <boost/fusion/algorithm/iteration/for_each.hpp>
 373     #include <boost/fusion/include/for_each.hpp>
 374
 375 [heading Example]
 376     struct increment
 377     {
 378         template<typename T>
 379         void operator()(T& t) const
 380         {
 381             ++t;
 382         }
 383     };
 384     ...
 385     __vector__<int,int> vec(1,2);
 386     __for_each__(vec, increment());
 387     assert(vec == __make_vector__(2,3));
 388
 389 [endsect]
 390
 391 [endsect]
 392
 393 [section Metafunctions]
 394
 395 [template meta_fold_desc[name name_func seq_concept arg_id arg_type_id invoke_meta_desc]
 396 [heading Description]
 397 Returns the result type of [name_func].
 398
 399 [def name_macro [name]]
 400 [heading Synopsis]
 401     template<
 402         typename Sequence,
 403         typename State,
 404         typename F>
 405     struct name_macro
 406     {
 407         typedef __unspecified__ type;
 408     };
 409
 410 [def seq_concept_macro [seq_concept]]
 411 [def arg_type_id_macro [arg_type_id]]
 412 [def arg_id_macro [arg_id]]
 413 [def invoke_meta_desc_macro [invoke_meta_desc]]
 414 [table Parameters
 415     [[Parameter]  [Requirement] [Description]]
 416     [[`Sequence`] [A model of seq_concept_macro]    [The sequence to iterate]]
 417     [[`State`]    [Any type]                        [The initial state for the first application of `F`]]
 418     [[`F`]        [`__boost_result_of_call__<F(S,arg_type_id_macro)>::type` is the return type of `f(s,arg_id_macro)` with current state `s` of type `S`, and an invoke_meta_desc_macro][The operation to be applied on traversal]]
 419 ]
 420
 421 [heading Expression Semantics]
 422     name_macro<Sequence, State, F>::type
 423
 424 [*Return type]: Any type
 425
 426 [*Semantics]: Returns the result of applying [name_func] to a sequence of type
 427 `Sequence`, with an initial state of type `State` and binary function object or
 428 function pointer of type `F`.
 429
 430 [heading Complexity]
 431 Linear, exactly `__result_of_size__<Sequence>::value` applications of `F`.
 432
 433 [heading Header]
 434
 435     #include <boost/fusion/algorithm/iteration/name_macro.hpp>
 436     #include <boost/fusion/include/name_macro.hpp>
 437 ]
 438
 439 [section fold]
 440 [meta_fold_desc fold..__fold__..__forward_sequence__..e..E..element `e` of type `E` in `seq`]
 441 [endsect]
 442
 443 [section reverse_fold]
 444 [meta_fold_desc reverse_fold..__reverse_fold__..__bidirectional_sequence__..e..E..element `e` of type `E` in `seq`]
 445 [endsect]
 446
 447 [section iter_fold]
 448 [meta_fold_desc iter_fold..__iter_fold__..__forward_sequence__..it..It..iterator `it` of type `It` on an element of `seq`]
 449 [endsect]
 450
 451 [section reverse_iter_fold]
 452 [meta_fold_desc reverse_iter_fold..__reverse_iter_fold__..__bidirectional_sequence__..it..It..iterator `it` of type `It` on an element of `seq`]
 453 [endsect]
 454
 455 [section accumulate]
 456 [meta_fold_desc accumulate..__accumulate__..__forward_sequence__..e..E..element `e` of type `E` in `seq`]
 457 [endsect]
 458
 459 [section for_each]
 460
 461 [heading Description]
 462 A metafunction returning the result type of applying __for_each__ to a sequence. The
 463 return type of __for_each__ is always `void`.
 464
 465 [heading Synopsis]
 466     template<
 467         typename Sequence,
 468         typename F
 469     >
 470     struct for_each
 471     {
 472         typedef void type;
 473     };
 474
 475 [table Parameters
 476     [[Parameter] [Requirement] [Description]]
 477     [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
 478     [[`F`]    [Any type] [Operation's argument]]
 479 ]
 480
 481 [heading Expression Semantics]
 482     __result_of_for_each__<Sequence, F>::type
 483
 484 [*Return type]: `void`.
 485
 486 [*Semantics]: Returns the return type of __for_each__ for a sequence of type `Sequence` and a unary function object `F`.
 487 The return type is always `void`.
 488
 489 [heading Complexity]
 490 Constant.
 491
 492 [heading Header]
 493
 494     #include <boost/fusion/algorithm/iteration/for_each.hpp>
 495     #include <boost/fusion/include/for_each.hpp>
 496
 497 [endsect]
 498
 499 [endsect]
 500
 501 [endsect]
 502
 503 [section Query]
 504 The query algorithms provide support for searching and analyzing sequences.
 505
 506 [heading Header]
 507
 508     #include <boost/fusion/algorithm/query.hpp>
 509     #include <boost/fusion/include/query.hpp>
 510
 511 [section Functions]
 512
 513 [section any]
 514
 515 [heading Description]
 516 For a sequence `seq` and unary function object `f`, `any` returns true if `f` returns true for at least one element of `seq`.
 517
 518 [heading Synopsis]
 519     template<
 520         typename Sequence,
 521         typename F
 522         >
 523     typename __result_of_any__<Sequence,F>::type any(
 524         Sequence const& seq, F f);
 525
 526 [table Parameters
 527     [[Parameter][Requirement][Description]]
 528     [[`seq`][A model of __forward_sequence__, `f(e)` must be a valid expression, convertible to `bool`, for each element `e` in `seq`][The sequence to search]]
 529     [[`f`][A unary function object][The search predicate]]
 530 ]
 531
 532 [heading Expression semantics]
 533     __any__(seq, f);
 534
 535 [*Return type]: `bool`
 536
 537 [*Semantics]: Returns true if and only if `f(e)` evaluates to `true` for some element `e` in `seq`.
 538
 539 [heading Complexity]
 540 Linear. At most `__result_of_size__<Sequence>::value` comparisons.
 541
 542 [heading Header]
 543
 544     #include <boost/fusion/algorithm/query/any.hpp>
 545     #include <boost/fusion/include/any.hpp>
 546
 547 [heading Example]
 548     struct odd
 549     {
 550         template<typename T>
 551         bool operator()(T t) const
 552         {
 553             return t % 2;
 554         }
 555     };
 556     ...
 557     assert(__any__(__make_vector__(1,2), odd()));
 558     assert(!__any__(__make_vector__(2,4), odd()));
 559
 560 [endsect]
 561
 562 [section all]
 563
 564 [heading Description]
 565 For a sequence `seq` and unary function object `f`, `all` returns true if `f` returns true for every element of `seq`.
 566
 567 [heading Synopsis]
 568     template<
 569         typename Sequence,
 570         typename F
 571         >
 572     typename __result_of_all__<Sequence,F>::type all(
 573         Sequence const& seq, F f);
 574
 575 [table Parameters
 576     [[Parameter][Requirement][Description]]
 577     [[`seq`][A model of __forward_sequence__, `f(e)` is a valid expression, convertible to `bool`, for every element `e` in `seq`][The sequence to search]]
 578     [[`f`][A unary function object][The search predicate]]
 579 ]
 580
 581 [heading Expression Semantics]
 582     __all__(seq, f);
 583
 584 [*Return type]: `bool`
 585
 586 [*Semantics]: Returns true if and only if `f(e)` evaluates to `true` for every element `e` in `seq`.
 587
 588 [heading Complexity]
 589 Linear. At most `__result_of_size__<Sequence>::value` comparisons.
 590
 591 [heading Header]
 592
 593     #include <boost/fusion/algorithm/query/all.hpp>
 594     #include <boost/fusion/include/all.hpp>
 595
 596 [heading Example]
 597     struct odd
 598     {
 599         template<typename T>
 600         bool operator()(T t) const
 601         {
 602             return t % 2;
 603         }
 604     };
 605     ...
 606     assert(__all__(__make_vector__(1,3), odd()));
 607     assert(!__all__(__make_vector__(1,2), odd()));
 608
 609 [endsect]
 610
 611 [section none]
 612
 613 [heading Description]
 614 For a sequence `seq` and unary function object `f`, `none` returns true if `f` returns false for every element of `seq`.
 615
 616 [heading Synopsis]
 617     template<
 618         typename Sequence,
 619         typename F
 620         >
 621     typename __result_of_none__<Sequence,F>::type none(
 622         Sequence const& seq, F f);
 623
 624 [table Parameters
 625     [[Parameter][Requirement][Description]]
 626     [[`seq`][A model of __forward_sequence__, `f(e)` is a valid expression, convertible to `bool`, for every element `e` in `seq`][The sequence to search]]
 627     [[`f`][A unary function object][The search predicate]]
 628 ]
 629
 630 [heading Expression Semantics]
 631     __none__(seq, f);
 632
 633 [*Return type]: `bool`
 634
 635 [*Semantics]: Returns true if and only if `f(e)` evaluates to `false` for every element `e` in `seq`. Result equivalent to `!any(seq, f)`.
 636
 637 [heading Complexity]
 638 Linear. At most `__result_of_size__<Sequence>::value` comparisons.
 639
 640 [heading Header]
 641
 642     #include <boost/fusion/algorithm/query/none.hpp>
 643     #include <boost/fusion/include/none.hpp>
 644
 645 [heading Example]
 646     struct odd
 647     {
 648         template<typename T>
 649         bool operator()(T t) const
 650         {
 651             return t % 2;
 652         }
 653     };
 654     ...
 655     assert(__none__(__make_vector__(2,4), odd()));
 656     assert(!__none__(__make_vector__(1,2), odd()));
 657
 658 [endsect]
 659
 660 [section find]
 661
 662 [heading Description]
 663 Finds the first element of a given type within a sequence.
 664
 665 [heading Synopsis]
 666     template<
 667         typename T,
 668         typename Sequence
 669         >
 670     typename __result_of_find__<Sequence const, T>::type find(Sequence const& seq);
 671
 672     template<
 673         typename T,
 674         typename Sequence
 675         >
 676     typename __result_of_find__<Sequence, T>::type find(Sequence& seq);
 677
 678 [table Parameters
 679     [[Parameter][Requirement][Description]]
 680     [[`seq`][A model of __forward_sequence__][The sequence to search]]
 681     [[`T`][Any type][The type to search for]]
 682 ]
 683
 684 [heading Expression Semantics]
 685     __find__<T>(seq)
 686
 687 [*Return type]: A model of the same iterator category as the iterators of `seq`.
 688
 689 [*Semantics]: Returns an iterator to the first element of `seq` of type `T`, or `__end__(seq)` if there is no such element.
 690 Equivalent to `__find_if__<boost::is_same<_, T> >(seq)`
 691
 692 [heading Complexity]
 693 Linear. At most `__result_of_size__<Sequence>::value` comparisons.
 694
 695 [heading Header]
 696
 697     #include <boost/fusion/algorithm/query/find.hpp>
 698     #include <boost/fusion/include/find.hpp>
 699
 700 [heading Example]
 701     const __vector__<char,int> vec('a','0');
 702     assert(*__find__<int>(vec) == '0');
 703     assert(__find__<double>(vec) == __end__(vec));
 704
 705 [endsect]
 706
 707 [section find_if]
 708
 709 [heading Description]
 710 Finds the first element within a sequence with a type for which a given __mpl_lambda_expression__ evaluates to
 711 `boost::mpl::true_`.
 712
 713 [heading Synopsis]
 714     template<
 715         typename F,
 716         typename Sequence
 717         >
 718     typename __result_of_find_if__<Sequence const, F>::type find_if(Sequence const& seq);
 719
 720     template<
 721         typename F,
 722         typename Sequence
 723         >
 724     typename __result_of_find_if__<Sequence, F>::type find_if(Sequence& seq);
 725
 726 [table Parameters
 727     [[Parameter][Requirement][Description]]
 728     [[`seq`][A model of __forward_sequence__][The sequence to search]]
 729     [[`F`][A unary __mpl_lambda_expression__][The search predicate]]
 730 ]
 731
 732 [heading Expression Semantics]
 733     __find_if__<F>(seq)
 734
 735 [*Return type]: An iterator of the same iterator category as the iterators of `seq`.
 736
 737 [*Semantics]: Returns the first element of `seq` for which __mpl_lambda_expression__ `F` evaluates to `boost::mpl::true_`,
 738 or `__end__(seq)` if there is no such element.
 739
 740 [heading Complexity]
 741 Linear. At most `__result_of_size__<Sequence>::value` comparisons.
 742
 743 [heading Header]
 744
 745     #include <boost/fusion/algorithm/query/find_if.hpp>
 746     #include <boost/fusion/include/find_if.hpp>
 747
 748 [heading Example]
 749     const __vector__<double,int> vec(1.0,2);
 750     assert(*__find_if__<is_integral<mpl::_> >(vec) == 2);
 751     assert(__find_if__<is_class<mpl::_> >(vec) == __end__(vec));
 752
 753 [endsect]
 754
 755 [section count]
 756
 757 [heading Description]
 758 Returns the number of elements of a given type within a sequence.
 759
 760 [heading Synopsis]
 761     template<
 762         typename Sequence,
 763         typename T
 764         >
 765     typename __result_of_count__<Sequence, T>::type count(
 766         Sequence const& seq, T const& t);
 767
 768 [table Parameters
 769     [[Parameter][Requirement][Description]]
 770     [[`seq`][A model of __forward_sequence__, `e == t` must be a valid expression, convertible to `bool`, for each element `e` in `seq`][The sequence to search]]
 771     [[`T`][Any type][The type to count]]
 772 ]
 773
 774 [heading Expression Semantics]
 775     __count__(seq, t);
 776
 777 [*Return type]: `int`
 778
 779 [*Semantics]: Returns the number of elements of type `T` and equal to `t` in `seq`.
 780
 781 [heading Complexity]
 782 Linear. At most `__result_of_size__<Sequence>::value` comparisons.
 783
 784 [heading Header]
 785
 786     #include <boost/fusion/algorithm/query/count.hpp>
 787     #include <boost/fusion/include/count.hpp>
 788
 789 [heading Example]
 790     const __vector__<double,int,int> vec(1.0,2,3);
 791     assert(__count__(vec,2) == 1);
 792
 793 [endsect]
 794
 795 [section count_if]
 796
 797 [heading Description]
 798 Returns the number of elements within a sequence with a type for which a given unary function object evaluates to
 799 `true`.
 800
 801 [heading Synopsis]
 802     template<
 803         typename Sequence,
 804         typename F
 805         >
 806     typename __result_of_count_if__<Sequence, F>::type count_if(
 807         Sequence const& seq, F f);
 808
 809 [table Parameters
 810     [[Parameter][Requirement][Description]]
 811     [[`seq`][A model of __forward_sequence__, `f(e)` is a valid expression, convertible to `bool`, for each element `e` in `seq`][The sequence to search]]
 812     [[`f`][A unary function object][The search predicate]]
 813 ]
 814
 815 [heading Expression Semantics]
 816     __count_if__(seq, f)
 817
 818 [*Return type]: `int`
 819
 820 [*Semantics]: Returns the number of elements in `seq` where `f` evaluates to `true`.
 821
 822 [heading Complexity]
 823 Linear. At most `__result_of_size__<Sequence>::value` comparisons.
 824
 825 [heading Header]
 826
 827     #include <boost/fusion/algorithm/query/count_if.hpp>
 828     #include <boost/fusion/include/count_if.hpp>
 829
 830 [heading Example]
 831     const __vector__<int,int,int> vec(1,2,3);
 832     assert(__count_if__(vec,odd()) == 2);
 833
 834 [endsect]
 835
 836 [endsect]
 837
 838 [section Metafunctions]
 839
 840 [section any]
 841
 842 [heading Description]
 843 A metafunction returning the result type of __any__.
 844
 845 [heading Synopsis]
 846     template<
 847         typename Sequence,
 848         typename F
 849         >
 850     struct any
 851     {
 852         typedef bool type;
 853     };
 854
 855 [table Parameters
 856     [[Parameter] [Requirement] [Description]]
 857     [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
 858     [[`F`]       [A model of unary __poly_func_obj__] [Operation's argument]]
 859 ]
 860
 861 [heading Expression Semantics]
 862     __result_of_any__<Sequence, F>::type
 863
 864 [*Return type]: `bool`.
 865
 866 [*Semantics]: Returns the return type of __any__ given a sequence of type `Sequence` and a unary __poly_func_obj__ of type `F`. The return type is always `bool`.
 867
 868 [heading Complexity]
 869 Constant.
 870
 871 [heading Header]
 872
 873     #include <boost/fusion/algorithm/query/any.hpp>
 874     #include <boost/fusion/include/any.hpp>
 875
 876 [endsect]
 877
 878 [section all]
 879
 880 [heading Description]
 881 A metafunction returning the result type of __all__.
 882
 883 [heading Synopsis]
 884     template<
 885         typename Sequence,
 886         typename F
 887         >
 888     struct all
 889     {
 890         typedef bool type;
 891     };
 892
 893 [table Parameters
 894     [[Parameter] [Requirement] [Description]]
 895     [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
 896     [[`F`]        [A model of unary __poly_func_obj__] [Operation's argument]]
 897 ]
 898
 899 [heading Expression Semantics]
 900     __result_of_all__<Sequence, F>::type
 901
 902 [*Return type]: `bool`.
 903
 904 [*Semantics]: Returns the return type of __all__ given a sequence of type `Sequence` and a unary __poly_func_obj__ of type `F`. The return type is always `bool`.
 905
 906 [heading Complexity]
 907 Constant.
 908
 909 [heading Header]
 910
 911     #include <boost/fusion/algorithm/query/all.hpp>
 912     #include <boost/fusion/include/all.hpp>
 913
 914 [endsect]
 915
 916 [section none]
 917
 918 [heading Description]
 919 A metafunction returning the result type of __none__.
 920
 921 [heading Synopsis]
 922     template<
 923         typename Sequence,
 924         typename F
 925         >
 926     struct none
 927     {
 928         typedef bool type;
 929     };
 930
 931 [table Parameters
 932     [[Parameter] [Requirement] [Description]]
 933     [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
 934     [[`F`]        [A model of unary __poly_func_obj__] [Operation's argument]]
 935 ]
 936
 937 [heading Expression Semantics]
 938     __result_of_none__<Sequence, F>::type
 939
 940 [*Return type]: `bool`.
 941
 942 [*Semantics]: Returns the return type of __none__ given a sequence of type `Sequence` and a unary __poly_func_obj__ of type `F`. The return type is always `bool`.
 943
 944 [heading Complexity]
 945 Constant.
 946
 947 [heading Header]
 948
 949     #include <boost/fusion/algorithm/query/none.hpp>
 950     #include <boost/fusion/include/none.hpp>
 951
 952 [endsect]
 953
 954 [section find]
 955
 956 [heading Description]
 957 Returns the result type of __find__, given the sequence and search types.
 958
 959 [heading Synopsis]
 960     template<
 961         typename Sequence,
 962         typename T
 963         >
 964     struct find
 965     {
 966         typedef __unspecified__ type;
 967     };
 968
 969 [table Parameters
 970     [[Parameter] [Requirement] [Description]]
 971     [[`Sequence`] [Model of __forward_sequence__] [Operation's argument]]
 972     [[`T`]        [Any type] [Operation's argument]]
 973 ]
 974
 975 [heading Expression Semantics]
 976     __result_of_find__<Sequence, T>::type
 977
 978 [*Return type]: A model of the same iterator category as the iterators of `Sequence`.
 979
 980 [*Semantics]: Returns an iterator to the first element of type `T` in `Sequence`, or `__result_of_end__<Sequence>::type` if there is no such element.
 981
 982 [heading Complexity]
 983 Linear, at most `__result_of_size__<Sequence>::value` comparisons.
 984
 985 [heading Header]
 986
 987     #include <boost/fusion/algorithm/query/find.hpp>
 988     #include <boost/fusion/include/find.hpp>
 989
 990 [endsect]
 991
 992 [section find_if]
 993
 994 [heading Description]
 995 Returns the result type of __find_if__ given the sequence and predicate types.
 996
 997 [heading Synopsis]
 998     template<
 999         typename Sequence,
1000         typename Pred
1001         >
1002     struct find_if
1003     {
1004         typedef __unspecified__ type;
1005     };
1006
1007 [table Parameters
1008     [[Parameter] [Requirement] [Description]]
1009     [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
1010     [[`Pred`]     [A model of __mpl_lambda_expression__] [Operation's arguments]]
1011 ]
1012
1013 [heading Expression Semantics]
1014     __result_of_find_if__<Sequence, Pred>::type
1015
1016 [*Return type]: A model of the same iterator category as the iterators of `Sequence`.
1017
1018 [*Semantics]: Returns an iterator to the first element in `Sequence` for which `Pred` evaluates to true. Returns `__result_of_end__<Sequence>::type` if there is no such element.
1019
1020 [heading Complexity]
1021 Linear. At most `__result_of_size__<Sequence>::value` comparisons.
1022
1023 [heading Header]
1024
1025     #include <boost/fusion/algorithm/query/find_if.hpp>
1026     #include <boost/fusion/include/find_if.hpp>
1027
1028 [endsect]
1029
1030 [section count]
1031
1032 [heading Description]
1033 A metafunction that returns the result type of `count` given the sequence and search types.
1034
1035 [heading Synopsis]
1036     template<
1037         typename Sequence,
1038         typename T
1039         >
1040     struct count
1041     {
1042         typedef int type;
1043     };
1044
1045 [table Parameters
1046     [[Parameter] [Requirement] [heading Description]]
1047     [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
1048     [[`T`] [Any type] [Operation's argument]]
1049 ]
1050
1051 [heading Expression Semantics]
1052     __result_of_count__<T>::type
1053
1054 [*Return type]: `int`.
1055
1056 [*Semantics]: Returns the return type of __count__. The return type is always `int`.
1057
1058 [heading Complexity]
1059 Constant.
1060
1061 [heading Header]
1062
1063     #include <boost/fusion/algorithm/query/count.hpp>
1064     #include <boost/fusion/include/count.hpp>
1065
1066 [endsect]
1067
1068 [section count_if]
1069
1070 [heading Description]
1071 A metafunction that returns the result type of `count_if` given the sequence and predicate types.
1072
1073 [heading Synopsis]
1074     template<
1075         typename Sequence,
1076         typename Pred
1077         >
1078     struct count_if
1079     {
1080         typedef int type;
1081     };
1082
1083 [table Parameters
1084     [[Parameter] [Requirement] [Description]]
1085     [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
1086     [[`Pred`]     [A unary function object] [Operation's argument]]
1087 ]
1088
1089 [heading Expression Semantics]
1090     __result_of_count_if__<Sequence, Pred>::type
1091
1092 [*Return type]: `int`.
1093
1094 [*Semantics]: Returns the return type of __count_if__. The return type is always `int`.
1095
1096 [heading Complexity]
1097 Constant.
1098
1099 [heading Header]
1100
1101     #include <boost/fusion/algorithm/query/count_if.hpp>
1102     #include <boost/fusion/include/count_if.hpp>
1103
1104 [endsect]
1105
1106 [endsect]
1107
1108 [endsect]
1109
1110 [section Transformation]
1111 The transformation algorithms create new sequences out of existing sequences by performing some sort of transformation. In reality the new sequences are views onto the data in the original sequences.
1112
1113 [note As the transformation algorithms return views onto their input arguments,
1114 it is important that the lifetime of the input arguments is greater than the
1115 period during which you wish to use the results.]
1116
1117 [heading Header]
1118
1119     #include <boost/fusion/algorithm/transformation.hpp>
1120     #include <boost/fusion/include/transformation.hpp>
1121
1122 [section Functions]
1123
1124 [section filter]
1125
1126 [heading Description]
1127 For a given sequence, filter returns a new sequences containing only the elements of a specified type.
1128
1129 [heading Synopsis]
1130     template<
1131         typename T,
1132         typename Sequence
1133         >
1134     typename __result_of_filter__<Sequence const, T>::type filter(Sequence const& seq);
1135
1136 [table Parameters
1137     [[Parameter][Requirement][Description]]
1138     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1139     [[`T`][Any type][The type to retain]]
1140 ]
1141
1142 [heading Expression Semantics]
1143     __filter__<T>(seq);
1144
1145 [*Return type]:
1146
1147 * A model of __forward_sequence__.
1148 * A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
1149
1150 [*Semantics]: Returns a sequence containing all the elements of `seq` of type `T`.
1151 Equivalent to `__filter_if__<boost::same_type<_, T> >(seq)`.
1152
1153 [heading Complexity]
1154 Constant. Returns a view which is lazily evaluated.
1155
1156 [heading Header]
1157
1158     #include <boost/fusion/algorithm/transformation/filter.hpp>
1159     #include <boost/fusion/include/filter.hpp>
1160
1161 [heading Example]
1162     const __vector__<int,int,long,long> vec(1,2,3,4);
1163     assert(__filter__<int>(vec) == __make_vector__(1,2));
1164
1165 [endsect]
1166
1167 [section filter_if]
1168
1169 [heading Description]
1170 For a given sequence, __filter_if__ returns a new sequences containing
1171 only the elements with types for which a given __mpl_lambda_expression__ evaluates to `boost::mpl::true_`.
1172
1173 [heading Synopsis]
1174     template<
1175         typename Pred,
1176         typename Sequence
1177         >
1178     typename __result_of_filter_if__<Sequence const, Pred>::type filter_if(Sequence const& seq);
1179
1180 [table Parameters
1181     [[Parameter][Requirement][Description]]
1182     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1183     [[`Pred`][A unary __mpl_lambda_expression__][The predicate to filter by]]
1184 ]
1185
1186 [heading Expression Semantics]
1187     __filter_if__<Pred>(seq);
1188
1189 [*Return type]:
1190
1191 * A model of __forward_sequence__.
1192 * A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
1193
1194 [*Semantics]: Returns a sequence containing all the elements of `seq` with types for which `Pred` evaluates
1195 to `boost::mpl::true_`. The order of the retained elements is the same as in the original sequence.
1196
1197 [heading Complexity]
1198 Constant. Returns a view which is lazily evaluated.
1199
1200 [heading Header]
1201
1202     #include <boost/fusion/algorithm/transformation/filter_if.hpp>
1203     #include <boost/fusion/include/filter_if.hpp>
1204
1205 [heading Example]
1206     const __vector__<int,int,double,double> vec(1,2,3.0,4.0);
1207     assert(__filter_if__<is_integral<mpl::_> >(vec) == __make_vector__(1,2));
1208
1209 [endsect]
1210
1211 [section transform]
1212
1213 [heading Description]
1214 For a sequence `seq` and function object or function pointer `f`, `transform` returns a new sequence
1215 with elements created by applying `f(e)` to each element of `e` of `seq`.
1216
1217 [heading Unary version synopsis]
1218     template<
1219         typename Sequence,
1220         typename F
1221         >
1222     typename __result_of_transform__<Sequence const, F>::type transform(
1223         Sequence const& seq, F f);
1224
1225 [table Parameters
1226     [[Parameter][Requirement][Description]]
1227     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1228     [[`f`][`f(e)` is a valid expression for each element `e` of `seq`. `__boost_result_of_call__<F(E)>::type` is the return type of `f` when called with a value of each element type `E`.][Transformation function]]
1229 ]
1230
1231 [heading Expression Semantics]
1232     __transform__(seq, f);
1233
1234 [*Return type]: A model of __forward_sequence__
1235
1236 [*Semantics]: Returns a new sequence, containing the return values of `f(e)` for each element `e` within `seq`.
1237
1238 [heading Binary version synopsis]
1239     template<
1240         typename Sequence1,
1241         typename Sequence2,
1242         typename F
1243         >
1244     typename __result_of_transform__<Sequence1 const, Sequence2 const, F>::type transform(
1245         Sequence1 const& seq1, Sequence2 const& seq2, F f);
1246
1247 [table Parameters
1248     [[Parameter][Requirement][Description]]
1249     [[`seq1`][A model of __forward_sequence__][Operation's argument]]
1250     [[`seq2`][A model of __forward_sequence__][Operation's argument]]
1251     [[`f`][`f(e1,e2)` is a valid expression for each pair of elements `e1` of `seq1` and `e2` of `seq2`. `__boost_result_of_call__<F(E1,E2)>::type` is the return type of `f` when called with elements of type `E1` and `E2`][Transformation function]]
1252 ]
1253
1254 [*Return type]: A model of __forward_sequence__.
1255
1256 [*Semantics]: Returns a new sequence, containing the return values of `f(e1, e2)` for each pair of elements `e1` and `e2` within `seq1` and `seq2` respectively.
1257
1258 [heading Complexity]
1259 Constant. Returns a view which is lazily evaluated.
1260
1261 [heading Header]
1262
1263     #include <boost/fusion/algorithm/transformation/transform.hpp>
1264     #include <boost/fusion/include/transform.hpp>
1265
1266 [heading Example]
1267     struct triple
1268     {
1269         typedef int result_type;
1270
1271         int operator()(int t) const
1272         {
1273             return t * 3;
1274         };
1275     };
1276     ...
1277     assert(__transform__(__make_vector__(1,2,3), triple()) == __make_vector__(3,6,9));
1278
1279 [endsect]
1280
1281 [section replace]
1282
1283 [heading Description]
1284 Replaces each value within a sequence of a given type and value with a new value.
1285
1286 [heading Synopsis]
1287     template<
1288         typename Sequence,
1289         typename T
1290         >
1291     typename __result_of_replace__<Sequence const, T>::type replace(
1292         Sequence const& seq, T const& old_value, T const& new_value);
1293
1294 [table Parameters
1295     [[Parameter][Requirement][Description]]
1296     [[`seq`][A model of __forward_sequence__, `e == old_value` is a valid expression, convertible to `bool`, for each element `e` in `seq` with type convertible to `T`][Operation's argument]]
1297     [[`old_value`][Any type][Value to replace]]
1298     [[`new_value`][Any type][Replacement value]]
1299 ]
1300
1301 [heading Expression Semantics]
1302     __replace__(seq, old_value, new_value);
1303
1304 [*Return type]: A model of __forward_sequence__.
1305
1306 [*Semantics]: Returns a new sequence with all the values of `seq` with `new_value` assigned to elements with the same type and equal to `old_value`.
1307
1308 [heading Complexity]
1309 Constant. Returns a view which is lazily evaluated.
1310
1311 [heading Header]
1312
1313     #include <boost/fusion/algorithm/transformation/replace.hpp>
1314     #include <boost/fusion/include/replace.hpp>
1315
1316 [heading Example]
1317     assert(__replace__(__make_vector__(1,2), 2, 3) == __make_vector__(1,3));
1318
1319 [endsect]
1320
1321 [section replace_if]
1322
1323 [heading Description]
1324 Replaces each element of a given sequence for which an unary function object evaluates to `true` replaced with
1325 a new value.
1326
1327 [heading Synopsis]
1328     template<
1329         typename Sequence,
1330         typename F,
1331         typename T>
1332     typename __result_of_replace_if__<Sequence const, F, T>::type replace_if(
1333         Sequence const& seq, F f, T const& new_value);
1334
1335 [table Parameters
1336     [[Parameter][Requirement][Description]]
1337     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1338     [[`f`][A function object for which `f(e)` is a valid expression, convertible to `bool`, for each element `e` in `seq`][Operation's argument]]
1339     [[`new_value`][Any type][Replacement value]]
1340 ]
1341
1342 [heading Expression Semantics]
1343     __replace_if__(seq, f, new_value);
1344
1345 [*Return type]: A model of __forward_sequence__.
1346
1347 [*Semantics]: Returns a new sequence with all the elements of `seq`,
1348 with `new_value` assigned to each element for which `f` evaluates to `true`.
1349
1350 [heading Complexity]
1351 Constant. Returns a view which is lazily evaluated.
1352
1353 [heading Header]
1354
1355     #include <boost/fusion/algorithm/transformation/replace_if.hpp>
1356     #include <boost/fusion/include/replace_if.hpp>
1357
1358 [heading Example]
1359     struct odd
1360     {
1361         template<typename T>
1362         bool operator()(T t) const
1363         {
1364             return t % 2;
1365         }
1366     };
1367     ...
1368     assert(__replace_if__(__make_vector__(1,2), odd(), 3) == __make_vector__(3,2));
1369
1370 [endsect]
1371
1372 [section remove]
1373
1374 [heading Description]
1375 Returns a new sequence, with all the elements of the original sequence, except those of a given type.
1376
1377 [heading Synopsis]
1378     template<
1379         typename T,
1380         typename Sequence
1381         >
1382     typename __result_of_remove__<Sequence const, T>::type remove(Sequence const& seq);
1383
1384 [table Parameters
1385     [[Parameter][Requirement][Description]]
1386     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1387     [[`T`][Any type][Type to remove]]
1388 ]
1389
1390 [heading Expression Semantics]
1391     __remove__<T>(seq);
1392
1393 [*Return type]:
1394
1395 * A model of __forward_sequence__.
1396 * A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
1397
1398 [*Semantics]: Returns a new sequence, containing all the elements of `seq`, in their original order, except
1399 those of type `T`. Equivalent to `__remove_if__<boost::is_same<_,T> >(seq)`.
1400
1401 [heading Complexity]
1402 Constant. Returns a view which is lazily evaluated.
1403
1404 [heading Header]
1405
1406     #include <boost/fusion/algorithm/transformation/remove.hpp>
1407     #include <boost/fusion/include/remove.hpp>
1408
1409 [heading Example]
1410     const __vector__<int,double> vec(1,2.0);
1411     assert(__remove__<double>(vec) == __make_vector__(1));
1412
1413 [endsect]
1414
1415 [section remove_if]
1416
1417 [heading Description]
1418 Returns a new sequence, containing all the elements of the original except those where a given unary
1419 function object evaluates to `true`.
1420
1421 [heading Synopsis]
1422     template<
1423         typename Pred,
1424         typename Sequence
1425         >
1426     typename __result_of_remove_if__<Sequence const, Pred>::type remove_if(Sequence const& seq);
1427
1428 [table Parameters
1429     [[Parameter][Requirement][Description]]
1430     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1431     [[`Pred`][A model of unary __mpl_lambda_expression__][Removal predicate]]
1432 ]
1433
1434 [heading Expression Semantics]
1435     __remove_if__<Pred>(seq);
1436
1437 [*Return type]:
1438
1439 * A model of __forward_sequence__.
1440 * A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
1441
1442 [*Semantics]: Returns a new sequence, containing all the elements of `seq`, in their original order, except
1443 those elements with types for which `Pred` evaluates to `boost::mpl::true_`.
1444 Equivalent to `__filter__<boost::mpl::not_<Pred> >(seq)`.
1445
1446 [heading Complexity]
1447 Constant. Returns a view which is lazily evaluated.
1448
1449 [heading Header]
1450
1451     #include <boost/fusion/algorithm/transformation/remove_if.hpp>
1452     #include <boost/fusion/include/remove_if.hpp>
1453
1454 [heading Example]
1455     const __vector__<int,double> vec(1,2.0);
1456     assert(__remove_if__<is_floating_point<mpl::_> >(vec) == __make_vector__(1));
1457
1458 [endsect]
1459
1460 [section reverse]
1461
1462 [heading Description]
1463 Returns a new sequence with the elements of the original in reverse order.
1464
1465 [heading Synopsis]
1466     template<
1467         typename Sequence
1468         >
1469     typename __result_of_reverse__<Sequence const>::type reverse(Sequence const& seq);
1470
1471 [table Parameters
1472     [[Parameter][Requirement][Description]]
1473     [[`seq`][A model of __bidirectional_sequence__][Operation's argument]]
1474 ]
1475
1476 [heading Expression Semantics]
1477     __reverse__(seq);
1478
1479 [*Return type]:
1480
1481 * A model of __bidirectional_sequence__ if `seq` is a __bidirectional_sequence__
1482 else, __random_access_sequence__ if `seq` is a __random_access_sequence__.
1483 * A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
1484
1485 [*Semantics]: Returns a new sequence containing all the elements of `seq` in reverse order.
1486
1487 [heading Complexity]
1488 Constant. Returns a view which is lazily evaluated.
1489
1490 [heading Header]
1491
1492     #include <boost/fusion/algorithm/transformation/reverse.hpp>
1493     #include <boost/fusion/include/reverse.hpp>
1494
1495 [heading Example]
1496     assert(__reverse__(__make_vector__(1,2,3)) == __make_vector__(3,2,1));
1497
1498 [endsect]
1499
1500 [section clear]
1501
1502 [heading Description]
1503 __clear__ returns an empty sequence.
1504
1505 [heading Synopsis]
1506     template<
1507         typename Sequence
1508         >
1509     typename __result_of_clear__<Sequence const>::type clear(Sequence const& seq);
1510
1511 [table Parameters
1512     [[Parameter][Requirement][Description]]
1513     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1514 ]
1515
1516 [heading Expression Semantics]
1517     __clear__(seq);
1518
1519 [*Return type]: A model of __forward_sequence__.
1520
1521 [*Expression Semantics]: Returns a sequence with no elements.
1522
1523 [heading Complexity]
1524 Constant.
1525
1526 [heading Header]
1527
1528     #include <boost/fusion/algorithm/transformation/clear.hpp>
1529     #include <boost/fusion/include/clear.hpp>
1530
1531 [heading Example]
1532     assert(__clear__(__make_vector__(1,2,3)) == __make_vector__());
1533
1534 [endsect]
1535
1536 [section erase]
1537
1538 [heading Description]
1539 Returns a new sequence, containing all the elements of the original except those at a specified iterator, or
1540 between two iterators.
1541
1542 [heading Synopsis]
1543     template<
1544         typename Sequence,
1545         typename First
1546         >
1547     typename __result_of_erase__<Sequence const, First>::type erase(
1548         Sequence const& seq, First const& it1);
1549
1550     template<
1551         typename Sequence,
1552         typename First,
1553         typename Last
1554         >
1555     typename __result_of_erase__<Sequence const, First, Last>::type erase(
1556         Sequence const& seq, First const& it1, Last const& it2);
1557
1558 [table Parameters
1559     [[Parameters][Requirement][Description]]
1560     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1561     [[`it1`][A model of __forward_iterator__][Iterator into `seq`]]
1562     [[`it2`][A model of __forward_iterator__][Iterator into `seq` after `it1`]]
1563 ]
1564
1565 [heading Expression Semantics]
1566     __erase__(seq, pos);
1567
1568 [*Return type]:
1569
1570 * A model of __forward_sequence__.
1571 * A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
1572
1573 [*Semantics]: Returns a new sequence, containing all the elements of `seq` except the element at `pos`.
1574
1575     __erase__(seq, first, last);
1576
1577 [*Return type]:
1578
1579 * A model of __forward_sequence__.
1580 * A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
1581
1582 [*Semantics]: Returns a new sequence, with all the elements of `seq`, in their original order, except those
1583 in the range [`first`,`last`).
1584
1585 [heading Complexity]
1586 Constant. Returns a view which is lazily evaluated.
1587
1588 [heading Header]
1589
1590     #include <boost/fusion/algorithm/transformation/erase.hpp>
1591     #include <boost/fusion/include/erase.hpp>
1592
1593 [heading Example]
1594     const __vector__<int, double, char> vec(1, 2.0, 'c');
1595     assert(__erase__(vec, __next__(__begin__(vec))) == __make_vector__(1, 'c'));
1596     assert(__erase__(vec, __next__(__begin__(vec)), __end__(vec)) == __make_vector__(1));
1597
1598 [endsect]
1599
1600 [section erase_key]
1601
1602 [heading Description]
1603 For an [link fusion.sequence.concepts.associative_sequence associative] __forward_sequence__ `seq`,
1604 returns a [link fusion.sequence.concepts.associative_sequence associative] __forward_sequence__ containing
1605 all the elements of the original except those with a given key.
1606
1607 [heading Synopsis]
1608     template<
1609         typename Key,
1610         typename Sequence
1611         >
1612     typename __result_of_erase_key__<Sequence const, Key>::type erase_key(Sequence const& seq);
1613
1614 [table Parameters
1615     [[Parameter][Requirement][Description]]
1616     [[`seq`][A model of __forward_sequence__ and __associative_sequence__][Operation's argument]]
1617     [[`Key`][Any type][Key to erase]]
1618 ]
1619
1620 [heading Expression Semantics]
1621     __erase_key__<Key>(seq);
1622
1623 [*Return type]: A model of __forward_sequence__ and __associative_sequence__.
1624
1625 [*Semantics]: Returns a new sequence, containing all the elements of `seq`, except those with key `Key`.
1626
1627 [heading Complexity]
1628 Constant. Returns a view which is lazily evaluated.
1629
1630 [heading Header]
1631
1632     #include <boost/fusion/algorithm/transformation/erase_key.hpp>
1633     #include <boost/fusion/include/erase_key.hpp>
1634
1635 [heading Example]
1636     assert(__erase_key__<int>(__make_map__<int, long>('a', 'b')) == __make_map__<long>('b'));
1637
1638 [endsect]
1639
1640 [section insert]
1641
1642 [heading Description]
1643 Returns a new sequence with all the elements of the original, an a new element inserted the
1644 position described by a given iterator.
1645
1646 [heading Synopsis]
1647     template<
1648         typename Sequence,
1649         typename Pos,
1650         typename T
1651         >
1652     typename __result_of_insert__<Sequence const, Pos, T>::type insert(
1653         Sequence const& seq, Pos const& pos, T const& t);
1654
1655 [table Parameters
1656     [[Parameter][Requirement][Description]]
1657     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1658     [[`pos`][A model of __forward_iterator__][The position to insert at]]
1659     [[`t`][Any type][The value to insert]]
1660 ]
1661
1662 [heading Expression Semantics]
1663     __insert__(seq, pos, t);
1664
1665 [*Return type]:
1666
1667 * A model of __forward_sequence__.
1668
1669 [*Semantics]: Returns a new sequence, containing all the elements of `seq`, in their original order, and a new element with the
1670 type and value of `t` inserted at iterator `pos`.
1671
1672 [heading Complexity]
1673 Constant. Returns a view which is lazily evaluated.
1674
1675 [heading Header]
1676
1677     #include <boost/fusion/algorithm/transformation/insert.hpp>
1678     #include <boost/fusion/include/insert.hpp>
1679
1680 [heading Example]
1681     const __vector__<int,int> vec(1,2);
1682     assert(__insert__(vec, __next__(__begin__(vec)), 3) == __make_vector__(1,3,2));
1683
1684 [endsect]
1685
1686 [section insert_range]
1687
1688 [heading Description]
1689 Returns a new sequence with another sequence inserted at a specified iterator.
1690
1691 [heading Synopsis]
1692     template<
1693         typename Sequence,
1694         typename Pos,
1695         typename Range
1696         >
1697     typename __result_of_insert_range__<Sequence const, Pos, Range>::type insert_range(
1698         Sequence const& seq, Pos const& pos, Range const& range);
1699
1700 [table Parameters
1701     [[Parameter][Requirement][Description]]
1702     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1703     [[`pos`][A model of __forward_iterator__][The position to insert at]]
1704     [[`range`][A model of __forward_sequence__][Range to insert]]
1705 ]
1706
1707 [heading Expression Semantics]
1708     __insert_range__(seq, pos, range);
1709
1710 [*Return type]:
1711
1712 * A model of __forward_sequence__.
1713 * A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
1714
1715 [*Semantics]: Returns a new sequence, containing all the elements of `seq`, and the elements of
1716 `range` inserted at iterator `pos`. All elements retaining their ordering from the original sequences.
1717
1718 [heading Complexity]
1719 Constant. Returns a view which is lazily evaluated.
1720
1721 [heading Header]
1722
1723     #include <boost/fusion/algorithm/transformation/insert_range.hpp>
1724     #include <boost/fusion/include/insert_range.hpp>
1725
1726 [heading Example]
1727     const __vector__<int,int> vec(1,2);
1728     assert(__insert_range__(vec, __next__(__begin__(vec)), __make_vector__(3,4)) == __make_vector__(1,3,4,2));
1729
1730 [endsect]
1731
1732 [section join]
1733
1734 [heading Description]
1735 Takes 2 sequences and returns a sequence containing the elements of the first followed by the elements of the second.
1736
1737 [heading Synopsis]
1738     template<
1739         typename LhSequence,
1740         typename RhSequence>
1741     typename __result_of_join__<LhSequence const, RhSequence const>::type join(LhSequence const& lhs, RhSequence const& rhs);
1742
1743 [table Parameters
1744     [[Parameter][Requirement][Description]]
1745     [[`lhs`][A model of __forward_sequence__][Operation's argument]]
1746     [[`rhs`][A model of __forward_sequence__][Operation's argument]]
1747 ]
1748
1749 [heading Expression Semantics]
1750     __join__(lhs, rhs);
1751
1752 [*Return type]:
1753
1754 * A model of __forward_sequence__.
1755 * A model of __associative_sequence__ if `lhs` and `rhs` implement the __associative_sequence__ model.
1756
1757 [*Semantics]: Returns a sequence containing all the elements of `lhs` followed by all the elements of `rhs`. The order of the elements is preserved.
1758
1759 [heading Complexity]
1760 Constant. Returns a view which is lazily evaluated.
1761
1762 [heading Header]
1763
1764     #include <boost/fusion/algorithm/transformation/join.hpp>
1765     #include <boost/fusion/include/join.hpp>
1766
1767 [heading Example]
1768     __vector__<int,char> v1(1, 'a');
1769     __vector__<int,char> v2(2, 'b');
1770     assert(__join__(v1, v2) == __make_vector__(1,'a',2,'b'));
1771
1772 [endsect]
1773
1774 [section zip]
1775
1776 [heading Description]
1777 Zips sequences together to form a single sequence, whose members are tuples of the members of the component sequences.
1778
1779 [heading Synopsis]
1780     template<
1781         typename Sequence1,
1782         typename Sequence2,
1783         ...
1784         typename SequenceN
1785         >
1786     typename __result_of_zip__<Sequence1 const, Sequence2 const, ... SequenceN const>::type
1787     zip(Sequence1 const& seq1, Sequence2 const& seq2, ... SequenceN const& seqN);
1788
1789 [table Parameters
1790     [[Parameter][Requirement][Description]]
1791     [[`seq1` to `seqN`][Each sequence is a model of __forward_sequence__.][Operation's argument]]
1792 ]
1793
1794 [heading Expression Semantics]
1795     __zip__(seq1, seq2, ... seqN);
1796
1797 [*Return type]: A model of __forward_sequence__.
1798
1799 [*Semantics]: Returns a sequence containing tuples of elements from sequences `seq1` to `seqN`. For example, applying zip to tuples `(1, 2, 3)` and `('a', 'b', 'c')` would return `((1, 'a'),(2, 'b'),(3, 'c'))`
1800
1801 [heading Complexity]
1802 Constant. Returns a view which is lazily evaluated.
1803
1804 [heading Header]
1805
1806     #include <boost/fusion/algorithm/transformation/zip.hpp>
1807     #include <boost/fusion/include/zip.hpp>
1808
1809 [heading Example]
1810     __vector__<int,char> v1(1, 'a');
1811     __vector__<int,char> v2(2, 'b');
1812     assert(__zip__(v1, v2) == __make_vector__(__make_vector__(1, 2),__make_vector__('a', 'b'));
1813
1814 [endsect]
1815
1816 [section pop_back]
1817
1818 [heading Description]
1819 Returns a new sequence, with the last element of the original removed.
1820
1821 [heading Synopsis]
1822     template<
1823         typename Sequence
1824         >
1825     typename __result_of_pop_back__<Sequence const>::type pop_back(Sequence const& seq);
1826
1827 [table Parameters
1828     [[Parameter][Requirement][Description]]
1829     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1830 ]
1831
1832 [heading Expression Semantics]
1833     __pop_back__(seq);
1834
1835 [*Return type]:
1836
1837 * A model of __forward_sequence__.
1838 * A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
1839
1840 [*Semantics]: Returns a new sequence containing all the elements of `seq`, except the last element. The elements in the new sequence are in the same order as they were in `seq`.
1841
1842 [heading Complexity]
1843 Constant. Returns a view which is lazily evaluated.
1844
1845 [heading Header]
1846
1847     #include <boost/fusion/algorithm/transformation/pop_back.hpp>
1848     #include <boost/fusion/include/pop_back.hpp>
1849
1850 [heading Example]
1851     assert(__pop_back__(__make_vector__(1,2,3)) == __make_vector__(1,2));
1852
1853 [endsect]
1854
1855 [section pop_front]
1856
1857 [heading Description]
1858 Returns a new sequence, with the first element of the original removed.
1859
1860 [heading Synopsis]
1861     template<
1862         typename Sequence
1863         >
1864     typename __result_of_pop_front__<Sequence const>::type pop_front(Sequence const& seq);
1865
1866
1867 [table Parameters
1868     [[Parameter][Requirement][Description]]
1869     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1870 ]
1871
1872 [heading Expression Semantics]
1873     __pop_front__(seq);
1874
1875 [*Return type]:
1876
1877 * A model of __forward_sequence__.
1878 * A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
1879
1880 [*Semantics]: Returns a new sequence containing all the elements of `seq`, except the first element. The elements in the new sequence are in the same order as they were in `seq`.
1881
1882 [heading Complexity]
1883 Constant. Returns a view which is lazily evaluated.
1884
1885 [heading Header]
1886
1887     #include <boost/fusion/algorithm/transformation/pop_front.hpp>
1888     #include <boost/fusion/include/pop_front.hpp>
1889
1890 [heading Example]
1891     assert(__pop_front__(__make_vector__(1,2,3)) == __make_vector__(2,3));
1892
1893 [endsect]
1894
1895 [section push_back]
1896
1897 [heading Description]
1898 Returns a new sequence with an element added at the end.
1899
1900 [heading Synopsis]
1901     template<
1902         typename Sequence,
1903         typename T
1904         >
1905     typename __result_of_push_back__<Sequence const, T>::type push_back(
1906         Sequence const& seq, T const& t);
1907
1908 [table Parameters
1909     [[Parameter][Requirement][Description]]
1910     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1911     [[`t`][Any type][The value to add to the end]]
1912 ]
1913
1914 [heading Expression Semantics]
1915     __push_back__(seq, t);
1916
1917 [*Return type]:
1918
1919 * A model of __forward_sequence__.
1920
1921 [*Semantics]: Returns a new sequence, containing all the elements of `seq`, and new element `t` appended to the end. The elements are in the same order as they were in `seq`.
1922
1923 [heading Complexity]
1924 Constant. Returns a view which is lazily evaluated.
1925
1926 [heading Header]
1927
1928     #include <boost/fusion/algorithm/transformation/push_back.hpp>
1929     #include <boost/fusion/include/push_back.hpp>
1930
1931 [heading Example]
1932     assert(__push_back__(__make_vector__(1,2,3),4) == __make_vector__(1,2,3,4));
1933
1934 [endsect]
1935
1936 [section push_front]
1937
1938 [heading Description]
1939 Returns a new sequence with an element added at the beginning.
1940
1941 [heading Synopsis]
1942     template<
1943         typename Sequence,
1944         typename T
1945         >
1946     typename __result_of_push_front__<Sequence const, T>::type push_front(
1947         Sequence const& seq, T const& t);
1948
1949 [table Parameters
1950     [[Parameter][Requirement][Description]]
1951     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1952     [[`t`][Any type][The value to add to the beginning]]
1953 ]
1954
1955 [heading Expression Semantics]
1956     __push_back__(seq, t);
1957
1958 [*Return type]:
1959
1960 * A model of __forward_sequence__.
1961
1962 [*Semantics]: Returns a new sequence, containing all the elements of `seq`, and new element `t` appended to the beginning. The elements are in the same order as they were in `seq`.
1963
1964 [heading Complexity]
1965 Constant. Returns a view which is lazily evaluated.
1966
1967 [heading Header]
1968
1969     #include <boost/fusion/algorithm/transformation/push_front.hpp>
1970     #include <boost/fusion/include/push_front.hpp>
1971
1972 [heading Example]
1973     assert(__push_front__(__make_vector__(1,2,3),0) == __make_vector__(0,1,2,3));
1974
1975 [endsect]
1976
1977 [section flatten]
1978
1979 [heading Description]
1980 Returns a new sequence without nested sequences.
1981
1982 [heading Synopsis]
1983     template<
1984         typename Sequence
1985         >
1986     typename __result_of_flatten__<Sequence>::type flatten(Sequence& seq);
1987
1988     template<
1989         typename Sequence
1990         >
1991     typename __result_of_flatten__<Sequence const>::type flatten(Sequence const& seq);
1992
1993 [table Parameters
1994     [[Parameter][Requirement][Description]]
1995     [[`seq`][A model of __forward_sequence__][Operation's argument]]
1996 ]
1997
1998 [heading Expression Semantics]
1999     __flatten__(seq);
2000
2001 [*Return type]:
2002
2003 * A model of __forward_sequence__.
2004
2005 [*Semantics]: Returns a new sequence containing all the leaf elements of `seq`.
2006
2007 [heading Complexity]
2008 Constant. Returns a view which is lazily evaluated.
2009
2010 [heading Header]
2011
2012     #include <boost/fusion/algorithm/transformation/flatten.hpp>
2013     #include <boost/fusion/include/flatten.hpp>
2014
2015 [heading Example]
2016     const __vector__<int, int, __vector__<int, int>, int> vec(1, 2, __make_vector__(3, 4), 5);
2017     assert(__flatten__(vec) == __make_vector__(1, 2, 3, 4, 5)));
2018
2019 [endsect]
2020
2021 [endsect]
2022
2023 [section Metafunctions]
2024
2025 [section filter]
2026
2027 [heading Description]
2028 Returns the result type of __filter__ given the sequence type and type to retain.
2029
2030 [heading Synopsis]
2031     template<
2032         typename Sequence,
2033         typename T
2034         >
2035     struct filter
2036     {
2037         typedef __unspecified__ type;
2038     };
2039
2040 [table Parameter
2041     [[Parameter] [Requirement] [Description]]
2042     [[`Sequence`][A model of __forward_sequence__] [Operation's argument]]
2043     [[`T`][Any type][Type to retain]]
2044 ]
2045
2046 [heading Expression Semantics]
2047     __result_of_filter__<Sequence, T>::type
2048
2049 [*Return type]:
2050
2051 * A model of __forward_sequence__.
2052 * A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
2053
2054 [*Semantics]: Returns a sequence containing the elements of `Sequence` that are of type `T`. Equivalent to `__result_of_filter_if__<Sequence, boost::is_same<mpl::_, T> >::type`.
2055
2056 [heading Complexity]
2057 Constant.
2058
2059 [heading Header]
2060
2061     #include <boost/fusion/algorithm/transformation/filter.hpp>
2062     #include <boost/fusion/include/filter.hpp>
2063
2064 [endsect]
2065
2066 [section filter_if]
2067
2068 [heading Description]
2069 Returns the result type of __filter_if__ given the sequence and unary __mpl_lambda_expression__ predicate type.
2070
2071 [heading Synopsis]
2072     template<
2073         typename Sequence,
2074         typename Pred
2075         >
2076     struct filter_if
2077     {
2078         typedef __unspecified__ type;
2079     };
2080
2081 [table Parameter
2082     [[Parameter] [Requirement] [Description]]
2083     [[`Sequence`][A model of __forward_sequence__] [Operation's argument]]
2084     [[`Pred`][A unary __mpl_lambda_expression__][Type to retain]]
2085 ]
2086
2087 [heading Expression Semantics]
2088     __result_of_filter_if__<Sequence, Pred>::type
2089
2090 [*Return type]:
2091
2092 * A model of __forward_sequence__.
2093 * A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
2094
2095 [*Semantics]: Returns a sequence containing the elements of `Sequence` for which `Pred` evaluates to `boost::mpl::true_`.
2096
2097 [heading Complexity]
2098 Constant.
2099
2100 [heading Header]
2101
2102     #include <boost/fusion/algorithm/transformation/filter_if.hpp>
2103     #include <boost/fusion/include/filter_if.hpp>
2104
2105 [endsect]
2106
2107 [section transform]
2108
2109 [heading Description]
2110 Returns the result type of __transform__, given the types of the input sequence and unary __poly_func_obj__.
2111
2112 [heading Unary version synopsis]
2113     template<
2114         typename Sequence,
2115         typename F
2116         >
2117     struct transform
2118     {
2119         typedef __unspecified__ type;
2120     };
2121
2122 [table Parameters
2123     [[Parameter][Requirement][Description]]
2124     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
2125     [[`F`][A model of unary __poly_func_obj__][Transformation metafunction]]
2126 ]
2127
2128 [heading Expression Semantics]
2129     __result_of_transform__<Sequence, F>::type
2130
2131 [*Return type]:
2132
2133 * A model of __forward_sequence__
2134 * A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
2135
2136 [*Semantics]: Returns a sequence that contains the types of `__result_of__<F(E)>::type` for each element `E` within `Sequence`.
2137
2138 [heading Binary version synopsis]
2139     template<
2140         typename Sequence1,
2141         typename Sequence2,
2142         typename F
2143         >
2144     struct transform
2145     {
2146           typedef __unspecified__ type;
2147     };
2148
2149 [table Parameters
2150     [[Parameter][Requirement][Description]]
2151     [[`Sequence1`][A model of __forward_sequence__][Operation's argument]]
2152     [[`Sequence2`][A model of __forward_sequence__][Operation's argument]]
2153     [[`F`][A model of binary __poly_func_obj__][Transformation metafunction]]
2154 ]
2155
2156 [heading Expression Semantics]
2157     __result_of_transform__<Sequence1, Sequence2, F>::type
2158
2159 [*Return type]: A model of __forward_sequence__.
2160
2161 [*Semantics]: Returns a sequence, that contains the types of `__result_of__<F(E1, E2)>::type` for each pair of elements `E1` and `E2` within `Sequence1` and `Sequence2` respectively.
2162
2163 [heading Complexity]
2164 Constant.
2165
2166 [heading Header]
2167
2168     #include <boost/fusion/algorithm/transformation/transform.hpp>
2169     #include <boost/fusion/include/transform.hpp>
2170
2171 [endsect]
2172
2173 [section replace]
2174
2175 [heading Description]
2176 Returns the result type of __replace__, given the types of the input sequence and element to replace.
2177
2178 [heading Synopsis]
2179     template<
2180         typename Sequence,
2181         typename T
2182         >
2183     struct replace
2184     {
2185         typedef __unspecified__ type;
2186     };
2187
2188 [table Parameters
2189     [[Parameter][Requirement][Description]]
2190     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
2191     [[`T`][Any type][The type of the search and replacement objects]]
2192 ]
2193
2194 [heading Expression Semantics]
2195     __result_of_replace__<Sequence,T>::type
2196
2197 [*Return type]: A model of __forward_sequence__.
2198
2199 [*Semantics]: Returns the return type of __replace__.
2200
2201 [heading Complexity]
2202 Constant.
2203
2204 [heading Header]
2205
2206     #include <boost/fusion/algorithm/transformation/replace.hpp>
2207     #include <boost/fusion/include/replace.hpp>
2208
2209 [endsect]
2210
2211 [section replace_if]
2212
2213 [heading Description]
2214 Returns the result type of __replace_if__, given the types of the sequence, unary __mpl_lambda_expression__ predicate and replacement object.
2215
2216 [heading Synopsis]
2217     template<
2218         typename Sequence,
2219         typename F,
2220         typename T>
2221     struct replace_if
2222     {
2223         typedef __unspecified__ type;
2224     };
2225
2226 [table Parameters
2227     [[Parameter][Requirement][Description]]
2228     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
2229     [[`F`][A model of unary __mpl_lambda_expression__][Replacement predicate]]
2230     [[`T`][Any type][The type of the replacement object]]
2231 ]
2232
2233 [heading Expression Semantics]
2234     __result_of_replace_if__<Sequence,F,T>::type
2235
2236 [*Return type]: A model of __forward_sequence__.
2237
2238 [*Semantics]: Returns the return type of __replace_if__.
2239
2240 [heading Complexity]
2241 Constant.
2242
2243 [heading Header]
2244
2245     #include <boost/fusion/algorithm/transformation/replace_if.hpp>
2246     #include <boost/fusion/include/replace_if.hpp>
2247
2248 [endsect]
2249
2250 [section remove]
2251
2252 [heading Description]
2253 Returns the result type of __remove__, given the sequence and removal types.
2254
2255 [heading Synopsis]
2256     template<
2257         typename Sequence,
2258         typename T
2259         >
2260     struct remove
2261     {
2262         typedef __unspecified__ type;
2263     };
2264
2265 [table Parameters
2266     [[Parameter][Requirement][Description]]
2267     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
2268     [[`T`][Any type][Remove elements of this type]]
2269 ]
2270
2271 [heading Expression Semantics]
2272     __result_of_remove__<Sequence, T>::type
2273
2274 [*Return type]:
2275
2276 * A model of __forward_sequence__.
2277 * A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
2278
2279 [*Semantics]: Returns a sequence containing the elements of `Sequence` not of type `T`. Equivalent to `__result_of_remove_if__<Sequence, boost::is_same<mpl::_, T> >::type`.
2280
2281 [heading Complexity]
2282 Constant.
2283
2284 [heading Header]
2285
2286     #include <boost/fusion/algorithm/transformation/remove.hpp>
2287     #include <boost/fusion/include/remove.hpp>
2288
2289 [endsect]
2290
2291 [section remove_if]
2292
2293 [heading Description]
2294 Returns the result type of __remove_if__, given the input sequence and unary __mpl_lambda_expression__ predicate types.
2295
2296 [heading Synopsis]
2297     template<
2298         typename Sequence,
2299         typename Pred
2300         >
2301     struct remove_if
2302     {
2303         typedef __unspecified__ type;
2304     };
2305
2306 [table Parameters
2307     [[Parameter][Requirement][Description]]
2308     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
2309     [[`Pred`][A model of unary __mpl_lambda_expression__][Remove elements which evaluate to `boost::mpl::true_`]]
2310 ]
2311
2312 [heading Expression Semantics]
2313     __result_of_remove_if__<Sequence, Pred>::type
2314
2315 [*Return type]:
2316
2317 * A model of __forward_sequence__.
2318 * A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
2319
2320 [*Semantics]: Returns a sequence containing the elements of `Sequence` for which `Pred` evaluates to `boost::mpl::false_`.
2321
2322 [heading Complexity]
2323 Constant.
2324
2325 [heading Header]
2326
2327     #include <boost/fusion/algorithm/transformation/remove_if.hpp>
2328     #include <boost/fusion/include/remove_if.hpp>
2329
2330 [endsect]
2331
2332 [section reverse]
2333
2334 [heading Description]
2335 Returns the result type of __reverse__, given the input sequence type.
2336
2337 [heading Synopsis]
2338     template<
2339         typename Sequence
2340         >
2341     struct reverse
2342     {
2343         typedef __unspecified__ type;
2344     };
2345
2346 [table Parameters
2347     [[Parameter][Requirement][Description]]
2348     [[`Sequence`][A model of __bidirectional_sequence__][Operation's argument]]
2349 ]
2350
2351 [heading Expression Semantics]
2352     __result_of_reverse__<Sequence>::type
2353
2354 [*Return type]:
2355
2356 * A model of __bidirectional_sequence__ if `Sequence` is a __bidirectional_sequence__
2357 else, __random_access_sequence__ if `Sequence` is a __random_access_sequence__.
2358 * A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
2359
2360 [*Semantics]: Returns a sequence with the elements in the reverse order to `Sequence`.
2361
2362 [heading Complexity]
2363 Constant.
2364
2365 [heading Header]
2366
2367     #include <boost/fusion/algorithm/transformation/reverse.hpp>
2368     #include <boost/fusion/include/reverse.hpp>
2369
2370 [endsect]
2371
2372 [section clear]
2373
2374 [heading Description]
2375 Returns the result type of __clear__, given the input sequence type.
2376
2377 [heading Synopsis]
2378     template<
2379         typename Sequence
2380         >
2381     struct clear
2382     {
2383         typedef __unspecified__ type;
2384     };
2385
2386 [table Parameters
2387     [[Parameter][Requirement][Description]]
2388     [[`Sequence`][Any type][Operation's argument]]
2389 ]
2390
2391 [heading Expression Semantics]
2392     __result_of_clear__<Sequence>::type
2393
2394 [*Return type]: A model of __forward_sequence__.
2395
2396 [*Semantics]: Returns an empty sequence.
2397
2398 [heading Complexity]
2399 Constant.
2400
2401 [heading Header]
2402
2403     #include <boost/fusion/algorithm/transformation/clear.hpp>
2404     #include <boost/fusion/include/clear.hpp>
2405
2406 [endsect]
2407
2408 [section erase]
2409 Returns the result type of __erase__, given the input sequence and range delimiting iterator types.
2410
2411 [heading Description]
2412
2413 [heading Synopsis]
2414     template<
2415         typename Sequence,
2416         typename It1,
2417         typename It2 = __unspecified__>
2418     struct erase
2419     {
2420         typedef __unspecified__ type;
2421     };
2422
2423 [table Parameters
2424     [[Parameter][Requirement][Description]]
2425     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
2426     [[`It1`][A model of __forward_iterator__][Operation's argument]]
2427     [[`It2`][A model of __forward_iterator__][Operation's argument]]
2428 ]
2429
2430 [heading Expression Semantics]
2431     __result_of_erase__<Sequence, It1>::type
2432
2433 [*Return type]:
2434
2435 * A model of __forward_sequence__.
2436 * A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
2437
2438 [*Semantics]: Returns a new sequence with the element at `It1` removed.
2439
2440     __result_of_erase__<Sequence, It1, It2>::type
2441
2442 [*Return type]: A model of __forward_sequence__.
2443
2444 [*Semantics]: Returns a new sequence with the elements between `It1` and `It2` removed.
2445
2446 [heading Complexity]
2447 Constant.
2448
2449 [heading Header]
2450
2451     #include <boost/fusion/algorithm/transformation/erase.hpp>
2452     #include <boost/fusion/include/erase.hpp>
2453
2454 [endsect]
2455
2456 [section erase_key]
2457
2458 [heading Description]
2459 Returns the result type of __erase_key__, given the sequence and key types.
2460
2461 [heading Synopsis]
2462     template<
2463         typename Sequence,
2464         typename Key
2465         >
2466     struct erase_key
2467     {
2468         typedef __unspecified__ type;
2469     };
2470
2471 [table Parameters
2472     [[Parameter][Requirement][Description]]
2473     [[`Sequence`][A model of __forward_sequence__ and __associative_sequence__][Operation's argument]]
2474     [[`Key`][Any type][Key type]]
2475 ]
2476
2477 [heading Expression Semantics]
2478     __result_of_erase_key__<Sequence, Key>::type
2479
2480 [*Return type]: A model of __forward_sequence__ and __associative_sequence__.
2481
2482 [*Semantics]: Returns a sequence with the elements of `Sequence`, except those with key `Key`.
2483
2484 [heading Complexity]
2485 Constant.
2486
2487 [heading Header]
2488
2489     #include <boost/fusion/algorithm/transformation/erase_key.hpp>
2490     #include <boost/fusion/include/erase_key.hpp>
2491
2492 [endsect]
2493
2494 [section insert]
2495
2496 [heading Description]
2497 Returns the result type of __insert__, given the sequence, position iterator and insertion types.
2498
2499 [heading Synopsis]
2500     template<
2501         typename Sequence,
2502         typename Position,
2503         typename T
2504         >
2505     struct insert
2506     {
2507         typedef __unspecified__ type;
2508     };
2509
2510 [table Parameters
2511     [[Parameter][Requirement][Description]]
2512     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
2513     [[`Position`][A model of __forward_iterator__][Operation's argument]]
2514     [[`T`][Any type][Operation's argument]]
2515 ]
2516
2517 [heading Expression Semantics]
2518     __result_of_insert__<Sequence, Position, T>::type
2519
2520 [*Return type]:
2521
2522 * A model of __forward_sequence__.
2523
2524 [*Semantics]: Returns a sequence with an element of type `T` inserted at position `Position` in `Sequence`.
2525
2526 [heading Complexity]
2527 Constant.
2528
2529 [heading Header]
2530
2531     #include <boost/fusion/algorithm/transformation/insert.hpp>
2532     #include <boost/fusion/include/insert.hpp>
2533
2534 [endsect]
2535
2536 [section insert_range]
2537
2538 [heading Description]
2539 Returns the result type of __insert_range__, given the input sequence, position iterator and insertion range types.
2540
2541 [heading Synopsis]
2542     template<
2543         typename Sequence,
2544         typename Position,
2545         typename Range
2546         >
2547     struct insert_range
2548     {
2549         typedef __unspecified__ type;
2550     };
2551
2552 [table Parameters
2553     [[Parameter][Requirement][Description]]
2554     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
2555     [[`Position`][A model of __forward_iterator__][Operation's argument]]
2556     [[`Range`][A model of __forward_sequence__][Operation's argument]]
2557 ]
2558
2559 [heading Expression Semantics]
2560     __result_of_insert_range__<Sequence, Position, Range>::type
2561
2562 [*Return type]:
2563
2564 * A model of __forward_sequence__.
2565 * A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
2566
2567 [*Semantics]: Returns a sequence with the elements of `Range` inserted at position `Position` into `Sequence`.
2568
2569 [heading Complexity]
2570 Constant.
2571
2572 [heading Header]
2573
2574     #include <boost/fusion/algorithm/transformation/insert_range.hpp>
2575     #include <boost/fusion/include/insert_range.hpp>
2576
2577 [endsect]
2578
2579 [section join]
2580
2581 [heading Description]
2582 Returns the result of joining 2 sequences, given the sequence types.
2583
2584 [heading Synopsis]
2585     template<
2586         typename LhSequence,
2587         typename RhSequence
2588         >
2589     struct join
2590     {
2591         typedef __unspecified__ type;
2592     };
2593
2594 [heading Expression Semantics]
2595     __result_of_join__<LhSequence, RhSequence>::type
2596
2597 [*Return type]:
2598
2599 * A model of __forward_sequence__.
2600 * A model of __associative_sequence__ if `LhSequence` and `RhSequence` implement the __associative_sequence__ model.
2601
2602 [*Semantics]: Returns a sequence containing the elements of `LhSequence` followed by the elements of `RhSequence`. The order of the elements in the 2 sequences is preserved.
2603
2604 [heading Complexity]
2605 Constant.
2606
2607 [heading Header]
2608
2609     #include <boost/fusion/algorithm/transformation/join.hpp>
2610     #include <boost/fusion/include/join.hpp>
2611
2612 [endsect]
2613
2614 [section zip]
2615
2616 [heading Description]
2617 Zips sequences together to form a single sequence, whose members are tuples of the members of the component sequences.
2618
2619 [heading Synopsis]
2620     template<
2621         typename Sequence1,
2622         typename Sequence2,
2623         ...
2624         typename SequenceN
2625         >
2626     struct zip
2627     {
2628         typedef __unspecified__ type;
2629     };
2630
2631 [heading Expression Semantics]
2632     __result_of_zip__<Sequence1, Sequence2, ... SequenceN>::type
2633
2634 [*Return type]: A model of the most restrictive traversal category of sequences `Sequence1` to `SequenceN`.
2635
2636 [*Semantics]: Return a sequence containing tuples of elements from each sequence. For example, applying zip to tuples `(1, 2, 3)` and `('a', 'b', 'c')` would return `((1, 'a'),(2, 'b'),(3, 'c'))`
2637
2638 [heading Complexity]
2639 Constant.
2640
2641 [heading Header]
2642
2643     #include <boost/fusion/algorithm/transformation/zip.hpp>
2644     #include <boost/fusion/include/zip.hpp>
2645
2646 [endsect]
2647
2648 [section pop_back]
2649
2650 [heading Description]
2651 Returns the result type of __pop_back__, given the input sequence type.
2652
2653 [heading Synopsis]
2654     template<
2655         typename Sequence
2656         >
2657     struct pop_back
2658     {
2659         typedef __unspecified__ type;
2660     };
2661
2662 [table Parameters
2663     [[Parameter][Requirement][Description]]
2664     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
2665 ]
2666
2667 [heading Expression Semantics]
2668     __result_of_pop_back__<Sequence>::type
2669
2670 [*Return type]:
2671
2672 * A model of __forward_sequence__.
2673 * A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
2674
2675 [*Semantics]: Returns a sequence with all the elements of `Sequence` except the last element.
2676
2677 [heading Complexity]
2678 Constant.
2679
2680 [heading Header]
2681
2682     #include <boost/fusion/algorithm/transformation/pop_back.hpp>
2683     #include <boost/fusion/include/pop_back.hpp>
2684
2685 [endsect]
2686
2687 [section pop_front]
2688
2689 [heading Description]
2690 Returns the result type of __pop_front__, given the input sequence type.
2691
2692 [heading Synopsis]
2693     template<
2694         typename Sequence
2695         >
2696     struct pop_front
2697     {
2698         typedef __unspecified__ type;
2699     };
2700
2701 [table Parameters
2702     [[Parameter][Requirement][Description]]
2703     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
2704 ]
2705
2706 [heading Expression Semantics]
2707     __result_of_pop_front__<Sequence>::type
2708
2709 [*Return type]:
2710
2711 * A model of __forward_sequence__.
2712 * A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
2713
2714 [*Semantics]: Returns a sequence with all the elements of `Sequence` except the first element.
2715
2716 [heading Complexity]
2717 Constant.
2718
2719 [heading Header]
2720
2721     #include <boost/fusion/algorithm/transformation/pop_front.hpp>
2722     #include <boost/fusion/include/pop_front.hpp>
2723
2724 [endsect]
2725
2726 [section push_back]
2727
2728 [heading Description]
2729 Returns the result type of __push_back__, given the types of the input sequence and element to push.
2730
2731 [heading Synopsis]
2732     template<
2733         typename Sequence,
2734         typename T
2735         >
2736     struct push_back
2737     {
2738         typedef __unspecified__ type;
2739     };
2740
2741 [table Parameters
2742     [[Parameter][Requirement][Description]]
2743     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
2744     [[`T`][Any type][Operation's argument]]
2745 ]
2746
2747 [heading Expression Semantics]
2748     __result_of_push_back__<Sequence, T>::type
2749
2750 [*Return type]:
2751
2752 * A model of __forward_sequence__.
2753
2754 [*Semantics]: Returns a sequence with the elements of `Sequence` and an element of type `T` added to the end.
2755
2756 [heading Complexity]
2757 Constant.
2758
2759 [heading Header]
2760
2761     #include <boost/fusion/algorithm/transformation/push_back.hpp>
2762     #include <boost/fusion/include/push_back.hpp>
2763
2764 [endsect]
2765
2766 [section push_front]
2767
2768 [heading Description]
2769 Returns the result type of __push_front__, given the types of the input sequence and element to push.
2770
2771 [heading Synopsis]
2772     template<
2773         typename Sequence,
2774         typename T
2775         >
2776     struct push_front
2777     {
2778         typedef __unspecified__ type;
2779     };
2780
2781 [table Parameters
2782     [[Parameter][Requirement][Description]]
2783     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
2784     [[`T`][Any type][Operation's argument]]
2785 ]
2786
2787 [heading Expression Semantics]
2788     __result_of_push_front__<Sequence, T>::type
2789
2790 [*Return type]:
2791
2792 * A model of __forward_sequence__.
2793
2794 [*Semantics]: Returns a sequence with the elements of `Sequence` and an element of type `T` added to the beginning.
2795
2796 [heading Complexity]
2797 Constant.
2798
2799 [heading Header]
2800
2801     #include <boost/fusion/algorithm/transformation/push_front.hpp>
2802     #include <boost/fusion/include/push_front.hpp>
2803
2804 [endsect]
2805
2806 [section flatten]
2807
2808 [heading Description]
2809 Returns the result type of __flatten__, given the input sequence type.
2810
2811 [heading Synopsis]
2812     template<
2813         typename Sequence
2814         >
2815     struct flatten
2816     {
2817         typedef __unspecified__ type;
2818     };
2819
2820 [table Parameters
2821     [[Parameter][Requirement][Description]]
2822     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
2823 ]
2824
2825 [heading Expression Semantics]
2826     __result_of_flatten__<Sequence>::type
2827
2828 [*Return type]:
2829
2830 * A model of __forward_sequence__.
2831
2832 [*Semantics]: Returns a sequence with all the leaf elements of `Sequence`.
2833
2834 [heading Complexity]
2835 Constant.
2836
2837 [heading Header]
2838
2839     #include <boost/fusion/algorithm/transformation/flatten.hpp>
2840     #include <boost/fusion/include/flatten.hpp>
2841
2842 [endsect]
2843
2844 [endsect]
2845
2846 [endsect]
2847
2848 [endsect]