boost/proto/detail/preprocessed/expr.hpp

   1         ///////////////////////////////////////////////////////////////////////////////
   2         /// \file expr.hpp
   3         /// Contains definition of expr\<\> class template.
   4         //
   5         //  Copyright 2008 Eric Niebler. Distributed under the Boost
   6         //  Software License, Version 1.0. (See accompanying file
   7         //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   8
   9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36     template<typename Tag, typename Arg0>
  37     struct expr<Tag, term<Arg0>, 0>
  38     {
  39         typedef Tag proto_tag;
  40         static const long proto_arity_c = 0;
  41         typedef mpl::long_<0 > proto_arity;
  42         typedef expr proto_base_expr;
  43         typedef term<Arg0> proto_args;
  44         typedef basic_expr<Tag, proto_args, 0 > proto_grammar;
  45         typedef default_domain proto_domain;
  46         typedef default_generator proto_generator;
  47         typedef proto::tag::proto_expr fusion_tag;
  48         typedef expr proto_derived_expr;
  49         typedef void proto_is_expr_;
  50         typedef Arg0 proto_child0; proto_child0 child0;
  51         typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
  52
  53
  54         BOOST_FORCEINLINE
  55         expr const &proto_base() const
  56         {
  57             return *this;
  58         }
  59
  60
  61         BOOST_FORCEINLINE
  62         expr &proto_base()
  63         {
  64             return *this;
  65         }
  66
  67
  68
  69         template<typename A0>
  70         BOOST_FORCEINLINE
  71         static expr const make(A0 &a0)
  72         {
  73             return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
  74         }
  75
  76
  77         template<typename A0>
  78         BOOST_FORCEINLINE
  79         static expr const make(A0 const &a0)
  80         {
  81             return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
  82         }
  83
  84
  85         typedef detail::not_a_valid_type address_of_hack_type_;
  86
  87
  88
  89
  90         BOOST_FORCEINLINE
  91         proto::expr<
  92             proto::tag::assign
  93           , list2<expr &, expr const &>
  94           , 2
  95         > const
  96         operator =(expr const &a)
  97         {
  98             proto::expr<
  99                 proto::tag::assign
 100               , list2<expr &, expr const &>
 101               , 2
 102             > that = {*this, a};
 103             return that;
 104         }
 105
 106
 107
 108
 109         template<typename A>
 110         BOOST_FORCEINLINE
 111         proto::expr<
 112             proto::tag::assign
 113           , list2<expr const &, typename result_of::as_child<A>::type>
 114           , 2
 115         > const
 116         operator =(A &a) const
 117         {
 118             proto::expr<
 119                 proto::tag::assign
 120               , list2<expr const &, typename result_of::as_child<A>::type>
 121               , 2
 122             > that = {*this, proto::as_child(a)};
 123             return that;
 124         }
 125
 126
 127         template<typename A>
 128         BOOST_FORCEINLINE
 129         proto::expr<
 130             proto::tag::assign
 131           , list2<expr const &, typename result_of::as_child<A const>::type>
 132           , 2
 133         > const
 134         operator =(A const &a) const
 135         {
 136             proto::expr<
 137                 proto::tag::assign
 138               , list2<expr const &, typename result_of::as_child<A const>::type>
 139               , 2
 140             > that = {*this, proto::as_child(a)};
 141             return that;
 142         }
 143
 144
 145         template<typename A>
 146         BOOST_FORCEINLINE
 147         proto::expr<
 148             proto::tag::assign
 149           , list2<expr &, typename result_of::as_child<A>::type>
 150           , 2
 151         > const
 152         operator =(A &a)
 153         {
 154             proto::expr<
 155                 proto::tag::assign
 156               , list2<expr &, typename result_of::as_child<A>::type>
 157               , 2
 158             > that = {*this, proto::as_child(a)};
 159             return that;
 160         }
 161
 162
 163         template<typename A>
 164         BOOST_FORCEINLINE
 165         proto::expr<
 166             proto::tag::assign
 167           , list2<expr &, typename result_of::as_child<A const>::type>
 168           , 2
 169         > const
 170         operator =(A const &a)
 171         {
 172             proto::expr<
 173                 proto::tag::assign
 174               , list2<expr &, typename result_of::as_child<A const>::type>
 175               , 2
 176             > that = {*this, proto::as_child(a)};
 177             return that;
 178         }
 179
 180
 181
 182
 183         template<typename A>
 184         BOOST_FORCEINLINE
 185         proto::expr<
 186             proto::tag::subscript
 187           , list2<expr const &, typename result_of::as_child<A>::type>
 188           , 2
 189         > const
 190         operator [](A &a) const
 191         {
 192             proto::expr<
 193                 proto::tag::subscript
 194               , list2<expr const &, typename result_of::as_child<A>::type>
 195               , 2
 196             > that = {*this, proto::as_child(a)};
 197             return that;
 198         }
 199
 200
 201         template<typename A>
 202         BOOST_FORCEINLINE
 203         proto::expr<
 204             proto::tag::subscript
 205           , list2<expr const &, typename result_of::as_child<A const>::type>
 206           , 2
 207         > const
 208         operator [](A const &a) const
 209         {
 210             proto::expr<
 211                 proto::tag::subscript
 212               , list2<expr const &, typename result_of::as_child<A const>::type>
 213               , 2
 214             > that = {*this, proto::as_child(a)};
 215             return that;
 216         }
 217
 218
 219         template<typename A>
 220         BOOST_FORCEINLINE
 221         proto::expr<
 222             proto::tag::subscript
 223           , list2<expr &, typename result_of::as_child<A>::type>
 224           , 2
 225         > const
 226         operator [](A &a)
 227         {
 228             proto::expr<
 229                 proto::tag::subscript
 230               , list2<expr &, typename result_of::as_child<A>::type>
 231               , 2
 232             > that = {*this, proto::as_child(a)};
 233             return that;
 234         }
 235
 236
 237         template<typename A>
 238         BOOST_FORCEINLINE
 239         proto::expr<
 240             proto::tag::subscript
 241           , list2<expr &, typename result_of::as_child<A const>::type>
 242           , 2
 243         > const
 244         operator [](A const &a)
 245         {
 246             proto::expr<
 247                 proto::tag::subscript
 248               , list2<expr &, typename result_of::as_child<A const>::type>
 249               , 2
 250             > that = {*this, proto::as_child(a)};
 251             return that;
 252         }
 253
 254
 255         template<typename Sig>
 256         struct result
 257         {
 258             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
 259         };
 260
 261
 262
 263         BOOST_FORCEINLINE
 264         proto::expr<proto::tag::function, list1<expr const &>, 1> const
 265         operator ()() const
 266         {
 267             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
 268             return that;
 269         }
 270
 271
 272         BOOST_FORCEINLINE
 273         proto::expr<proto::tag::function, list1<expr &>, 1> const
 274         operator ()()
 275         {
 276             proto::expr<proto::tag::function, list1<expr &>, 1> that = {*this};
 277             return that;
 278         }
 279
 280
 281         template<typename A0>
 282         BOOST_FORCEINLINE
 283         typename result_of::funop1<
 284             expr const
 285           , default_domain , const A0
 286         >::type const
 287         operator ()(A0 const &a0) const
 288         {
 289             return result_of::funop1<
 290                 expr const
 291               , default_domain , const A0
 292             >::call(*this , a0);
 293         }
 294
 295
 296         template<typename A0>
 297         BOOST_FORCEINLINE
 298         typename result_of::funop1<
 299             expr
 300           , default_domain , const A0
 301         >::type const
 302         operator ()(A0 const &a0)
 303         {
 304             return result_of::funop1<
 305                 expr
 306               , default_domain , const A0
 307             >::call(*this , a0);
 308         }
 309
 310
 311         template<typename A0 , typename A1>
 312         BOOST_FORCEINLINE
 313         typename result_of::funop2<
 314             expr const
 315           , default_domain , const A0 , const A1
 316         >::type const
 317         operator ()(A0 const &a0 , A1 const &a1) const
 318         {
 319             return result_of::funop2<
 320                 expr const
 321               , default_domain , const A0 , const A1
 322             >::call(*this , a0 , a1);
 323         }
 324
 325
 326         template<typename A0 , typename A1>
 327         BOOST_FORCEINLINE
 328         typename result_of::funop2<
 329             expr
 330           , default_domain , const A0 , const A1
 331         >::type const
 332         operator ()(A0 const &a0 , A1 const &a1)
 333         {
 334             return result_of::funop2<
 335                 expr
 336               , default_domain , const A0 , const A1
 337             >::call(*this , a0 , a1);
 338         }
 339
 340
 341         template<typename A0 , typename A1 , typename A2>
 342         BOOST_FORCEINLINE
 343         typename result_of::funop3<
 344             expr const
 345           , default_domain , const A0 , const A1 , const A2
 346         >::type const
 347         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
 348         {
 349             return result_of::funop3<
 350                 expr const
 351               , default_domain , const A0 , const A1 , const A2
 352             >::call(*this , a0 , a1 , a2);
 353         }
 354
 355
 356         template<typename A0 , typename A1 , typename A2>
 357         BOOST_FORCEINLINE
 358         typename result_of::funop3<
 359             expr
 360           , default_domain , const A0 , const A1 , const A2
 361         >::type const
 362         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2)
 363         {
 364             return result_of::funop3<
 365                 expr
 366               , default_domain , const A0 , const A1 , const A2
 367             >::call(*this , a0 , a1 , a2);
 368         }
 369
 370
 371         template<typename A0 , typename A1 , typename A2 , typename A3>
 372         BOOST_FORCEINLINE
 373         typename result_of::funop4<
 374             expr const
 375           , default_domain , const A0 , const A1 , const A2 , const A3
 376         >::type const
 377         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
 378         {
 379             return result_of::funop4<
 380                 expr const
 381               , default_domain , const A0 , const A1 , const A2 , const A3
 382             >::call(*this , a0 , a1 , a2 , a3);
 383         }
 384
 385
 386         template<typename A0 , typename A1 , typename A2 , typename A3>
 387         BOOST_FORCEINLINE
 388         typename result_of::funop4<
 389             expr
 390           , default_domain , const A0 , const A1 , const A2 , const A3
 391         >::type const
 392         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3)
 393         {
 394             return result_of::funop4<
 395                 expr
 396               , default_domain , const A0 , const A1 , const A2 , const A3
 397             >::call(*this , a0 , a1 , a2 , a3);
 398         }
 399
 400
 401         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
 402         BOOST_FORCEINLINE
 403         typename result_of::funop5<
 404             expr const
 405           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
 406         >::type const
 407         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
 408         {
 409             return result_of::funop5<
 410                 expr const
 411               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
 412             >::call(*this , a0 , a1 , a2 , a3 , a4);
 413         }
 414
 415
 416         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
 417         BOOST_FORCEINLINE
 418         typename result_of::funop5<
 419             expr
 420           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
 421         >::type const
 422         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4)
 423         {
 424             return result_of::funop5<
 425                 expr
 426               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
 427             >::call(*this , a0 , a1 , a2 , a3 , a4);
 428         }
 429
 430
 431         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 432         BOOST_FORCEINLINE
 433         typename result_of::funop6<
 434             expr const
 435           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
 436         >::type const
 437         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
 438         {
 439             return result_of::funop6<
 440                 expr const
 441               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
 442             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
 443         }
 444
 445
 446         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 447         BOOST_FORCEINLINE
 448         typename result_of::funop6<
 449             expr
 450           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
 451         >::type const
 452         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
 453         {
 454             return result_of::funop6<
 455                 expr
 456               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
 457             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
 458         }
 459
 460
 461         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 462         BOOST_FORCEINLINE
 463         typename result_of::funop7<
 464             expr const
 465           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
 466         >::type const
 467         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
 468         {
 469             return result_of::funop7<
 470                 expr const
 471               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
 472             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
 473         }
 474
 475
 476         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 477         BOOST_FORCEINLINE
 478         typename result_of::funop7<
 479             expr
 480           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
 481         >::type const
 482         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
 483         {
 484             return result_of::funop7<
 485                 expr
 486               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
 487             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
 488         }
 489
 490
 491         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
 492         BOOST_FORCEINLINE
 493         typename result_of::funop8<
 494             expr const
 495           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
 496         >::type const
 497         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
 498         {
 499             return result_of::funop8<
 500                 expr const
 501               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
 502             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
 503         }
 504
 505
 506         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
 507         BOOST_FORCEINLINE
 508         typename result_of::funop8<
 509             expr
 510           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
 511         >::type const
 512         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
 513         {
 514             return result_of::funop8<
 515                 expr
 516               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
 517             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
 518         }
 519
 520
 521         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
 522         BOOST_FORCEINLINE
 523         typename result_of::funop9<
 524             expr const
 525           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
 526         >::type const
 527         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
 528         {
 529             return result_of::funop9<
 530                 expr const
 531               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
 532             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
 533         }
 534
 535
 536         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
 537         BOOST_FORCEINLINE
 538         typename result_of::funop9<
 539             expr
 540           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
 541         >::type const
 542         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
 543         {
 544             return result_of::funop9<
 545                 expr
 546               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
 547             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
 548         }
 549     };
 550
 551
 552
 553
 554
 555
 556
 557
 558
 559
 560
 561
 562
 563
 564
 565
 566
 567
 568
 569
 570
 571
 572
 573
 574
 575
 576
 577     template<typename Tag , typename Arg0>
 578     struct expr<Tag, list1<Arg0>, 1 >
 579     {
 580         typedef Tag proto_tag;
 581         static const long proto_arity_c = 1;
 582         typedef mpl::long_<1 > proto_arity;
 583         typedef expr proto_base_expr;
 584         typedef list1<Arg0> proto_args;
 585         typedef basic_expr<Tag, proto_args, 1 > proto_grammar;
 586         typedef default_domain proto_domain;
 587         typedef default_generator proto_generator;
 588         typedef proto::tag::proto_expr fusion_tag;
 589         typedef expr proto_derived_expr;
 590         typedef void proto_is_expr_;
 591         typedef Arg0 proto_child0; proto_child0 child0;
 592         typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
 593
 594
 595         BOOST_FORCEINLINE
 596         expr const &proto_base() const
 597         {
 598             return *this;
 599         }
 600
 601
 602         BOOST_FORCEINLINE
 603         expr &proto_base()
 604         {
 605             return *this;
 606         }
 607
 608
 609
 610         template<typename A0>
 611         BOOST_FORCEINLINE
 612         static expr const make(A0 const &a0)
 613         {
 614             expr that = {a0};
 615             return that;
 616         }
 617
 618
 619
 620         typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_;
 621
 622
 623
 624
 625
 626
 627
 628         BOOST_FORCEINLINE
 629         operator address_of_hack_type_() const
 630         {
 631             return boost::addressof(this->child0);
 632         }
 633
 634
 635
 636
 637         BOOST_FORCEINLINE
 638         proto::expr<
 639             proto::tag::assign
 640           , list2<expr &, expr const &>
 641           , 2
 642         > const
 643         operator =(expr const &a)
 644         {
 645             proto::expr<
 646                 proto::tag::assign
 647               , list2<expr &, expr const &>
 648               , 2
 649             > that = {*this, a};
 650             return that;
 651         }
 652
 653
 654
 655
 656         template<typename A>
 657         BOOST_FORCEINLINE
 658         proto::expr<
 659             proto::tag::assign
 660           , list2<expr const &, typename result_of::as_child<A>::type>
 661           , 2
 662         > const
 663         operator =(A &a) const
 664         {
 665             proto::expr<
 666                 proto::tag::assign
 667               , list2<expr const &, typename result_of::as_child<A>::type>
 668               , 2
 669             > that = {*this, proto::as_child(a)};
 670             return that;
 671         }
 672
 673
 674         template<typename A>
 675         BOOST_FORCEINLINE
 676         proto::expr<
 677             proto::tag::assign
 678           , list2<expr const &, typename result_of::as_child<A const>::type>
 679           , 2
 680         > const
 681         operator =(A const &a) const
 682         {
 683             proto::expr<
 684                 proto::tag::assign
 685               , list2<expr const &, typename result_of::as_child<A const>::type>
 686               , 2
 687             > that = {*this, proto::as_child(a)};
 688             return that;
 689         }
 690
 691
 692
 693
 694         template<typename A>
 695         BOOST_FORCEINLINE
 696         proto::expr<
 697             proto::tag::subscript
 698           , list2<expr const &, typename result_of::as_child<A>::type>
 699           , 2
 700         > const
 701         operator [](A &a) const
 702         {
 703             proto::expr<
 704                 proto::tag::subscript
 705               , list2<expr const &, typename result_of::as_child<A>::type>
 706               , 2
 707             > that = {*this, proto::as_child(a)};
 708             return that;
 709         }
 710
 711
 712         template<typename A>
 713         BOOST_FORCEINLINE
 714         proto::expr<
 715             proto::tag::subscript
 716           , list2<expr const &, typename result_of::as_child<A const>::type>
 717           , 2
 718         > const
 719         operator [](A const &a) const
 720         {
 721             proto::expr<
 722                 proto::tag::subscript
 723               , list2<expr const &, typename result_of::as_child<A const>::type>
 724               , 2
 725             > that = {*this, proto::as_child(a)};
 726             return that;
 727         }
 728
 729
 730         template<typename Sig>
 731         struct result
 732         {
 733             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
 734         };
 735
 736
 737
 738         BOOST_FORCEINLINE
 739         proto::expr<proto::tag::function, list1<expr const &>, 1> const
 740         operator ()() const
 741         {
 742             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
 743             return that;
 744         }
 745
 746
 747         template<typename A0>
 748         BOOST_FORCEINLINE
 749         typename result_of::funop1<
 750             expr const
 751           , default_domain , const A0
 752         >::type const
 753         operator ()(A0 const &a0) const
 754         {
 755             return result_of::funop1<
 756                 expr const
 757               , default_domain , const A0
 758             >::call(*this , a0);
 759         }
 760
 761
 762         template<typename A0 , typename A1>
 763         BOOST_FORCEINLINE
 764         typename result_of::funop2<
 765             expr const
 766           , default_domain , const A0 , const A1
 767         >::type const
 768         operator ()(A0 const &a0 , A1 const &a1) const
 769         {
 770             return result_of::funop2<
 771                 expr const
 772               , default_domain , const A0 , const A1
 773             >::call(*this , a0 , a1);
 774         }
 775
 776
 777         template<typename A0 , typename A1 , typename A2>
 778         BOOST_FORCEINLINE
 779         typename result_of::funop3<
 780             expr const
 781           , default_domain , const A0 , const A1 , const A2
 782         >::type const
 783         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
 784         {
 785             return result_of::funop3<
 786                 expr const
 787               , default_domain , const A0 , const A1 , const A2
 788             >::call(*this , a0 , a1 , a2);
 789         }
 790
 791
 792         template<typename A0 , typename A1 , typename A2 , typename A3>
 793         BOOST_FORCEINLINE
 794         typename result_of::funop4<
 795             expr const
 796           , default_domain , const A0 , const A1 , const A2 , const A3
 797         >::type const
 798         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
 799         {
 800             return result_of::funop4<
 801                 expr const
 802               , default_domain , const A0 , const A1 , const A2 , const A3
 803             >::call(*this , a0 , a1 , a2 , a3);
 804         }
 805
 806
 807         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
 808         BOOST_FORCEINLINE
 809         typename result_of::funop5<
 810             expr const
 811           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
 812         >::type const
 813         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
 814         {
 815             return result_of::funop5<
 816                 expr const
 817               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
 818             >::call(*this , a0 , a1 , a2 , a3 , a4);
 819         }
 820
 821
 822         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 823         BOOST_FORCEINLINE
 824         typename result_of::funop6<
 825             expr const
 826           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
 827         >::type const
 828         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
 829         {
 830             return result_of::funop6<
 831                 expr const
 832               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
 833             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
 834         }
 835
 836
 837         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 838         BOOST_FORCEINLINE
 839         typename result_of::funop7<
 840             expr const
 841           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
 842         >::type const
 843         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
 844         {
 845             return result_of::funop7<
 846                 expr const
 847               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
 848             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
 849         }
 850
 851
 852         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
 853         BOOST_FORCEINLINE
 854         typename result_of::funop8<
 855             expr const
 856           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
 857         >::type const
 858         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
 859         {
 860             return result_of::funop8<
 861                 expr const
 862               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
 863             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
 864         }
 865
 866
 867         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
 868         BOOST_FORCEINLINE
 869         typename result_of::funop9<
 870             expr const
 871           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
 872         >::type const
 873         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
 874         {
 875             return result_of::funop9<
 876                 expr const
 877               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
 878             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
 879         }
 880     };
 881
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897
 898
 899
 900
 901
 902
 903
 904
 905
 906
 907
 908     template<typename Tag , typename Arg0 , typename Arg1>
 909     struct expr<Tag, list2<Arg0 , Arg1>, 2 >
 910     {
 911         typedef Tag proto_tag;
 912         static const long proto_arity_c = 2;
 913         typedef mpl::long_<2 > proto_arity;
 914         typedef expr proto_base_expr;
 915         typedef list2<Arg0 , Arg1> proto_args;
 916         typedef basic_expr<Tag, proto_args, 2 > proto_grammar;
 917         typedef default_domain proto_domain;
 918         typedef default_generator proto_generator;
 919         typedef proto::tag::proto_expr fusion_tag;
 920         typedef expr proto_derived_expr;
 921         typedef void proto_is_expr_;
 922         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1;
 923         typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
 924
 925
 926         BOOST_FORCEINLINE
 927         expr const &proto_base() const
 928         {
 929             return *this;
 930         }
 931
 932
 933         BOOST_FORCEINLINE
 934         expr &proto_base()
 935         {
 936             return *this;
 937         }
 938
 939
 940
 941         template<typename A0 , typename A1>
 942         BOOST_FORCEINLINE
 943         static expr const make(A0 const &a0 , A1 const &a1)
 944         {
 945             expr that = {a0 , a1};
 946             return that;
 947         }
 948
 949
 950         typedef detail::not_a_valid_type address_of_hack_type_;
 951
 952
 953
 954
 955         BOOST_FORCEINLINE
 956         proto::expr<
 957             proto::tag::assign
 958           , list2<expr &, expr const &>
 959           , 2
 960         > const
 961         operator =(expr const &a)
 962         {
 963             proto::expr<
 964                 proto::tag::assign
 965               , list2<expr &, expr const &>
 966               , 2
 967             > that = {*this, a};
 968             return that;
 969         }
 970
 971
 972
 973
 974         template<typename A>
 975         BOOST_FORCEINLINE
 976         proto::expr<
 977             proto::tag::assign
 978           , list2<expr const &, typename result_of::as_child<A>::type>
 979           , 2
 980         > const
 981         operator =(A &a) const
 982         {
 983             proto::expr<
 984                 proto::tag::assign
 985               , list2<expr const &, typename result_of::as_child<A>::type>
 986               , 2
 987             > that = {*this, proto::as_child(a)};
 988             return that;
 989         }
 990
 991
 992         template<typename A>
 993         BOOST_FORCEINLINE
 994         proto::expr<
 995             proto::tag::assign
 996           , list2<expr const &, typename result_of::as_child<A const>::type>
 997           , 2
 998         > const
 999         operator =(A const &a) const
1000         {
1001             proto::expr<
1002                 proto::tag::assign
1003               , list2<expr const &, typename result_of::as_child<A const>::type>
1004               , 2
1005             > that = {*this, proto::as_child(a)};
1006             return that;
1007         }
1008
1009
1010
1011
1012         template<typename A>
1013         BOOST_FORCEINLINE
1014         proto::expr<
1015             proto::tag::subscript
1016           , list2<expr const &, typename result_of::as_child<A>::type>
1017           , 2
1018         > const
1019         operator [](A &a) const
1020         {
1021             proto::expr<
1022                 proto::tag::subscript
1023               , list2<expr const &, typename result_of::as_child<A>::type>
1024               , 2
1025             > that = {*this, proto::as_child(a)};
1026             return that;
1027         }
1028
1029
1030         template<typename A>
1031         BOOST_FORCEINLINE
1032         proto::expr<
1033             proto::tag::subscript
1034           , list2<expr const &, typename result_of::as_child<A const>::type>
1035           , 2
1036         > const
1037         operator [](A const &a) const
1038         {
1039             proto::expr<
1040                 proto::tag::subscript
1041               , list2<expr const &, typename result_of::as_child<A const>::type>
1042               , 2
1043             > that = {*this, proto::as_child(a)};
1044             return that;
1045         }
1046
1047
1048         template<typename Sig>
1049         struct result
1050         {
1051             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
1052         };
1053
1054
1055
1056         BOOST_FORCEINLINE
1057         proto::expr<proto::tag::function, list1<expr const &>, 1> const
1058         operator ()() const
1059         {
1060             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
1061             return that;
1062         }
1063
1064
1065         template<typename A0>
1066         BOOST_FORCEINLINE
1067         typename result_of::funop1<
1068             expr const
1069           , default_domain , const A0
1070         >::type const
1071         operator ()(A0 const &a0) const
1072         {
1073             return result_of::funop1<
1074                 expr const
1075               , default_domain , const A0
1076             >::call(*this , a0);
1077         }
1078
1079
1080         template<typename A0 , typename A1>
1081         BOOST_FORCEINLINE
1082         typename result_of::funop2<
1083             expr const
1084           , default_domain , const A0 , const A1
1085         >::type const
1086         operator ()(A0 const &a0 , A1 const &a1) const
1087         {
1088             return result_of::funop2<
1089                 expr const
1090               , default_domain , const A0 , const A1
1091             >::call(*this , a0 , a1);
1092         }
1093
1094
1095         template<typename A0 , typename A1 , typename A2>
1096         BOOST_FORCEINLINE
1097         typename result_of::funop3<
1098             expr const
1099           , default_domain , const A0 , const A1 , const A2
1100         >::type const
1101         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
1102         {
1103             return result_of::funop3<
1104                 expr const
1105               , default_domain , const A0 , const A1 , const A2
1106             >::call(*this , a0 , a1 , a2);
1107         }
1108
1109
1110         template<typename A0 , typename A1 , typename A2 , typename A3>
1111         BOOST_FORCEINLINE
1112         typename result_of::funop4<
1113             expr const
1114           , default_domain , const A0 , const A1 , const A2 , const A3
1115         >::type const
1116         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
1117         {
1118             return result_of::funop4<
1119                 expr const
1120               , default_domain , const A0 , const A1 , const A2 , const A3
1121             >::call(*this , a0 , a1 , a2 , a3);
1122         }
1123
1124
1125         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
1126         BOOST_FORCEINLINE
1127         typename result_of::funop5<
1128             expr const
1129           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
1130         >::type const
1131         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
1132         {
1133             return result_of::funop5<
1134                 expr const
1135               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
1136             >::call(*this , a0 , a1 , a2 , a3 , a4);
1137         }
1138
1139
1140         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
1141         BOOST_FORCEINLINE
1142         typename result_of::funop6<
1143             expr const
1144           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
1145         >::type const
1146         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
1147         {
1148             return result_of::funop6<
1149                 expr const
1150               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
1151             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
1152         }
1153
1154
1155         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
1156         BOOST_FORCEINLINE
1157         typename result_of::funop7<
1158             expr const
1159           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
1160         >::type const
1161         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
1162         {
1163             return result_of::funop7<
1164                 expr const
1165               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
1166             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
1167         }
1168
1169
1170         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1171         BOOST_FORCEINLINE
1172         typename result_of::funop8<
1173             expr const
1174           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
1175         >::type const
1176         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
1177         {
1178             return result_of::funop8<
1179                 expr const
1180               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
1181             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
1182         }
1183
1184
1185         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1186         BOOST_FORCEINLINE
1187         typename result_of::funop9<
1188             expr const
1189           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
1190         >::type const
1191         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
1192         {
1193             return result_of::funop9<
1194                 expr const
1195               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
1196             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
1197         }
1198     };
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2>
1227     struct expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 >
1228     {
1229         typedef Tag proto_tag;
1230         static const long proto_arity_c = 3;
1231         typedef mpl::long_<3 > proto_arity;
1232         typedef expr proto_base_expr;
1233         typedef list3<Arg0 , Arg1 , Arg2> proto_args;
1234         typedef basic_expr<Tag, proto_args, 3 > proto_grammar;
1235         typedef default_domain proto_domain;
1236         typedef default_generator proto_generator;
1237         typedef proto::tag::proto_expr fusion_tag;
1238         typedef expr proto_derived_expr;
1239         typedef void proto_is_expr_;
1240         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2;
1241         typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
1242
1243
1244         BOOST_FORCEINLINE
1245         expr const &proto_base() const
1246         {
1247             return *this;
1248         }
1249
1250
1251         BOOST_FORCEINLINE
1252         expr &proto_base()
1253         {
1254             return *this;
1255         }
1256
1257
1258
1259         template<typename A0 , typename A1 , typename A2>
1260         BOOST_FORCEINLINE
1261         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2)
1262         {
1263             expr that = {a0 , a1 , a2};
1264             return that;
1265         }
1266
1267
1268         typedef detail::not_a_valid_type address_of_hack_type_;
1269
1270
1271
1272
1273         BOOST_FORCEINLINE
1274         proto::expr<
1275             proto::tag::assign
1276           , list2<expr &, expr const &>
1277           , 2
1278         > const
1279         operator =(expr const &a)
1280         {
1281             proto::expr<
1282                 proto::tag::assign
1283               , list2<expr &, expr const &>
1284               , 2
1285             > that = {*this, a};
1286             return that;
1287         }
1288
1289
1290
1291
1292         template<typename A>
1293         BOOST_FORCEINLINE
1294         proto::expr<
1295             proto::tag::assign
1296           , list2<expr const &, typename result_of::as_child<A>::type>
1297           , 2
1298         > const
1299         operator =(A &a) const
1300         {
1301             proto::expr<
1302                 proto::tag::assign
1303               , list2<expr const &, typename result_of::as_child<A>::type>
1304               , 2
1305             > that = {*this, proto::as_child(a)};
1306             return that;
1307         }
1308
1309
1310         template<typename A>
1311         BOOST_FORCEINLINE
1312         proto::expr<
1313             proto::tag::assign
1314           , list2<expr const &, typename result_of::as_child<A const>::type>
1315           , 2
1316         > const
1317         operator =(A const &a) const
1318         {
1319             proto::expr<
1320                 proto::tag::assign
1321               , list2<expr const &, typename result_of::as_child<A const>::type>
1322               , 2
1323             > that = {*this, proto::as_child(a)};
1324             return that;
1325         }
1326
1327
1328
1329
1330         template<typename A>
1331         BOOST_FORCEINLINE
1332         proto::expr<
1333             proto::tag::subscript
1334           , list2<expr const &, typename result_of::as_child<A>::type>
1335           , 2
1336         > const
1337         operator [](A &a) const
1338         {
1339             proto::expr<
1340                 proto::tag::subscript
1341               , list2<expr const &, typename result_of::as_child<A>::type>
1342               , 2
1343             > that = {*this, proto::as_child(a)};
1344             return that;
1345         }
1346
1347
1348         template<typename A>
1349         BOOST_FORCEINLINE
1350         proto::expr<
1351             proto::tag::subscript
1352           , list2<expr const &, typename result_of::as_child<A const>::type>
1353           , 2
1354         > const
1355         operator [](A const &a) const
1356         {
1357             proto::expr<
1358                 proto::tag::subscript
1359               , list2<expr const &, typename result_of::as_child<A const>::type>
1360               , 2
1361             > that = {*this, proto::as_child(a)};
1362             return that;
1363         }
1364
1365
1366         template<typename Sig>
1367         struct result
1368         {
1369             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
1370         };
1371
1372
1373
1374         BOOST_FORCEINLINE
1375         proto::expr<proto::tag::function, list1<expr const &>, 1> const
1376         operator ()() const
1377         {
1378             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
1379             return that;
1380         }
1381
1382
1383         template<typename A0>
1384         BOOST_FORCEINLINE
1385         typename result_of::funop1<
1386             expr const
1387           , default_domain , const A0
1388         >::type const
1389         operator ()(A0 const &a0) const
1390         {
1391             return result_of::funop1<
1392                 expr const
1393               , default_domain , const A0
1394             >::call(*this , a0);
1395         }
1396
1397
1398         template<typename A0 , typename A1>
1399         BOOST_FORCEINLINE
1400         typename result_of::funop2<
1401             expr const
1402           , default_domain , const A0 , const A1
1403         >::type const
1404         operator ()(A0 const &a0 , A1 const &a1) const
1405         {
1406             return result_of::funop2<
1407                 expr const
1408               , default_domain , const A0 , const A1
1409             >::call(*this , a0 , a1);
1410         }
1411
1412
1413         template<typename A0 , typename A1 , typename A2>
1414         BOOST_FORCEINLINE
1415         typename result_of::funop3<
1416             expr const
1417           , default_domain , const A0 , const A1 , const A2
1418         >::type const
1419         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
1420         {
1421             return result_of::funop3<
1422                 expr const
1423               , default_domain , const A0 , const A1 , const A2
1424             >::call(*this , a0 , a1 , a2);
1425         }
1426
1427
1428         template<typename A0 , typename A1 , typename A2 , typename A3>
1429         BOOST_FORCEINLINE
1430         typename result_of::funop4<
1431             expr const
1432           , default_domain , const A0 , const A1 , const A2 , const A3
1433         >::type const
1434         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
1435         {
1436             return result_of::funop4<
1437                 expr const
1438               , default_domain , const A0 , const A1 , const A2 , const A3
1439             >::call(*this , a0 , a1 , a2 , a3);
1440         }
1441
1442
1443         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
1444         BOOST_FORCEINLINE
1445         typename result_of::funop5<
1446             expr const
1447           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
1448         >::type const
1449         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
1450         {
1451             return result_of::funop5<
1452                 expr const
1453               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
1454             >::call(*this , a0 , a1 , a2 , a3 , a4);
1455         }
1456
1457
1458         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
1459         BOOST_FORCEINLINE
1460         typename result_of::funop6<
1461             expr const
1462           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
1463         >::type const
1464         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
1465         {
1466             return result_of::funop6<
1467                 expr const
1468               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
1469             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
1470         }
1471
1472
1473         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
1474         BOOST_FORCEINLINE
1475         typename result_of::funop7<
1476             expr const
1477           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
1478         >::type const
1479         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
1480         {
1481             return result_of::funop7<
1482                 expr const
1483               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
1484             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
1485         }
1486
1487
1488         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1489         BOOST_FORCEINLINE
1490         typename result_of::funop8<
1491             expr const
1492           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
1493         >::type const
1494         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
1495         {
1496             return result_of::funop8<
1497                 expr const
1498               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
1499             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
1500         }
1501
1502
1503         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1504         BOOST_FORCEINLINE
1505         typename result_of::funop9<
1506             expr const
1507           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
1508         >::type const
1509         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
1510         {
1511             return result_of::funop9<
1512                 expr const
1513               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
1514             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
1515         }
1516     };
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3>
1545     struct expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 >
1546     {
1547         typedef Tag proto_tag;
1548         static const long proto_arity_c = 4;
1549         typedef mpl::long_<4 > proto_arity;
1550         typedef expr proto_base_expr;
1551         typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args;
1552         typedef basic_expr<Tag, proto_args, 4 > proto_grammar;
1553         typedef default_domain proto_domain;
1554         typedef default_generator proto_generator;
1555         typedef proto::tag::proto_expr fusion_tag;
1556         typedef expr proto_derived_expr;
1557         typedef void proto_is_expr_;
1558         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3;
1559         typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
1560
1561
1562         BOOST_FORCEINLINE
1563         expr const &proto_base() const
1564         {
1565             return *this;
1566         }
1567
1568
1569         BOOST_FORCEINLINE
1570         expr &proto_base()
1571         {
1572             return *this;
1573         }
1574
1575
1576
1577         template<typename A0 , typename A1 , typename A2 , typename A3>
1578         BOOST_FORCEINLINE
1579         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3)
1580         {
1581             expr that = {a0 , a1 , a2 , a3};
1582             return that;
1583         }
1584
1585
1586         typedef detail::not_a_valid_type address_of_hack_type_;
1587
1588
1589
1590
1591         BOOST_FORCEINLINE
1592         proto::expr<
1593             proto::tag::assign
1594           , list2<expr &, expr const &>
1595           , 2
1596         > const
1597         operator =(expr const &a)
1598         {
1599             proto::expr<
1600                 proto::tag::assign
1601               , list2<expr &, expr const &>
1602               , 2
1603             > that = {*this, a};
1604             return that;
1605         }
1606
1607
1608
1609
1610         template<typename A>
1611         BOOST_FORCEINLINE
1612         proto::expr<
1613             proto::tag::assign
1614           , list2<expr const &, typename result_of::as_child<A>::type>
1615           , 2
1616         > const
1617         operator =(A &a) const
1618         {
1619             proto::expr<
1620                 proto::tag::assign
1621               , list2<expr const &, typename result_of::as_child<A>::type>
1622               , 2
1623             > that = {*this, proto::as_child(a)};
1624             return that;
1625         }
1626
1627
1628         template<typename A>
1629         BOOST_FORCEINLINE
1630         proto::expr<
1631             proto::tag::assign
1632           , list2<expr const &, typename result_of::as_child<A const>::type>
1633           , 2
1634         > const
1635         operator =(A const &a) const
1636         {
1637             proto::expr<
1638                 proto::tag::assign
1639               , list2<expr const &, typename result_of::as_child<A const>::type>
1640               , 2
1641             > that = {*this, proto::as_child(a)};
1642             return that;
1643         }
1644
1645
1646
1647
1648         template<typename A>
1649         BOOST_FORCEINLINE
1650         proto::expr<
1651             proto::tag::subscript
1652           , list2<expr const &, typename result_of::as_child<A>::type>
1653           , 2
1654         > const
1655         operator [](A &a) const
1656         {
1657             proto::expr<
1658                 proto::tag::subscript
1659               , list2<expr const &, typename result_of::as_child<A>::type>
1660               , 2
1661             > that = {*this, proto::as_child(a)};
1662             return that;
1663         }
1664
1665
1666         template<typename A>
1667         BOOST_FORCEINLINE
1668         proto::expr<
1669             proto::tag::subscript
1670           , list2<expr const &, typename result_of::as_child<A const>::type>
1671           , 2
1672         > const
1673         operator [](A const &a) const
1674         {
1675             proto::expr<
1676                 proto::tag::subscript
1677               , list2<expr const &, typename result_of::as_child<A const>::type>
1678               , 2
1679             > that = {*this, proto::as_child(a)};
1680             return that;
1681         }
1682
1683
1684         template<typename Sig>
1685         struct result
1686         {
1687             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
1688         };
1689
1690
1691
1692         BOOST_FORCEINLINE
1693         proto::expr<proto::tag::function, list1<expr const &>, 1> const
1694         operator ()() const
1695         {
1696             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
1697             return that;
1698         }
1699
1700
1701         template<typename A0>
1702         BOOST_FORCEINLINE
1703         typename result_of::funop1<
1704             expr const
1705           , default_domain , const A0
1706         >::type const
1707         operator ()(A0 const &a0) const
1708         {
1709             return result_of::funop1<
1710                 expr const
1711               , default_domain , const A0
1712             >::call(*this , a0);
1713         }
1714
1715
1716         template<typename A0 , typename A1>
1717         BOOST_FORCEINLINE
1718         typename result_of::funop2<
1719             expr const
1720           , default_domain , const A0 , const A1
1721         >::type const
1722         operator ()(A0 const &a0 , A1 const &a1) const
1723         {
1724             return result_of::funop2<
1725                 expr const
1726               , default_domain , const A0 , const A1
1727             >::call(*this , a0 , a1);
1728         }
1729
1730
1731         template<typename A0 , typename A1 , typename A2>
1732         BOOST_FORCEINLINE
1733         typename result_of::funop3<
1734             expr const
1735           , default_domain , const A0 , const A1 , const A2
1736         >::type const
1737         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
1738         {
1739             return result_of::funop3<
1740                 expr const
1741               , default_domain , const A0 , const A1 , const A2
1742             >::call(*this , a0 , a1 , a2);
1743         }
1744
1745
1746         template<typename A0 , typename A1 , typename A2 , typename A3>
1747         BOOST_FORCEINLINE
1748         typename result_of::funop4<
1749             expr const
1750           , default_domain , const A0 , const A1 , const A2 , const A3
1751         >::type const
1752         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
1753         {
1754             return result_of::funop4<
1755                 expr const
1756               , default_domain , const A0 , const A1 , const A2 , const A3
1757             >::call(*this , a0 , a1 , a2 , a3);
1758         }
1759
1760
1761         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
1762         BOOST_FORCEINLINE
1763         typename result_of::funop5<
1764             expr const
1765           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
1766         >::type const
1767         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
1768         {
1769             return result_of::funop5<
1770                 expr const
1771               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
1772             >::call(*this , a0 , a1 , a2 , a3 , a4);
1773         }
1774
1775
1776         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
1777         BOOST_FORCEINLINE
1778         typename result_of::funop6<
1779             expr const
1780           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
1781         >::type const
1782         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
1783         {
1784             return result_of::funop6<
1785                 expr const
1786               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
1787             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
1788         }
1789
1790
1791         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
1792         BOOST_FORCEINLINE
1793         typename result_of::funop7<
1794             expr const
1795           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
1796         >::type const
1797         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
1798         {
1799             return result_of::funop7<
1800                 expr const
1801               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
1802             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
1803         }
1804
1805
1806         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1807         BOOST_FORCEINLINE
1808         typename result_of::funop8<
1809             expr const
1810           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
1811         >::type const
1812         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
1813         {
1814             return result_of::funop8<
1815                 expr const
1816               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
1817             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
1818         }
1819
1820
1821         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1822         BOOST_FORCEINLINE
1823         typename result_of::funop9<
1824             expr const
1825           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
1826         >::type const
1827         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
1828         {
1829             return result_of::funop9<
1830                 expr const
1831               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
1832             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
1833         }
1834     };
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4>
1863     struct expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 >
1864     {
1865         typedef Tag proto_tag;
1866         static const long proto_arity_c = 5;
1867         typedef mpl::long_<5 > proto_arity;
1868         typedef expr proto_base_expr;
1869         typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args;
1870         typedef basic_expr<Tag, proto_args, 5 > proto_grammar;
1871         typedef default_domain proto_domain;
1872         typedef default_generator proto_generator;
1873         typedef proto::tag::proto_expr fusion_tag;
1874         typedef expr proto_derived_expr;
1875         typedef void proto_is_expr_;
1876         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4;
1877         typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
1878
1879
1880         BOOST_FORCEINLINE
1881         expr const &proto_base() const
1882         {
1883             return *this;
1884         }
1885
1886
1887         BOOST_FORCEINLINE
1888         expr &proto_base()
1889         {
1890             return *this;
1891         }
1892
1893
1894
1895         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
1896         BOOST_FORCEINLINE
1897         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4)
1898         {
1899             expr that = {a0 , a1 , a2 , a3 , a4};
1900             return that;
1901         }
1902
1903
1904         typedef detail::not_a_valid_type address_of_hack_type_;
1905
1906
1907
1908
1909         BOOST_FORCEINLINE
1910         proto::expr<
1911             proto::tag::assign
1912           , list2<expr &, expr const &>
1913           , 2
1914         > const
1915         operator =(expr const &a)
1916         {
1917             proto::expr<
1918                 proto::tag::assign
1919               , list2<expr &, expr const &>
1920               , 2
1921             > that = {*this, a};
1922             return that;
1923         }
1924
1925
1926
1927
1928         template<typename A>
1929         BOOST_FORCEINLINE
1930         proto::expr<
1931             proto::tag::assign
1932           , list2<expr const &, typename result_of::as_child<A>::type>
1933           , 2
1934         > const
1935         operator =(A &a) const
1936         {
1937             proto::expr<
1938                 proto::tag::assign
1939               , list2<expr const &, typename result_of::as_child<A>::type>
1940               , 2
1941             > that = {*this, proto::as_child(a)};
1942             return that;
1943         }
1944
1945
1946         template<typename A>
1947         BOOST_FORCEINLINE
1948         proto::expr<
1949             proto::tag::assign
1950           , list2<expr const &, typename result_of::as_child<A const>::type>
1951           , 2
1952         > const
1953         operator =(A const &a) const
1954         {
1955             proto::expr<
1956                 proto::tag::assign
1957               , list2<expr const &, typename result_of::as_child<A const>::type>
1958               , 2
1959             > that = {*this, proto::as_child(a)};
1960             return that;
1961         }
1962
1963
1964
1965
1966         template<typename A>
1967         BOOST_FORCEINLINE
1968         proto::expr<
1969             proto::tag::subscript
1970           , list2<expr const &, typename result_of::as_child<A>::type>
1971           , 2
1972         > const
1973         operator [](A &a) const
1974         {
1975             proto::expr<
1976                 proto::tag::subscript
1977               , list2<expr const &, typename result_of::as_child<A>::type>
1978               , 2
1979             > that = {*this, proto::as_child(a)};
1980             return that;
1981         }
1982
1983
1984         template<typename A>
1985         BOOST_FORCEINLINE
1986         proto::expr<
1987             proto::tag::subscript
1988           , list2<expr const &, typename result_of::as_child<A const>::type>
1989           , 2
1990         > const
1991         operator [](A const &a) const
1992         {
1993             proto::expr<
1994                 proto::tag::subscript
1995               , list2<expr const &, typename result_of::as_child<A const>::type>
1996               , 2
1997             > that = {*this, proto::as_child(a)};
1998             return that;
1999         }
2000
2001
2002         template<typename Sig>
2003         struct result
2004         {
2005             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
2006         };
2007
2008
2009
2010         BOOST_FORCEINLINE
2011         proto::expr<proto::tag::function, list1<expr const &>, 1> const
2012         operator ()() const
2013         {
2014             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
2015             return that;
2016         }
2017
2018
2019         template<typename A0>
2020         BOOST_FORCEINLINE
2021         typename result_of::funop1<
2022             expr const
2023           , default_domain , const A0
2024         >::type const
2025         operator ()(A0 const &a0) const
2026         {
2027             return result_of::funop1<
2028                 expr const
2029               , default_domain , const A0
2030             >::call(*this , a0);
2031         }
2032
2033
2034         template<typename A0 , typename A1>
2035         BOOST_FORCEINLINE
2036         typename result_of::funop2<
2037             expr const
2038           , default_domain , const A0 , const A1
2039         >::type const
2040         operator ()(A0 const &a0 , A1 const &a1) const
2041         {
2042             return result_of::funop2<
2043                 expr const
2044               , default_domain , const A0 , const A1
2045             >::call(*this , a0 , a1);
2046         }
2047
2048
2049         template<typename A0 , typename A1 , typename A2>
2050         BOOST_FORCEINLINE
2051         typename result_of::funop3<
2052             expr const
2053           , default_domain , const A0 , const A1 , const A2
2054         >::type const
2055         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
2056         {
2057             return result_of::funop3<
2058                 expr const
2059               , default_domain , const A0 , const A1 , const A2
2060             >::call(*this , a0 , a1 , a2);
2061         }
2062
2063
2064         template<typename A0 , typename A1 , typename A2 , typename A3>
2065         BOOST_FORCEINLINE
2066         typename result_of::funop4<
2067             expr const
2068           , default_domain , const A0 , const A1 , const A2 , const A3
2069         >::type const
2070         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
2071         {
2072             return result_of::funop4<
2073                 expr const
2074               , default_domain , const A0 , const A1 , const A2 , const A3
2075             >::call(*this , a0 , a1 , a2 , a3);
2076         }
2077
2078
2079         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
2080         BOOST_FORCEINLINE
2081         typename result_of::funop5<
2082             expr const
2083           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
2084         >::type const
2085         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
2086         {
2087             return result_of::funop5<
2088                 expr const
2089               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
2090             >::call(*this , a0 , a1 , a2 , a3 , a4);
2091         }
2092
2093
2094         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
2095         BOOST_FORCEINLINE
2096         typename result_of::funop6<
2097             expr const
2098           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
2099         >::type const
2100         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
2101         {
2102             return result_of::funop6<
2103                 expr const
2104               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
2105             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
2106         }
2107
2108
2109         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
2110         BOOST_FORCEINLINE
2111         typename result_of::funop7<
2112             expr const
2113           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
2114         >::type const
2115         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
2116         {
2117             return result_of::funop7<
2118                 expr const
2119               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
2120             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
2121         }
2122
2123
2124         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
2125         BOOST_FORCEINLINE
2126         typename result_of::funop8<
2127             expr const
2128           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
2129         >::type const
2130         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
2131         {
2132             return result_of::funop8<
2133                 expr const
2134               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
2135             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
2136         }
2137
2138
2139         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
2140         BOOST_FORCEINLINE
2141         typename result_of::funop9<
2142             expr const
2143           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
2144         >::type const
2145         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
2146         {
2147             return result_of::funop9<
2148                 expr const
2149               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
2150             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
2151         }
2152     };
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5>
2181     struct expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 >
2182     {
2183         typedef Tag proto_tag;
2184         static const long proto_arity_c = 6;
2185         typedef mpl::long_<6 > proto_arity;
2186         typedef expr proto_base_expr;
2187         typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args;
2188         typedef basic_expr<Tag, proto_args, 6 > proto_grammar;
2189         typedef default_domain proto_domain;
2190         typedef default_generator proto_generator;
2191         typedef proto::tag::proto_expr fusion_tag;
2192         typedef expr proto_derived_expr;
2193         typedef void proto_is_expr_;
2194         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5;
2195         typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
2196
2197
2198         BOOST_FORCEINLINE
2199         expr const &proto_base() const
2200         {
2201             return *this;
2202         }
2203
2204
2205         BOOST_FORCEINLINE
2206         expr &proto_base()
2207         {
2208             return *this;
2209         }
2210
2211
2212
2213         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
2214         BOOST_FORCEINLINE
2215         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
2216         {
2217             expr that = {a0 , a1 , a2 , a3 , a4 , a5};
2218             return that;
2219         }
2220
2221
2222         typedef detail::not_a_valid_type address_of_hack_type_;
2223
2224
2225
2226
2227         BOOST_FORCEINLINE
2228         proto::expr<
2229             proto::tag::assign
2230           , list2<expr &, expr const &>
2231           , 2
2232         > const
2233         operator =(expr const &a)
2234         {
2235             proto::expr<
2236                 proto::tag::assign
2237               , list2<expr &, expr const &>
2238               , 2
2239             > that = {*this, a};
2240             return that;
2241         }
2242
2243
2244
2245
2246         template<typename A>
2247         BOOST_FORCEINLINE
2248         proto::expr<
2249             proto::tag::assign
2250           , list2<expr const &, typename result_of::as_child<A>::type>
2251           , 2
2252         > const
2253         operator =(A &a) const
2254         {
2255             proto::expr<
2256                 proto::tag::assign
2257               , list2<expr const &, typename result_of::as_child<A>::type>
2258               , 2
2259             > that = {*this, proto::as_child(a)};
2260             return that;
2261         }
2262
2263
2264         template<typename A>
2265         BOOST_FORCEINLINE
2266         proto::expr<
2267             proto::tag::assign
2268           , list2<expr const &, typename result_of::as_child<A const>::type>
2269           , 2
2270         > const
2271         operator =(A const &a) const
2272         {
2273             proto::expr<
2274                 proto::tag::assign
2275               , list2<expr const &, typename result_of::as_child<A const>::type>
2276               , 2
2277             > that = {*this, proto::as_child(a)};
2278             return that;
2279         }
2280
2281
2282
2283
2284         template<typename A>
2285         BOOST_FORCEINLINE
2286         proto::expr<
2287             proto::tag::subscript
2288           , list2<expr const &, typename result_of::as_child<A>::type>
2289           , 2
2290         > const
2291         operator [](A &a) const
2292         {
2293             proto::expr<
2294                 proto::tag::subscript
2295               , list2<expr const &, typename result_of::as_child<A>::type>
2296               , 2
2297             > that = {*this, proto::as_child(a)};
2298             return that;
2299         }
2300
2301
2302         template<typename A>
2303         BOOST_FORCEINLINE
2304         proto::expr<
2305             proto::tag::subscript
2306           , list2<expr const &, typename result_of::as_child<A const>::type>
2307           , 2
2308         > const
2309         operator [](A const &a) const
2310         {
2311             proto::expr<
2312                 proto::tag::subscript
2313               , list2<expr const &, typename result_of::as_child<A const>::type>
2314               , 2
2315             > that = {*this, proto::as_child(a)};
2316             return that;
2317         }
2318
2319
2320         template<typename Sig>
2321         struct result
2322         {
2323             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
2324         };
2325
2326
2327
2328         BOOST_FORCEINLINE
2329         proto::expr<proto::tag::function, list1<expr const &>, 1> const
2330         operator ()() const
2331         {
2332             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
2333             return that;
2334         }
2335
2336
2337         template<typename A0>
2338         BOOST_FORCEINLINE
2339         typename result_of::funop1<
2340             expr const
2341           , default_domain , const A0
2342         >::type const
2343         operator ()(A0 const &a0) const
2344         {
2345             return result_of::funop1<
2346                 expr const
2347               , default_domain , const A0
2348             >::call(*this , a0);
2349         }
2350
2351
2352         template<typename A0 , typename A1>
2353         BOOST_FORCEINLINE
2354         typename result_of::funop2<
2355             expr const
2356           , default_domain , const A0 , const A1
2357         >::type const
2358         operator ()(A0 const &a0 , A1 const &a1) const
2359         {
2360             return result_of::funop2<
2361                 expr const
2362               , default_domain , const A0 , const A1
2363             >::call(*this , a0 , a1);
2364         }
2365
2366
2367         template<typename A0 , typename A1 , typename A2>
2368         BOOST_FORCEINLINE
2369         typename result_of::funop3<
2370             expr const
2371           , default_domain , const A0 , const A1 , const A2
2372         >::type const
2373         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
2374         {
2375             return result_of::funop3<
2376                 expr const
2377               , default_domain , const A0 , const A1 , const A2
2378             >::call(*this , a0 , a1 , a2);
2379         }
2380
2381
2382         template<typename A0 , typename A1 , typename A2 , typename A3>
2383         BOOST_FORCEINLINE
2384         typename result_of::funop4<
2385             expr const
2386           , default_domain , const A0 , const A1 , const A2 , const A3
2387         >::type const
2388         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
2389         {
2390             return result_of::funop4<
2391                 expr const
2392               , default_domain , const A0 , const A1 , const A2 , const A3
2393             >::call(*this , a0 , a1 , a2 , a3);
2394         }
2395
2396
2397         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
2398         BOOST_FORCEINLINE
2399         typename result_of::funop5<
2400             expr const
2401           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
2402         >::type const
2403         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
2404         {
2405             return result_of::funop5<
2406                 expr const
2407               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
2408             >::call(*this , a0 , a1 , a2 , a3 , a4);
2409         }
2410
2411
2412         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
2413         BOOST_FORCEINLINE
2414         typename result_of::funop6<
2415             expr const
2416           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
2417         >::type const
2418         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
2419         {
2420             return result_of::funop6<
2421                 expr const
2422               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
2423             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
2424         }
2425
2426
2427         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
2428         BOOST_FORCEINLINE
2429         typename result_of::funop7<
2430             expr const
2431           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
2432         >::type const
2433         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
2434         {
2435             return result_of::funop7<
2436                 expr const
2437               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
2438             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
2439         }
2440
2441
2442         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
2443         BOOST_FORCEINLINE
2444         typename result_of::funop8<
2445             expr const
2446           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
2447         >::type const
2448         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
2449         {
2450             return result_of::funop8<
2451                 expr const
2452               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
2453             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
2454         }
2455
2456
2457         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
2458         BOOST_FORCEINLINE
2459         typename result_of::funop9<
2460             expr const
2461           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
2462         >::type const
2463         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
2464         {
2465             return result_of::funop9<
2466                 expr const
2467               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
2468             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
2469         }
2470     };
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6>
2499     struct expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 >
2500     {
2501         typedef Tag proto_tag;
2502         static const long proto_arity_c = 7;
2503         typedef mpl::long_<7 > proto_arity;
2504         typedef expr proto_base_expr;
2505         typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args;
2506         typedef basic_expr<Tag, proto_args, 7 > proto_grammar;
2507         typedef default_domain proto_domain;
2508         typedef default_generator proto_generator;
2509         typedef proto::tag::proto_expr fusion_tag;
2510         typedef expr proto_derived_expr;
2511         typedef void proto_is_expr_;
2512         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6;
2513         typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
2514
2515
2516         BOOST_FORCEINLINE
2517         expr const &proto_base() const
2518         {
2519             return *this;
2520         }
2521
2522
2523         BOOST_FORCEINLINE
2524         expr &proto_base()
2525         {
2526             return *this;
2527         }
2528
2529
2530
2531         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
2532         BOOST_FORCEINLINE
2533         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
2534         {
2535             expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6};
2536             return that;
2537         }
2538
2539
2540         typedef detail::not_a_valid_type address_of_hack_type_;
2541
2542
2543
2544
2545         BOOST_FORCEINLINE
2546         proto::expr<
2547             proto::tag::assign
2548           , list2<expr &, expr const &>
2549           , 2
2550         > const
2551         operator =(expr const &a)
2552         {
2553             proto::expr<
2554                 proto::tag::assign
2555               , list2<expr &, expr const &>
2556               , 2
2557             > that = {*this, a};
2558             return that;
2559         }
2560
2561
2562
2563
2564         template<typename A>
2565         BOOST_FORCEINLINE
2566         proto::expr<
2567             proto::tag::assign
2568           , list2<expr const &, typename result_of::as_child<A>::type>
2569           , 2
2570         > const
2571         operator =(A &a) const
2572         {
2573             proto::expr<
2574                 proto::tag::assign
2575               , list2<expr const &, typename result_of::as_child<A>::type>
2576               , 2
2577             > that = {*this, proto::as_child(a)};
2578             return that;
2579         }
2580
2581
2582         template<typename A>
2583         BOOST_FORCEINLINE
2584         proto::expr<
2585             proto::tag::assign
2586           , list2<expr const &, typename result_of::as_child<A const>::type>
2587           , 2
2588         > const
2589         operator =(A const &a) const
2590         {
2591             proto::expr<
2592                 proto::tag::assign
2593               , list2<expr const &, typename result_of::as_child<A const>::type>
2594               , 2
2595             > that = {*this, proto::as_child(a)};
2596             return that;
2597         }
2598
2599
2600
2601
2602         template<typename A>
2603         BOOST_FORCEINLINE
2604         proto::expr<
2605             proto::tag::subscript
2606           , list2<expr const &, typename result_of::as_child<A>::type>
2607           , 2
2608         > const
2609         operator [](A &a) const
2610         {
2611             proto::expr<
2612                 proto::tag::subscript
2613               , list2<expr const &, typename result_of::as_child<A>::type>
2614               , 2
2615             > that = {*this, proto::as_child(a)};
2616             return that;
2617         }
2618
2619
2620         template<typename A>
2621         BOOST_FORCEINLINE
2622         proto::expr<
2623             proto::tag::subscript
2624           , list2<expr const &, typename result_of::as_child<A const>::type>
2625           , 2
2626         > const
2627         operator [](A const &a) const
2628         {
2629             proto::expr<
2630                 proto::tag::subscript
2631               , list2<expr const &, typename result_of::as_child<A const>::type>
2632               , 2
2633             > that = {*this, proto::as_child(a)};
2634             return that;
2635         }
2636
2637
2638         template<typename Sig>
2639         struct result
2640         {
2641             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
2642         };
2643
2644
2645
2646         BOOST_FORCEINLINE
2647         proto::expr<proto::tag::function, list1<expr const &>, 1> const
2648         operator ()() const
2649         {
2650             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
2651             return that;
2652         }
2653
2654
2655         template<typename A0>
2656         BOOST_FORCEINLINE
2657         typename result_of::funop1<
2658             expr const
2659           , default_domain , const A0
2660         >::type const
2661         operator ()(A0 const &a0) const
2662         {
2663             return result_of::funop1<
2664                 expr const
2665               , default_domain , const A0
2666             >::call(*this , a0);
2667         }
2668
2669
2670         template<typename A0 , typename A1>
2671         BOOST_FORCEINLINE
2672         typename result_of::funop2<
2673             expr const
2674           , default_domain , const A0 , const A1
2675         >::type const
2676         operator ()(A0 const &a0 , A1 const &a1) const
2677         {
2678             return result_of::funop2<
2679                 expr const
2680               , default_domain , const A0 , const A1
2681             >::call(*this , a0 , a1);
2682         }
2683
2684
2685         template<typename A0 , typename A1 , typename A2>
2686         BOOST_FORCEINLINE
2687         typename result_of::funop3<
2688             expr const
2689           , default_domain , const A0 , const A1 , const A2
2690         >::type const
2691         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
2692         {
2693             return result_of::funop3<
2694                 expr const
2695               , default_domain , const A0 , const A1 , const A2
2696             >::call(*this , a0 , a1 , a2);
2697         }
2698
2699
2700         template<typename A0 , typename A1 , typename A2 , typename A3>
2701         BOOST_FORCEINLINE
2702         typename result_of::funop4<
2703             expr const
2704           , default_domain , const A0 , const A1 , const A2 , const A3
2705         >::type const
2706         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
2707         {
2708             return result_of::funop4<
2709                 expr const
2710               , default_domain , const A0 , const A1 , const A2 , const A3
2711             >::call(*this , a0 , a1 , a2 , a3);
2712         }
2713
2714
2715         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
2716         BOOST_FORCEINLINE
2717         typename result_of::funop5<
2718             expr const
2719           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
2720         >::type const
2721         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
2722         {
2723             return result_of::funop5<
2724                 expr const
2725               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
2726             >::call(*this , a0 , a1 , a2 , a3 , a4);
2727         }
2728
2729
2730         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
2731         BOOST_FORCEINLINE
2732         typename result_of::funop6<
2733             expr const
2734           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
2735         >::type const
2736         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
2737         {
2738             return result_of::funop6<
2739                 expr const
2740               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
2741             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
2742         }
2743
2744
2745         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
2746         BOOST_FORCEINLINE
2747         typename result_of::funop7<
2748             expr const
2749           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
2750         >::type const
2751         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
2752         {
2753             return result_of::funop7<
2754                 expr const
2755               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
2756             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
2757         }
2758
2759
2760         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
2761         BOOST_FORCEINLINE
2762         typename result_of::funop8<
2763             expr const
2764           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
2765         >::type const
2766         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
2767         {
2768             return result_of::funop8<
2769                 expr const
2770               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
2771             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
2772         }
2773
2774
2775         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
2776         BOOST_FORCEINLINE
2777         typename result_of::funop9<
2778             expr const
2779           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
2780         >::type const
2781         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
2782         {
2783             return result_of::funop9<
2784                 expr const
2785               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
2786             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
2787         }
2788     };
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7>
2817     struct expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 >
2818     {
2819         typedef Tag proto_tag;
2820         static const long proto_arity_c = 8;
2821         typedef mpl::long_<8 > proto_arity;
2822         typedef expr proto_base_expr;
2823         typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args;
2824         typedef basic_expr<Tag, proto_args, 8 > proto_grammar;
2825         typedef default_domain proto_domain;
2826         typedef default_generator proto_generator;
2827         typedef proto::tag::proto_expr fusion_tag;
2828         typedef expr proto_derived_expr;
2829         typedef void proto_is_expr_;
2830         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7;
2831         typedef void proto_child8; typedef void proto_child9;
2832
2833
2834         BOOST_FORCEINLINE
2835         expr const &proto_base() const
2836         {
2837             return *this;
2838         }
2839
2840
2841         BOOST_FORCEINLINE
2842         expr &proto_base()
2843         {
2844             return *this;
2845         }
2846
2847
2848
2849         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
2850         BOOST_FORCEINLINE
2851         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
2852         {
2853             expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7};
2854             return that;
2855         }
2856
2857
2858         typedef detail::not_a_valid_type address_of_hack_type_;
2859
2860
2861
2862
2863         BOOST_FORCEINLINE
2864         proto::expr<
2865             proto::tag::assign
2866           , list2<expr &, expr const &>
2867           , 2
2868         > const
2869         operator =(expr const &a)
2870         {
2871             proto::expr<
2872                 proto::tag::assign
2873               , list2<expr &, expr const &>
2874               , 2
2875             > that = {*this, a};
2876             return that;
2877         }
2878
2879
2880
2881
2882         template<typename A>
2883         BOOST_FORCEINLINE
2884         proto::expr<
2885             proto::tag::assign
2886           , list2<expr const &, typename result_of::as_child<A>::type>
2887           , 2
2888         > const
2889         operator =(A &a) const
2890         {
2891             proto::expr<
2892                 proto::tag::assign
2893               , list2<expr const &, typename result_of::as_child<A>::type>
2894               , 2
2895             > that = {*this, proto::as_child(a)};
2896             return that;
2897         }
2898
2899
2900         template<typename A>
2901         BOOST_FORCEINLINE
2902         proto::expr<
2903             proto::tag::assign
2904           , list2<expr const &, typename result_of::as_child<A const>::type>
2905           , 2
2906         > const
2907         operator =(A const &a) const
2908         {
2909             proto::expr<
2910                 proto::tag::assign
2911               , list2<expr const &, typename result_of::as_child<A const>::type>
2912               , 2
2913             > that = {*this, proto::as_child(a)};
2914             return that;
2915         }
2916
2917
2918
2919
2920         template<typename A>
2921         BOOST_FORCEINLINE
2922         proto::expr<
2923             proto::tag::subscript
2924           , list2<expr const &, typename result_of::as_child<A>::type>
2925           , 2
2926         > const
2927         operator [](A &a) const
2928         {
2929             proto::expr<
2930                 proto::tag::subscript
2931               , list2<expr const &, typename result_of::as_child<A>::type>
2932               , 2
2933             > that = {*this, proto::as_child(a)};
2934             return that;
2935         }
2936
2937
2938         template<typename A>
2939         BOOST_FORCEINLINE
2940         proto::expr<
2941             proto::tag::subscript
2942           , list2<expr const &, typename result_of::as_child<A const>::type>
2943           , 2
2944         > const
2945         operator [](A const &a) const
2946         {
2947             proto::expr<
2948                 proto::tag::subscript
2949               , list2<expr const &, typename result_of::as_child<A const>::type>
2950               , 2
2951             > that = {*this, proto::as_child(a)};
2952             return that;
2953         }
2954
2955
2956         template<typename Sig>
2957         struct result
2958         {
2959             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
2960         };
2961
2962
2963
2964         BOOST_FORCEINLINE
2965         proto::expr<proto::tag::function, list1<expr const &>, 1> const
2966         operator ()() const
2967         {
2968             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
2969             return that;
2970         }
2971
2972
2973         template<typename A0>
2974         BOOST_FORCEINLINE
2975         typename result_of::funop1<
2976             expr const
2977           , default_domain , const A0
2978         >::type const
2979         operator ()(A0 const &a0) const
2980         {
2981             return result_of::funop1<
2982                 expr const
2983               , default_domain , const A0
2984             >::call(*this , a0);
2985         }
2986
2987
2988         template<typename A0 , typename A1>
2989         BOOST_FORCEINLINE
2990         typename result_of::funop2<
2991             expr const
2992           , default_domain , const A0 , const A1
2993         >::type const
2994         operator ()(A0 const &a0 , A1 const &a1) const
2995         {
2996             return result_of::funop2<
2997                 expr const
2998               , default_domain , const A0 , const A1
2999             >::call(*this , a0 , a1);
3000         }
3001
3002
3003         template<typename A0 , typename A1 , typename A2>
3004         BOOST_FORCEINLINE
3005         typename result_of::funop3<
3006             expr const
3007           , default_domain , const A0 , const A1 , const A2
3008         >::type const
3009         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
3010         {
3011             return result_of::funop3<
3012                 expr const
3013               , default_domain , const A0 , const A1 , const A2
3014             >::call(*this , a0 , a1 , a2);
3015         }
3016
3017
3018         template<typename A0 , typename A1 , typename A2 , typename A3>
3019         BOOST_FORCEINLINE
3020         typename result_of::funop4<
3021             expr const
3022           , default_domain , const A0 , const A1 , const A2 , const A3
3023         >::type const
3024         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
3025         {
3026             return result_of::funop4<
3027                 expr const
3028               , default_domain , const A0 , const A1 , const A2 , const A3
3029             >::call(*this , a0 , a1 , a2 , a3);
3030         }
3031
3032
3033         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
3034         BOOST_FORCEINLINE
3035         typename result_of::funop5<
3036             expr const
3037           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
3038         >::type const
3039         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
3040         {
3041             return result_of::funop5<
3042                 expr const
3043               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
3044             >::call(*this , a0 , a1 , a2 , a3 , a4);
3045         }
3046
3047
3048         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
3049         BOOST_FORCEINLINE
3050         typename result_of::funop6<
3051             expr const
3052           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
3053         >::type const
3054         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
3055         {
3056             return result_of::funop6<
3057                 expr const
3058               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
3059             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
3060         }
3061
3062
3063         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
3064         BOOST_FORCEINLINE
3065         typename result_of::funop7<
3066             expr const
3067           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
3068         >::type const
3069         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
3070         {
3071             return result_of::funop7<
3072                 expr const
3073               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
3074             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
3075         }
3076
3077
3078         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
3079         BOOST_FORCEINLINE
3080         typename result_of::funop8<
3081             expr const
3082           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
3083         >::type const
3084         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
3085         {
3086             return result_of::funop8<
3087                 expr const
3088               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
3089             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
3090         }
3091
3092
3093         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
3094         BOOST_FORCEINLINE
3095         typename result_of::funop9<
3096             expr const
3097           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
3098         >::type const
3099         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
3100         {
3101             return result_of::funop9<
3102                 expr const
3103               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
3104             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
3105         }
3106     };
3107
3108
3109
3110
3111
3112
3113
3114
3115
3116
3117
3118
3119
3120
3121
3122
3123
3124
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8>
3135     struct expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 >
3136     {
3137         typedef Tag proto_tag;
3138         static const long proto_arity_c = 9;
3139         typedef mpl::long_<9 > proto_arity;
3140         typedef expr proto_base_expr;
3141         typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args;
3142         typedef basic_expr<Tag, proto_args, 9 > proto_grammar;
3143         typedef default_domain proto_domain;
3144         typedef default_generator proto_generator;
3145         typedef proto::tag::proto_expr fusion_tag;
3146         typedef expr proto_derived_expr;
3147         typedef void proto_is_expr_;
3148         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8;
3149         typedef void proto_child9;
3150
3151
3152         BOOST_FORCEINLINE
3153         expr const &proto_base() const
3154         {
3155             return *this;
3156         }
3157
3158
3159         BOOST_FORCEINLINE
3160         expr &proto_base()
3161         {
3162             return *this;
3163         }
3164
3165
3166
3167         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
3168         BOOST_FORCEINLINE
3169         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
3170         {
3171             expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8};
3172             return that;
3173         }
3174
3175
3176         typedef detail::not_a_valid_type address_of_hack_type_;
3177
3178
3179
3180
3181         BOOST_FORCEINLINE
3182         proto::expr<
3183             proto::tag::assign
3184           , list2<expr &, expr const &>
3185           , 2
3186         > const
3187         operator =(expr const &a)
3188         {
3189             proto::expr<
3190                 proto::tag::assign
3191               , list2<expr &, expr const &>
3192               , 2
3193             > that = {*this, a};
3194             return that;
3195         }
3196
3197
3198
3199
3200         template<typename A>
3201         BOOST_FORCEINLINE
3202         proto::expr<
3203             proto::tag::assign
3204           , list2<expr const &, typename result_of::as_child<A>::type>
3205           , 2
3206         > const
3207         operator =(A &a) const
3208         {
3209             proto::expr<
3210                 proto::tag::assign
3211               , list2<expr const &, typename result_of::as_child<A>::type>
3212               , 2
3213             > that = {*this, proto::as_child(a)};
3214             return that;
3215         }
3216
3217
3218         template<typename A>
3219         BOOST_FORCEINLINE
3220         proto::expr<
3221             proto::tag::assign
3222           , list2<expr const &, typename result_of::as_child<A const>::type>
3223           , 2
3224         > const
3225         operator =(A const &a) const
3226         {
3227             proto::expr<
3228                 proto::tag::assign
3229               , list2<expr const &, typename result_of::as_child<A const>::type>
3230               , 2
3231             > that = {*this, proto::as_child(a)};
3232             return that;
3233         }
3234
3235
3236
3237
3238         template<typename A>
3239         BOOST_FORCEINLINE
3240         proto::expr<
3241             proto::tag::subscript
3242           , list2<expr const &, typename result_of::as_child<A>::type>
3243           , 2
3244         > const
3245         operator [](A &a) const
3246         {
3247             proto::expr<
3248                 proto::tag::subscript
3249               , list2<expr const &, typename result_of::as_child<A>::type>
3250               , 2
3251             > that = {*this, proto::as_child(a)};
3252             return that;
3253         }
3254
3255
3256         template<typename A>
3257         BOOST_FORCEINLINE
3258         proto::expr<
3259             proto::tag::subscript
3260           , list2<expr const &, typename result_of::as_child<A const>::type>
3261           , 2
3262         > const
3263         operator [](A const &a) const
3264         {
3265             proto::expr<
3266                 proto::tag::subscript
3267               , list2<expr const &, typename result_of::as_child<A const>::type>
3268               , 2
3269             > that = {*this, proto::as_child(a)};
3270             return that;
3271         }
3272
3273
3274         template<typename Sig>
3275         struct result
3276         {
3277             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
3278         };
3279
3280
3281
3282         BOOST_FORCEINLINE
3283         proto::expr<proto::tag::function, list1<expr const &>, 1> const
3284         operator ()() const
3285         {
3286             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
3287             return that;
3288         }
3289
3290
3291         template<typename A0>
3292         BOOST_FORCEINLINE
3293         typename result_of::funop1<
3294             expr const
3295           , default_domain , const A0
3296         >::type const
3297         operator ()(A0 const &a0) const
3298         {
3299             return result_of::funop1<
3300                 expr const
3301               , default_domain , const A0
3302             >::call(*this , a0);
3303         }
3304
3305
3306         template<typename A0 , typename A1>
3307         BOOST_FORCEINLINE
3308         typename result_of::funop2<
3309             expr const
3310           , default_domain , const A0 , const A1
3311         >::type const
3312         operator ()(A0 const &a0 , A1 const &a1) const
3313         {
3314             return result_of::funop2<
3315                 expr const
3316               , default_domain , const A0 , const A1
3317             >::call(*this , a0 , a1);
3318         }
3319
3320
3321         template<typename A0 , typename A1 , typename A2>
3322         BOOST_FORCEINLINE
3323         typename result_of::funop3<
3324             expr const
3325           , default_domain , const A0 , const A1 , const A2
3326         >::type const
3327         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
3328         {
3329             return result_of::funop3<
3330                 expr const
3331               , default_domain , const A0 , const A1 , const A2
3332             >::call(*this , a0 , a1 , a2);
3333         }
3334
3335
3336         template<typename A0 , typename A1 , typename A2 , typename A3>
3337         BOOST_FORCEINLINE
3338         typename result_of::funop4<
3339             expr const
3340           , default_domain , const A0 , const A1 , const A2 , const A3
3341         >::type const
3342         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
3343         {
3344             return result_of::funop4<
3345                 expr const
3346               , default_domain , const A0 , const A1 , const A2 , const A3
3347             >::call(*this , a0 , a1 , a2 , a3);
3348         }
3349
3350
3351         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
3352         BOOST_FORCEINLINE
3353         typename result_of::funop5<
3354             expr const
3355           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
3356         >::type const
3357         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
3358         {
3359             return result_of::funop5<
3360                 expr const
3361               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
3362             >::call(*this , a0 , a1 , a2 , a3 , a4);
3363         }
3364
3365
3366         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
3367         BOOST_FORCEINLINE
3368         typename result_of::funop6<
3369             expr const
3370           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
3371         >::type const
3372         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
3373         {
3374             return result_of::funop6<
3375                 expr const
3376               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
3377             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
3378         }
3379
3380
3381         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
3382         BOOST_FORCEINLINE
3383         typename result_of::funop7<
3384             expr const
3385           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
3386         >::type const
3387         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
3388         {
3389             return result_of::funop7<
3390                 expr const
3391               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
3392             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
3393         }
3394
3395
3396         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
3397         BOOST_FORCEINLINE
3398         typename result_of::funop8<
3399             expr const
3400           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
3401         >::type const
3402         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
3403         {
3404             return result_of::funop8<
3405                 expr const
3406               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
3407             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
3408         }
3409
3410
3411         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
3412         BOOST_FORCEINLINE
3413         typename result_of::funop9<
3414             expr const
3415           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
3416         >::type const
3417         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
3418         {
3419             return result_of::funop9<
3420                 expr const
3421               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
3422             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
3423         }
3424     };
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9>
3453     struct expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 >
3454     {
3455         typedef Tag proto_tag;
3456         static const long proto_arity_c = 10;
3457         typedef mpl::long_<10 > proto_arity;
3458         typedef expr proto_base_expr;
3459         typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args;
3460         typedef basic_expr<Tag, proto_args, 10 > proto_grammar;
3461         typedef default_domain proto_domain;
3462         typedef default_generator proto_generator;
3463         typedef proto::tag::proto_expr fusion_tag;
3464         typedef expr proto_derived_expr;
3465         typedef void proto_is_expr_;
3466         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9;
3467
3468
3469
3470         BOOST_FORCEINLINE
3471         expr const &proto_base() const
3472         {
3473             return *this;
3474         }
3475
3476
3477         BOOST_FORCEINLINE
3478         expr &proto_base()
3479         {
3480             return *this;
3481         }
3482
3483
3484
3485         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
3486         BOOST_FORCEINLINE
3487         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9)
3488         {
3489             expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9};
3490             return that;
3491         }
3492
3493
3494         typedef detail::not_a_valid_type address_of_hack_type_;
3495
3496
3497
3498
3499         BOOST_FORCEINLINE
3500         proto::expr<
3501             proto::tag::assign
3502           , list2<expr &, expr const &>
3503           , 2
3504         > const
3505         operator =(expr const &a)
3506         {
3507             proto::expr<
3508                 proto::tag::assign
3509               , list2<expr &, expr const &>
3510               , 2
3511             > that = {*this, a};
3512             return that;
3513         }
3514
3515
3516
3517
3518         template<typename A>
3519         BOOST_FORCEINLINE
3520         proto::expr<
3521             proto::tag::assign
3522           , list2<expr const &, typename result_of::as_child<A>::type>
3523           , 2
3524         > const
3525         operator =(A &a) const
3526         {
3527             proto::expr<
3528                 proto::tag::assign
3529               , list2<expr const &, typename result_of::as_child<A>::type>
3530               , 2
3531             > that = {*this, proto::as_child(a)};
3532             return that;
3533         }
3534
3535
3536         template<typename A>
3537         BOOST_FORCEINLINE
3538         proto::expr<
3539             proto::tag::assign
3540           , list2<expr const &, typename result_of::as_child<A const>::type>
3541           , 2
3542         > const
3543         operator =(A const &a) const
3544         {
3545             proto::expr<
3546                 proto::tag::assign
3547               , list2<expr const &, typename result_of::as_child<A const>::type>
3548               , 2
3549             > that = {*this, proto::as_child(a)};
3550             return that;
3551         }
3552
3553
3554
3555
3556         template<typename A>
3557         BOOST_FORCEINLINE
3558         proto::expr<
3559             proto::tag::subscript
3560           , list2<expr const &, typename result_of::as_child<A>::type>
3561           , 2
3562         > const
3563         operator [](A &a) const
3564         {
3565             proto::expr<
3566                 proto::tag::subscript
3567               , list2<expr const &, typename result_of::as_child<A>::type>
3568               , 2
3569             > that = {*this, proto::as_child(a)};
3570             return that;
3571         }
3572
3573
3574         template<typename A>
3575         BOOST_FORCEINLINE
3576         proto::expr<
3577             proto::tag::subscript
3578           , list2<expr const &, typename result_of::as_child<A const>::type>
3579           , 2
3580         > const
3581         operator [](A const &a) const
3582         {
3583             proto::expr<
3584                 proto::tag::subscript
3585               , list2<expr const &, typename result_of::as_child<A const>::type>
3586               , 2
3587             > that = {*this, proto::as_child(a)};
3588             return that;
3589         }
3590
3591
3592         template<typename Sig>
3593         struct result
3594         {
3595             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
3596         };
3597
3598
3599
3600         BOOST_FORCEINLINE
3601         proto::expr<proto::tag::function, list1<expr const &>, 1> const
3602         operator ()() const
3603         {
3604             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
3605             return that;
3606         }
3607
3608
3609         template<typename A0>
3610         BOOST_FORCEINLINE
3611         typename result_of::funop1<
3612             expr const
3613           , default_domain , const A0
3614         >::type const
3615         operator ()(A0 const &a0) const
3616         {
3617             return result_of::funop1<
3618                 expr const
3619               , default_domain , const A0
3620             >::call(*this , a0);
3621         }
3622
3623
3624         template<typename A0 , typename A1>
3625         BOOST_FORCEINLINE
3626         typename result_of::funop2<
3627             expr const
3628           , default_domain , const A0 , const A1
3629         >::type const
3630         operator ()(A0 const &a0 , A1 const &a1) const
3631         {
3632             return result_of::funop2<
3633                 expr const
3634               , default_domain , const A0 , const A1
3635             >::call(*this , a0 , a1);
3636         }
3637
3638
3639         template<typename A0 , typename A1 , typename A2>
3640         BOOST_FORCEINLINE
3641         typename result_of::funop3<
3642             expr const
3643           , default_domain , const A0 , const A1 , const A2
3644         >::type const
3645         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
3646         {
3647             return result_of::funop3<
3648                 expr const
3649               , default_domain , const A0 , const A1 , const A2
3650             >::call(*this , a0 , a1 , a2);
3651         }
3652
3653
3654         template<typename A0 , typename A1 , typename A2 , typename A3>
3655         BOOST_FORCEINLINE
3656         typename result_of::funop4<
3657             expr const
3658           , default_domain , const A0 , const A1 , const A2 , const A3
3659         >::type const
3660         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
3661         {
3662             return result_of::funop4<
3663                 expr const
3664               , default_domain , const A0 , const A1 , const A2 , const A3
3665             >::call(*this , a0 , a1 , a2 , a3);
3666         }
3667
3668
3669         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
3670         BOOST_FORCEINLINE
3671         typename result_of::funop5<
3672             expr const
3673           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
3674         >::type const
3675         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
3676         {
3677             return result_of::funop5<
3678                 expr const
3679               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
3680             >::call(*this , a0 , a1 , a2 , a3 , a4);
3681         }
3682
3683
3684         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
3685         BOOST_FORCEINLINE
3686         typename result_of::funop6<
3687             expr const
3688           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
3689         >::type const
3690         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
3691         {
3692             return result_of::funop6<
3693                 expr const
3694               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
3695             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
3696         }
3697
3698
3699         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
3700         BOOST_FORCEINLINE
3701         typename result_of::funop7<
3702             expr const
3703           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
3704         >::type const
3705         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
3706         {
3707             return result_of::funop7<
3708                 expr const
3709               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
3710             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
3711         }
3712
3713
3714         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
3715         BOOST_FORCEINLINE
3716         typename result_of::funop8<
3717             expr const
3718           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
3719         >::type const
3720         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
3721         {
3722             return result_of::funop8<
3723                 expr const
3724               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
3725             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
3726         }
3727
3728
3729         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
3730         BOOST_FORCEINLINE
3731         typename result_of::funop9<
3732             expr const
3733           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
3734         >::type const
3735         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
3736         {
3737             return result_of::funop9<
3738                 expr const
3739               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
3740             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
3741         }
3742     };