Boost-Commit mailing page: [Boost-commit] svn:boost r49591 - in branches/release: . libs/proto/doc libs/proto/doc/reference libs/proto/doc/reference/context libs/proto/doc/reference/transform

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r49591 - in branches/release: . libs/proto/doc libs/proto/doc/reference libs/proto/doc/reference/context libs/proto/doc/reference/transform
From: eric_at_[hidden]
Date: 2008-11-04 14:26:34

Author: eric_niebler
Date: 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
New Revision: 49591
URL: http://svn.boost.org/trac/boost/changeset/49591

Log:
Merged revisions 49590 via svnmerge from
https://svn.boost.org/svn/boost/trunk

........
  r49590 | eric_niebler | 2008-11-04 11:11:59 -0800 (Tue, 04 Nov 2008) | 1 line

  misc doc clean-up
........

Properties modified:
   branches/release/ (props changed)
Text files modified:
   branches/release/libs/proto/doc/reference.xml | 981 +++++++++++++++++++++++++++++++++++++++
   branches/release/libs/proto/doc/reference/args.xml | 25
   branches/release/libs/proto/doc/reference/context/null.xml | 9
   branches/release/libs/proto/doc/reference/eval.xml | 11
   branches/release/libs/proto/doc/reference/expr.xml | 29
   branches/release/libs/proto/doc/reference/matches.xml | 9
   branches/release/libs/proto/doc/reference/traits.xml | 22
   branches/release/libs/proto/doc/reference/transform/call.xml | 56 +-
   branches/release/libs/proto/doc/reference/transform/default.xml | 2
   branches/release/libs/proto/doc/reference/transform/fold.xml | 17
   branches/release/libs/proto/doc/reference/transform/fold_tree.xml | 25
   branches/release/libs/proto/doc/reference/transform/impl.xml | 29 +
   branches/release/libs/proto/doc/reference/transform/lazy.xml | 40 +
   branches/release/libs/proto/doc/reference/transform/make.xml | 73 ++
   branches/release/libs/proto/doc/reference/transform/pass_through.xml | 17
   branches/release/libs/proto/doc/reference/transform/when.xml | 55 +
   16 files changed, 1252 insertions(+), 148 deletions(-)

Modified: branches/release/libs/proto/doc/reference.xml
==============================================================================
--- branches/release/libs/proto/doc/reference.xml (original)
+++ branches/release/libs/proto/doc/reference.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -2,38 +2,997 @@
<library-reference xmlns:xi="http://www.w3.org/2001/XInclude">

   
- 
+ </section>

   
   <xi:include href="reference/args.xml"/>

Modified: branches/release/libs/proto/doc/reference/args.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/args.xml (original)
+++ branches/release/libs/proto/doc/reference/args.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -2,9 +2,11 @@
<header name="boost/proto/args.hpp">
   <para>
     Contains definitions of the <computeroutput>
- <classname alt="boost::proto::term">proto::term<></classname></computeroutput> and <computeroutput>
- <classname alt="boost::proto::listN">proto::list<replaceable>N</replaceable><></classname>
- </computeroutput> class templates.</para>
+ <classname alt="boost::proto::term">proto::term<></classname></computeroutput>,
+ <computeroutput><classname alt="boost::proto::listN">proto::list1<></classname></computeroutput>,
+ <computeroutput><classname alt="boost::proto::listN">proto::list2<></classname></computeroutput>, etc.
+ class templates.
+ </para>

   <namespace name="boost">
     <namespace name="proto">
@@ -12,7 +14,7 @@
       
       <struct name="term">
         <template>
- <template-type-parameter name="Arg0"/>
+ <template-type-parameter name="T"/>
         </template>
         <purpose>A type sequence, for use as the 2<superscript>nd</superscript> parameter to the <computeroutput>
           <classname alt="proto::expr">proto::expr<></classname></computeroutput> class template.</purpose>
@@ -28,7 +30,7 @@
           <type>const long</type>
         </data-member>
         <typedef name="child0">
- <type>Arg0</type>
+ <type>T</type>
         </typedef>
       </struct>

@@ -37,13 +39,18 @@
         <template>
           <template-type-parameter name="Arg" pack="1"/>
         </template>
- <purpose>A type sequence, for use as the 2<superscript>nd</superscript> parameter to the <computeroutput>
- <classname alt="proto::expr">proto::expr<></classname></computeroutput> class template.</purpose>
+ <purpose><computeroutput>proto::list1<></computeroutput>, <computeroutput>proto::list2<></computeroutput>, etc.,
+ are type sequences for use as the 2<superscript>nd</superscript> parameter to the <computeroutput>
+ <classname>proto::expr<></classname></computeroutput> class template.</purpose>
         <description>
           <para>
- A type sequence, for use as the 2<superscript>nd</superscript> parameter to the <computeroutput>
- <classname alt="proto::expr">proto::expr<></classname></computeroutput> class template. The
+ Type sequences, for use as the 2<superscript>nd</superscript> parameter to the <computeroutput>
+ <classname>proto::expr<></classname></computeroutput> class template. The
             types in the sequence correspond to the children of a node in an expression tree.
+ There is no type literally named "<computeroutput>listN</computeroutput>"; rather, there is
+ a set of types named
+ <computeroutput>proto::list1<></computeroutput>,
+ <computeroutput>proto::list2<></computeroutput>, etc.
           </para>
         </description>
         <data-member name="arity" specifiers="static">

Modified: branches/release/libs/proto/doc/reference/context/null.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/context/null.xml (original)
+++ branches/release/libs/proto/doc/reference/context/null.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -1,9 +1,12 @@
<?xml version="1.0" encoding="utf-8"?>
<header name="boost/proto/context/null.hpp">
- <para>Definintion of
+ <para>
+ Definintion of
     <computeroutput><classname alt="boost::proto::context::null_context">proto::context::null_context<></classname></computeroutput>,
- an evaluation context for <functionname alt="boost::proto::eval">proto::eval()</functionname> that simply evaluates
- each child expression, doesn't combine the results at all, and returns void. </para>
+ an evaluation context for
+ <computeroutput><functionname alt="boost::proto::eval">proto::eval()</functionname></computeroutput>
+ that simply evaluates each child expression, doesn't combine the results at all, and returns void.
+ </para>
   <namespace name="boost">
     <namespace name="proto">
       <namespace name="context">

Modified: branches/release/libs/proto/doc/reference/eval.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/eval.xml (original)
+++ branches/release/libs/proto/doc/reference/eval.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -1,6 +1,11 @@
ï»¿<?xml version="1.0" encoding="utf-8"?>
<header name="boost/proto/eval.hpp">
- <para>Contains the <functionname alt="boost::proto::eval">proto::eval()</functionname> expression evaluator.</para>
+ <para>
+ Contains the
+ <computeroutput>
+ <functionname alt="boost::proto::eval">proto::eval()</functionname>
+ </computeroutput> expression evaluator.
+ </para>
   <namespace name="boost">
     <namespace name="proto">
       <namespace name="functional">
@@ -23,8 +28,8 @@
             <inherit>
               <type>
     <classname>proto::result_of::eval</classname><
- typename remove_reference< Expr >::type,
- typename remove_reference< Context >::type
+ typename boost::remove_reference< Expr >::type,
+ typename boost::remove_reference< Context >::type
     ></type>
             </inherit>
           </struct-specialization>

Modified: branches/release/libs/proto/doc/reference/expr.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/expr.xml (original)
+++ branches/release/libs/proto/doc/reference/expr.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -34,10 +34,13 @@
           <para>
             <computeroutput>Args</computeroutput> is a list of types representing
             the children of this expression. It is an instantiation of one of
- <computeroutput>proto::list1<></computeroutput>,
- <computeroutput>proto::list2<></computeroutput>, etc. The child types
- must all themselves be either <computeroutput>expr<></computeroutput>
- or <computeroutput>proto::expr<>&</computeroutput>, unless
+ <computeroutput><classname alt="proto::listN">proto::list1<></classname></computeroutput>,
+ <computeroutput><classname alt="proto::listN">proto::list2<></classname></computeroutput>,
+ etc. The child types
+ must all themselves be either <computeroutput>proto::expr<></computeroutput>
+ or <computeroutput>proto::expr<>&</computeroutput> (or extensions thereof via
+ <computeroutput><classname>proto::extends<></classname></computeroutput> or
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS</macroname>()</computeroutput>), unless
             <computeroutput>Arity</computeroutput> is 0, in which case
             <computeroutput>Args</computeroutput> must be
             <computeroutput>proto::term<T></computeroutput>, where
@@ -65,7 +68,7 @@
         </typedef>

         <typedef name="proto_domain">
- <type><classname>default_domain</classname></type>
+ <type><classname>proto::default_domain</classname></type>
         </typedef>

         <typedef name="proto_base_expr">
@@ -87,8 +90,8 @@
           </template>
           <description>
             <para>
- Encodes the return type of <computeroutput>expr<>::operator()</computeroutput>.
- Makes <computeroutput>expr<></computeroutput> a TR1-style function object type
+ Encodes the return type of <computeroutput><classname>proto::expr<></classname>::operator()</computeroutput>.
+ Makes <computeroutput><classname>proto::expr<></classname></computeroutput> a TR1-style function object type
               usable with <computeroutput>boost::result_of<></computeroutput>
             </para>
           </description>
@@ -316,12 +319,24 @@
         </template>
         <purpose>Lets you inherit the interface of an expression while hiding from Proto the fact that
           the type is a Proto expression.</purpose>
+ <inherit><type>Expr</type></inherit>
         <method-group name="public member functions"/>
         <constructor>
           <parameter name="expr">
             <paramtype>Expr const &</paramtype>
           </parameter>
         </constructor>
+ <description>
+ <para>
+ For an expression type <computeroutput>E</computeroutput>,
+ <computeroutput>
+ <classname>proto::is_expr</classname><E>::value
+ </computeroutput> is <computeroutput>true</computeroutput>, but
+ <computeroutput>
+ <classname>proto::is_expr</classname><proto::unexpr<E> >::value
+ </computeroutput> is <computeroutput>false</computeroutput>.
+ </para>
+ </description>
       </struct>

     </namespace>

Modified: branches/release/libs/proto/doc/reference/matches.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/matches.xml (original)
+++ branches/release/libs/proto/doc/reference/matches.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -1,7 +1,12 @@
ï»¿<?xml version="1.0" encoding="utf-8"?>
<header name="boost/proto/matches.hpp">
- <para>Contains definition of the <classname alt="boost::proto::matches">proto::matches<></classname>
- metafunction for determining if a given expression matches a given pattern.</para>
+ <para>
+ Contains definition of the
+ <computeroutput>
+ <classname alt="boost::proto::matches">proto::matches<></classname>
+ </computeroutput>
+ metafunction for determining if a given expression matches a given pattern.
+ </para>
   <namespace name="boost">
     <namespace name="proto">
       <struct name="_">

Modified: branches/release/libs/proto/doc/reference/traits.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/traits.xml (original)
+++ branches/release/libs/proto/doc/reference/traits.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -13,7 +13,7 @@
           <para>
             <computeroutput>proto::is_callable<></computeroutput> is used by the
             <computeroutput><classname alt="proto::when">proto::when<></classname></computeroutput>
- transform to determine whether a function type <computeroutput>R(A<subscript>1</subscript>,...<subscript>n</subscript>)</computeroutput>
+ transform to determine whether a function type <computeroutput>R(A<subscript>1</subscript>,...A<subscript>n</subscript>)</computeroutput>
             is a <conceptname>CallableTransform</conceptname> or an <conceptname>ObjectTransform</conceptname>.
             The former are evaluated using <computeroutput><classname>proto::call<></classname></computeroutput>
             and the later with <computeroutput><classname>proto::make<></classname></computeroutput>.
@@ -50,6 +50,7 @@
             </itemizedlist>
           </para>
         </description>
+ <inherit><type>mpl::bool_<<replaceable>true-or-false</replaceable>></type></inherit>
       </struct>

       <struct name="is_aggregate">
@@ -66,13 +67,16 @@
             If <computeroutput>proto::is_aggregate<T>::value</computeroutput> is <computeroutput>true</computeroutput>,
             then an object of type <computeroutput>T</computeroutput> will be initialized as
             <computeroutput>T t = {a<subscript>0</subscript>,...a<subscript>n</subscript>};</computeroutput>.
- Otherwise, it will be initialized as <computeroutput>T t(a<subscript>0</subscript>,...a<subscript>n</subscript>)</computeroutput>.
+ Otherwise, it will be initialized as
+ <computeroutput>T t(a<subscript>0</subscript>,...a<subscript>n</subscript>)</computeroutput>.
           </para>
           <para>
             Note: <computeroutput><classname>proto::expr<></classname> is an aggregate.</computeroutput>
           </para>
         </description>
+ <inherit><type>mpl::bool_<<replaceable>true-or-false</replaceable>></type></inherit>
       </struct>
+
       <namespace name="functional">
         <struct name="as_expr">
           <template>
@@ -113,7 +117,7 @@
               </description>
               <returns>
                 <para>
- <computeroutput>proto::as_expr<Domain>(t)</computeroutput>
+ <computeroutput><functionname>proto::as_expr</functionname><Domain>(t)</computeroutput>
                 </para>
               </returns>
             </method>
@@ -172,7 +176,7 @@
               </description>
               <returns>
                 <para>
- <computeroutput>proto::as_child<Domain>(t)</computeroutput>
+ <computeroutput><functionname>proto::as_child</functionname><Domain>(t)</computeroutput>
                 </para>
               </returns>
             </method>
@@ -563,7 +567,7 @@
           </typedef>
           <method-group name="public member functions">
             <method name="operator()" cv="const">
- <type>impl::expr_param</type>
+ <type>typename impl::expr_param</type>
               <parameter name="expr">
                 <paramtype>typename impl::expr_param</paramtype>
                 <description>
@@ -1964,7 +1968,7 @@
           </inherit>
         </struct>
         <typedef name="type">
- <type><classname>proto::expr</classname>< Tag, <classname alt="proto::listN">proto::list<replaceable>N</replaceable></classname>< A0 > ></type>
+ <type><classname>proto::expr</classname>< Tag, <classname alt="proto::listN">proto::list<replaceable>N</replaceable></classname>< A... > ></type>
         </typedef>
         <typedef name="proto_base_expr">
           <type>type</type>
@@ -2129,7 +2133,7 @@
                   </listitem>
                   <listitem>
                     <para>
- <computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput>
+ <computeroutput>R(&)(A...)</computeroutput> becomes <computeroutput>R(&)(A...)</computeroutput>
                     </para>
                   </listitem>
                   <listitem>
@@ -2170,7 +2174,7 @@
                   </listitem>
                   <listitem>
                     <para>
- <computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput>
+ <computeroutput>R(&)(A...)</computeroutput> becomes <computeroutput>R(&)(A...)</computeroutput>
                     </para>
                   </listitem>
                   <listitem>
@@ -2211,7 +2215,7 @@
                   </listitem>
                   <listitem>
                     <para>
- <computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput>
+ <computeroutput>R(&)(A...)</computeroutput> becomes <computeroutput>R(&)(A...)</computeroutput>
                     </para>
                   </listitem>
                   <listitem>

Modified: branches/release/libs/proto/doc/reference/transform/call.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/transform/call.xml (original)
+++ branches/release/libs/proto/doc/reference/transform/call.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -7,7 +7,7 @@
         <template>
           <template-type-parameter name="T"/>
         </template>
- <purpose>Make the given <conceptname>Transform</conceptname> into a <conceptname>PrimitiveTransform</conceptname>.</purpose>
+ <purpose>Make the given <conceptname>CallableTransform</conceptname> into a <conceptname>PrimitiveTransform</conceptname>.</purpose>

         <description>
           <para>
@@ -36,12 +36,12 @@
             <template-type-parameter name="State"/>
             <template-type-parameter name="Data"/>
           </template>
- <inherit><type><classname>proto::transform_impl<Expr, State, Data></classname></type></inherit>
+ <inherit><type><classname>proto::transform_impl</classname><Expr, State, Data></type></inherit>
           <typedef name="result_type">
             <type><replaceable>see-below</replaceable></type>
             <description>
               <para>
- <computeroutput>proto::call<T>::impl<Expr,State,Data>::result_type</computeroutput>
+ <computeroutput><classname>proto::call</classname><T>::impl<Expr,State,Data>::result_type</computeroutput>
                 is computed as follows:
                 <itemizedlist>
                   <listitem>
@@ -56,10 +56,10 @@
                   <listitem>
                     <para>
                       If <computeroutput>T</computeroutput> is of the form
- <computeroutput><conceptname>PrimitiveTransform</conceptname>(T0)</computeroutput>, then
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>(A<subscript>0</subscript>)</computeroutput>, then
                       <computeroutput>result_type</computeroutput> is:
                       <programlisting>typename boost::result_of<PrimitiveTransform(
- typename boost::result_of<<classname>when</classname><<classname>_</classname>,T0>(Expr, State, Data)>::type,
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,A<subscript>0</subscript>>(Expr, State, Data)>::type,
   State,
   Data
)>::type</programlisting>
@@ -68,11 +68,11 @@
                   <listitem>
                     <para>
                       If <computeroutput>T</computeroutput> is of the form
- <computeroutput><conceptname>PrimitiveTransform</conceptname>(T0, T1)</computeroutput>, then
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>(A<subscript>0</subscript>, A<subscript>1</subscript>)</computeroutput>, then
                       <computeroutput>result_type</computeroutput> is:
                       <programlisting>typename boost::result_of<PrimitiveTransform(
- typename boost::result_of<<classname>when</classname><<classname>_</classname>,T0>(Expr, State, Data)>::type,
- typename boost::result_of<<classname>when</classname><<classname>_</classname>,T1>(Expr, State, Data)>::type,
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,A<subscript>0</subscript>>(Expr, State, Data)>::type,
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,A<subscript>1</subscript>>(Expr, State, Data)>::type,
   Data
)>::type</programlisting>
                     </para>
@@ -80,24 +80,24 @@
                   <listitem>
                     <para>
                       If <computeroutput>T</computeroutput> is of the form
- <computeroutput><conceptname>PrimitiveTransform</conceptname>(T0, T1, T2)</computeroutput>, then
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>(A<subscript>0</subscript>, A<subscript>1</subscript>, A<subscript>2</subscript>)</computeroutput>, then
                       <computeroutput>result_type</computeroutput> is:
                       <programlisting>typename boost::result_of<PrimitiveTransform(
- typename boost::result_of<<classname>when</classname><<classname>_</classname>,T0>(Expr, State, Data)>::type,
- typename boost::result_of<<classname>when</classname><<classname>_</classname>,T1>(Expr, State, Data)>::type,
- typename boost::result_of<<classname>when</classname><<classname>_</classname>,T2>(Expr, State, Data)>::type
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,A<subscript>0</subscript>>(Expr, State, Data)>::type,
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,A<subscript>1</subscript>>(Expr, State, Data)>::type,
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,A<subscript>2</subscript>>(Expr, State, Data)>::type
)>::type</programlisting>
                     </para>
                   </listitem>
                   <listitem>
                     <para>
                       If <computeroutput>T</computeroutput> is of the form
- <computeroutput><conceptname>PolymorphicFunctionObject</conceptname>(T0,...TN)</computeroutput>, then
+ <computeroutput><conceptname>PolymorphicFunctionObject</conceptname>(A<subscript>0</subscript>,...A<subscript>n</subscript>)</computeroutput>, then
                       <computeroutput>result_type</computeroutput> is:
                       <programlisting>typename boost::result_of<PolymorphicFunctionObject(
- typename boost::result_of<<classname>when</classname><<classname>_</classname>,T0>(Expr, State, Data)>::type,
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,A<subscript>0</subscript>>(Expr, State, Data)>::type,
   ...
- typename boost::result_of<<classname>when</classname><<classname>_</classname>,TN>(Expr, State, Data)>::type
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,A<subscript>n</subscript>>(Expr, State, Data)>::type
>::type</programlisting>
                     </para>
                   </listitem>
@@ -119,7 +119,7 @@
               </parameter>
               <description>
               <para>
- <computeroutput>proto::call<T>::impl<Expr,State,Data>::operator()</computeroutput> behaves as follows:
+ <computeroutput><classname>proto::call</classname><T>::impl<Expr,State,Data>::operator()</computeroutput> behaves as follows:
                 <itemizedlist>
                   <listitem>
                     <para>
@@ -133,10 +133,10 @@
                   <listitem>
                     <para>
                       If <computeroutput>T</computeroutput> is of the form
- <computeroutput><conceptname>PrimitiveTransform</conceptname>(T0)</computeroutput>, then
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>(A<subscript>0</subscript>)</computeroutput>, then
                       return
                       <programlisting>PrimitiveTransform()(
- <classname>when</classname><<classname>_</classname>,T0>()(expr, state, data),
+ <classname>when</classname><<classname>_</classname>,A<subscript>0</subscript>>()(expr, state, data),
   state,
   sata
)</programlisting>
@@ -145,11 +145,11 @@
                   <listitem>
                     <para>
                       If <computeroutput>T</computeroutput> is of the form
- <computeroutput><conceptname>PrimitiveTransform</conceptname>(T0, T1)</computeroutput>, then
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>(A<subscript>0</subscript>, A<subscript>1</subscript>)</computeroutput>, then
                       return:
                       <programlisting>PrimitiveTransform()(
- <classname>when</classname><<classname>_</classname>,T0>()(expr, state, data),
- <classname>when</classname><<classname>_</classname>,T1>()(expr, state, data),
+ <classname>when</classname><<classname>_</classname>,A<subscript>0</subscript>>()(expr, state, data),
+ <classname>when</classname><<classname>_</classname>,A<subscript>1</subscript>>()(expr, state, data),
   Data
)</programlisting>
                     </para>
@@ -157,24 +157,24 @@
                   <listitem>
                     <para>
                       If <computeroutput>T</computeroutput> is of the form
- <computeroutput><conceptname>PrimitiveTransform</conceptname>(T0, T1, T2)</computeroutput>, then
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>(A<subscript>0</subscript>, A<subscript>1</subscript>, A<subscript>2</subscript>)</computeroutput>, then
                       return
                       <programlisting>PrimitiveTransform()(
- <classname>when</classname><<classname>_</classname>,T0>()(expr, state, data),
- <classname>when</classname><<classname>_</classname>,T1>()(expr, state, data),
- <classname>when</classname><<classname>_</classname>,T2>()(expr, state, data)
+ <classname>when</classname><<classname>_</classname>,A<subscript>0</subscript>>()(expr, state, data),
+ <classname>when</classname><<classname>_</classname>,A<subscript>1</subscript>>()(expr, state, data),
+ <classname>when</classname><<classname>_</classname>,A<subscript>2</subscript>>()(expr, state, data)
)</programlisting>
                     </para>
                   </listitem>
                   <listitem>
                     <para>
                       If <computeroutput>T</computeroutput> is of the form
- <computeroutput><conceptname>PolymorphicFunctionObject</conceptname>(T0,...TN)</computeroutput>, then
+ <computeroutput><conceptname>PolymorphicFunctionObject</conceptname>(A<subscript>0</subscript>,...A<subscript>n</subscript>)</computeroutput>, then
                       return:
                       <programlisting>PolymorphicFunctionObject()(
- <classname>when</classname><<classname>_</classname>,T0>()(expr, state, data),
+ <classname>when</classname><<classname>_</classname>,A<subscript>0</subscript>>()(expr, state, data),
   ...
- <classname>when</classname><<classname>_</classname>,TN>()(expr, state, data)
+ <classname>when</classname><<classname>_</classname>,A<subscript>n</subscript>>()(expr, state, data)
)</programlisting>
                     </para>
                   </listitem>

Modified: branches/release/libs/proto/doc/reference/transform/default.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/transform/default.xml (original)
+++ branches/release/libs/proto/doc/reference/transform/default.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -23,7 +23,7 @@
             <template-type-parameter name="State"/>
             <template-type-parameter name="Data"/>
           </template>
- <inherit><type><classname>proto::transform_impl<Expr, State, Data></classname></type></inherit>
+ <inherit><type><classname>proto::transform_impl</classname><Expr, State, Data></type></inherit>
           <typedef name="Tag">
             <purpose>For exposition only</purpose>
             <type>typename Expr::tag_type</type>

Modified: branches/release/libs/proto/doc/reference/transform/fold.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/transform/fold.xml (original)
+++ branches/release/libs/proto/doc/reference/transform/fold.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -1,6 +1,13 @@
<?xml version="1.0" encoding="utf-8"?>
<header name="boost/proto/transform/fold.hpp">
- <para>Contains definition of the fold<> and reverse_fold<> transforms. </para>
+ <para>Contains definition of the
+ <computeroutput>
+ <classname alt="boost::proto::fold">proto::fold<></classname>
+ </computeroutput> and
+ <computeroutput>
+ <classname alt="boost::proto::reverse_fold">proto::reverse_fold<></classname>
+ </computeroutput>
+ transforms.</para>
   <namespace name="boost">
     <namespace name="proto">
       <struct name="fold">
@@ -75,12 +82,12 @@
               <description>
                 <para>
                   Let <computeroutput>seq</computeroutput> be
- <computeroutput>when<_, Sequence>()(expr, state, data)</computeroutput>,
+ <computeroutput><classname>when</classname><<classname>_</classname>, Sequence>()(expr, state, data)</computeroutput>,
                   let <computeroutput>state0</computeroutput> be
- <computeroutput>when<_, State0>()(expr, state, data)</computeroutput>,
+ <computeroutput><classname>when</classname><<classname>_</classname>, State0>()(expr, state, data)</computeroutput>,
                   and let <computeroutput>fun(data)</computeroutput> be an object such that
                   <computeroutput>fun(data)(expr, state)</computeroutput> is equivalent to
- <computeroutput>when<_, Fun>()(expr, state, data)</computeroutput>. Then,
+ <computeroutput><classname>when</classname><<classname>_</classname>, Fun>()(expr, state, data)</computeroutput>. Then,
                   this function returns <computeroutput>fusion::fold(seq, state0, fun(data))</computeroutput>.
                 </para>
               </description>
@@ -97,7 +104,7 @@
         </template>
         <inherit><classname>proto::fold</classname>< <classname>proto::_reverse</classname>(Sequence), State0, Fun ></inherit>
         <purpose>
- A PrimitiveTransform that is the same as the <computeroutput><classname>proto::fold<></classname></computeroutput>
+ A <conceptname>PrimitiveTransform</conceptname> that is the same as the <computeroutput><classname>proto::fold<></classname></computeroutput>
           transform, except that it folds back-to-front instead of front-to-back. It uses the
           <computeroutput>
             <classname>proto::_reverse</classname>

Modified: branches/release/libs/proto/doc/reference/transform/fold_tree.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/transform/fold_tree.xml (original)
+++ branches/release/libs/proto/doc/reference/transform/fold_tree.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -1,6 +1,15 @@
<?xml version="1.0" encoding="utf-8"?>
<header name="boost/proto/transform/fold_tree.hpp">
- <para>Contains definition of the fold_tree<> and reverse_fold_tree<> transforms. </para>
+ <para>
+ Contains definition of the
+ <computeroutput>
+ <classname alt="boost::proto::fold_tree">proto::fold_tree<></classname>
+ </computeroutput> and
+ <computeroutput>
+ <classname alt="boost::proto::reverse_fold_tree">proto::reverse_fold_tree<></classname>
+ </computeroutput>
+ transforms.
+ </para>
   <namespace name="boost">
     <namespace name="proto">
       <struct name="fold_tree">
@@ -25,11 +34,11 @@
             <computeroutput>recurse_if_<></computeroutput> helper, defined as follows:
             <programlisting> template<typename Tag, typename Fun>
struct recurse_if_ :
- proto::if_<
+ <classname>proto::if_</classname><
     // If the current node has type type "Tag" ...
- boost::is_same<proto::tag_of<proto::_>, Tag>(),
+ boost::is_same<<classname>proto::tag_of</classname><<classname>proto::_</classname>>, Tag>(),
     // ... recurse, otherwise ...
- proto::fold<proto::_, proto::_state, recurse_if_<Tag, Fun> >,
+ <classname>proto::fold</classname><<classname>proto::_</classname>, <classname>proto::_state</classname>, recurse_if_<Tag, Fun> >,
     // ... apply the Fun transform.
     Fun
   >
@@ -84,11 +93,11 @@
             a <computeroutput>recurse_if_<></computeroutput> helper, defined as follows:
             <programlisting> template<typename Tag, typename Fun>
struct recurse_if_ :
- proto::if_<
+ <classname>proto::if_</classname><
     // If the current node has type type "Tag" ...
- boost::is_same<proto::tag_of<proto::_>, Tag>(),
+ boost::is_same<<classname>proto::tag_of</classname><<classname>proto::_</classname>>, Tag>(),
     // ... recurse, otherwise ...
- proto::reverse_fold<proto::_, proto::_state, recurse_if_<Tag, Fun> >,
+ <classname>proto::reverse_fold</classname><<classname>proto::_</classname>, <classname>proto::_state</classname>, recurse_if_<Tag, Fun> >,
     // ... apply the Fun transform.
     Fun
   >
@@ -98,7 +107,7 @@
             With <computeroutput>recurse_if_<></computeroutput> as defined above,
             <computeroutput>proto::reverse_fold_tree<Sequence, State0, Fun>()(expr, state, data)</computeroutput>
             is equivalent to:
- <programlisting>proto::reverse_fold<
+ <programlisting><classname>proto::reverse_fold</classname><
   Sequence,
   State0,
   recurse_if_<typename Expr::proto_tag, Fun>

Modified: branches/release/libs/proto/doc/reference/transform/impl.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/transform/impl.xml (original)
+++ branches/release/libs/proto/doc/reference/transform/impl.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -19,7 +19,7 @@
             <template-arg>This(Expr)</template-arg>
           </specialization>
           <typedef name="type">
- <type>typename PrimitiveTransform::template impl< Expr, int, int >::result_type</type>
+ <type>typename PrimitiveTransform::template impl< Expr, <replaceable>unspecified</replaceable>, <replaceable>unspecified</replaceable> >::result_type</type>
           </typedef>
         </struct-specialization>
         <struct-specialization name="result">
@@ -32,7 +32,7 @@
             <template-arg>This(Expr, State)</template-arg>
           </specialization>
           <typedef name="type">
- <type>typename PrimitiveTransform::template impl< Expr, State, int >::result_type</type>
+ <type>typename PrimitiveTransform::template impl< Expr, State, <replaceable>unspecified</replaceable> >::result_type</type>
           </typedef>
         </struct-specialization>
         <struct-specialization name="result">
@@ -61,6 +61,11 @@
             <parameter name="expr">
               <paramtype>Expr &</paramtype>
             </parameter>
+ <returns>
+ <computeroutput>
+ typename PrimitiveTransform::template impl<Expr &, <replaceable>unspecified</replaceable>, <replaceable>unspecified</replaceable>>()(expr, <replaceable>unspecified</replaceable>, <replaceable>unspecified</replaceable>)
+ </computeroutput>
+ </returns>
           </method>
           <method name="operator()" cv="const">
             <type>typename PrimitiveTransform::template impl<Expr &, State &, <replaceable>unspecified</replaceable>>::result_type</type>
@@ -74,6 +79,11 @@
             <parameter name="state">
               <paramtype>State &</paramtype>
             </parameter>
+ <returns>
+ <computeroutput>
+ typename PrimitiveTransform::template impl<Expr &, State &, <replaceable>unspecified</replaceable>>()(expr, state, <replaceable>unspecified</replaceable>)
+ </computeroutput>
+ </returns>
           </method>
           <method name="operator()" cv="const">
             <type>typename PrimitiveTransform::template impl<Expr &, State const &, <replaceable>unspecified</replaceable>>::result_type</type>
@@ -87,6 +97,11 @@
             <parameter name="state">
               <paramtype>State const &</paramtype>
             </parameter>
+ <returns>
+ <computeroutput>
+ typename PrimitiveTransform::template impl<Expr &, State const &, <replaceable>unspecified</replaceable>>()(expr, state, <replaceable>unspecified</replaceable>)
+ </computeroutput>
+ </returns>
           </method>
           <method name="operator()" cv="const">
             <type>typename PrimitiveTransform::template impl<Expr &, State &, Data &>::result_type</type>
@@ -104,6 +119,11 @@
             <parameter name="data">
               <paramtype>Data &</paramtype>
             </parameter>
+ <returns>
+ <computeroutput>
+ typename PrimitiveTransform::template impl<Expr &, State &, Data &>()(expr, state, data)
+ </computeroutput>
+ </returns>
           </method>
           <method name="operator()" cv="const">
             <type>typename PrimitiveTransform::template impl<Expr &, State const &, Data &>::result_type</type>
@@ -121,6 +141,11 @@
             <parameter name="data">
               <paramtype>Data &</paramtype>
             </parameter>
+ <returns>
+ <computeroutput>
+ typename PrimitiveTransform::template impl<Expr &, State const &, Data &>()(expr, state, data)
+ </computeroutput>
+ </returns>
           </method>
         </method-group>
       </struct>

Modified: branches/release/libs/proto/doc/reference/transform/lazy.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/transform/lazy.xml (original)
+++ branches/release/libs/proto/doc/reference/transform/lazy.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -1,6 +1,11 @@
<?xml version="1.0" encoding="utf-8"?>
<header name="boost/proto/transform/lazy.hpp">
- <para>Contains definition of the lazy<> transform. </para>
+ <para>
+ Contains definition of the
+ <computeroutput>
+ <classname alt="boost::proto::lazy">proto::lazy<></classname>
+ </computeroutput> transform.
+ </para>
   <namespace name="boost">
     <namespace name="proto">
       <struct name="lazy">
@@ -46,24 +51,30 @@
             <type><replaceable>see-below</replaceable></type>
             <description>
               <para>
- <computeroutput>proto::lazy<T>::impl<Expr,State,Data>::result_type</computeroutput>
+ <computeroutput><classname>proto::lazy</classname><T>::impl<Expr,State,Data>::result_type</computeroutput>
                 is calculated as follows:
                 <itemizedlist>
                   <listitem>
                     <para>
                       If <computeroutput>T</computeroutput> if of the form
- <computeroutput>O(T0,...TN)</computeroutput>, then let <computeroutput>O'</computeroutput>
- be <computeroutput>boost::result_of<<classname>proto::make</classname><O>(Expr, State, Data)>::type</computeroutput>.
+ <computeroutput>O(A<subscript>0</subscript>,...A<subscript>n</subscript>)</computeroutput>, then let <computeroutput>O'</computeroutput>
+ be <computeroutput>boost::result_of<<classname>proto::make</classname><O>(Expr, State, Data)>::type</computeroutput>
+ and let <computeroutput>T'</computeroutput> be <computeroutput>O'(A<subscript>0</subscript>,...A<subscript>n</subscript>)</computeroutput>.
                     </para>
                   </listitem>
                   <listitem>
                     <para>
- Otherwise, let <computeroutput>O'</computeroutput>
+ Otherwise, let <computeroutput>T'</computeroutput>
                       be <computeroutput>boost::result_of<<classname>proto::make</classname><T>(Expr, State, Data)>::type</computeroutput>.
                     </para>
                   </listitem>
                 </itemizedlist>
- The result type is <computeroutput>boost::result_of<<classname>proto::call</classname><O'(T0,...TN)>(Expr, State, Data)>::type</computeroutput>.
+ <para>
+ The result type is
+ <computeroutput>
+ boost::result_of<<classname>proto::call</classname><T'>(Expr, State, Data)>::type
+ </computeroutput>.
+ </para>
               </para>
             </description>
           </typedef>
@@ -81,18 +92,19 @@
               </parameter>
               <description>
                 <para>
- <computeroutput>proto::lazy<T>::impl<Expr,State,Data>::operator()</computeroutput> behaves as follows:
+ <computeroutput><classname>proto::lazy</classname><T>::impl<Expr,State,Data>::operator()</computeroutput> behaves as follows:
                   <itemizedlist>
                     <listitem>
                       <para>
                         If <computeroutput>T</computeroutput> if of the form
- <computeroutput>O(T0,...TN)</computeroutput>, then let <computeroutput>O'</computeroutput>
- be <computeroutput>boost::result_of<<classname>proto::make</classname><O>(Expr, State, Data)>::type</computeroutput>.
+ <computeroutput>O(A<subscript>0</subscript>,...A<subscript>n</subscript>)</computeroutput>, then let <computeroutput>O'</computeroutput>
+ be <computeroutput>boost::result_of<<classname>proto::make</classname><O>(Expr, State, Data)>::type</computeroutput>
+ and let <computeroutput>T'</computeroutput> be <computeroutput>O'(A<subscript>0</subscript>,...A<subscript>n</subscript>)</computeroutput>.
                       </para>
                     </listitem>
                     <listitem>
                       <para>
- Otherwise, let <computeroutput>O'</computeroutput>
+ Otherwise, let <computeroutput>T'</computeroutput>
                         be <computeroutput>boost::result_of<<classname>proto::make</classname><T>(Expr, State, Data)>::type</computeroutput>.
                       </para>
                     </listitem>
@@ -100,9 +112,11 @@
                 </para>
               </description>
               <returns>
- <computeroutput>
- <classname>proto::call</classname><O'(T0,...TN)>()(expr, state, data)
- </computeroutput>
+ <para>
+ <computeroutput>
+ <classname>proto::call</classname><T'>()(expr, state, data)
+ </computeroutput>
+ </para>
               </returns>
             </method>
           </method-group>

Modified: branches/release/libs/proto/doc/reference/transform/make.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/transform/make.xml (original)
+++ branches/release/libs/proto/doc/reference/transform/make.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -1,6 +1,16 @@
<?xml version="1.0" encoding="utf-8"?>
<header name="boost/proto/transform/make.hpp">
- <para>Contains definition of the make<> transform. </para>
+ <para>
+ Contains definition of the
+ <computeroutput>
+ <classname alt="boost::proto::make">proto::make<></classname>
+ </computeroutput>
+ and
+ <computeroutput>
+ <classname alt="boost::proto::protect">proto::protect<></classname>
+ </computeroutput>
+ transforms.
+ </para>
   <namespace name="boost">
     <namespace name="proto">
       <struct name="protect">
@@ -33,10 +43,10 @@
{};

struct Foo :
- proto::when<_, Bar<_>() >
+ <classname>proto::when</classname><<classname>proto::_</classname>, Bar<<classname>proto::_</classname>>() >
{};

-proto::terminal<int>::type i = {0};
+<classname>proto::terminal</classname><int>::type i = {0};

int main() {
   Foo()(i);
@@ -45,14 +55,14 @@
           </para>
           <para>
             If you actually wanted to default-construct an object of type
- <computeroutput>Bar<_></computeroutput>, you would have to protect the
+ <computeroutput>Bar<proto::_></computeroutput>, you would have to protect the
             <computeroutput>_</computeroutput> to prevent it from being applied. You can
             use <computeroutput>proto::protect<></computeroutput> as follows:
           </para>
           <para>
             <programlisting>// OK: replace anything with Bar<_>()
struct Foo :
- proto::when<_, Bar<protect<_> >() >
+ <classname>proto::when</classname><<classname>proto::_</classname>, Bar<<classname>proto::protect</classname><<classname>proto::_</classname>> >() >
{};</programlisting>
           </para>
         </description>
@@ -108,27 +118,35 @@
             <type><emphasis>see-below</emphasis></type>
             <description>
               <para>
- <computeroutput>proto::make<T>::impl<Expr, State, Data>::result_type</computeroutput> is
+ <computeroutput><classname>proto::make</classname><T>::impl<Expr, State, Data>::result_type</computeroutput> is
                 computed as follows:
               </para>

               <para>
                 If <computeroutput>T</computeroutput> is an <conceptname>ObjectTransform</conceptname> of the form
- <computeroutput>Object(T0,...TN)</computeroutput>, then let <computeroutput>O</computeroutput> be
+ <computeroutput>
+ Object(A<subscript>0</subscript>,...A<subscript>n</subscript>)
+ </computeroutput>, then let <computeroutput>O</computeroutput> be
                 the return type <computeroutput>Object</computeroutput>. Otherwise, let <computeroutput>O</computeroutput>
                 be <computeroutput>T</computeroutput>. The <computeroutput>result_type</computeroutput> typedef is
                 then computed as follows:
+ </para>
+ <para>
                 <itemizedlist>
                   <listitem>
                     If <computeroutput>O</computeroutput> is a template like
- <computeroutput>S<X0,...XN></computeroutput>, then the result type is calculated as follows:
+ <computeroutput>
+ S<X<subscript>0</subscript>,...X<subscript>n</subscript>>
+ </computeroutput>, then the result type is calculated as follows:
                     <itemizedlist>
                       <listitem>
                         <para>
- For each <computeroutput>X</computeroutput> in
- <computeroutput>X0,...XN</computeroutput>, let <computeroutput>X'</computeroutput> be
+ For each <computeroutput>i</computeroutput> in
+ <computeroutput>[0,n]</computeroutput>, let <computeroutput>
+ X<subscript>i</subscript>'
+ </computeroutput> be
                           <computeroutput>
- <classname>proto::make</classname><X>::impl<Expr, State, Data>::result_type
+ <classname>proto::make</classname><X<subscript>i</subscript>>::impl<Expr, State, Data>::result_type
                           </computeroutput>
                           (which evaluates this procedure recursively). Note whether any substitutions took place during
                           this operation.
@@ -137,15 +155,21 @@
                       <listitem>
                         <para>
                           If any substitutions took place in the above step and
- <computeroutput>S<X0',...XN'></computeroutput> has a nested
+ <computeroutput>
+ S<X<subscript>0</subscript>',...X<subscript>n</subscript>'>
+ </computeroutput> has a nested
                           <computeroutput>type</computeroutput> typedef, the result type is
- <computeroutput>S<X0',...XN'>::type</computeroutput>.
+ <computeroutput>
+ S<X<subscript>0</subscript>',...X<subscript>n</subscript>'>::type
+ </computeroutput>.
                         </para>
                       </listitem>
                       <listitem>
                         <para>
                           Otherwise, the result type is
- <computeroutput>S<X0',...XN'></computeroutput>.
+ <computeroutput>
+ S<X<subscript>0</subscript>',...X<subscript>n</subscript>'>
+ </computeroutput>.
                         </para>
                       </listitem>
                     </itemizedlist>
@@ -155,7 +179,7 @@
                       Otherwise, if <computeroutput>O</computeroutput> is a <conceptname>Transform</conceptname>, then let
                       the result type be
                       <computeroutput>
- <classname>when</classname><<classname>_</classname>, O>::impl<Expr, State, Data>::result_type
+ <classname>proto::when</classname><<classname>_</classname>, O>::impl<Expr, State, Data>::result_type
                       </computeroutput>.
                       Note that a substitution took place.
                     </para>
@@ -165,6 +189,8 @@
                     substitution took place.
                   </listitem>
                 </itemizedlist>
+ </para>
+ <para>
                 Note that <computeroutput><classname alt="proto::when">proto::when<></classname></computeroutput> is implemented
                 in terms of <computeroutput><classname alt="proto::call">proto::call<></classname></computeroutput>
                 and <computeroutput><classname alt="proto::make">proto::make<></classname></computeroutput>, so the
@@ -186,12 +212,17 @@
               </parameter>
               <description>
                 <para>
- <computeroutput>proto::make<T>::impl<Expr,State,Data>::operator()</computeroutput> behaves as follows:
+ <computeroutput>
+ <classname>proto::make</classname><T>::impl<Expr,State,Data>::operator()
+ </computeroutput>
+ behaves as follows:
+ </para>
+ <para>
                   <itemizedlist>
                     <listitem>
                       <para>
                         If <computeroutput>T</computeroutput> if of the form
- <computeroutput>O(T0,...TN)</computeroutput>, then:
+ <computeroutput>O(A<subscript>0</subscript>,...A<subscript>n</subscript>)</computeroutput>, then:
                       </para>
                       <itemizedlist>
                         <listitem>
@@ -201,9 +232,9 @@
                             </computeroutput> is <computeroutput>true</computeroutput>, then construct
                             and return an object <computeroutput>that</computeroutput> as follows:
                             <programlisting>result_type that = {
- proto::when<_, T0>()(expr, state, data),
+ <classname>proto::when</classname><<classname>_</classname>, A<subscript>0</subscript>>()(expr, state, data),
   ...
- proto::when<_, TN>()(expr, state, data)
+ <classname>proto::when</classname><<classname>_</classname>, A<subscript>n</subscript>>()(expr, state, data)
};</programlisting>
                           </para>
                         </listitem>
@@ -212,9 +243,9 @@
                             Otherwise, construct
                             and return an object <computeroutput>that</computeroutput> as follows:
                             <programlisting>result_type that(
- proto::when<_, T0>()(expr, state, data),
+ <classname>proto::when</classname><<classname>_</classname>, A<subscript>0</subscript>>()(expr, state, data),
   ...
- proto::when<_, TN>()(expr, state, data)
+ <classname>proto::when</classname><<classname>_</classname>, A<subscript>n</subscript>>()(expr, state, data)
);</programlisting>
                           </para>
                         </listitem>

Modified: branches/release/libs/proto/doc/reference/transform/pass_through.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/transform/pass_through.xml (original)
+++ branches/release/libs/proto/doc/reference/transform/pass_through.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -1,10 +1,11 @@
<?xml version="1.0" encoding="utf-8"?>
<header name="boost/proto/transform/pass_through.hpp">
- <para>Definition of the <classname alt="boost::proto::pass_through">proto::pass_through<></classname> transform,
- which is the default transform of all of the expression generator metafunctions such as
- <classname alt="boost::proto::unary_plus">proto::unary_plus<></classname>,
- <classname alt="boost::proto::plus">proto::plus<></classname> and
- <classname alt="boost::proto::nary_expr">proto::nary_expr<></classname>.</para>
+ <para>Definition of the
+ <computeroutput><classname alt="boost::proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform, which is the default transform of all of the expression generator metafunctions such as
+ <computeroutput><classname alt="boost::proto::unary_plus">proto::unary_plus<></classname></computeroutput>,
+ <computeroutput><classname alt="boost::proto::plus">proto::plus<></classname></computeroutput> and
+ <computeroutput><classname alt="boost::proto::nary_expr">proto::nary_expr<></classname></computeroutput>.</para>
   <namespace name="boost">
     <namespace name="proto">
       <struct name="pass_through">
@@ -123,7 +124,11 @@
               </requires>
               <returns>
                 <para>
- <computeroutput>result_type::make(G0()(proto::child_c<0>(expr),state,data),...GN()(proto::child_c<N>(expr),state,data))</computeroutput>
+ <programlisting>result_type::make(
+ G0()(<functionname>proto::child_c</functionname><0>(expr), state, data),
+ ...
+ GN()(<functionname>proto::child_c</functionname><N>(expr), state, data)
+)</programlisting>
                 </para>
               </returns>
             </method>

Modified: branches/release/libs/proto/doc/reference/transform/when.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/transform/when.xml (original)
+++ branches/release/libs/proto/doc/reference/transform/when.xml 2008-11-04 14:26:32 EST (Tue, 04 Nov 2008)
@@ -1,6 +1,14 @@
<?xml version="1.0" encoding="utf-8"?>
<header name="boost/proto/transform/when.hpp">
- <para>Definition of when transform. </para>
+ <para>
+ Definition of the
+ <computeroutput>
+ <classname alt="boost::proto::when">proto::when<></classname>
+ </computeroutput> and
+ <computeroutput>
+ <classname alt="boost::proto::otherwise">proto::otherwise<></classname>
+ </computeroutput> transforms.
+ </para>
   <namespace name="boost">
     <namespace name="proto">
       <struct name="when">
@@ -21,9 +29,9 @@
             <programlisting>// Count the terminals in an expression tree.
// Must be invoked with initial state == mpl::int_<0>().
struct CountLeaves :
- proto::or_<
- proto::when<proto::terminal<proto::_>, mpl::next<proto::_state>()>,
- proto::otherwise<proto::fold<proto::_, proto::_state, CountLeaves> >
+ <classname>proto::or_</classname><
+ proto::when<<classname>proto::terminal</classname><<classname>proto::_</classname>>, mpl::next<<classname>proto::_state</classname>>()>,
+ proto::otherwise<<classname>proto::fold</classname><<classname>proto::_</classname>, <classname>proto::_state</classname>, CountLeaves> >
   >
{};</programlisting>
           </para>
@@ -31,20 +39,27 @@
             In <computeroutput>proto::when<G, T></computeroutput>, when <computeroutput>T</computeroutput>
             is a class type it is a <conceptname>PrimitiveTransform</conceptname> and the following equivalencies hold:
           </para>
- <para>
- <computeroutput>proto::when<G,T>::impl<E,S,V>::type</computeroutput> is the same as
- <computeroutput>T::impl<E,S,V>::type</computeroutput>.
- </para>
- <para>
- <computeroutput>proto::when<G,T>()(e,s,v)</computeroutput> is the same as
- <computeroutput>T()(e,s,v)</computeroutput>.
- </para>
+ <itemizedlist>
+ <listitem>
+ <para>
+ <computeroutput>boost::result_of<proto::when<G,T>(E,S,V)>::type</computeroutput> is the same as
+ <computeroutput>boost::result_of<T(E,S,V)>::type</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>proto::when<G,T>()(e,s,v)</computeroutput> is the same as
+ <computeroutput>T()(e,s,v)</computeroutput>.
+ </para>
+ </listitem>
+ </itemizedlist>
         </description>
         <inherit><type>PrimitiveTransform</type></inherit>
         <typedef name="proto_base_expr">
           <type>typename Grammar::proto_base_expr</type>
         </typedef>
       </struct>
+
       <struct-specialization name="when">
         <template>
           <template-type-parameter name="Grammar"/>
@@ -54,7 +69,7 @@
           <template-arg>Grammar</template-arg>
           <template-arg>Fun *</template-arg>
         </specialization>
- <inherit>proto::when< Grammar, Fun ></inherit>
+ <inherit><classname>proto::when</classname>< Grammar, Fun ></inherit>
         <purpose>A specialization that treats function pointer <conceptname>Transform</conceptname>s as if they
           were function type <conceptname>Transform</conceptname>s.</purpose>
         <description>
@@ -88,7 +103,7 @@
         <description>
           <para>
             Use <computeroutput>proto::when<></computeroutput> to override a grammar's default
- transform with a custom transform. It is for used when composing larger transforms by associating
+ transform with a custom transform. It is for use when composing larger transforms by associating
             smaller transforms with individual rules in your grammar.
           </para>
           <para>
@@ -123,7 +138,7 @@
             <type>typename mpl::if_<<classname>proto::is_callable</classname><R>,call_,make_>::type</type>
           </typedef>
           <typedef name="result_type">
- <type>typename which::template impl< Expr, State, Data >::result_type</type>
+ <type>typename boost::result_of<which(Expr, State, Data)>::type</type>
           </typedef>
           <method-group name="public member functions">
             <method name="operator()" cv="const">
@@ -148,7 +163,7 @@
               </parameter>
               <description>
                 <para>
- Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with
+ Evaluate <computeroutput>R(A...)</computeroutput> as a transform either with
                   <computeroutput><classname>proto::call<></classname></computeroutput> or with
                   <computeroutput><classname>proto::make<></classname></computeroutput> depending
                   on whether <computeroutput><classname>proto::is_callable</classname><R>::value</computeroutput>
@@ -170,7 +185,7 @@
           </method-group>
         </struct>
         <typedef name="proto_base_expr">
- <type>typenme Grammar::proto_base_expr</type>
+ <type>typename Grammar::proto_base_expr</type>
         </typedef>
       </struct-specialization>

@@ -193,9 +208,9 @@
             <programlisting>// Count the terminals in an expression tree.
// Must be invoked with initial state == mpl::int_<0>().
struct CountLeaves :
- proto::or_<
- proto::when<proto::terminal<proto::_>, mpl::next<proto::_state>()>,
- proto::otherwise<proto::fold<proto::_, proto::_state, CountLeaves> >
+ <classname>proto::or_</classname><
+ proto::when<<classname>proto::terminal</classname><<classname>proto::_</classname>>, mpl::next<<classname>proto::_state</classname>>()>,
+ proto::otherwise<<classname>proto::fold</classname><<classname>proto::_</classname>, <classname>proto::_state</classname>, CountLeaves> >
   >
{};</programlisting>
           </para>

Date view	Thread view	Subject view	Author view