ceph/src/boost/libs/proto/doc/reference/traits.xml

   1 <?xml version="1.0" encoding="utf-8"?>
   2 <!--
   3   Copyright 2012 Eric Niebler
   4
   5   Distributed under the Boost
   6   Software License, Version 1.0. (See accompanying
   7   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   8   -->
   9 <header name="boost/proto/traits.hpp">
  10   <para>
  11     Contains definitions for various expression traits and utilities like
  12     <computeroutput><classname alt="boost::proto::tag_of">proto::tag_of</classname>&lt;&gt;</computeroutput> and
  13     <computeroutput><classname alt="boost::proto::arity_of">proto::arity_of</classname>&lt;&gt;</computeroutput>;
  14     the functions
  15     <computeroutput><functionname alt="boost::proto::value">proto::value</functionname>()</computeroutput>,
  16     <computeroutput><functionname alt="boost::proto::left">proto::left</functionname>()</computeroutput> and
  17     <computeroutput><functionname alt="boost::proto::right">proto::right</functionname>()</computeroutput>;
  18     <computeroutput><functionname alt="boost::proto::child">proto::child</functionname>()</computeroutput>,
  19     <computeroutput><functionname alt="boost::proto::child_c">proto::child_c</functionname>()</computeroutput>,
  20     <computeroutput><functionname alt="boost::proto::as_expr">proto::as_expr</functionname>()</computeroutput>,
  21     <computeroutput><functionname alt="boost::proto::as_child">proto::as_child</functionname>()</computeroutput>,
  22     and assorted helpers.
  23   </para>
  24   <namespace name="boost">
  25     <namespace name="proto">
  26
  27       <struct name="is_callable">
  28         <template>
  29           <template-type-parameter name="T"/>
  30         </template>
  31         <purpose>Boolean metafunction which tells whether a type is a callable
  32           <conceptname>PolymorphicFunctionObject</conceptname> or not.</purpose>
  33         <description>
  34           <para>
  35             <computeroutput>proto::is_callable&lt;&gt;</computeroutput> is used by the
  36             <computeroutput><classname alt="proto::when">proto::when&lt;&gt;</classname></computeroutput>
  37             transform to determine whether a function type <computeroutput>R(A<subscript>1</subscript>,...A<subscript>n</subscript>)</computeroutput>
  38             is a <conceptname>CallableTransform</conceptname> or an <conceptname>ObjectTransform</conceptname>.
  39             The former are evaluated using <computeroutput><classname>proto::call&lt;&gt;</classname></computeroutput>
  40             and the later with <computeroutput><classname>proto::make&lt;&gt;</classname></computeroutput>.
  41             If <computeroutput>proto::is_callable&lt;R&gt;::value</computeroutput> is <computeroutput>true</computeroutput>,
  42             the function type is a <conceptname>CallableTransform</conceptname>; otherwise, it is an <conceptname>ObjectTransform</conceptname>.
  43           </para>
  44           <para>
  45             Unless specialized for a type
  46             <computeroutput>T</computeroutput>, <computeroutput>proto::is_callable&lt;T&gt;::value</computeroutput>
  47             is computed as follows:
  48             <itemizedlist>
  49               <listitem>
  50                 <para>
  51                   If <computeroutput>T</computeroutput> is a template type
  52                   <computeroutput>X&lt;Y<subscript>0</subscript>,...Y<subscript>n</subscript>&gt;</computeroutput>,
  53                   where all <computeroutput>Y<subscript>x</subscript></computeroutput> are types for
  54                   <computeroutput>x</computeroutput> in <computeroutput>[0,n]</computeroutput>,
  55                   <computeroutput>proto::is_callable&lt;T&gt;::value</computeroutput> is
  56                   <computeroutput>boost::is_same&lt;Y<subscript>n</subscript>, <classname>proto::callable</classname>&gt;::value</computeroutput>.
  57                 </para>
  58               </listitem>
  59               <listitem>
  60                 <para>
  61                   If <computeroutput>T</computeroutput> is derived from <computeroutput><classname>proto::callable</classname></computeroutput>,
  62                   <computeroutput>proto::is_callable&lt;T&gt;::value</computeroutput> is <computeroutput>true</computeroutput>.
  63                 </para>
  64               </listitem>
  65               <listitem>
  66                 <para>
  67                   Otherwise, <computeroutput>proto::is_callable&lt;T&gt;::value</computeroutput>
  68                   is <computeroutput>false</computeroutput>.
  69                 </para>
  70               </listitem>
  71             </itemizedlist>
  72           </para>
  73         </description>
  74         <inherit><type>mpl::bool_&lt;<replaceable>true-or-false</replaceable>&gt;</type></inherit>
  75       </struct>
  76
  77       <struct name="is_transform">
  78         <template>
  79           <template-type-parameter name="T"/>
  80         </template>
  81         <purpose>Boolean metafunction which tells whether a type is a
  82           <conceptname>PrimitiveTransform</conceptname> or not.</purpose>
  83         <description>
  84           <para>
  85             <computeroutput>proto::is_transform&lt;&gt;</computeroutput> is used by the
  86             <computeroutput><classname alt="proto::make">proto::make&lt;&gt;</classname></computeroutput>
  87             transform to determine whether a type <computeroutput>R</computeroutput> represents a
  88             <conceptname>PrimitiveTransform</conceptname> to apply, or whether it merely represents itself.
  89           </para>
  90           <para>
  91             It is also used by the
  92             <computeroutput><classname alt="proto::call">proto::call&lt;&gt;</classname></computeroutput>
  93             transform to determine whether the function types <computeroutput>R()</computeroutput>,
  94             <computeroutput>R(A1)</computeroutput>, and <computeroutput>R(A1, A2)</computeroutput> should
  95             be passed the expression, state and data parameters (as needed).
  96           </para>
  97           <para>
  98             Unless specialized for a type
  99             <computeroutput>T</computeroutput>, <computeroutput>proto::is_transform&lt;T&gt;::value</computeroutput>
 100             is computed as follows:
 101             <itemizedlist>
 102               <listitem>
 103                 <para>
 104                   If <computeroutput>T</computeroutput> is a class type that inherits directly or indirectly from
 105                   an instantiation of
 106                   <computeroutput><classname alt="proto::transform">proto::transform&lt;&gt;</classname></computeroutput>,
 107                   <computeroutput>proto::is_transform&lt;T&gt;::value</computeroutput> is <computeroutput>true</computeroutput>.
 108                 </para>
 109               </listitem>
 110               <listitem>
 111                 <para>
 112                   Otherwise, <computeroutput>proto::is_transform&lt;T&gt;::value</computeroutput>
 113                   is <computeroutput>false</computeroutput>.
 114                 </para>
 115               </listitem>
 116             </itemizedlist>
 117           </para>
 118         </description>
 119         <inherit><type>mpl::bool_&lt;<replaceable>true-or-false</replaceable>&gt;</type></inherit>
 120       </struct>
 121
 122       <struct name="is_aggregate">
 123         <template>
 124           <template-type-parameter name="T"/>
 125         </template>
 126         <purpose>A Boolean metafunction that indicates whether a type requires aggregate initialization. </purpose>
 127         <description>
 128           <para>
 129             <computeroutput>proto::is_aggregate&lt;&gt;</computeroutput> is used by the
 130             <computeroutput><classname>proto::make&lt;&gt;</classname></computeroutput> transform to determine how
 131             to construct an object of some type <computeroutput>T</computeroutput>, given some initialization arguments
 132             <computeroutput>a<subscript>0</subscript>,...a<subscript>n</subscript></computeroutput>.
 133             If <computeroutput>proto::is_aggregate&lt;T&gt;::value</computeroutput> is <computeroutput>true</computeroutput>,
 134             then an object of type <computeroutput>T</computeroutput> will be initialized as
 135             <computeroutput>T t = {a<subscript>0</subscript>,...a<subscript>n</subscript>};</computeroutput>.
 136             Otherwise, it will be initialized as
 137             <computeroutput>T t(a<subscript>0</subscript>,...a<subscript>n</subscript>)</computeroutput>.
 138           </para>
 139           <para>
 140             Note: <computeroutput><classname>proto::expr&lt;&gt;</classname></computeroutput> and
 141             <computeroutput><classname>proto::basic_expr&lt;&gt;</classname></computeroutput>are aggregates.
 142           </para>
 143         </description>
 144         <inherit><type>mpl::bool_&lt;<replaceable>true-or-false</replaceable>&gt;</type></inherit>
 145       </struct>
 146
 147       <namespace name="functional">
 148         <struct name="as_expr">
 149           <template>
 150             <template-type-parameter name="Domain">
 151               <default><classname>proto::default_domain</classname></default>
 152             </template-type-parameter>
 153           </template>
 154           <purpose>A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
 155             <computeroutput><functionname alt="proto::as_expr">proto::as_expr()</functionname></computeroutput> function.
 156           </purpose>
 157           <inherit><type><classname>proto::callable</classname></type></inherit>
 158           <struct-specialization name="result">
 159             <template>
 160               <template-type-parameter name="This"/>
 161               <template-type-parameter name="T"/>
 162             </template>
 163             <specialization>
 164               <template-arg>This(T)</template-arg>
 165             </specialization>
 166             <inherit><type><classname>proto::result_of::as_expr</classname>&lt; typename remove_reference&lt; T &gt;::type, Domain &gt;</type></inherit>
 167           </struct-specialization>
 168           <method-group name="public member functions">
 169             <method name="operator()" cv="const">
 170               <type>typename <classname>proto::result_of::as_expr</classname>&lt; T, Domain &gt;::type</type>
 171               <template>
 172                 <template-type-parameter name="T"/>
 173               </template>
 174               <parameter name="t">
 175                 <paramtype>T &amp;</paramtype>
 176                 <description>
 177                   <para>The object to wrap. </para>
 178                 </description>
 179               </parameter>
 180               <description>
 181                 <para>
 182                   Wrap an object in a Proto terminal if it isn't a Proto expression already.
 183                 </para>
 184               </description>
 185               <returns>
 186                 <para>
 187                   <computeroutput><functionname>proto::as_expr</functionname>&lt;Domain&gt;(t)</computeroutput>
 188                 </para>
 189               </returns>
 190             </method>
 191             <method name="operator()" cv="const">
 192               <type>typename <classname>proto::result_of::as_expr</classname>&lt; T const, Domain &gt;::type</type>
 193               <template>
 194                 <template-type-parameter name="T"/>
 195               </template>
 196               <parameter name="t">
 197                 <paramtype>T const &amp;</paramtype>
 198               </parameter>
 199               <description>
 200                 <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
 201               </description>
 202             </method>
 203           </method-group>
 204         </struct>
 205
 206         <struct name="as_child">
 207           <template>
 208             <template-type-parameter name="Domain">
 209               <default><classname>proto::default_domain</classname></default>
 210             </template-type-parameter>
 211           </template>
 212           <purpose>
 213             A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
 214             <computeroutput><functionname alt="proto::as_child">proto::as_child()</functionname></computeroutput> function.
 215           </purpose>
 216           <inherit><type><classname>proto::callable</classname></type></inherit>
 217           <struct-specialization name="result">
 218             <template>
 219               <template-type-parameter name="This"/>
 220               <template-type-parameter name="T"/>
 221             </template>
 222             <specialization>
 223               <template-arg>This(T)</template-arg>
 224             </specialization>
 225             <inherit><type><classname>proto::result_of::as_child</classname>&lt; typename remove_reference&lt; T &gt;::type, Domain &gt;</type></inherit>
 226           </struct-specialization>
 227           <method-group name="public member functions">
 228             <method name="operator()" cv="const">
 229               <type>typename <classname>proto::result_of::as_child</classname>&lt; T, Domain &gt;::type</type>
 230               <template>
 231                 <template-type-parameter name="T"/>
 232               </template>
 233               <parameter name="t">
 234                 <paramtype>T &amp;</paramtype>
 235                 <description>
 236                   <para>The object to wrap. </para>
 237                 </description>
 238               </parameter>
 239               <description>
 240                 <para>
 241                   Wrap an object in a Proto terminal if it isn't a Proto expression already.
 242                 </para>
 243               </description>
 244               <returns>
 245                 <para>
 246                   <computeroutput><functionname>proto::as_child</functionname>&lt;Domain&gt;(t)</computeroutput>
 247                 </para>
 248               </returns>
 249             </method>
 250             <method name="operator()" cv="const">
 251               <type>typename <classname>proto::result_of::as_child</classname>&lt; T const, Domain &gt;::type</type>
 252               <template>
 253                 <template-type-parameter name="T"/>
 254               </template>
 255               <parameter name="t">
 256                 <paramtype>T const &amp;</paramtype>
 257               </parameter>
 258               <description>
 259                 <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
 260               </description>
 261             </method>
 262           </method-group>
 263         </struct>
 264
 265         <struct name="child_c">
 266           <template>
 267             <template-nontype-parameter name="N">
 268               <type>long</type>
 269             </template-nontype-parameter>
 270           </template>
 271           <purpose>
 272             A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
 273             <computeroutput><functionname alt="proto::child_c">proto::child_c()</functionname></computeroutput> function.
 274           </purpose>
 275           <inherit><type><classname>proto::callable</classname></type></inherit>
 276           <struct-specialization name="result">
 277             <template>
 278               <template-type-parameter name="This"/>
 279               <template-type-parameter name="Expr"/>
 280             </template>
 281             <specialization>
 282               <template-arg>This(Expr)</template-arg>
 283             </specialization>
 284             <inherit><type><classname>proto::result_of::child_c</classname>&lt; Expr, N &gt;</type></inherit>
 285           </struct-specialization>
 286           <method-group name="public member functions">
 287             <method name="operator()" cv="const">
 288               <type>typename <classname>proto::result_of::child_c</classname>&lt; Expr &amp;, N &gt;::type</type>
 289               <template>
 290                 <template-type-parameter name="Expr"/>
 291               </template>
 292               <parameter name="expr">
 293                 <paramtype>Expr &amp;</paramtype>
 294                 <description>
 295                   <para>The expression node. </para>
 296                 </description>
 297               </parameter>
 298               <description>
 299                 <para>
 300                   Return the <replaceable>N</replaceable><superscript>th</superscript> child of the given expression.
 301                 </para>
 302               </description>
 303               <requires>
 304                 <para>
 305                   <computeroutput><classname>proto::is_expr</classname>&lt;Expr&gt;::value</computeroutput> is
 306                   <computeroutput>true</computeroutput>
 307                 </para>
 308                 <para>
 309                   <computeroutput>N &lt; Expr::proto_arity::value</computeroutput>
 310                 </para>
 311               </requires>
 312               <returns>
 313                 <para>
 314                   <computeroutput><functionname>proto::child_c</functionname>&lt;N&gt;(expr)</computeroutput>
 315                 </para>
 316               </returns>
 317               <throws>
 318                 <simpara>Will not throw.</simpara>
 319               </throws>
 320             </method>
 321             <method name="operator()" cv="const">
 322               <type>typename <classname>proto::result_of::child_c</classname>&lt; Expr const &amp;, N &gt;::type</type>
 323               <template>
 324                 <template-type-parameter name="Expr"/>
 325               </template>
 326               <parameter name="expr">
 327                 <paramtype>Expr const &amp;</paramtype>
 328               </parameter>
 329               <description>
 330                 <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
 331               </description>
 332             </method>
 333           </method-group>
 334         </struct>
 335
 336         <struct name="child">
 337           <template>
 338             <template-type-parameter name="N">
 339               <default>mpl::long_&lt;0&gt;</default>
 340             </template-type-parameter>
 341           </template>
 342           <purpose>A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
 343             <computeroutput><functionname alt="proto::child">proto::child()</functionname></computeroutput> function.</purpose>
 344           <description>
 345             <para>
 346               A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
 347               <computeroutput><functionname alt="proto::child">proto::child()</functionname></computeroutput>
 348               function. <computeroutput>N</computeroutput> is required to be an MPL Integral Constant.
 349             </para>
 350           </description>
 351           <inherit><type><classname>proto::callable</classname></type></inherit>
 352           <struct-specialization name="result">
 353             <template>
 354               <template-type-parameter name="This"/>
 355               <template-type-parameter name="Expr"/>
 356             </template>
 357             <specialization>
 358               <template-arg>This(Expr)</template-arg>
 359             </specialization>
 360             <inherit>
 361               <type><classname>proto::result_of::child</classname>&lt; Expr, N &gt;</type>
 362             </inherit>
 363           </struct-specialization>
 364           <method-group name="public member functions">
 365             <method name="operator()" cv="const">
 366               <type>typename <classname>proto::result_of::child</classname>&lt; Expr &amp;, N &gt;::type</type>
 367               <template>
 368                 <template-type-parameter name="Expr"/>
 369               </template>
 370               <parameter name="expr">
 371                 <paramtype>Expr &amp;</paramtype>
 372                 <description>
 373                   <para>The expression node. </para>
 374                 </description>
 375               </parameter>
 376               <description>
 377                 <para>
 378                   Return the <replaceable>N</replaceable><superscript>th</superscript> child of the given expression.
 379                 </para>
 380               </description>
 381               <requires>
 382                 <para>
 383                   <computeroutput><classname>proto::is_expr</classname>&lt;Expr&gt;::value</computeroutput> is
 384                   <computeroutput>true</computeroutput>
 385                 </para>
 386                 <para>
 387                   <computeroutput>N::value &lt; Expr::proto_arity::value</computeroutput>
 388                 </para>
 389               </requires>
 390               <returns>
 391                 <para>
 392                   <computeroutput><functionname>proto::child</functionname>&lt;N&gt;(expr)</computeroutput>
 393                 </para>
 394               </returns>
 395               <throws>
 396                 <simpara>Will not throw.</simpara>
 397               </throws>
 398             </method>
 399             <method name="operator()" cv="const">
 400               <type>typename <classname>proto::result_of::child</classname>&lt; Expr const &amp;, N &gt;::type</type>
 401               <template>
 402                 <template-type-parameter name="Expr"/>
 403               </template>
 404               <parameter name="expr">
 405                 <paramtype>Expr const &amp;</paramtype>
 406               </parameter>
 407               <description>
 408                 <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
 409               </description>
 410             </method>
 411           </method-group>
 412         </struct>
 413
 414         <struct name="value">
 415           <purpose>
 416             A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
 417             <computeroutput><functionname alt="proto::value">proto::value()</functionname></computeroutput> function.
 418           </purpose>
 419           <inherit><type><classname>proto::callable</classname></type></inherit>
 420           <struct-specialization name="result">
 421             <template>
 422               <template-type-parameter name="This"/>
 423               <template-type-parameter name="Expr"/>
 424             </template>
 425             <specialization>
 426               <template-arg>This(Expr)</template-arg>
 427             </specialization>
 428             <inherit>
 429               <type><classname>proto::result_of::value</classname>&lt; Expr &gt;</type>
 430             </inherit>
 431           </struct-specialization>
 432           <method-group name="public member functions">
 433             <method name="operator()" cv="const">
 434               <type>typename <classname>proto::result_of::value</classname>&lt; Expr &amp; &gt;::type</type>
 435               <template>
 436                 <template-type-parameter name="Expr"/>
 437               </template>
 438               <parameter name="expr">
 439                 <paramtype>Expr &amp;</paramtype>
 440                 <description>
 441                   <para>The terminal expression node. </para>
 442                 </description>
 443               </parameter>
 444               <description>
 445                 <para>
 446                   Return the value of the given terminal expression.
 447                 </para>
 448               </description>
 449               <requires>
 450                 <para>
 451                   <computeroutput><classname>proto::is_expr</classname>&lt;Expr&gt;::value</computeroutput> is
 452                   <computeroutput>true</computeroutput>
 453                 </para>
 454                 <para>
 455                   <computeroutput>0 == Expr::proto_arity::value</computeroutput>
 456                 </para>
 457               </requires>
 458               <returns>
 459                 <para>
 460                   <computeroutput><functionname>proto::value</functionname>(expr)</computeroutput>
 461                 </para>
 462               </returns>
 463               <throws>
 464                 <simpara>Will not throw.</simpara>
 465               </throws>
 466             </method>
 467             <method name="operator()" cv="const">
 468               <type>typename <classname>proto::result_of::value</classname>&lt; Expr const &amp; &gt;::type</type>
 469               <template>
 470                 <template-type-parameter name="Expr"/>
 471               </template>
 472               <parameter name="expr">
 473                 <paramtype>Expr const &amp;</paramtype>
 474               </parameter>
 475               <description>
 476                 <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
 477               </description>
 478             </method>
 479           </method-group>
 480         </struct>
 481
 482         <struct name="left">
 483           <purpose>A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
 484             <computeroutput><functionname alt="proto::left">proto::left()</functionname></computeroutput> function.</purpose>
 485           <struct-specialization name="result">
 486             <template>
 487               <template-type-parameter name="This"/>
 488               <template-type-parameter name="Expr"/>
 489             </template>
 490             <specialization>
 491               <template-arg>This(Expr)</template-arg>
 492             </specialization>
 493             <inherit>
 494               <type><classname>proto::result_of::left</classname>&lt; Expr &gt;</type>
 495             </inherit>
 496           </struct-specialization>
 497           <inherit>
 498             <type><classname>proto::callable</classname></type>
 499           </inherit>
 500           <method-group name="public member functions">
 501             <method name="operator()" cv="const">
 502               <type>typename <classname>proto::result_of::left</classname>&lt; Expr &amp; &gt;::type</type>
 503               <template>
 504                 <template-type-parameter name="Expr"/>
 505               </template>
 506               <parameter name="expr">
 507                 <paramtype>Expr &amp;</paramtype>
 508                 <description>
 509                   <para>The expression node. </para>
 510                 </description>
 511               </parameter>
 512               <description>
 513                 <para>
 514                   Return the left child of the given binary expression.
 515                 </para>
 516               </description>
 517               <requires>
 518                 <para>
 519                   <computeroutput><classname>proto::is_expr</classname>&lt;Expr&gt;::value</computeroutput> is
 520                   <computeroutput>true</computeroutput>
 521                 </para>
 522                 <para>
 523                   <computeroutput>2 == Expr::proto_arity::value</computeroutput>
 524                 </para>
 525               </requires>
 526               <returns>
 527                 <para>
 528                   <computeroutput><functionname>proto::left</functionname>(expr)</computeroutput>
 529                 </para>
 530               </returns>
 531               <throws>
 532                 <simpara>Will not throw.</simpara>
 533               </throws>
 534             </method>
 535             <method name="operator()" cv="const">
 536               <type>typename <classname>proto::result_of::left</classname>&lt; Expr const &amp; &gt;::type</type>
 537               <template>
 538                 <template-type-parameter name="Expr"/>
 539               </template>
 540               <parameter name="expr">
 541                 <paramtype>Expr const &amp;</paramtype>
 542               </parameter>
 543               <description>
 544                 <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
 545               </description>
 546             </method>
 547           </method-group>
 548         </struct>
 549
 550         <struct name="right">
 551           <purpose>A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
 552             <computeroutput><functionname alt="proto::right">proto::right()</functionname></computeroutput> function.</purpose>
 553           <struct-specialization name="result">
 554             <template>
 555               <template-type-parameter name="This"/>
 556               <template-type-parameter name="Expr"/>
 557             </template>
 558             <specialization>
 559               <template-arg>This(Expr)</template-arg>
 560             </specialization>
 561             <inherit>
 562               <type><classname>proto::result_of::right</classname>&lt; Expr &gt;</type>
 563             </inherit>
 564           </struct-specialization>
 565           <inherit>
 566             <type><classname>proto::callable</classname></type>
 567           </inherit>
 568           <method-group name="public member functions">
 569             <method name="operator()" cv="const">
 570               <type>typename <classname>proto::result_of::right</classname>&lt; Expr &amp; &gt;::type</type>
 571               <template>
 572                 <template-type-parameter name="Expr"/>
 573               </template>
 574               <parameter name="expr">
 575                 <paramtype>Expr &amp;</paramtype>
 576                 <description>
 577                   <para>The expression node. </para>
 578                 </description>
 579               </parameter>
 580               <description>
 581                 <para>Return the right child of the given binary expression.</para>
 582               </description>
 583               <requires>
 584                 <para>
 585                   <computeroutput><classname>proto::is_expr</classname>&lt;Expr&gt;::value</computeroutput> is <computeroutput>true</computeroutput>
 586                 </para>
 587                 <para>
 588                   <computeroutput>2 == Expr::proto_arity::value</computeroutput>
 589                 </para>
 590               </requires>
 591               <returns>
 592                 <para>
 593                   <computeroutput><functionname>proto::right</functionname>(expr)</computeroutput>
 594                 </para>
 595               </returns>
 596               <throws>
 597                 <simpara>Will not throw.</simpara>
 598               </throws>
 599             </method>
 600             <method name="operator()" cv="const">
 601               <type>typename <classname>proto::result_of::right</classname>&lt; Expr const &amp; &gt;::type</type>
 602               <template>
 603                 <template-type-parameter name="Expr"/>
 604               </template>
 605               <parameter name="expr">
 606                 <paramtype>Expr const &amp;</paramtype>
 607               </parameter>
 608             </method>
 609           </method-group>
 610         </struct>
 611       </namespace>
 612
 613       <struct name="terminal">
 614         <template>
 615           <template-type-parameter name="T"/>
 616         </template>
 617         <inherit><classname>proto::transform</classname>&lt; terminal&lt;T&gt; &gt;</inherit>
 618         <purpose>A metafunction for generating terminal expression types, a grammar element for matching
 619           terminal expressions, and
 620           a <conceptname>PrimitiveTransform</conceptname> that returns the current expression unchanged. </purpose>
 621         <struct name="impl">
 622           <template>
 623             <template-type-parameter name="Expr"/>
 624             <template-type-parameter name="State"/>
 625             <template-type-parameter name="Data"/>
 626           </template>
 627           <inherit><classname>proto::transform_impl</classname>&lt; Expr, State, Data &gt;</inherit>
 628           <typedef name="result_type">
 629             <type>Expr</type>
 630           </typedef>
 631           <method-group name="public member functions">
 632             <method name="operator()" cv="const">
 633               <type>Expr</type>
 634               <parameter name="expr">
 635                 <paramtype>typename impl::expr_param</paramtype>
 636                 <description>
 637                   <para>The current expression </para>
 638                 </description>
 639               </parameter>
 640               <parameter name="">
 641                 <paramtype>typename impl::state_param</paramtype>
 642               </parameter>
 643               <parameter name="">
 644                 <paramtype>typename impl::data_param</paramtype>
 645               </parameter>
 646               <requires>
 647                 <para>
 648                   <computeroutput><classname>proto::matches</classname>&lt;Expr, proto::terminal&lt;T&gt; &gt;::value</computeroutput> is <computeroutput>true</computeroutput>.
 649                 </para>
 650               </requires>
 651               <returns>
 652                 <para>
 653                   <computeroutput>expr</computeroutput>
 654                 </para>
 655               </returns>
 656               <throws>
 657                 <simpara>Will not throw.</simpara>
 658               </throws>
 659             </method>
 660           </method-group>
 661         </struct>
 662         <typedef name="type">
 663           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::terminal</classname>, <classname>proto::term</classname>&lt; T &gt; &gt;</type>
 664         </typedef>
 665         <typedef name="proto_grammar">
 666           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::terminal</classname>, <classname>proto::term</classname>&lt; T &gt; &gt;</type>
 667         </typedef>
 668       </struct>
 669
 670       <struct name="if_else_">
 671         <template>
 672           <template-type-parameter name="T"/>
 673           <template-type-parameter name="U"/>
 674           <template-type-parameter name="V"/>
 675         </template>
 676         <inherit><classname>proto::transform</classname>&lt; if_else_&lt;T, U, V&gt; &gt;</inherit>
 677         <purpose>A metafunction for generating ternary conditional expression types, a grammar element for
 678           matching ternary conditional expressions, and
 679           a <conceptname>PrimitiveTransform</conceptname>
 680           that dispatches to the
 681           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
 682           transform.</purpose>
 683         <struct name="impl">
 684           <template>
 685             <template-type-parameter name="Expr"/>
 686             <template-type-parameter name="State"/>
 687             <template-type-parameter name="Data"/>
 688           </template>
 689           <inherit>
 690             <type><classname>proto::pass_through</classname>&lt;if_else_&gt;::template impl&lt;Expr, State, Data&gt;</type>
 691           </inherit>
 692         </struct>
 693         <typedef name="type">
 694           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::if_else_</classname>, <classname alt="proto::listN">proto::list3</classname>&lt; T, U, V &gt; &gt;</type>
 695         </typedef>
 696         <typedef name="proto_grammar">
 697           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::if_else_</classname>, <classname alt="proto::listN">proto::list3</classname>&lt; T, U, V &gt; &gt;</type>
 698         </typedef>
 699       </struct>
 700
 701       <struct name="unary_plus">
 702         <template>
 703           <template-type-parameter name="T"/>
 704         </template>
 705         <inherit><classname>proto::transform</classname>&lt; unary_plus&lt;T&gt; &gt;</inherit>
 706         <purpose>A metafunction for generating unary plus expression types,
 707           a grammar element for matching unary plus expressions, and
 708           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
 709           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
 710           transform.</purpose>
 711         <struct name="impl">
 712           <template>
 713             <template-type-parameter name="Expr"/>
 714             <template-type-parameter name="State"/>
 715             <template-type-parameter name="Data"/>
 716           </template>
 717           <inherit>
 718             <type><classname>proto::pass_through</classname>&lt;unary_plus&gt;::template impl&lt;Expr, State, Data&gt;</type>
 719           </inherit>
 720         </struct>
 721         <typedef name="type">
 722           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::unary_plus</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 723         </typedef>
 724         <typedef name="proto_grammar">
 725           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::unary_plus</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 726         </typedef>
 727       </struct>
 728
 729       <struct name="negate">
 730         <template>
 731           <template-type-parameter name="T"/>
 732         </template>
 733         <inherit><classname>proto::transform</classname>&lt; negate&lt;T&gt; &gt;</inherit>
 734         <purpose>A metafunction for generating unary minus expression types,
 735           a grammar element for matching unary minus expressions, and
 736           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
 737           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
 738           transform.</purpose>
 739         <struct name="impl">
 740           <template>
 741             <template-type-parameter name="Expr"/>
 742             <template-type-parameter name="State"/>
 743             <template-type-parameter name="Data"/>
 744           </template>
 745           <inherit>
 746             <type><classname>proto::pass_through</classname>&lt;negate&gt;::template impl&lt;Expr, State, Data&gt;</type>
 747           </inherit>
 748         </struct>
 749         <typedef name="type">
 750           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::negate</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 751         </typedef>
 752         <typedef name="proto_grammar">
 753           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::negate</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 754         </typedef>
 755       </struct>
 756
 757       <struct name="dereference">
 758         <template>
 759           <template-type-parameter name="T"/>
 760         </template>
 761         <inherit><classname>proto::transform</classname>&lt; dereference&lt;T&gt; &gt;</inherit>
 762         <purpose>A metafunction for generating defereference expression types,
 763           a grammar element for matching dereference expressions, and
 764           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
 765           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
 766           transform.</purpose>
 767         <struct name="impl">
 768           <template>
 769             <template-type-parameter name="Expr"/>
 770             <template-type-parameter name="State"/>
 771             <template-type-parameter name="Data"/>
 772           </template>
 773           <inherit>
 774             <type><classname>proto::pass_through</classname>&lt;dereference&gt;::template impl&lt;Expr, State, Data&gt;</type>
 775           </inherit>
 776         </struct>
 777         <typedef name="type">
 778           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::dereference</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 779         </typedef>
 780         <typedef name="proto_grammar">
 781           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::dereference</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 782         </typedef>
 783       </struct>
 784
 785       <struct name="complement">
 786         <template>
 787           <template-type-parameter name="T"/>
 788         </template>
 789         <inherit><classname>proto::transform</classname>&lt; complement&lt;T&gt; &gt;</inherit>
 790         <purpose>A metafunction for generating complement expression types,
 791           a grammar element for matching complement expressions, and
 792           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
 793           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
 794           transform.</purpose>
 795         <struct name="impl">
 796           <template>
 797             <template-type-parameter name="Expr"/>
 798             <template-type-parameter name="State"/>
 799             <template-type-parameter name="Data"/>
 800           </template>
 801           <inherit>
 802             <type><classname>proto::pass_through</classname>&lt;complement&gt;::template impl&lt;Expr, State, Data&gt;</type>
 803           </inherit>
 804         </struct>
 805         <typedef name="type">
 806           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::complement</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 807         </typedef>
 808         <typedef name="proto_grammar">
 809           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::complement</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 810         </typedef>
 811       </struct>
 812
 813       <struct name="address_of">
 814         <template>
 815           <template-type-parameter name="T"/>
 816         </template>
 817         <inherit><classname>proto::transform</classname>&lt; address_of&lt;T&gt; &gt;</inherit>
 818         <purpose>A metafunction for generating address_of expression types,
 819           a grammar element for matching address_of expressions, and
 820           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
 821           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
 822           transform.</purpose>
 823         <struct name="impl">
 824           <template>
 825             <template-type-parameter name="Expr"/>
 826             <template-type-parameter name="State"/>
 827             <template-type-parameter name="Data"/>
 828           </template>
 829           <inherit>
 830             <type><classname>proto::pass_through</classname>&lt;address_of&gt;::template impl&lt;Expr, State, Data&gt;</type>
 831           </inherit>
 832         </struct>
 833         <typedef name="type">
 834           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::address_of</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 835         </typedef>
 836         <typedef name="proto_grammar">
 837           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::address_of</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 838         </typedef>
 839       </struct>
 840
 841       <struct name="logical_not">
 842         <template>
 843           <template-type-parameter name="T"/>
 844         </template>
 845         <inherit><classname>proto::transform</classname>&lt; logical_not&lt;T&gt; &gt;</inherit>
 846         <purpose>A metafunction for generating logical_not expression types,
 847           a grammar element for matching logical_not expressions, and
 848           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
 849           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
 850           transform.</purpose>
 851         <struct name="impl">
 852           <template>
 853             <template-type-parameter name="Expr"/>
 854             <template-type-parameter name="State"/>
 855             <template-type-parameter name="Data"/>
 856           </template>
 857           <inherit>
 858             <type><classname>proto::pass_through</classname>&lt;logical_not&gt;::template impl&lt;Expr, State, Data&gt;</type>
 859           </inherit>
 860         </struct>
 861         <typedef name="type">
 862           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::logical_not</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 863         </typedef>
 864         <typedef name="proto_grammar">
 865           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::logical_not</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 866         </typedef>
 867       </struct>
 868
 869       <struct name="pre_inc">
 870         <template>
 871           <template-type-parameter name="T"/>
 872         </template>
 873         <inherit><classname>proto::transform</classname>&lt; pre_inc&lt;T&gt; &gt;</inherit>
 874         <purpose>A metafunction for generating pre-increment expression types,
 875           a grammar element for matching pre-increment expressions, and
 876           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
 877           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
 878           transform.</purpose>
 879         <struct name="impl">
 880           <template>
 881             <template-type-parameter name="Expr"/>
 882             <template-type-parameter name="State"/>
 883             <template-type-parameter name="Data"/>
 884           </template>
 885           <inherit>
 886             <type><classname>proto::pass_through</classname>&lt;pre_inc&gt;::template impl&lt;Expr, State, Data&gt;</type>
 887           </inherit>
 888         </struct>
 889         <typedef name="type">
 890           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::pre_inc</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 891         </typedef>
 892         <typedef name="proto_grammar">
 893           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::pre_inc</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 894         </typedef>
 895       </struct>
 896
 897       <struct name="pre_dec">
 898         <template>
 899           <template-type-parameter name="T"/>
 900         </template>
 901         <inherit><classname>proto::transform</classname>&lt; pre_dec&lt;T&gt; &gt;</inherit>
 902         <purpose>A metafunction for generating pre-decrement expression types,
 903           a grammar element for matching pre-decrement expressions, and
 904           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
 905           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
 906           transform.</purpose>
 907         <struct name="impl">
 908           <template>
 909             <template-type-parameter name="Expr"/>
 910             <template-type-parameter name="State"/>
 911             <template-type-parameter name="Data"/>
 912           </template>
 913           <inherit>
 914             <type><classname>proto::pass_through</classname>&lt;pre_dec&gt;::template impl&lt;Expr, State, Data&gt;</type>
 915           </inherit>
 916         </struct>
 917         <typedef name="type">
 918           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::pre_dec</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 919         </typedef>
 920         <typedef name="proto_grammar">
 921           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::pre_dec</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 922         </typedef>
 923       </struct>
 924
 925       <struct name="post_inc">
 926         <template>
 927           <template-type-parameter name="T"/>
 928         </template>
 929         <inherit><classname>proto::transform</classname>&lt; post_inc&lt;T&gt; &gt;</inherit>
 930         <purpose>A metafunction for generating post-increment expression types,
 931           a grammar element for matching post-increment expressions, and
 932           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
 933           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
 934           transform.</purpose>
 935         <struct name="impl">
 936           <template>
 937             <template-type-parameter name="Expr"/>
 938             <template-type-parameter name="State"/>
 939             <template-type-parameter name="Data"/>
 940           </template>
 941           <inherit>
 942             <type><classname>proto::pass_through</classname>&lt;post_inc&gt;::template impl&lt;Expr, State, Data&gt;</type>
 943           </inherit>
 944         </struct>
 945         <typedef name="type">
 946           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::post_inc</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 947         </typedef>
 948         <typedef name="proto_grammar">
 949           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::post_inc</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 950         </typedef>
 951       </struct>
 952
 953       <struct name="post_dec">
 954         <template>
 955           <template-type-parameter name="T"/>
 956         </template>
 957         <inherit><classname>proto::transform</classname>&lt; post_dec&lt;T&gt; &gt;</inherit>
 958         <purpose>A metafunction for generating post-decrement expression types,
 959           a grammar element for matching post-decrement expressions, and
 960           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
 961           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
 962           transform.</purpose>
 963         <struct name="impl">
 964           <template>
 965             <template-type-parameter name="Expr"/>
 966             <template-type-parameter name="State"/>
 967             <template-type-parameter name="Data"/>
 968           </template>
 969           <inherit>
 970             <type><classname>proto::pass_through</classname>&lt;post_dec&gt;::template impl&lt;Expr, State, Data&gt;</type>
 971           </inherit>
 972         </struct>
 973         <typedef name="type">
 974           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::post_dec</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
 975         </typedef>
 976         <typedef name="proto_grammar">
 977           <type>
 978             <classname>proto::basic_expr</classname>&lt; <classname>proto::tag::post_dec</classname>, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;
 979           </type>
 980         </typedef>
 981       </struct>
 982
 983       <struct name="shift_left">
 984         <template>
 985           <template-type-parameter name="T"/>
 986           <template-type-parameter name="U"/>
 987         </template>
 988         <inherit><classname>proto::transform</classname>&lt; shift_left&lt;T, U&gt; &gt;</inherit>
 989         <purpose>A metafunction for generating left-shift expression types,
 990           a grammar element for matching left-shift expressions, and
 991           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
 992           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
 993           transform.</purpose>
 994         <struct name="impl">
 995           <template>
 996             <template-type-parameter name="Expr"/>
 997             <template-type-parameter name="State"/>
 998             <template-type-parameter name="Data"/>
 999           </template>
1000           <inherit>
1001             <type><classname>proto::pass_through</classname>&lt;shift_left&gt;::template impl&lt;Expr, State, Data&gt;</type>
1002           </inherit>
1003         </struct>
1004         <typedef name="type">
1005           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::shift_left</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1006         </typedef>
1007         <typedef name="proto_grammar">
1008           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::shift_left</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1009         </typedef>
1010       </struct>
1011
1012       <struct name="shift_right">
1013         <template>
1014           <template-type-parameter name="T"/>
1015           <template-type-parameter name="U"/>
1016         </template>
1017         <inherit><classname>proto::transform</classname>&lt; shift_right&lt;T, U&gt; &gt;</inherit>
1018         <purpose>A metafunction for generating right-shift expression types,
1019           a grammar element for matching right-shift expressions, and a
1020           <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1021           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1022           transform.</purpose>
1023         <struct name="impl">
1024           <template>
1025             <template-type-parameter name="Expr"/>
1026             <template-type-parameter name="State"/>
1027             <template-type-parameter name="Data"/>
1028           </template>
1029           <inherit>
1030             <type><classname>proto::pass_through</classname>&lt;shift_right&gt;::template impl&lt;Expr, State, Data&gt;</type>
1031           </inherit>
1032         </struct>
1033         <typedef name="type">
1034           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::shift_right</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1035         </typedef>
1036         <typedef name="proto_grammar">
1037           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::shift_right</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1038         </typedef>
1039       </struct>
1040
1041       <struct name="multiplies">
1042         <template>
1043           <template-type-parameter name="T"/>
1044           <template-type-parameter name="U"/>
1045         </template>
1046         <inherit><classname>proto::transform</classname>&lt; multiplies&lt;T, U&gt; &gt;</inherit>
1047         <purpose>A metafunction for generating multiplies expression types,
1048           a grammar element for matching multiplies expressions, and
1049           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1050           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1051           transform.</purpose>
1052         <struct name="impl">
1053           <template>
1054             <template-type-parameter name="Expr"/>
1055             <template-type-parameter name="State"/>
1056             <template-type-parameter name="Data"/>
1057           </template>
1058           <inherit>
1059             <type><classname>proto::pass_through</classname>&lt;multiplies&gt;::template impl&lt;Expr, State, Data&gt;</type>
1060           </inherit>
1061         </struct>
1062         <typedef name="type">
1063           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::multiplies</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1064         </typedef>
1065         <typedef name="proto_grammar">
1066           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::multiplies</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1067         </typedef>
1068       </struct>
1069
1070       <struct name="divides">
1071         <template>
1072           <template-type-parameter name="T"/>
1073           <template-type-parameter name="U"/>
1074         </template>
1075         <inherit><classname>proto::transform</classname>&lt; divides&lt;T, U&gt; &gt;</inherit>
1076         <purpose>A metafunction for generating divides expression types,
1077           a grammar element for matching divides expressions, and
1078           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1079           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1080           transform.</purpose>
1081         <struct name="impl">
1082           <template>
1083             <template-type-parameter name="Expr"/>
1084             <template-type-parameter name="State"/>
1085             <template-type-parameter name="Data"/>
1086           </template>
1087           <inherit>
1088             <type><classname>proto::pass_through</classname>&lt;divides&gt;::template impl&lt;Expr, State, Data&gt;</type>
1089           </inherit>
1090         </struct>
1091         <typedef name="type">
1092           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::divides</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1093         </typedef>
1094         <typedef name="proto_grammar">
1095           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::divides</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1096         </typedef>
1097       </struct>
1098
1099       <struct name="modulus">
1100         <template>
1101           <template-type-parameter name="T"/>
1102           <template-type-parameter name="U"/>
1103         </template>
1104         <inherit><classname>proto::transform</classname>&lt; modulus&lt;T, U&gt; &gt;</inherit>
1105         <purpose>A metafunction for generating modulus expression types,
1106           a grammar element for matching modulus expressions, and
1107           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1108           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1109           transform.</purpose>
1110         <struct name="impl">
1111           <template>
1112             <template-type-parameter name="Expr"/>
1113             <template-type-parameter name="State"/>
1114             <template-type-parameter name="Data"/>
1115           </template>
1116           <inherit>
1117             <type><classname>proto::pass_through</classname>&lt;modulus&gt;::template impl&lt;Expr, State, Data&gt;</type>
1118           </inherit>
1119         </struct>
1120         <typedef name="type">
1121           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::modulus</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1122         </typedef>
1123         <typedef name="proto_grammar">
1124           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::modulus</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1125         </typedef>
1126       </struct>
1127
1128       <struct name="plus">
1129         <template>
1130           <template-type-parameter name="T"/>
1131           <template-type-parameter name="U"/>
1132         </template>
1133         <inherit><classname>proto::transform</classname>&lt; plus&lt;T, U&gt; &gt;</inherit>
1134         <purpose>A metafunction for generating binary plus expression types,
1135           a grammar element for matching binary plus expressions, and
1136           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1137           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1138           transform.</purpose>
1139         <struct name="impl">
1140           <template>
1141             <template-type-parameter name="Expr"/>
1142             <template-type-parameter name="State"/>
1143             <template-type-parameter name="Data"/>
1144           </template>
1145           <inherit>
1146             <type><classname>proto::pass_through</classname>&lt;plus&gt;::template impl&lt;Expr, State, Data&gt;</type>
1147           </inherit>
1148         </struct>
1149         <typedef name="type">
1150           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::plus</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1151         </typedef>
1152         <typedef name="proto_grammar">
1153           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::plus</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1154         </typedef>
1155       </struct>
1156
1157       <struct name="minus">
1158         <template>
1159           <template-type-parameter name="T"/>
1160           <template-type-parameter name="U"/>
1161         </template>
1162         <inherit><classname>proto::transform</classname>&lt; minus&lt;T, U&gt; &gt;</inherit>
1163         <purpose>A metafunction for generating binary minus expression types,
1164           a grammar element for matching binary minus expressions, and
1165           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1166           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1167           transform.</purpose>
1168         <struct name="impl">
1169           <template>
1170             <template-type-parameter name="Expr"/>
1171             <template-type-parameter name="State"/>
1172             <template-type-parameter name="Data"/>
1173           </template>
1174           <inherit>
1175             <type><classname>proto::pass_through</classname>&lt;minus&gt;::template impl&lt;Expr, State, Data&gt;</type>
1176           </inherit>
1177         </struct>
1178         <typedef name="type">
1179           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::minus</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1180         </typedef>
1181         <typedef name="proto_grammar">
1182           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::minus</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1183         </typedef>
1184       </struct>
1185
1186       <struct name="less">
1187         <template>
1188           <template-type-parameter name="T"/>
1189           <template-type-parameter name="U"/>
1190         </template>
1191         <inherit><classname>proto::transform</classname>&lt; less&lt;T, U&gt; &gt;</inherit>
1192         <purpose>A metafunction for generating less expression types,
1193           a grammar element for matching less expressions, and
1194           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1195           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1196           transform.</purpose>
1197         <struct name="impl">
1198           <template>
1199             <template-type-parameter name="Expr"/>
1200             <template-type-parameter name="State"/>
1201             <template-type-parameter name="Data"/>
1202           </template>
1203           <inherit>
1204             <type><classname>proto::pass_through</classname>&lt;less&gt;::template impl&lt;Expr, State, Data&gt;</type>
1205           </inherit>
1206         </struct>
1207         <typedef name="type">
1208           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::less</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1209         </typedef>
1210         <typedef name="proto_grammar">
1211           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::less</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1212         </typedef>
1213       </struct>
1214
1215       <struct name="greater">
1216         <template>
1217           <template-type-parameter name="T"/>
1218           <template-type-parameter name="U"/>
1219         </template>
1220         <inherit><classname>proto::transform</classname>&lt; greater&lt;T, U&gt; &gt;</inherit>
1221         <purpose>A metafunction for generating greater expression types,
1222           a grammar element for matching greater expressions, and
1223           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1224           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1225           transform.</purpose>
1226         <struct name="impl">
1227           <template>
1228             <template-type-parameter name="Expr"/>
1229             <template-type-parameter name="State"/>
1230             <template-type-parameter name="Data"/>
1231           </template>
1232           <inherit>
1233             <type><classname>proto::pass_through</classname>&lt;greater&gt;::template impl&lt;Expr, State, Data&gt;</type>
1234           </inherit>
1235         </struct>
1236         <typedef name="type">
1237           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::greater</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1238         </typedef>
1239         <typedef name="proto_grammar">
1240           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::greater</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1241         </typedef>
1242       </struct>
1243
1244       <struct name="less_equal">
1245         <template>
1246           <template-type-parameter name="T"/>
1247           <template-type-parameter name="U"/>
1248         </template>
1249         <inherit><classname>proto::transform</classname>&lt; less_equal&lt;T, U&gt; &gt;</inherit>
1250         <purpose>A metafunction for generating less-or-equal expression types,
1251           a grammar element for matching less-or-equal expressions, and
1252           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1253           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1254           transform.</purpose>
1255         <struct name="impl">
1256           <template>
1257             <template-type-parameter name="Expr"/>
1258             <template-type-parameter name="State"/>
1259             <template-type-parameter name="Data"/>
1260           </template>
1261           <inherit>
1262             <type><classname>proto::pass_through</classname>&lt;less_equal&gt;::template impl&lt;Expr, State, Data&gt;</type>
1263           </inherit>
1264         </struct>
1265         <typedef name="type">
1266           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::less_equal</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1267         </typedef>
1268         <typedef name="proto_grammar">
1269           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::less_equal</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1270         </typedef>
1271       </struct>
1272
1273       <struct name="greater_equal">
1274         <template>
1275           <template-type-parameter name="T"/>
1276           <template-type-parameter name="U"/>
1277         </template>
1278         <inherit><classname>proto::transform</classname>&lt; greater_equal&lt;T, U&gt; &gt;</inherit>
1279         <purpose>A metafunction for generating greater-or-equal expression types,
1280           a grammar element for matching greater-or-equal expressions, and
1281           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1282           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1283           transform.</purpose>
1284         <struct name="impl">
1285           <template>
1286             <template-type-parameter name="Expr"/>
1287             <template-type-parameter name="State"/>
1288             <template-type-parameter name="Data"/>
1289           </template>
1290           <inherit>
1291             <type><classname>proto::pass_through</classname>&lt;greater_equal&gt;::template impl&lt;Expr, State, Data&gt;</type>
1292           </inherit>
1293         </struct>
1294         <typedef name="type">
1295           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::greater_equal</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1296         </typedef>
1297         <typedef name="proto_grammar">
1298           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::greater_equal</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1299         </typedef>
1300       </struct>
1301
1302       <struct name="equal_to">
1303         <template>
1304           <template-type-parameter name="T"/>
1305           <template-type-parameter name="U"/>
1306         </template>
1307         <inherit><classname>proto::transform</classname>&lt; equal_to&lt;T, U&gt; &gt;</inherit>
1308         <purpose>A metafunction for generating equal-to expression types,
1309           a grammar element for matching equal-to expressions, and
1310           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1311           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1312           transform.</purpose>
1313         <struct name="impl">
1314           <template>
1315             <template-type-parameter name="Expr"/>
1316             <template-type-parameter name="State"/>
1317             <template-type-parameter name="Data"/>
1318           </template>
1319           <inherit>
1320             <type><classname>proto::pass_through</classname>&lt;equal_to&gt;::template impl&lt;Expr, State, Data&gt;</type>
1321           </inherit>
1322         </struct>
1323         <typedef name="type">
1324           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::equal_to</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1325         </typedef>
1326         <typedef name="proto_grammar">
1327           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::equal_to</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1328         </typedef>
1329       </struct>
1330
1331       <struct name="not_equal_to">
1332         <template>
1333           <template-type-parameter name="T"/>
1334           <template-type-parameter name="U"/>
1335         </template>
1336         <inherit><classname>proto::transform</classname>&lt; not_equal_to&lt;T, U&gt; &gt;</inherit>
1337         <purpose>A metafunction for generating not-equal-to expression types,
1338           a grammar element for matching not-equal-to expressions, and
1339           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1340           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1341           transform.</purpose>
1342         <struct name="impl">
1343           <template>
1344             <template-type-parameter name="Expr"/>
1345             <template-type-parameter name="State"/>
1346             <template-type-parameter name="Data"/>
1347           </template>
1348           <inherit>
1349             <type><classname>proto::pass_through</classname>&lt;mot_equal_to&gt;::template impl&lt;Expr, State, Data&gt;</type>
1350           </inherit>
1351         </struct>
1352         <typedef name="type">
1353           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::not_equal_to</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1354         </typedef>
1355         <typedef name="proto_grammar">
1356           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::not_equal_to</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1357         </typedef>
1358       </struct>
1359
1360       <struct name="logical_or">
1361         <template>
1362           <template-type-parameter name="T"/>
1363           <template-type-parameter name="U"/>
1364         </template>
1365         <inherit><classname>proto::transform</classname>&lt; logical_or&lt;T, U&gt; &gt;</inherit>
1366         <purpose>A metafunction for generating logical-or expression types,
1367           a grammar element for matching logical-or expressions, and
1368           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1369           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1370           transform.</purpose>
1371         <struct name="impl">
1372           <template>
1373             <template-type-parameter name="Expr"/>
1374             <template-type-parameter name="State"/>
1375             <template-type-parameter name="Data"/>
1376           </template>
1377           <inherit>
1378             <type><classname>proto::pass_through</classname>&lt;logical_or&gt;::template impl&lt;Expr, State, Data&gt;</type>
1379           </inherit>
1380         </struct>
1381         <typedef name="type">
1382           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::logical_or</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1383         </typedef>
1384         <typedef name="proto_grammar">
1385           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::logical_or</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1386         </typedef>
1387       </struct>
1388
1389       <struct name="logical_and">
1390         <template>
1391           <template-type-parameter name="T"/>
1392           <template-type-parameter name="U"/>
1393         </template>
1394         <inherit><classname>proto::transform</classname>&lt; logical_and&lt;T, U&gt; &gt;</inherit>
1395         <purpose>A metafunction for generating logical-and expression types,
1396           a grammar element for matching logical-and expressions, and
1397           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1398           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1399           transform.</purpose>
1400         <struct name="impl">
1401           <template>
1402             <template-type-parameter name="Expr"/>
1403             <template-type-parameter name="State"/>
1404             <template-type-parameter name="Data"/>
1405           </template>
1406           <inherit>
1407             <type><classname>proto::pass_through</classname>&lt;logical_and&gt;::template impl&lt;Expr, State, Data&gt;</type>
1408           </inherit>
1409         </struct>
1410         <typedef name="type">
1411           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::logical_and</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1412         </typedef>
1413         <typedef name="proto_grammar">
1414           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::logical_and</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1415         </typedef>
1416       </struct>
1417
1418       <struct name="bitwise_and">
1419         <template>
1420           <template-type-parameter name="T"/>
1421           <template-type-parameter name="U"/>
1422         </template>
1423         <inherit><classname>proto::transform</classname>&lt; bitwise_and&lt;T, U&gt; &gt;</inherit>
1424         <purpose>A metafunction for generating bitwise-and expression types,
1425           a grammar element for matching bitwise-and expressions, and
1426           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1427           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1428           transform.</purpose>
1429         <struct name="impl">
1430           <template>
1431             <template-type-parameter name="Expr"/>
1432             <template-type-parameter name="State"/>
1433             <template-type-parameter name="Data"/>
1434           </template>
1435           <inherit>
1436             <type><classname>proto::pass_through</classname>&lt;bitwise_and&gt;::template impl&lt;Expr, State, Data&gt;</type>
1437           </inherit>
1438         </struct>
1439         <typedef name="type">
1440           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::bitwise_and</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1441         </typedef>
1442         <typedef name="proto_grammar">
1443           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::bitwise_and</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1444         </typedef>
1445       </struct>
1446
1447       <struct name="bitwise_or">
1448         <template>
1449           <template-type-parameter name="T"/>
1450           <template-type-parameter name="U"/>
1451         </template>
1452         <inherit><classname>proto::transform</classname>&lt; bitwise_or&lt;T, U&gt; &gt;</inherit>
1453         <purpose>A metafunction for generating bitwise-or expression types,
1454           a grammar element for matching bitwise-or expressions, and
1455           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1456           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1457           transform.</purpose>
1458         <struct name="impl">
1459           <template>
1460             <template-type-parameter name="Expr"/>
1461             <template-type-parameter name="State"/>
1462             <template-type-parameter name="Data"/>
1463           </template>
1464           <inherit>
1465             <type><classname>proto::pass_through</classname>&lt;bitwise_or&gt;::template impl&lt;Expr, State, Data&gt;</type>
1466           </inherit>
1467         </struct>
1468         <typedef name="type">
1469           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::bitwise_or</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1470         </typedef>
1471         <typedef name="proto_grammar">
1472           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::bitwise_or</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1473         </typedef>
1474       </struct>
1475
1476       <struct name="bitwise_xor">
1477         <template>
1478           <template-type-parameter name="T"/>
1479           <template-type-parameter name="U"/>
1480         </template>
1481         <inherit><classname>proto::transform</classname>&lt; bitwise_xor&lt;T, U&gt; &gt;</inherit>
1482         <purpose>A metafunction for generating bitwise-xor expression types,
1483           a grammar element for matching bitwise-xor expressions, and
1484           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1485           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1486           transform.</purpose>
1487         <struct name="impl">
1488           <template>
1489             <template-type-parameter name="Expr"/>
1490             <template-type-parameter name="State"/>
1491             <template-type-parameter name="Data"/>
1492           </template>
1493           <inherit>
1494             <type><classname>proto::pass_through</classname>&lt;bitwise_xor&gt;::template impl&lt;Expr, State, Data&gt;</type>
1495           </inherit>
1496         </struct>
1497         <typedef name="type">
1498           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::bitwise_xor</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1499         </typedef>
1500         <typedef name="proto_grammar">
1501           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::bitwise_xor</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1502         </typedef>
1503       </struct>
1504
1505       <struct name="comma">
1506         <template>
1507           <template-type-parameter name="T"/>
1508           <template-type-parameter name="U"/>
1509         </template>
1510         <inherit><classname>proto::transform</classname>&lt; comma&lt;T, U&gt; &gt;</inherit>
1511         <purpose>A metafunction for generating comma expression types,
1512           a grammar element for matching comma expressions, and
1513           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1514           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1515           transform.</purpose>
1516         <struct name="impl">
1517           <template>
1518             <template-type-parameter name="Expr"/>
1519             <template-type-parameter name="State"/>
1520             <template-type-parameter name="Data"/>
1521           </template>
1522           <inherit>
1523             <type><classname>proto::pass_through</classname>&lt;comma&gt;::template impl&lt;Expr, State, Data&gt;</type>
1524           </inherit>
1525         </struct>
1526         <typedef name="type">
1527           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::comma</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1528         </typedef>
1529         <typedef name="proto_grammar">
1530           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::comma</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1531         </typedef>
1532       </struct>
1533
1534       <struct name="mem_ptr">
1535         <template>
1536           <template-type-parameter name="T"/>
1537           <template-type-parameter name="U"/>
1538         </template>
1539         <inherit><classname>proto::transform</classname>&lt; mem_ptr&lt;T, U&gt; &gt;</inherit>
1540         <struct name="impl">
1541           <template>
1542             <template-type-parameter name="Expr"/>
1543             <template-type-parameter name="State"/>
1544             <template-type-parameter name="Data"/>
1545           </template>
1546           <inherit>
1547             <type><classname>proto::pass_through</classname>&lt;mem_ptr&gt;::template impl&lt;Expr, State, Data&gt;</type>
1548           </inherit>
1549         </struct>
1550         <typedef name="type">
1551           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::mem_ptr</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1552         </typedef>
1553         <typedef name="proto_grammar">
1554           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::mem_ptr</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1555         </typedef>
1556       </struct>
1557
1558       <struct name="assign">
1559         <template>
1560           <template-type-parameter name="T"/>
1561           <template-type-parameter name="U"/>
1562         </template>
1563         <inherit><classname>proto::transform</classname>&lt; assign&lt;T, U&gt; &gt;</inherit>
1564         <purpose>A metafunction for generating assignment expression types,
1565           a grammar element for matching assignment expressions, and
1566           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1567           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1568           transform.</purpose>
1569         <struct name="impl">
1570           <template>
1571             <template-type-parameter name="Expr"/>
1572             <template-type-parameter name="State"/>
1573             <template-type-parameter name="Data"/>
1574           </template>
1575           <inherit>
1576             <type><classname>proto::pass_through</classname>&lt;assign&gt;::template impl&lt;Expr, State, Data&gt;</type>
1577           </inherit>
1578         </struct>
1579         <typedef name="type">
1580           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1581         </typedef>
1582         <typedef name="proto_grammar">
1583           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1584         </typedef>
1585       </struct>
1586
1587       <struct name="shift_left_assign">
1588         <template>
1589           <template-type-parameter name="T"/>
1590           <template-type-parameter name="U"/>
1591         </template>
1592         <inherit><classname>proto::transform</classname>&lt; shift_left_assign&lt;T, U&gt; &gt;</inherit>
1593         <purpose>A metafunction for generating left-shift-assign expression types,
1594           a grammar element for matching left-shift-assign expressions, and
1595           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1596           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1597           transform.</purpose>
1598         <struct name="impl">
1599           <template>
1600             <template-type-parameter name="Expr"/>
1601             <template-type-parameter name="State"/>
1602             <template-type-parameter name="Data"/>
1603           </template>
1604           <inherit>
1605             <type><classname>proto::pass_through</classname>&lt;shift_left_assign&gt;::template impl&lt;Expr, State, Data&gt;</type>
1606           </inherit>
1607         </struct>
1608         <typedef name="type">
1609           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::shift_left_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1610         </typedef>
1611         <typedef name="proto_grammar">
1612           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::shift_left_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1613         </typedef>
1614       </struct>
1615
1616       <struct name="shift_right_assign">
1617         <template>
1618           <template-type-parameter name="T"/>
1619           <template-type-parameter name="U"/>
1620         </template>
1621         <inherit><classname>proto::transform</classname>&lt; shift_right_assign&lt;T, U&gt; &gt;</inherit>
1622         <purpose>A metafunction for generating right-shift-assign expression types,
1623           a grammar element for matching right-shift-assign expressions, and
1624           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1625           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1626           transform.</purpose>
1627         <struct name="impl">
1628           <template>
1629             <template-type-parameter name="Expr"/>
1630             <template-type-parameter name="State"/>
1631             <template-type-parameter name="Data"/>
1632           </template>
1633           <inherit>
1634             <type><classname>proto::pass_through</classname>&lt;shift_right_assign&gt;::template impl&lt;Expr, State, Data&gt;</type>
1635           </inherit>
1636         </struct>
1637         <typedef name="type">
1638           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::shift_right_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1639         </typedef>
1640         <typedef name="proto_grammar">
1641           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::shift_right_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1642         </typedef>
1643       </struct>
1644
1645       <struct name="multiplies_assign">
1646         <template>
1647           <template-type-parameter name="T"/>
1648           <template-type-parameter name="U"/>
1649         </template>
1650         <inherit><classname>proto::transform</classname>&lt; multiplies_assign&lt;T, U&gt; &gt;</inherit>
1651         <purpose>A metafunction for generating multiplies-assign expression types,
1652           a grammar element for matching multiplies-assign expressions, and
1653           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1654           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1655           transform.</purpose>
1656         <struct name="impl">
1657           <template>
1658             <template-type-parameter name="Expr"/>
1659             <template-type-parameter name="State"/>
1660             <template-type-parameter name="Data"/>
1661           </template>
1662           <inherit>
1663             <type><classname>proto::pass_through</classname>&lt;multiplies_assign&gt;::template impl&lt;Expr, State, Data&gt;</type>
1664           </inherit>
1665         </struct>
1666         <typedef name="type">
1667           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::multiplies_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1668         </typedef>
1669         <typedef name="proto_grammar">
1670           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::multiplies_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1671         </typedef>
1672       </struct>
1673
1674       <struct name="divides_assign">
1675         <template>
1676           <template-type-parameter name="T"/>
1677           <template-type-parameter name="U"/>
1678         </template>
1679         <inherit><classname>proto::transform</classname>&lt; divides_assign&lt;T, U&gt; &gt;</inherit>
1680         <purpose>A metafunction for generating divides-assign expression types,
1681           a grammar element for matching divides-assign expressions, and
1682           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1683           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1684           transform.</purpose>
1685         <struct name="impl">
1686           <template>
1687             <template-type-parameter name="Expr"/>
1688             <template-type-parameter name="State"/>
1689             <template-type-parameter name="Data"/>
1690           </template>
1691           <inherit>
1692             <type><classname>proto::pass_through</classname>&lt;divides_assign&gt;::template impl&lt;Expr, State, Data&gt;</type>
1693           </inherit>
1694         </struct>
1695         <typedef name="type">
1696           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::divides_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1697         </typedef>
1698         <typedef name="proto_grammar">
1699           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::divides_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1700         </typedef>
1701       </struct>
1702
1703       <struct name="modulus_assign">
1704         <template>
1705           <template-type-parameter name="T"/>
1706           <template-type-parameter name="U"/>
1707         </template>
1708         <inherit><classname>proto::transform</classname>&lt; modulus_assign&lt;T, U&gt; &gt;</inherit>
1709         <purpose>A metafunction for generating modulus-assign expression types,
1710           a grammar element for matching modulus-assign expressions, and
1711           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1712           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1713           transform.</purpose>
1714         <struct name="impl">
1715           <template>
1716             <template-type-parameter name="Expr"/>
1717             <template-type-parameter name="State"/>
1718             <template-type-parameter name="Data"/>
1719           </template>
1720           <inherit>
1721             <type><classname>proto::pass_through</classname>&lt;modulus_assign&gt;::template impl&lt;Expr, State, Data&gt;</type>
1722           </inherit>
1723         </struct>
1724         <typedef name="type">
1725           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::modulus_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1726         </typedef>
1727         <typedef name="proto_grammar">
1728           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::modulus_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1729         </typedef>
1730       </struct>
1731
1732       <struct name="plus_assign">
1733         <template>
1734           <template-type-parameter name="T"/>
1735           <template-type-parameter name="U"/>
1736         </template>
1737         <inherit><classname>proto::transform</classname>&lt; plus_assign&lt;T, U&gt; &gt;</inherit>
1738         <purpose>A metafunction for generating plus-assign expression types,
1739           a grammar element for matching plus-assign expressions, and
1740           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1741           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1742           transform.</purpose>
1743         <struct name="impl">
1744           <template>
1745             <template-type-parameter name="Expr"/>
1746             <template-type-parameter name="State"/>
1747             <template-type-parameter name="Data"/>
1748           </template>
1749           <inherit>
1750             <type><classname>proto::pass_through</classname>&lt;plus_assign&gt;::template impl&lt;Expr, State, Data&gt;</type>
1751           </inherit>
1752         </struct>
1753         <typedef name="type">
1754           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::plus_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1755         </typedef>
1756         <typedef name="proto_grammar">
1757           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::plus_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1758         </typedef>
1759       </struct>
1760
1761       <struct name="minus_assign">
1762         <template>
1763           <template-type-parameter name="T"/>
1764           <template-type-parameter name="U"/>
1765         </template>
1766         <inherit><classname>proto::transform</classname>&lt; minus_assign&lt;T, U&gt; &gt;</inherit>
1767         <purpose>A metafunction for generating minus-assign expression types,
1768           a grammar element for matching minus-assign expressions, and
1769           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1770           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1771           transform.</purpose>
1772         <struct name="impl">
1773           <template>
1774             <template-type-parameter name="Expr"/>
1775             <template-type-parameter name="State"/>
1776             <template-type-parameter name="Data"/>
1777           </template>
1778           <inherit>
1779             <type><classname>proto::pass_through</classname>&lt;minus_assign&gt;::template impl&lt;Expr, State, Data&gt;</type>
1780           </inherit>
1781         </struct>
1782         <typedef name="type">
1783           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::minus_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1784         </typedef>
1785         <typedef name="proto_grammar">
1786           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::minus_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1787         </typedef>
1788       </struct>
1789
1790       <struct name="bitwise_and_assign">
1791         <template>
1792           <template-type-parameter name="T"/>
1793           <template-type-parameter name="U"/>
1794         </template>
1795         <inherit><classname>proto::transform</classname>&lt; bitwise_and_assign&lt;T, U&gt; &gt;</inherit>
1796         <purpose>A metafunction for generating bitwise-and-assign expression types,
1797           a grammar element for matching bitwise-and-assign expressions, and
1798           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1799           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1800           transform.</purpose>
1801         <struct name="impl">
1802           <template>
1803             <template-type-parameter name="Expr"/>
1804             <template-type-parameter name="State"/>
1805             <template-type-parameter name="Data"/>
1806           </template>
1807           <inherit>
1808             <type><classname>proto::pass_through</classname>&lt;bitwise_and_assign&gt;::template impl&lt;Expr, State, Data&gt;</type>
1809           </inherit>
1810         </struct>
1811         <typedef name="type">
1812           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::bitwise_and_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1813         </typedef>
1814         <typedef name="proto_grammar">
1815           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::bitwise_and_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1816         </typedef>
1817       </struct>
1818
1819       <struct name="bitwise_or_assign">
1820         <template>
1821           <template-type-parameter name="T"/>
1822           <template-type-parameter name="U"/>
1823         </template>
1824         <inherit><classname>proto::transform</classname>&lt; bitwise_or_assign&lt;T, U&gt; &gt;</inherit>
1825         <purpose>A metafunction for generating bitwise-or-assign expression types,
1826           a grammar element for matching bitwise-or-assign expressions, and
1827           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1828           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1829           transform.</purpose>
1830         <struct name="impl">
1831           <template>
1832             <template-type-parameter name="Expr"/>
1833             <template-type-parameter name="State"/>
1834             <template-type-parameter name="Data"/>
1835           </template>
1836           <inherit>
1837             <type><classname>proto::pass_through</classname>&lt;bitwise_or_assign&gt;::template impl&lt;Expr, State, Data&gt;</type>
1838           </inherit>
1839         </struct>
1840         <typedef name="type">
1841           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::bitwise_or_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1842         </typedef>
1843         <typedef name="proto_grammar">
1844           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::bitwise_or_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1845         </typedef>
1846       </struct>
1847
1848       <struct name="bitwise_xor_assign">
1849         <template>
1850           <template-type-parameter name="T"/>
1851           <template-type-parameter name="U"/>
1852         </template>
1853         <inherit><classname>proto::transform</classname>&lt; bitwise_xor_assign&lt;T, U&gt; &gt;</inherit>
1854         <purpose>A metafunction for generating bitwise-xor-assign expression types,
1855           a grammar element for matching bitwise-xor-assign expressions, and
1856           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1857           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1858           transform.</purpose>
1859         <struct name="impl">
1860           <template>
1861             <template-type-parameter name="Expr"/>
1862             <template-type-parameter name="State"/>
1863             <template-type-parameter name="Data"/>
1864           </template>
1865           <inherit>
1866             <type><classname>proto::pass_through</classname>&lt;bitwise_xor_assign&gt;::template impl&lt;Expr, State, Data&gt;</type>
1867           </inherit>
1868         </struct>
1869         <typedef name="type">
1870           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::bitwise_xor_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1871         </typedef>
1872         <typedef name="proto_grammar">
1873           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::bitwise_xor_assign</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1874         </typedef>
1875       </struct>
1876
1877       <struct name="subscript">
1878         <template>
1879           <template-type-parameter name="T"/>
1880           <template-type-parameter name="U"/>
1881         </template>
1882         <inherit><classname>proto::transform</classname>&lt; subscript&lt;T, U&gt; &gt;</inherit>
1883         <purpose>A metafunction for generating subscript expression types,
1884           a grammar element for matching subscript expressions, and
1885           a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
1886           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1887           transform.</purpose>
1888         <struct name="impl">
1889           <template>
1890             <template-type-parameter name="Expr"/>
1891             <template-type-parameter name="State"/>
1892             <template-type-parameter name="Data"/>
1893           </template>
1894           <inherit>
1895             <type><classname>proto::pass_through</classname>&lt;subscript&gt;::template impl&lt;Expr, State, Data&gt;</type>
1896           </inherit>
1897         </struct>
1898         <typedef name="type">
1899           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::subscript</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1900         </typedef>
1901         <typedef name="proto_grammar">
1902           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::subscript</classname>, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
1903         </typedef>
1904       </struct>
1905
1906       <struct name="function">
1907         <template>
1908           <template-type-parameter name="A" pack="1"/>
1909         </template>
1910         <inherit><classname>proto::transform</classname>&lt; function&lt;A...&gt; &gt;</inherit>
1911         <purpose>A metafunction for generating function-call expression types, a grammar element for
1912           matching function-call expressions, and
1913           a <conceptname>PrimitiveTransform</conceptname>
1914           that dispatches to the
1915           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
1916           transform.</purpose>
1917         <struct name="impl">
1918           <template>
1919             <template-type-parameter name="Expr"/>
1920             <template-type-parameter name="State"/>
1921             <template-type-parameter name="Data"/>
1922           </template>
1923           <inherit>
1924             <type><classname>proto::pass_through</classname>&lt;function&gt;::template impl&lt;Expr, State, Data&gt;</type>
1925           </inherit>
1926         </struct>
1927         <typedef name="type">
1928           <type><classname>proto::expr</classname>&lt; <classname>proto::tag::function</classname>, <classname alt="proto::listN">proto::list<replaceable>N</replaceable></classname>&lt; A... &gt; &gt;</type>
1929         </typedef>
1930         <typedef name="proto_grammar">
1931           <type><classname>proto::basic_expr</classname>&lt; <classname>proto::tag::function</classname>, <classname alt="proto::listN">proto::list<replaceable>N</replaceable></classname>&lt; A... &gt; &gt;</type>
1932         </typedef>
1933       </struct>
1934
1935       <struct name="nullary_expr">
1936         <template>
1937           <template-type-parameter name="Tag"/>
1938           <template-type-parameter name="T"/>
1939         </template>
1940         <inherit><classname>proto::transform</classname>&lt; nullary_expr&lt;Tag, T&gt; &gt;</inherit>
1941         <purpose>A metafunction for generating nullary expression types, a grammar element for matching
1942           nullary expressions, and
1943           a <conceptname>PrimitiveTransform</conceptname> that returns the current expression unchanged. </purpose>
1944         <description>
1945           <para>
1946             Use <computeroutput>proto::nullary_expr&lt;<classname>proto::_</classname>, <classname>proto::_</classname>&gt;</computeroutput>
1947             as a grammar element to match any nullary expression.
1948           </para>
1949         </description>
1950         <struct name="impl">
1951           <template>
1952             <template-type-parameter name="Expr"/>
1953             <template-type-parameter name="State"/>
1954             <template-type-parameter name="Data"/>
1955           </template>
1956           <inherit><classname>proto::transform_impl</classname>&lt; Expr, State, Data &gt;</inherit>
1957           <typedef name="result_type">
1958             <type>Expr</type>
1959           </typedef>
1960           <method-group name="public member functions">
1961             <method name="operator()" cv="const">
1962               <type>Expr</type>
1963               <parameter name="expr">
1964                 <paramtype>typename impl::expr_param</paramtype>
1965                 <description>
1966                   <para>The current expression </para>
1967                 </description>
1968               </parameter>
1969               <parameter name="">
1970                 <paramtype>typename impl::state_param</paramtype>
1971               </parameter>
1972               <parameter name="">
1973                 <paramtype>typename impl::data_param</paramtype>
1974               </parameter>
1975               <requires>
1976                 <para>
1977                   <computeroutput><classname>proto::matches</classname>&lt;Expr, proto::nullary_expr&lt;Tag, T&gt; &gt;::value</computeroutput> is <computeroutput>true</computeroutput>.
1978                 </para>
1979               </requires>
1980               <returns>
1981                 <para>
1982                   <computeroutput>expr</computeroutput>
1983                 </para>
1984               </returns>
1985               <throws>
1986                 <simpara>Will not throw.</simpara>
1987               </throws>
1988             </method>
1989           </method-group>
1990         </struct>
1991         <typedef name="type">
1992           <type><classname>proto::expr</classname>&lt; Tag, <classname>proto::term</classname>&lt; T &gt; &gt;</type>
1993         </typedef>
1994         <typedef name="proto_grammar">
1995           <type><classname>proto::basic_expr</classname>&lt; Tag, <classname>proto::term</classname>&lt; T &gt; &gt;</type>
1996         </typedef>
1997       </struct>
1998
1999       <struct name="unary_expr">
2000         <template>
2001           <template-type-parameter name="Tag"/>
2002           <template-type-parameter name="T"/>
2003         </template>
2004         <inherit><classname>proto::transform</classname>&lt; unary_expr&lt;Tag, T&gt; &gt;</inherit>
2005         <purpose>A metafunction for generating unary expression types with a specified tag type,
2006           a grammar element for matching unary expressions, and
2007           a <conceptname>PrimitiveTransform</conceptname>
2008           that dispatches to the
2009           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
2010           transform.</purpose>
2011         <description>
2012           <para>
2013             Use <computeroutput>proto::unary_expr&lt;<classname>proto::_</classname>, <classname>proto::_</classname>&gt;</computeroutput>
2014             as a grammar element to match any unary expression.
2015           </para>
2016         </description>
2017         <struct name="impl">
2018           <template>
2019             <template-type-parameter name="Expr"/>
2020             <template-type-parameter name="State"/>
2021             <template-type-parameter name="Data"/>
2022           </template>
2023           <inherit>
2024             <type><classname>proto::pass_through</classname>&lt;unary_expr&gt;::template impl&lt;Expr, State, Data&gt;</type>
2025           </inherit>
2026         </struct>
2027         <typedef name="type">
2028           <type><classname>proto::expr</classname>&lt; Tag, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
2029         </typedef>
2030         <typedef name="proto_grammar">
2031           <type><classname>proto::basic_expr</classname>&lt; Tag, <classname alt="proto::listN">proto::list1</classname>&lt; T &gt; &gt;</type>
2032         </typedef>
2033       </struct>
2034
2035       <struct name="binary_expr">
2036         <template>
2037           <template-type-parameter name="Tag"/>
2038           <template-type-parameter name="T"/>
2039           <template-type-parameter name="U"/>
2040         </template>
2041         <inherit><classname>proto::transform</classname>&lt; binary_expr&lt;Tag, T, U&gt; &gt;</inherit>
2042         <purpose>A metafunction for generating binary expression types with a specified tag type,
2043           a grammar element for matching binary expressions, and
2044           a <conceptname>PrimitiveTransform</conceptname>
2045           that dispatches to the
2046           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
2047           transform.</purpose>
2048         <description>
2049           <para>
2050             Use <computeroutput>proto::binary_expr&lt;<classname>proto::_</classname>, <classname>proto::_</classname>, <classname>proto::_</classname>&gt;</computeroutput> as a grammar element to match any binary expression.
2051           </para>
2052         </description>
2053         <struct name="impl">
2054           <template>
2055             <template-type-parameter name="Expr"/>
2056             <template-type-parameter name="State"/>
2057             <template-type-parameter name="Data"/>
2058           </template>
2059           <inherit>
2060             <type><classname>proto::pass_through</classname>&lt;binary_expr&gt;::template impl&lt;Expr, State, Data&gt;</type>
2061           </inherit>
2062         </struct>
2063         <typedef name="type">
2064           <type><classname>proto::expr</classname>&lt; Tag, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
2065         </typedef>
2066         <typedef name="proto_grammar">
2067           <type><classname>proto::basic_expr</classname>&lt; Tag, <classname alt="proto::listN">proto::list2</classname>&lt; T, U &gt; &gt;</type>
2068         </typedef>
2069       </struct>
2070
2071       <struct name="nary_expr">
2072         <template>
2073           <template-type-parameter name="Tag"/>
2074           <template-type-parameter name="A" pack="1"/>
2075         </template>
2076         <inherit><classname>proto::transform</classname>&lt; nary_expr&lt;Tag, A...&gt; &gt;</inherit>
2077         <purpose>A metafunction for generating n-ary expression types with a specified tag type,
2078           a grammar element for matching n-ary expressions, and
2079           a <conceptname>PrimitiveTransform</conceptname>
2080           that dispatches to the
2081           <computeroutput><classname alt="proto::pass_through">proto::pass_through&lt;&gt;</classname></computeroutput>
2082           transform.</purpose>
2083         <description>
2084           <para>
2085             Use <computeroutput>proto::nary_expr&lt;<classname>proto::_</classname>, <classname>proto::vararg</classname>&lt;<classname>proto::_</classname>&gt; &gt;</computeroutput>
2086             as a grammar element to match any n-ary expression; that is, any non-terminal.
2087           </para>
2088         </description>
2089         <struct name="impl">
2090           <template>
2091             <template-type-parameter name="Expr"/>
2092             <template-type-parameter name="State"/>
2093             <template-type-parameter name="Data"/>
2094           </template>
2095           <inherit>
2096             <type><classname>proto::pass_through</classname>&lt;nary_expr&gt;::template impl&lt;Expr, State, Data&gt;</type>
2097           </inherit>
2098         </struct>
2099         <typedef name="type">
2100           <type><classname>proto::expr</classname>&lt; Tag, <classname alt="proto::listN">proto::list<replaceable>N</replaceable></classname>&lt; A... &gt; &gt;</type>
2101         </typedef>
2102         <typedef name="proto_grammar">
2103           <type><classname>proto::basic_expr</classname>&lt; Tag, <classname alt="proto::listN">proto::list<replaceable>N</replaceable></classname>&lt; A... &gt; &gt;</type>
2104         </typedef>
2105       </struct>
2106
2107       <struct name="is_expr">
2108         <template>
2109           <template-type-parameter name="T"/>
2110         </template>
2111         <inherit><type>mpl::bool_&lt;<replaceable>true-or-false</replaceable>&gt;</type></inherit>
2112         <purpose>A Boolean metafunction that indicates whether a given type <computeroutput>T</computeroutput>
2113           is a Proto expression type.</purpose>
2114         <description>
2115           <para>
2116             If <computeroutput>T</computeroutput> is an instantiation of
2117             <computeroutput><classname alt="proto::expr">proto::expr&lt;&gt;</classname></computeroutput> or
2118             <computeroutput><classname alt="proto::basic_expr">proto::basic_expr&lt;&gt;</classname></computeroutput> or is an extension
2119             (via <classname alt="proto::extends">proto::extends&lt;&gt;</classname> or
2120             <macroname>BOOST_PROTO_EXTENDS</macroname>()) of such an instantiation,
2121             <computeroutput><classname>proto::is_expr</classname>&lt;T&gt;::value</computeroutput>
2122             is <computeroutput>true</computeroutput>.
2123             Otherwise, <computeroutput><classname>proto::is_expr</classname>&lt;T&gt;::value</computeroutput>
2124             is <computeroutput>false</computeroutput>.
2125           </para>
2126         </description>
2127       </struct>
2128
2129       <struct name="tag_of">
2130         <template>
2131           <template-type-parameter name="Expr"/>
2132         </template>
2133         <purpose>A metafunction that returns the tag type of a Proto expression. </purpose>
2134         <typedef name="type">
2135           <type>typename Expr::proto_tag</type>
2136         </typedef>
2137       </struct>
2138
2139       <struct name="arity_of">
2140         <template>
2141           <template-type-parameter name="Expr"/>
2142         </template>
2143         <purpose>A metafunction that returns the arity of a Proto expression. </purpose>
2144         <inherit><type>Expr::proto_arity</type></inherit>
2145       </struct>
2146
2147       <namespace name="result_of">
2148         <struct name="as_expr">
2149           <template>
2150             <template-type-parameter name="T"/>
2151             <template-type-parameter name="Domain">
2152               <default><classname>proto::default_domain</classname></default>
2153             </template-type-parameter>
2154           </template>
2155           <purpose>A metafunction that computes the return type of the
2156             <computeroutput><functionname>proto::as_expr</functionname>()</computeroutput> function.</purpose>
2157           <description>
2158             <para>
2159               The <computeroutput>proto::result_of::as_expr&lt;&gt;</computeroutput> metafunction turns types
2160               into Proto expression types, if they are not already, in a domain-specific way. It is intended
2161               for use to compute the type of a local variable that can hold the result of the
2162               <computeroutput><functionname>proto::as_expr</functionname>()</computeroutput> function.
2163             </para>
2164             <para>
2165               See <computeroutput><classname>proto::domain::as_expr</classname>&lt;&gt;</computeroutput>
2166               for a complete description of the default behavior.
2167             </para>
2168           </description>
2169           <typedef name="type">
2170             <type>typename Domain::template as_expr&lt; T &gt;::result_type</type>
2171           </typedef>
2172         </struct>
2173
2174         <struct name="as_child">
2175           <template>
2176             <template-type-parameter name="T"/>
2177             <template-type-parameter name="Domain">
2178               <default><classname>proto::default_domain</classname></default>
2179             </template-type-parameter>
2180           </template>
2181           <purpose>A metafunction that computes the return type of the
2182             <computeroutput><functionname>proto::as_child</functionname>()</computeroutput> function.</purpose>
2183           <description>
2184             <para>
2185               The <computeroutput>proto::result_of::as_child&lt;&gt;</computeroutput> metafunction turns types
2186               into Proto expression types, if they are not already, in a domain-specific way. It is used by Proto
2187               to compute the type of an object to store as a child in another expression node.
2188             </para>
2189             <para>
2190               See <computeroutput><classname>proto::domain::as_child</classname>&lt;&gt;</computeroutput>
2191               for a complete description of the default behavior.
2192             </para>
2193           </description>
2194           <typedef name="type">
2195             <type>typename Domain::template as_child&lt; T &gt;::result_type</type>
2196           </typedef>
2197         </struct>
2198
2199         <struct name="child">
2200           <template>
2201             <template-type-parameter name="Expr"/>
2202             <template-type-parameter name="N">
2203               <default>mpl::long_&lt;0&gt;</default>
2204             </template-type-parameter>
2205           </template>
2206           <inherit><type><classname>proto::result_of::child_c</classname>&lt;Expr, N::value&gt;</type></inherit>
2207           <purpose>A metafunction that returns the type of the <replaceable>N</replaceable><superscript>th</superscript>
2208             child of a Proto expression, where N is an MPL Integral Constant. </purpose>
2209           <description>
2210             <para>
2211               <computeroutput>proto::result_of::child&lt;Expr, N&gt;</computeroutput> is equivalent to
2212               <computeroutput><classname>proto::result_of::child_c</classname>&lt;Expr, N::value&gt;</computeroutput>.
2213             </para>
2214           </description>
2215         </struct>
2216
2217         <struct name="value">
2218           <template>
2219             <template-type-parameter name="Expr"/>
2220           </template>
2221           <purpose>A metafunction that returns the type of the value of a terminal Proto expression. </purpose>
2222           <typedef name="value_type">
2223             <description>
2224               <para>
2225                 The raw type of the value as it is
2226                 stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference.
2227               </para>
2228             </description>
2229             <type>typename Expr::proto_child0</type>
2230           </typedef>
2231           <typedef name="type">
2232             <description>
2233               <para>
2234                 If <computeroutput>Expr</computeroutput> is not a reference type, <computeroutput>type</computeroutput>
2235                 is computed as follows:
2236                 <itemizedlist>
2237                   <listitem>
2238                     <para>
2239                       <computeroutput>T const(&amp;)[N]</computeroutput> becomes <computeroutput>T[N]</computeroutput>
2240                     </para>
2241                   </listitem>
2242                   <listitem>
2243                     <para>
2244                       <computeroutput>T[N]</computeroutput> becomes <computeroutput>T[N]</computeroutput>
2245                     </para>
2246                   </listitem>
2247                   <listitem>
2248                     <para>
2249                       <computeroutput>T(&amp;)[N]</computeroutput> becomes <computeroutput>T[N]</computeroutput>
2250                     </para>
2251                   </listitem>
2252                   <listitem>
2253                     <para>
2254                       <computeroutput>R(&amp;)(A...)</computeroutput> becomes <computeroutput>R(&amp;)(A...)</computeroutput>
2255                     </para>
2256                   </listitem>
2257                   <listitem>
2258                     <para>
2259                       <computeroutput>T const &amp;</computeroutput> becomes <computeroutput>T</computeroutput>
2260                     </para>
2261                   </listitem>
2262                   <listitem>
2263                     <para>
2264                       <computeroutput>T &amp;</computeroutput> becomes <computeroutput>T</computeroutput>
2265                     </para>
2266                   </listitem>
2267                   <listitem>
2268                     <para>
2269                       <computeroutput>T</computeroutput> becomes <computeroutput>T</computeroutput>
2270                     </para>
2271                   </listitem>
2272                 </itemizedlist>
2273               </para>
2274               <para>
2275                 If <computeroutput>Expr</computeroutput> is a non-const reference type, <computeroutput>type</computeroutput>
2276                 is computed as follows:
2277                 <itemizedlist>
2278                   <listitem>
2279                     <para>
2280                       <computeroutput>T const(&amp;)[N]</computeroutput> becomes <computeroutput>T const(&amp;)[N]</computeroutput>
2281                     </para>
2282                   </listitem>
2283                   <listitem>
2284                     <para>
2285                       <computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&amp;)[N]</computeroutput>
2286                     </para>
2287                   </listitem>
2288                   <listitem>
2289                     <para>
2290                       <computeroutput>T(&amp;)[N]</computeroutput> becomes <computeroutput>T(&amp;)[N]</computeroutput>
2291                     </para>
2292                   </listitem>
2293                   <listitem>
2294                     <para>
2295                       <computeroutput>R(&amp;)(A...)</computeroutput> becomes <computeroutput>R(&amp;)(A...)</computeroutput>
2296                     </para>
2297                   </listitem>
2298                   <listitem>
2299                     <para>
2300                       <computeroutput>T const &amp;</computeroutput> becomes <computeroutput>T const &amp;</computeroutput>
2301                     </para>
2302                   </listitem>
2303                   <listitem>
2304                     <para>
2305                       <computeroutput>T &amp;</computeroutput> becomes <computeroutput>T &amp;</computeroutput>
2306                     </para>
2307                   </listitem>
2308                   <listitem>
2309                     <para>
2310                       <computeroutput>T</computeroutput> becomes <computeroutput>T &amp;</computeroutput>
2311                     </para>
2312                   </listitem>
2313                 </itemizedlist>
2314               </para>
2315               <para>
2316                 If <computeroutput>Expr</computeroutput> is a const reference type, <computeroutput>type</computeroutput>
2317                 is computed as follows:
2318                 <itemizedlist>
2319                   <listitem>
2320                     <para>
2321                       <computeroutput>T const(&amp;)[N]</computeroutput> becomes <computeroutput>T const(&amp;)[N]</computeroutput>
2322                     </para>
2323                   </listitem>
2324                   <listitem>
2325                     <para>
2326                       <computeroutput>T[N]</computeroutput> becomes <computeroutput>T const(&amp;)[N]</computeroutput>
2327                     </para>
2328                   </listitem>
2329                   <listitem>
2330                     <para>
2331                       <computeroutput>T(&amp;)[N]</computeroutput> becomes <computeroutput>T(&amp;)[N]</computeroutput>
2332                     </para>
2333                   </listitem>
2334                   <listitem>
2335                     <para>
2336                       <computeroutput>R(&amp;)(A...)</computeroutput> becomes <computeroutput>R(&amp;)(A...)</computeroutput>
2337                     </para>
2338                   </listitem>
2339                   <listitem>
2340                     <para>
2341                       <computeroutput>T const &amp;</computeroutput> becomes <computeroutput>T const &amp;</computeroutput>
2342                     </para>
2343                   </listitem>
2344                   <listitem>
2345                     <para>
2346                       <computeroutput>T &amp;</computeroutput> becomes <computeroutput>T &amp;</computeroutput>
2347                     </para>
2348                   </listitem>
2349                   <listitem>
2350                     <para>
2351                       <computeroutput>T</computeroutput> becomes <computeroutput>T const &amp;</computeroutput>
2352                     </para>
2353                   </listitem>
2354                 </itemizedlist>
2355               </para>
2356             </description>
2357             <type><replaceable>see-below</replaceable></type>
2358           </typedef>
2359         </struct>
2360
2361         <struct name="left">
2362           <template>
2363             <template-type-parameter name="Expr"/>
2364           </template>
2365           <inherit>proto::result_of::child_c&lt; Expr, 0 &gt;</inherit>
2366           <purpose>A metafunction that returns the type of the left child of a binary Proto expression. </purpose>
2367           <description>
2368             <para>
2369               <computeroutput>proto::result_of::left&lt;Expr&gt;</computeroutput> is equivalent to
2370               <computeroutput><classname>proto::result_of::child_c</classname>&lt;Expr, 0&gt;</computeroutput>.
2371             </para>
2372           </description>
2373         </struct>
2374
2375         <struct name="right">
2376           <template>
2377             <template-type-parameter name="Expr"/>
2378           </template>
2379           <inherit>proto::result_of::child_c&lt; Expr, 1 &gt;</inherit>
2380           <purpose>A metafunction that returns the type of the right child of a binary Proto expression. </purpose>
2381           <description>
2382             <para>
2383               <computeroutput>proto::result_of::right&lt;Expr&gt;</computeroutput> is equivalent to
2384               <computeroutput><classname>proto::result_of::child_c</classname>&lt;Expr, 1&gt;</computeroutput>.
2385             </para>
2386           </description>
2387         </struct>
2388
2389         <struct name="child_c">
2390           <template>
2391             <template-type-parameter name="Expr"/>
2392             <template-nontype-parameter name="N">
2393               <type>long</type>
2394             </template-nontype-parameter>
2395           </template>
2396           <purpose>A metafunction that returns the type of the <replaceable>N</replaceable><superscript>th</superscript>
2397             child of a Proto expression. </purpose>
2398           <description>
2399             <para>
2400               A metafunction that returns the type of the <replaceable>N</replaceable><superscript>th</superscript>
2401               child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than
2402               <computeroutput>Expr::proto_arity::value</computeroutput>.
2403             </para>
2404           </description>
2405           <typedef name="value_type">
2406             <description>
2407               <para>
2408                 The raw type of the <replaceable>N</replaceable><superscript>th</superscript> child as it is stored
2409                 within <computeroutput>Expr</computeroutput>. This may be a value or a reference.
2410               </para>
2411             </description>
2412             <type>typename Expr::proto_child0</type>
2413           </typedef>
2414           <typedef name="type">
2415             <description>
2416               <para>
2417                 If <computeroutput>Expr</computeroutput> is not a reference type, <computeroutput>type</computeroutput>
2418                 is computed as follows:
2419                 <itemizedlist>
2420                   <listitem>
2421                     <para>
2422                       <computeroutput>T const &amp;</computeroutput> becomes <computeroutput>T</computeroutput>
2423                     </para>
2424                   </listitem>
2425                   <listitem>
2426                     <para>
2427                       <computeroutput>T &amp;</computeroutput> becomes <computeroutput>T</computeroutput>
2428                     </para>
2429                   </listitem>
2430                   <listitem>
2431                     <para>
2432                       <computeroutput>T</computeroutput> becomes <computeroutput>T</computeroutput>
2433                     </para>
2434                   </listitem>
2435                 </itemizedlist>
2436               </para>
2437               <para>
2438                 If <computeroutput>Expr</computeroutput> is a non-const reference type, <computeroutput>type</computeroutput>
2439                 is computed as follows:
2440                 <itemizedlist>
2441                   <listitem>
2442                     <para>
2443                       <computeroutput>T const &amp;</computeroutput> becomes <computeroutput>T const &amp;</computeroutput>
2444                     </para>
2445                   </listitem>
2446                   <listitem>
2447                     <para>
2448                       <computeroutput>T &amp;</computeroutput> becomes <computeroutput>T &amp;</computeroutput>
2449                     </para>
2450                   </listitem>
2451                   <listitem>
2452                     <para>
2453                       <computeroutput>T</computeroutput> becomes <computeroutput>T &amp;</computeroutput>
2454                     </para>
2455                   </listitem>
2456                 </itemizedlist>
2457               </para>
2458               <para>
2459                 If <computeroutput>Expr</computeroutput> is a const reference type, <computeroutput>type</computeroutput>
2460                 is computed as follows:
2461                 <itemizedlist>
2462                   <listitem>
2463                     <para>
2464                       <computeroutput>T const &amp;</computeroutput> becomes <computeroutput>T const &amp;</computeroutput>
2465                     </para>
2466                   </listitem>
2467                   <listitem>
2468                     <para>
2469                       <computeroutput>T &amp;</computeroutput> becomes <computeroutput>T &amp;</computeroutput>
2470                     </para>
2471                   </listitem>
2472                   <listitem>
2473                     <para>
2474                       <computeroutput>T</computeroutput> becomes <computeroutput>T const &amp;</computeroutput>
2475                     </para>
2476                   </listitem>
2477                 </itemizedlist>
2478               </para>
2479             </description>
2480             <type><replaceable>see-below</replaceable></type>
2481           </typedef>
2482         </struct>
2483
2484       </namespace>
2485
2486       <overloaded-function name="as_expr">
2487         <signature>
2488           <type>typename <classname>proto::result_of::as_expr</classname>&lt; T &gt;::type</type>
2489           <template>
2490             <template-type-parameter name="T"/>
2491           </template>
2492           <parameter name="t">
2493             <paramtype>T &amp;</paramtype>
2494           </parameter>
2495         </signature>
2496         <signature>
2497           <type>typename <classname>proto::result_of::as_expr</classname>&lt; T const &gt;::type</type>
2498           <template>
2499             <template-type-parameter name="T"/>
2500           </template>
2501           <parameter name="t">
2502             <paramtype>T const &amp;</paramtype>
2503           </parameter>
2504         </signature>
2505         <signature>
2506           <type>typename <classname>proto::result_of::as_expr</classname>&lt; T, Domain &gt;::type</type>
2507           <template>
2508             <template-type-parameter name="Domain"/>
2509             <template-type-parameter name="T"/>
2510           </template>
2511           <parameter name="t">
2512             <paramtype>T &amp;</paramtype>
2513           </parameter>
2514         </signature>
2515         <signature>
2516           <type>typename <classname>proto::result_of::as_expr</classname>&lt; T const, Domain &gt;::type</type>
2517           <template>
2518             <template-type-parameter name="Domain"/>
2519             <template-type-parameter name="T"/>
2520           </template>
2521           <parameter name="t">
2522             <paramtype>T const &amp;</paramtype>
2523           </parameter>
2524         </signature>
2525         <purpose>A function that wraps non-Proto expression types in Proto terminals and leaves Proto
2526           expression types alone.</purpose>
2527         <description>
2528           <para>
2529             The <computeroutput>proto::as_expr()</computeroutput> function returns Proto expression
2530             objects that are suitable for storage in a local variable. It turns non-Proto objects
2531             into Proto terminals. Its behavior is domain-specific. By default,
2532             non-Proto types are wrapped by value (if possible) in a new Proto terminal expression,
2533             and objects that are already Proto expressions are returned by value.
2534           </para>
2535           <para>
2536             If <computeroutput>Domain</computeroutput> is not explicitly specified, it is assumed to
2537             be <computeroutput><classname>proto::default_domain</classname></computeroutput>.
2538           </para>
2539           <para>
2540             See <computeroutput><classname>proto::domain::as_expr</classname>&lt;&gt;</computeroutput>
2541             for a complete description of this function's default behavior.
2542           </para>
2543         </description>
2544         <returns>
2545           <computeroutput>typename Domain::template as_expr&lt; T &gt;()(t)</computeroutput>
2546         </returns>
2547       </overloaded-function>
2548
2549       <overloaded-function name="as_child">
2550         <signature>
2551           <type>typename <classname>proto::result_of::as_child</classname>&lt; T &gt;::type</type>
2552           <template>
2553             <template-type-parameter name="T"/>
2554           </template>
2555           <parameter name="t">
2556             <paramtype>T &amp;</paramtype>
2557           </parameter>
2558         </signature>
2559         <signature>
2560           <type>typename <classname>proto::result_of::as_child</classname>&lt; T const &gt;::type</type>
2561           <template>
2562             <template-type-parameter name="T"/>
2563           </template>
2564           <parameter name="t">
2565             <paramtype>T const &amp;</paramtype>
2566           </parameter>
2567         </signature>
2568         <signature>
2569           <type>typename <classname>proto::result_of::as_child</classname>&lt; T, Domain &gt;::type</type>
2570           <template>
2571             <template-type-parameter name="Domain"/>
2572             <template-type-parameter name="T"/>
2573           </template>
2574           <parameter name="t">
2575             <paramtype>T &amp;</paramtype>
2576           </parameter>
2577         </signature>
2578         <signature>
2579           <type>typename <classname>proto::result_of::as_child</classname>&lt; T const, Domain &gt;::type</type>
2580           <template>
2581             <template-type-parameter name="Domain"/>
2582             <template-type-parameter name="T"/>
2583           </template>
2584           <parameter name="t">
2585             <paramtype>T const &amp;</paramtype>
2586           </parameter>
2587         </signature>
2588         <purpose>A function that wraps non-Proto objects in Proto terminals (by reference) and leaves
2589           Proto expression types alone.</purpose>
2590         <description>
2591           <para>
2592             The <computeroutput>proto::as_child()</computeroutput> function returns Proto expression
2593             objects that are suitable for storage as child nodes in an expression tree. It turns
2594             non-Proto objects into Proto terminals. Its behavior is domain-specific. By default,
2595             non-Proto types are held wrapped by reference in a new Proto terminal expression, and
2596             objects that are already Proto expressions are simply returned by reference.
2597           </para>
2598           <para>
2599             If <computeroutput>Domain</computeroutput> is not explicitly specified, it is assumed to
2600             be <computeroutput><classname>proto::default_domain</classname></computeroutput>.
2601           </para>
2602           <para>
2603             See <computeroutput><classname>proto::domain::as_child</classname>&lt;&gt;</computeroutput>
2604             for a complete description of this function's default behavior.
2605           </para>
2606         </description>
2607         <returns>
2608           <computeroutput>typename Domain::template as_child&lt; T &gt;()(t)</computeroutput>
2609         </returns>
2610       </overloaded-function>
2611
2612       <overloaded-function name="child">
2613         <signature>
2614           <type>typename <classname>proto::result_of::child</classname>&lt; Expr &amp;, N &gt;::type</type>
2615           <template>
2616             <template-type-parameter name="N"/>
2617             <template-type-parameter name="Expr"/>
2618           </template>
2619           <parameter name="expr">
2620             <paramtype>Expr &amp;</paramtype>
2621             <description>
2622               <para>The Proto expression. </para>
2623             </description>
2624           </parameter>
2625         </signature>
2626         <signature>
2627           <type>typename <classname>proto::result_of::child</classname>&lt; Expr const &amp;, N &gt;::type</type>
2628           <template>
2629             <template-type-parameter name="N"/>
2630             <template-type-parameter name="Expr"/>
2631           </template>
2632           <parameter name="expr">
2633             <paramtype>Expr const &amp;</paramtype>
2634           </parameter>
2635         </signature>
2636         <signature>
2637           <type>typename <classname>proto::result_of::child</classname>&lt; Expr &amp; &gt;::type</type>
2638           <template>
2639             <template-type-parameter name="Expr"/>
2640           </template>
2641           <parameter name="expr">
2642             <paramtype>Expr &amp;</paramtype>
2643           </parameter>
2644         </signature>
2645         <signature>
2646           <type>typename <classname>proto::result_of::child</classname>&lt; Expr const &amp; &gt;::type</type>
2647           <template>
2648             <template-type-parameter name="Expr"/>
2649           </template>
2650           <parameter name="expr">
2651             <paramtype>Expr const &amp;</paramtype>
2652           </parameter>
2653         </signature>
2654         <purpose>Return the <replaceable>N</replaceable><superscript>th</superscript> child of the specified Proto expression. </purpose>
2655         <description>
2656           <para>
2657             Return the <replaceable>N</replaceable><superscript>th</superscript> child of the specified Proto expression.
2658             If <computeroutput>N</computeroutput> is not specified, as in <computeroutput>proto::child(expr)</computeroutput>,
2659             then <computeroutput>N</computeroutput> is assumed to be <computeroutput>mpl::long_&lt;0&gt;</computeroutput>.
2660             The child is returned by reference.
2661           </para>
2662         </description>
2663         <requires>
2664           <para>
2665             <computeroutput><classname>proto::is_expr</classname>&lt;Expr&gt;::value</computeroutput> is
2666             <computeroutput>true</computeroutput>.
2667           </para>
2668           <para>
2669             <computeroutput>N</computeroutput> is an MPL Integral Constant.
2670           </para>
2671           <para>
2672             <computeroutput>N::value &lt; Expr::proto_arity::value</computeroutput>
2673           </para>
2674         </requires>
2675         <returns>
2676           <para>A reference to the <replaceable>N</replaceable><superscript>th</superscript> child
2677           of <computeroutput>expr</computeroutput>.</para>
2678         </returns>
2679         <throws>
2680           <simpara>Will not throw.</simpara>
2681         </throws>
2682       </overloaded-function>
2683
2684       <overloaded-function name="child_c">
2685         <signature>
2686           <type>typename <classname>proto::result_of::child_c</classname>&lt; Expr &amp;, N &gt;::type</type>
2687           <template>
2688             <template-nontype-parameter name="N">
2689               <type>long</type>
2690             </template-nontype-parameter>
2691             <template-type-parameter name="Expr"/>
2692           </template>
2693           <parameter name="expr">
2694             <paramtype>Expr &amp;</paramtype>
2695           </parameter>
2696         </signature>
2697         <signature>
2698           <type>typename <classname>proto::result_of::child_c</classname>&lt; Expr const &amp;, N &gt;::type</type>
2699           <template>
2700             <template-nontype-parameter name="N">
2701               <type>long</type>
2702             </template-nontype-parameter>
2703             <template-type-parameter name="Expr"/>
2704           </template>
2705           <parameter name="expr">
2706             <paramtype>Expr const &amp;</paramtype>
2707           </parameter>
2708         </signature>
2709         <purpose>Return the <replaceable>N</replaceable><superscript>th</superscript> child of the specified
2710           Proto expression. </purpose>
2711         <description>
2712           <para>
2713             Return the <replaceable>N</replaceable><superscript>th</superscript> child of the specified Proto
2714             expression. The child is returned by reference.
2715           </para>
2716         </description>
2717         <requires>
2718           <para>
2719             <computeroutput><classname>proto::is_expr</classname>&lt;Expr&gt;::value</computeroutput> is
2720             <computeroutput>true</computeroutput>.
2721           </para>
2722           <para>
2723             <computeroutput>N &lt; Expr::proto_arity::value</computeroutput>
2724           </para>
2725         </requires>
2726         <returns>
2727           <para>A reference to the <replaceable>N</replaceable><superscript>th</superscript> child
2728             of <computeroutput>expr</computeroutput>.</para>
2729         </returns>
2730         <throws>
2731           <simpara>Will not throw.</simpara>
2732         </throws>
2733       </overloaded-function>
2734
2735       <overloaded-function name="value">
2736         <signature>
2737           <type>typename <classname>proto::result_of::value</classname>&lt; Expr &amp; &gt;::type</type>
2738           <template>
2739             <template-type-parameter name="Expr"/>
2740           </template>
2741           <parameter name="expr">
2742             <paramtype>Expr &amp;</paramtype>
2743           </parameter>
2744         </signature>
2745         <signature>
2746           <type>typename <classname>proto::result_of::value</classname>&lt; Expr const &amp; &gt;::type</type>
2747           <template>
2748             <template-type-parameter name="Expr"/>
2749           </template>
2750           <parameter name="expr">
2751             <paramtype>Expr const &amp;</paramtype>
2752           </parameter>
2753         </signature>
2754         <purpose>Return the value stored within the specified Proto terminal expression. </purpose>
2755         <description>
2756           <para>
2757             Return the the value stored within the specified Proto terminal expression. The value is
2758             returned by reference.
2759           </para>
2760         </description>
2761         <requires>
2762           <para>
2763             <computeroutput>0 == Expr::proto_arity::value</computeroutput>
2764           </para>
2765         </requires>
2766         <returns>
2767           <para>A reference to the terminal's value </para>
2768         </returns>
2769         <throws>
2770           <simpara>Will not throw.</simpara>
2771         </throws>
2772       </overloaded-function>
2773
2774       <overloaded-function name="left">
2775         <signature>
2776           <type>typename <classname>proto::result_of::left</classname>&lt; Expr &amp; &gt;::type</type>
2777           <template>
2778             <template-type-parameter name="Expr"/>
2779           </template>
2780           <parameter name="expr">
2781             <paramtype>Expr &amp;</paramtype>
2782           </parameter>
2783         </signature>
2784         <signature>
2785           <type>typename <classname>proto::result_of::left</classname>&lt; Expr const &amp; &gt;::type</type>
2786           <template>
2787             <template-type-parameter name="Expr"/>
2788           </template>
2789           <parameter name="expr">
2790             <paramtype>Expr const &amp;</paramtype>
2791           </parameter>
2792         </signature>
2793         <purpose>Return the left child of the specified binary Proto expression. </purpose>
2794         <description>
2795           <para>Return the left child of the specified binary Proto expression. The child is returned by reference.</para>
2796         </description>
2797         <requires>
2798           <para>
2799             <computeroutput><classname>proto::is_expr</classname>&lt;Expr&gt;::value</computeroutput> is
2800             <computeroutput>true</computeroutput>.
2801           </para>
2802           <para>
2803             <computeroutput>2 == Expr::proto_arity::value</computeroutput>
2804           </para>
2805         </requires>
2806         <returns>
2807           <para>A reference to the left child of <computeroutput>expr</computeroutput>.
2808         </para>
2809         </returns>
2810         <throws>
2811           <simpara>Will not throw.</simpara>
2812         </throws>
2813       </overloaded-function>
2814
2815       <overloaded-function name="right">
2816         <signature>
2817           <type>typename <classname>proto::result_of::right</classname>&lt; Expr &amp; &gt;::type</type>
2818           <template>
2819             <template-type-parameter name="Expr"/>
2820           </template>
2821           <parameter name="expr">
2822             <paramtype>Expr &amp;</paramtype>
2823             <description>
2824               <para>The Proto expression. </para>
2825             </description>
2826           </parameter>
2827         </signature>
2828         <signature>
2829           <type>typename <classname>proto::result_of::right</classname>&lt; Expr const &amp; &gt;::type</type>
2830           <template>
2831             <template-type-parameter name="Expr"/>
2832           </template>
2833           <parameter name="expr">
2834             <paramtype>Expr const &amp;</paramtype>
2835           </parameter>
2836         </signature>
2837         <purpose>Return the right child of the specified binary Proto expression. </purpose>
2838         <description>
2839           <para>Return the right child of the specified binary Proto expression. The child is returned by reference.</para>
2840         </description>
2841         <requires>
2842           <para>
2843             <computeroutput><classname>proto::is_expr</classname>&lt;Expr&gt;::value</computeroutput> is
2844             <computeroutput>true</computeroutput>.
2845           </para>
2846           <para>
2847             <computeroutput>2 == Expr::proto_arity::value</computeroutput>
2848           </para>
2849         </requires>
2850         <returns>
2851           <para>
2852             A reference to the right child of <computeroutput>expr</computeroutput>.
2853           </para>
2854         </returns>
2855         <throws>
2856           <simpara>Will not throw.</simpara>
2857         </throws>
2858       </overloaded-function>
2859     </namespace>
2860   </namespace>
2861 </header>