Boost logo

Boost-Commit :

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">
 
   <!-- classes -->
- <!--<section id="proto.reference.classes">
+ <section id="proto.reference.classes">
     <title>Classes</title>
     <itemizedlist>
       <listitem>
- <classname alt="boost::proto::deduce_domain">proto::deduce_domain</classname>
+ <computeroutput>
+ <classname alt="boost::proto::_">proto::_</classname>
+ </computeroutput>
       </listitem>
       <listitem>
- <classname alt="boost::proto::default_domain">proto::default_domain</classname>
+ <computeroutput>
+ <classname alt="boost::proto::_byref">proto::_byref</classname>
+ </computeroutput>
       </listitem>
       <listitem>
- <classname alt="boost::proto::domain">proto::domain&lt;&gt;</classname>
+ <computeroutput>
+ <classname alt="boost::proto::_byval">proto::_byval</classname>
+ </computeroutput>
       </listitem>
       <listitem>
- <classname alt="boost::proto::domain_of">proto::domain_of&lt;&gt;</classname>
+ <computeroutput>
+ <classname alt="boost::proto::_child_c">proto::_child_c</classname>
+ </computeroutput>
       </listitem>
       <listitem>
- <classname alt="boost::proto::expr">proto::expr&lt;&gt;</classname>
+ <computeroutput>
+ <classname alt="boost::proto::_data">proto::_data</classname>
+ </computeroutput>
       </listitem>
       <listitem>
- <classname alt="boost::proto::is_domain">proto::is_domain&lt;&gt;</classname>
+ <computeroutput>
+ <classname alt="boost::proto::_default">proto::_default</classname>
+ </computeroutput>
       </listitem>
       <listitem>
- <classname alt="boost::proto::term">proto::term&lt;&gt;</classname>
+ <computeroutput>
+ <classname alt="boost::proto::_expr">proto::_expr</classname>
+ </computeroutput>
       </listitem>
       <listitem>
- <classname alt="boost::proto::listN">proto::list1&lt;&gt;, proto::list2&lt;&gt;, ...</classname>
+ <computeroutput>
+ <classname alt="boost::proto::_state">proto::_state</classname>
+ </computeroutput>
       </listitem>
       <listitem>
- <classname alt="boost::proto::functional::display_expr">proto::functional::display_expr</classname>
+ <computeroutput>
+ <classname alt="boost::proto::_value">proto::_value</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::address_of">proto::address_of</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::and_">proto::and_</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::arity_of">proto::arity_of</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::assign">proto::assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::binary_expr">proto::binary_expr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::bitwise_and">proto::bitwise_and</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::bitwise_and_assign">proto::bitwise_and_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::bitwise_or">proto::bitwise_or</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::bitwise_or_assign">proto::bitwise_or_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::bitwise_xor">proto::bitwise_xor</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::bitwise_xor_assign">proto::bitwise_xor_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::by_value_generator">proto::by_value_generator</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::call">proto::call</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::callable">proto::callable</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::comma">proto::comma</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::complement">proto::complement</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::compose_generators">proto::compose_generators</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::context::callable_context">proto::context::callable_context</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::context::callable_eval">proto::context::callable_eval</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::context::default_context">proto::context::default_context</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::context::default_eval">proto::context::default_eval</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::context::null_context">proto::context::null_context</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::context::null_eval">proto::context::null_eval</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::convertible_to">proto::convertible_to</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::deduce_domain">proto::deduce_domain</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::default_domain">proto::default_domain</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::default_generator">proto::default_generator</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::dereference">proto::dereference</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::divides">proto::divides</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::divides_assign">proto::divides_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::domain">proto::domain</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::domain_of">proto::domain_of</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::equal_to">proto::equal_to</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::exact">proto::exact</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::expr">proto::expr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::extends">proto::extends</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::fold">proto::fold</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::fold_tree">proto::fold_tree</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::function">proto::function</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::as_child">proto::functional::as_child</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::as_expr">proto::functional::as_expr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::child">proto::functional::child</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::child_c">proto::functional::child_c</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::deep_copy">proto::functional::deep_copy</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::display_expr">proto::functional::display_expr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::eval">proto::functional::eval</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::flatten">proto::functional::flatten</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::left">proto::functional::left</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::make_expr">proto::functional::make_expr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::pop_front">proto::functional::pop_front</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::reverse">proto::functional::reverse</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::right">proto::functional::right</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::unpack_expr">proto::functional::unpack_expr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::functional::value">proto::functional::value</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::generator">proto::generator</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::greater">proto::greater</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::greater_equal">proto::greater_equal</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::if_">proto::if_</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::if_else_">proto::if_else_</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::is_aggregate">proto::is_aggregate</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::is_callable">proto::is_callable</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::is_domain">proto::is_domain</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::is_expr">proto::is_expr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::is_extension">proto::is_extension</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::is_proto_expr">proto::is_proto_expr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::lazy">proto::lazy</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::less">proto::less</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::less_equal">proto::less_equal</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::listN">proto::list1&lt;&gt;, proto::list2&lt;&gt;, ...</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::literal">proto::literal</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::logical_and">proto::logical_and</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::logical_not">proto::logical_not</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::logical_or">proto::logical_or</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::make">proto::make</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::matches">proto::matches</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::mem_ptr">proto::mem_ptr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::minus">proto::minus</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::minus_assign">proto::minus_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::modulus">proto::modulus</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::modulus_assign">proto::modulus_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::multiplies">proto::multiplies</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::multiplies_assign">proto::multiplies_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::nary_expr">proto::nary_expr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::negate">proto::negate</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::not_">proto::not_</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::not_equal_to">proto::not_equal_to</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::or_">proto::or_</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::otherwise">proto::otherwise</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::pass_through">proto::pass_through</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::plus">proto::plus</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::plus_assign">proto::plus_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::pod_generator">proto::pod_generator</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::post_dec">proto::post_dec</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::post_inc">proto::post_inc</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::pre_dec">proto::pre_dec</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::pre_inc">proto::pre_inc</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::protect">proto::protect</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::result_of::as_child">proto::result_of::as_child</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::result_of::as_expr">proto::result_of::as_expr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::result_of::child">proto::result_of::child</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::result_of::child_c">proto::result_of::child_c</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::result_of::deep_copy">proto::result_of::deep_copy</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::result_of::eval">proto::result_of::eval</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::result_of::flatten">proto::result_of::flatten</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::result_of::left">proto::result_of::left</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::result_of::make_expr">proto::result_of::make_expr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::result_of::right">proto::result_of::right</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::result_of::unpack_expr">proto::result_of::unpack_expr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::result_of::value">proto::result_of::value</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::reverse_fold">proto::reverse_fold</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::reverse_fold_tree">proto::reverse_fold_tree</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::shift_left">proto::shift_left</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::shift_left_assign">proto::shift_left_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::shift_right">proto::shift_right</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::shift_right_assign">proto::shift_right_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::subscript">proto::subscript</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::switch_">proto::switch_</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::address_of">proto::tag::address_of</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::assign">proto::tag::assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::bitwise_and">proto::tag::bitwise_and</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::bitwise_and_assign">proto::tag::bitwise_and_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::bitwise_or">proto::tag::bitwise_or</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::bitwise_or_assign">proto::tag::bitwise_or_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::bitwise_xor">proto::tag::bitwise_xor</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::bitwise_xor_assign">proto::tag::bitwise_xor_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::comma">proto::tag::comma</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::complement">proto::tag::complement</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::dereference">proto::tag::dereference</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::divides">proto::tag::divides</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::divides_assign">proto::tag::divides_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::equal_to">proto::tag::equal_to</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::function">proto::tag::function</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::greater">proto::tag::greater</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::greater_equal">proto::tag::greater_equal</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::if_else_">proto::tag::if_else_</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::less">proto::tag::less</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::less_equal">proto::tag::less_equal</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::logical_and">proto::tag::logical_and</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::logical_not">proto::tag::logical_not</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::logical_or">proto::tag::logical_or</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::mem_ptr">proto::tag::mem_ptr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::minus">proto::tag::minus</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::minus_assign">proto::tag::minus_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::modulus">proto::tag::modulus</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::modulus_assign">proto::tag::modulus_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::multiplies">proto::tag::multiplies</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::multiplies_assign">proto::tag::multiplies_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::negate">proto::tag::negate</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::not_equal_to">proto::tag::not_equal_to</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::plus">proto::tag::plus</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::plus_assign">proto::tag::plus_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::post_dec">proto::tag::post_dec</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::post_inc">proto::tag::post_inc</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::pre_dec">proto::tag::pre_dec</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::pre_inc">proto::tag::pre_inc</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::shift_left">proto::tag::shift_left</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::shift_left_assign">proto::tag::shift_left_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::shift_right">proto::tag::shift_right</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::shift_right_assign">proto::tag::shift_right_assign</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::subscript">proto::tag::subscript</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::terminal">proto::tag::terminal</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag::unary_plus">proto::tag::unary_plus</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::tag_of">proto::tag_of</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::term">proto::term</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::terminal">proto::terminal</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::transform">proto::transform</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::transform_impl">proto::transform_impl</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::unary_expr">proto::unary_expr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::unary_plus">proto::unary_plus</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::unexpr">proto::unexpr</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::vararg">proto::vararg</classname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname alt="boost::proto::when">proto::when</classname>
+ </computeroutput>
+ </listitem>
+ </itemizedlist>
+ </section>
+
+ <section id="proto.reference.functions">
+ <title>Functions</title>
+ <itemizedlist>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::as_child">proto::as_child()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::as_expr">proto::as_expr()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::child">proto::child()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::child_c">proto::child_c()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::deep_copy">proto::deep_copy()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::display_expr">proto::display_expr()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::eval">proto::eval()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::flatten">proto::flatten()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::if_else">proto::if_else()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::left">proto::left()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::lit">proto::lit()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::make_expr">proto::make_expr()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::right">proto::right()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::unpack_expr">proto::unpack_expr()</functionname>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <functionname alt="boost::proto::value">proto::value()</functionname>
+ </computeroutput>
       </listitem>
     </itemizedlist>
- </section>-->
+ </section>
 
   <!-- headers -->
   <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&lt;&gt;</classname></computeroutput> and <computeroutput>
- <classname alt="boost::proto::listN">proto::list<replaceable>N</replaceable>&lt;&gt;</classname>
- </computeroutput> class templates.</para>
+ <classname alt="boost::proto::term">proto::term&lt;&gt;</classname></computeroutput>,
+ <computeroutput><classname alt="boost::proto::listN">proto::list1&lt;&gt;</classname></computeroutput>,
+ <computeroutput><classname alt="boost::proto::listN">proto::list2&lt;&gt;</classname></computeroutput>, etc.
+ class templates.
+ </para>
 
   <namespace name="boost">
     <namespace name="proto">
@@ -12,7 +14,7 @@
       <!-- proto::term<> -->
       <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&lt;&gt;</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&lt;&gt;</classname></computeroutput> class template.</purpose>
+ <purpose><computeroutput>proto::list1&lt;&gt;</computeroutput>, <computeroutput>proto::list2&lt;&gt;</computeroutput>, etc.,
+ are type sequences for use as the 2<superscript>nd</superscript> parameter to the <computeroutput>
+ <classname>proto::expr&lt;&gt;</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&lt;&gt;</classname></computeroutput> class template. The
+ Type sequences, for use as the 2<superscript>nd</superscript> parameter to the <computeroutput>
+ <classname>proto::expr&lt;&gt;</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&lt;&gt;</computeroutput>,
+ <computeroutput>proto::list2&lt;&gt;</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&lt;&gt;</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>&lt;
- typename remove_reference&lt; Expr &gt;::type,
- typename remove_reference&lt; Context &gt;::type
+ typename boost::remove_reference&lt; Expr &gt;::type,
+ typename boost::remove_reference&lt; Context &gt;::type
     &gt;</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&lt;&gt;</computeroutput>,
- <computeroutput>proto::list2&lt;&gt;</computeroutput>, etc. The child types
- must all themselves be either <computeroutput>expr&lt;&gt;</computeroutput>
- or <computeroutput>proto::expr&lt;&gt;&amp;</computeroutput>, unless
+ <computeroutput><classname alt="proto::listN">proto::list1&lt;&gt;</classname></computeroutput>,
+ <computeroutput><classname alt="proto::listN">proto::list2&lt;&gt;</classname></computeroutput>,
+ etc. The child types
+ must all themselves be either <computeroutput>proto::expr&lt;&gt;</computeroutput>
+ or <computeroutput>proto::expr&lt;&gt;&amp;</computeroutput> (or extensions thereof via
+ <computeroutput><classname>proto::extends&lt;&gt;</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&lt;T&gt;</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&lt;&gt;::operator()</computeroutput>.
- Makes <computeroutput>expr&lt;&gt;</computeroutput> a TR1-style function object type
+ Encodes the return type of <computeroutput><classname>proto::expr&lt;&gt;</classname>::operator()</computeroutput>.
+ Makes <computeroutput><classname>proto::expr&lt;&gt;</classname></computeroutput> a TR1-style function object type
               usable with <computeroutput>boost::result_of&lt;&gt;</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 &amp;</paramtype>
           </parameter>
         </constructor>
+ <description>
+ <para>
+ For an expression type <computeroutput>E</computeroutput>,
+ <computeroutput>
+ <classname>proto::is_expr</classname>&lt;E&gt;::value
+ </computeroutput> is <computeroutput>true</computeroutput>, but
+ <computeroutput>
+ <classname>proto::is_expr</classname>&lt;proto::unexpr&lt;E&gt; &gt;::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&lt;&gt;</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&lt;&gt;</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&lt;&gt;</computeroutput> is used by the
             <computeroutput><classname alt="proto::when">proto::when&lt;&gt;</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&lt;&gt;</classname></computeroutput>
             and the later with <computeroutput><classname>proto::make&lt;&gt;</classname></computeroutput>.
@@ -50,6 +50,7 @@
             </itemizedlist>
           </para>
         </description>
+ <inherit><type>mpl::bool_&lt;<replaceable>true-or-false</replaceable>&gt;</type></inherit>
       </struct>
 
       <struct name="is_aggregate">
@@ -66,13 +67,16 @@
             If <computeroutput>proto::is_aggregate&lt;T&gt;::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&lt;&gt;</classname> is an aggregate.</computeroutput>
           </para>
         </description>
+ <inherit><type>mpl::bool_&lt;<replaceable>true-or-false</replaceable>&gt;</type></inherit>
       </struct>
+
       <namespace name="functional">
         <struct name="as_expr">
           <template>
@@ -113,7 +117,7 @@
               </description>
               <returns>
                 <para>
- <computeroutput>proto::as_expr&lt;Domain&gt;(t)</computeroutput>
+ <computeroutput><functionname>proto::as_expr</functionname>&lt;Domain&gt;(t)</computeroutput>
                 </para>
               </returns>
             </method>
@@ -172,7 +176,7 @@
               </description>
               <returns>
                 <para>
- <computeroutput>proto::as_child&lt;Domain&gt;(t)</computeroutput>
+ <computeroutput><functionname>proto::as_child</functionname>&lt;Domain&gt;(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>&lt; Tag, <classname alt="proto::listN">proto::list<replaceable>N</replaceable></classname>&lt; A0 &gt; &gt;</type>
+ <type><classname>proto::expr</classname>&lt; Tag, <classname alt="proto::listN">proto::list<replaceable>N</replaceable></classname>&lt; A... &gt; &gt;</type>
         </typedef>
         <typedef name="proto_base_expr">
           <type>type</type>
@@ -2129,7 +2133,7 @@
                   </listitem>
                   <listitem>
                     <para>
- <computeroutput>R(&amp;)(A0,...)</computeroutput> becomes <computeroutput>R(&amp;)(A0,...)</computeroutput>
+ <computeroutput>R(&amp;)(A...)</computeroutput> becomes <computeroutput>R(&amp;)(A...)</computeroutput>
                     </para>
                   </listitem>
                   <listitem>
@@ -2170,7 +2174,7 @@
                   </listitem>
                   <listitem>
                     <para>
- <computeroutput>R(&amp;)(A0,...)</computeroutput> becomes <computeroutput>R(&amp;)(A0,...)</computeroutput>
+ <computeroutput>R(&amp;)(A...)</computeroutput> becomes <computeroutput>R(&amp;)(A...)</computeroutput>
                     </para>
                   </listitem>
                   <listitem>
@@ -2211,7 +2215,7 @@
                   </listitem>
                   <listitem>
                     <para>
- <computeroutput>R(&amp;)(A0,...)</computeroutput> becomes <computeroutput>R(&amp;)(A0,...)</computeroutput>
+ <computeroutput>R(&amp;)(A...)</computeroutput> becomes <computeroutput>R(&amp;)(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&lt;Expr, State, Data&gt;</classname></type></inherit>
+ <inherit><type><classname>proto::transform_impl</classname>&lt;Expr, State, Data&gt;</type></inherit>
           <typedef name="result_type">
             <type><replaceable>see-below</replaceable></type>
             <description>
               <para>
- <computeroutput>proto::call&lt;T&gt;::impl&lt;Expr,State,Data&gt;::result_type</computeroutput>
+ <computeroutput><classname>proto::call</classname>&lt;T&gt;::impl&lt;Expr,State,Data&gt;::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&lt;PrimitiveTransform(
- typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,T0&gt;(Expr, State, Data)&gt;::type,
+ typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,A<subscript>0</subscript>&gt;(Expr, State, Data)&gt;::type,
   State,
   Data
 )&gt;::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&lt;PrimitiveTransform(
- typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,T0&gt;(Expr, State, Data)&gt;::type,
- typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,T1&gt;(Expr, State, Data)&gt;::type,
+ typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,A<subscript>0</subscript>&gt;(Expr, State, Data)&gt;::type,
+ typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,A<subscript>1</subscript>&gt;(Expr, State, Data)&gt;::type,
   Data
 )&gt;::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&lt;PrimitiveTransform(
- typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,T0&gt;(Expr, State, Data)&gt;::type,
- typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,T1&gt;(Expr, State, Data)&gt;::type,
- typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,T2&gt;(Expr, State, Data)&gt;::type
+ typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,A<subscript>0</subscript>&gt;(Expr, State, Data)&gt;::type,
+ typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,A<subscript>1</subscript>&gt;(Expr, State, Data)&gt;::type,
+ typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,A<subscript>2</subscript>&gt;(Expr, State, Data)&gt;::type
 )&gt;::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&lt;PolymorphicFunctionObject(
- typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,T0&gt;(Expr, State, Data)&gt;::type,
+ typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,A<subscript>0</subscript>&gt;(Expr, State, Data)&gt;::type,
   ...
- typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,TN&gt;(Expr, State, Data)&gt;::type
+ typename boost::result_of&lt;<classname>when</classname>&lt;<classname>_</classname>,A<subscript>n</subscript>&gt;(Expr, State, Data)&gt;::type
 &gt;::type</programlisting>
                     </para>
                   </listitem>
@@ -119,7 +119,7 @@
               </parameter>
               <description>
               <para>
- <computeroutput>proto::call&lt;T&gt;::impl&lt;Expr,State,Data&gt;::operator()</computeroutput> behaves as follows:
+ <computeroutput><classname>proto::call</classname>&lt;T&gt;::impl&lt;Expr,State,Data&gt;::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>&lt;<classname>_</classname>,T0&gt;()(expr, state, data),
+ <classname>when</classname>&lt;<classname>_</classname>,A<subscript>0</subscript>&gt;()(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>&lt;<classname>_</classname>,T0&gt;()(expr, state, data),
- <classname>when</classname>&lt;<classname>_</classname>,T1&gt;()(expr, state, data),
+ <classname>when</classname>&lt;<classname>_</classname>,A<subscript>0</subscript>&gt;()(expr, state, data),
+ <classname>when</classname>&lt;<classname>_</classname>,A<subscript>1</subscript>&gt;()(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>&lt;<classname>_</classname>,T0&gt;()(expr, state, data),
- <classname>when</classname>&lt;<classname>_</classname>,T1&gt;()(expr, state, data),
- <classname>when</classname>&lt;<classname>_</classname>,T2&gt;()(expr, state, data)
+ <classname>when</classname>&lt;<classname>_</classname>,A<subscript>0</subscript>&gt;()(expr, state, data),
+ <classname>when</classname>&lt;<classname>_</classname>,A<subscript>1</subscript>&gt;()(expr, state, data),
+ <classname>when</classname>&lt;<classname>_</classname>,A<subscript>2</subscript>&gt;()(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>&lt;<classname>_</classname>,T0&gt;()(expr, state, data),
+ <classname>when</classname>&lt;<classname>_</classname>,A<subscript>0</subscript>&gt;()(expr, state, data),
   ...
- <classname>when</classname>&lt;<classname>_</classname>,TN&gt;()(expr, state, data)
+ <classname>when</classname>&lt;<classname>_</classname>,A<subscript>n</subscript>&gt;()(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&lt;Expr, State, Data&gt;</classname></type></inherit>
+ <inherit><type><classname>proto::transform_impl</classname>&lt;Expr, State, Data&gt;</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&lt;&gt; and reverse_fold&lt;&gt; transforms. </para>
+ <para>Contains definition of the
+ <computeroutput>
+ <classname alt="boost::proto::fold">proto::fold&lt;&gt;</classname>
+ </computeroutput> and
+ <computeroutput>
+ <classname alt="boost::proto::reverse_fold">proto::reverse_fold&lt;&gt;</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&lt;_, Sequence&gt;()(expr, state, data)</computeroutput>,
+ <computeroutput><classname>when</classname>&lt;<classname>_</classname>, Sequence&gt;()(expr, state, data)</computeroutput>,
                   let <computeroutput>state0</computeroutput> be
- <computeroutput>when&lt;_, State0&gt;()(expr, state, data)</computeroutput>,
+ <computeroutput><classname>when</classname>&lt;<classname>_</classname>, State0&gt;()(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&lt;_, Fun&gt;()(expr, state, data)</computeroutput>. Then,
+ <computeroutput><classname>when</classname>&lt;<classname>_</classname>, Fun&gt;()(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>&lt; <classname>proto::_reverse</classname>(Sequence), State0, Fun &gt;</inherit>
         <purpose>
- A PrimitiveTransform that is the same as the <computeroutput><classname>proto::fold&lt;&gt;</classname></computeroutput>
+ A <conceptname>PrimitiveTransform</conceptname> that is the same as the <computeroutput><classname>proto::fold&lt;&gt;</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&lt;&gt; and reverse_fold_tree&lt;&gt; transforms. </para>
+ <para>
+ Contains definition of the
+ <computeroutput>
+ <classname alt="boost::proto::fold_tree">proto::fold_tree&lt;&gt;</classname>
+ </computeroutput> and
+ <computeroutput>
+ <classname alt="boost::proto::reverse_fold_tree">proto::reverse_fold_tree&lt;&gt;</classname>
+ </computeroutput>
+ transforms.
+ </para>
   <namespace name="boost">
     <namespace name="proto">
       <struct name="fold_tree">
@@ -25,11 +34,11 @@
             <computeroutput>recurse_if_&lt;&gt;</computeroutput> helper, defined as follows:
             <programlisting> template&lt;typename Tag, typename Fun&gt;
 struct recurse_if_ :
- proto::if_&lt;
+ <classname>proto::if_</classname>&lt;
     // If the current node has type type "Tag" ...
- boost::is_same&lt;proto::tag_of&lt;proto::_&gt;, Tag&gt;(),
+ boost::is_same&lt;<classname>proto::tag_of</classname>&lt;<classname>proto::_</classname>&gt;, Tag&gt;(),
     // ... recurse, otherwise ...
- proto::fold&lt;proto::_, proto::_state, recurse_if_&lt;Tag, Fun&gt; &gt;,
+ <classname>proto::fold</classname>&lt;<classname>proto::_</classname>, <classname>proto::_state</classname>, recurse_if_&lt;Tag, Fun&gt; &gt;,
     // ... apply the Fun transform.
     Fun
   &gt;
@@ -84,11 +93,11 @@
             a <computeroutput>recurse_if_&lt;&gt;</computeroutput> helper, defined as follows:
             <programlisting> template&lt;typename Tag, typename Fun&gt;
 struct recurse_if_ :
- proto::if_&lt;
+ <classname>proto::if_</classname>&lt;
     // If the current node has type type "Tag" ...
- boost::is_same&lt;proto::tag_of&lt;proto::_&gt;, Tag&gt;(),
+ boost::is_same&lt;<classname>proto::tag_of</classname>&lt;<classname>proto::_</classname>&gt;, Tag&gt;(),
     // ... recurse, otherwise ...
- proto::reverse_fold&lt;proto::_, proto::_state, recurse_if_&lt;Tag, Fun&gt; &gt;,
+ <classname>proto::reverse_fold</classname>&lt;<classname>proto::_</classname>, <classname>proto::_state</classname>, recurse_if_&lt;Tag, Fun&gt; &gt;,
     // ... apply the Fun transform.
     Fun
   &gt;
@@ -98,7 +107,7 @@
             With <computeroutput>recurse_if_&lt;&gt;</computeroutput> as defined above,
             <computeroutput>proto::reverse_fold_tree&lt;Sequence, State0, Fun&gt;()(expr, state, data)</computeroutput>
             is equivalent to:
- <programlisting>proto::reverse_fold&lt;
+ <programlisting><classname>proto::reverse_fold</classname>&lt;
   Sequence,
   State0,
   recurse_if_&lt;typename Expr::proto_tag, Fun&gt;

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&lt; Expr, int, int &gt;::result_type</type>
+ <type>typename PrimitiveTransform::template impl&lt; Expr, <replaceable>unspecified</replaceable>, <replaceable>unspecified</replaceable> &gt;::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&lt; Expr, State, int &gt;::result_type</type>
+ <type>typename PrimitiveTransform::template impl&lt; Expr, State, <replaceable>unspecified</replaceable> &gt;::result_type</type>
           </typedef>
         </struct-specialization>
         <struct-specialization name="result">
@@ -61,6 +61,11 @@
             <parameter name="expr">
               <paramtype>Expr &amp;</paramtype>
             </parameter>
+ <returns>
+ <computeroutput>
+ typename PrimitiveTransform::template impl&lt;Expr &amp;, <replaceable>unspecified</replaceable>, <replaceable>unspecified</replaceable>&gt;()(expr, <replaceable>unspecified</replaceable>, <replaceable>unspecified</replaceable>)
+ </computeroutput>
+ </returns>
           </method>
           <method name="operator()" cv="const">
             <type>typename PrimitiveTransform::template impl&lt;Expr &amp;, State &amp;, <replaceable>unspecified</replaceable>&gt;::result_type</type>
@@ -74,6 +79,11 @@
             <parameter name="state">
               <paramtype>State &amp;</paramtype>
             </parameter>
+ <returns>
+ <computeroutput>
+ typename PrimitiveTransform::template impl&lt;Expr &amp;, State &amp;, <replaceable>unspecified</replaceable>&gt;()(expr, state, <replaceable>unspecified</replaceable>)
+ </computeroutput>
+ </returns>
           </method>
           <method name="operator()" cv="const">
             <type>typename PrimitiveTransform::template impl&lt;Expr &amp;, State const &amp;, <replaceable>unspecified</replaceable>&gt;::result_type</type>
@@ -87,6 +97,11 @@
             <parameter name="state">
               <paramtype>State const &amp;</paramtype>
             </parameter>
+ <returns>
+ <computeroutput>
+ typename PrimitiveTransform::template impl&lt;Expr &amp;, State const &amp;, <replaceable>unspecified</replaceable>&gt;()(expr, state, <replaceable>unspecified</replaceable>)
+ </computeroutput>
+ </returns>
           </method>
           <method name="operator()" cv="const">
             <type>typename PrimitiveTransform::template impl&lt;Expr &amp;, State &amp;, Data &amp;&gt;::result_type</type>
@@ -104,6 +119,11 @@
             <parameter name="data">
               <paramtype>Data &amp;</paramtype>
             </parameter>
+ <returns>
+ <computeroutput>
+ typename PrimitiveTransform::template impl&lt;Expr &amp;, State &amp;, Data &amp;&gt;()(expr, state, data)
+ </computeroutput>
+ </returns>
           </method>
           <method name="operator()" cv="const">
             <type>typename PrimitiveTransform::template impl&lt;Expr &amp;, State const &amp;, Data &amp;&gt;::result_type</type>
@@ -121,6 +141,11 @@
             <parameter name="data">
               <paramtype>Data &amp;</paramtype>
             </parameter>
+ <returns>
+ <computeroutput>
+ typename PrimitiveTransform::template impl&lt;Expr &amp;, State const &amp;, Data &amp;&gt;()(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&lt;&gt; transform. </para>
+ <para>
+ Contains definition of the
+ <computeroutput>
+ <classname alt="boost::proto::lazy">proto::lazy&lt;&gt;</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&lt;T&gt;::impl&lt;Expr,State,Data&gt;::result_type</computeroutput>
+ <computeroutput><classname>proto::lazy</classname>&lt;T&gt;::impl&lt;Expr,State,Data&gt;::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&lt;<classname>proto::make</classname>&lt;O&gt;(Expr, State, Data)&gt;::type</computeroutput>.
+ <computeroutput>O(A<subscript>0</subscript>,...A<subscript>n</subscript>)</computeroutput>, then let <computeroutput>O'</computeroutput>
+ be <computeroutput>boost::result_of&lt;<classname>proto::make</classname>&lt;O&gt;(Expr, State, Data)&gt;::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&lt;<classname>proto::make</classname>&lt;T&gt;(Expr, State, Data)&gt;::type</computeroutput>.
                     </para>
                   </listitem>
                 </itemizedlist>
- The result type is <computeroutput>boost::result_of&lt;<classname>proto::call</classname>&lt;O'(T0,...TN)&gt;(Expr, State, Data)&gt;::type</computeroutput>.
+ <para>
+ The result type is
+ <computeroutput>
+ boost::result_of&lt;<classname>proto::call</classname>&lt;T'&gt;(Expr, State, Data)&gt;::type
+ </computeroutput>.
+ </para>
               </para>
             </description>
           </typedef>
@@ -81,18 +92,19 @@
               </parameter>
               <description>
                 <para>
- <computeroutput>proto::lazy&lt;T&gt;::impl&lt;Expr,State,Data&gt;::operator()</computeroutput> behaves as follows:
+ <computeroutput><classname>proto::lazy</classname>&lt;T&gt;::impl&lt;Expr,State,Data&gt;::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&lt;<classname>proto::make</classname>&lt;O&gt;(Expr, State, Data)&gt;::type</computeroutput>.
+ <computeroutput>O(A<subscript>0</subscript>,...A<subscript>n</subscript>)</computeroutput>, then let <computeroutput>O'</computeroutput>
+ be <computeroutput>boost::result_of&lt;<classname>proto::make</classname>&lt;O&gt;(Expr, State, Data)&gt;::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&lt;<classname>proto::make</classname>&lt;T&gt;(Expr, State, Data)&gt;::type</computeroutput>.
                       </para>
                     </listitem>
@@ -100,9 +112,11 @@
                 </para>
               </description>
               <returns>
- <computeroutput>
- <classname>proto::call</classname>&lt;O'(T0,...TN)&gt;()(expr, state, data)
- </computeroutput>
+ <para>
+ <computeroutput>
+ <classname>proto::call</classname>&lt;T'&gt;()(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&lt;&gt; transform. </para>
+ <para>
+ Contains definition of the
+ <computeroutput>
+ <classname alt="boost::proto::make">proto::make&lt;&gt;</classname>
+ </computeroutput>
+ and
+ <computeroutput>
+ <classname alt="boost::proto::protect">proto::protect&lt;&gt;</classname>
+ </computeroutput>
+ transforms.
+ </para>
   <namespace name="boost">
     <namespace name="proto">
       <struct name="protect">
@@ -33,10 +43,10 @@
 {};
 
 struct Foo :
- proto::when&lt;_, Bar&lt;_&gt;() &gt;
+ <classname>proto::when</classname>&lt;<classname>proto::_</classname>, Bar&lt;<classname>proto::_</classname>&gt;() &gt;
 {};
 
-proto::terminal&lt;int&gt;::type i = {0};
+<classname>proto::terminal</classname>&lt;int&gt;::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&lt;_&gt;</computeroutput>, you would have to protect the
+ <computeroutput>Bar&lt;proto::_&gt;</computeroutput>, you would have to protect the
             <computeroutput>_</computeroutput> to prevent it from being applied. You can
             use <computeroutput>proto::protect&lt;&gt;</computeroutput> as follows:
           </para>
           <para>
             <programlisting>// OK: replace anything with Bar&lt;_&gt;()
 struct Foo :
- proto::when&lt;_, Bar&lt;protect&lt;_&gt; &gt;() &gt;
+ <classname>proto::when</classname>&lt;<classname>proto::_</classname>, Bar&lt;<classname>proto::protect</classname>&lt;<classname>proto::_</classname>&gt; &gt;() &gt;
 {};</programlisting>
           </para>
         </description>
@@ -108,27 +118,35 @@
             <type><emphasis>see-below</emphasis></type>
             <description>
               <para>
- <computeroutput>proto::make&lt;T&gt;::impl&lt;Expr, State, Data&gt;::result_type</computeroutput> is
+ <computeroutput><classname>proto::make</classname>&lt;T&gt;::impl&lt;Expr, State, Data&gt;::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&lt;X0,...XN&gt;</computeroutput>, then the result type is calculated as follows:
+ <computeroutput>
+ S&lt;X<subscript>0</subscript>,...X<subscript>n</subscript>&gt;
+ </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>&lt;X&gt;::impl&lt;Expr, State, Data&gt;::result_type
+ <classname>proto::make</classname>&lt;X<subscript>i</subscript>&gt;::impl&lt;Expr, State, Data&gt;::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&lt;X0',...XN'&gt;</computeroutput> has a nested
+ <computeroutput>
+ S&lt;X<subscript>0</subscript>',...X<subscript>n</subscript>'&gt;
+ </computeroutput> has a nested
                           <computeroutput>type</computeroutput> typedef, the result type is
- <computeroutput>S&lt;X0',...XN'&gt;::type</computeroutput>.
+ <computeroutput>
+ S&lt;X<subscript>0</subscript>',...X<subscript>n</subscript>'&gt;::type
+ </computeroutput>.
                         </para>
                       </listitem>
                       <listitem>
                         <para>
                           Otherwise, the result type is
- <computeroutput>S&lt;X0',...XN'&gt;</computeroutput>.
+ <computeroutput>
+ S&lt;X<subscript>0</subscript>',...X<subscript>n</subscript>'&gt;
+ </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>&lt;<classname>_</classname>, O&gt;::impl&lt;Expr, State, Data&gt;::result_type
+ <classname>proto::when</classname>&lt;<classname>_</classname>, O&gt;::impl&lt;Expr, State, Data&gt;::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&lt;&gt;</classname></computeroutput> is implemented
                 in terms of <computeroutput><classname alt="proto::call">proto::call&lt;&gt;</classname></computeroutput>
                 and <computeroutput><classname alt="proto::make">proto::make&lt;&gt;</classname></computeroutput>, so the
@@ -186,12 +212,17 @@
               </parameter>
               <description>
                 <para>
- <computeroutput>proto::make&lt;T&gt;::impl&lt;Expr,State,Data&gt;::operator()</computeroutput> behaves as follows:
+ <computeroutput>
+ <classname>proto::make</classname>&lt;T&gt;::impl&lt;Expr,State,Data&gt;::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&lt;_, T0&gt;()(expr, state, data),
+ <classname>proto::when</classname>&lt;<classname>_</classname>, A<subscript>0</subscript>&gt;()(expr, state, data),
   ...
- proto::when&lt;_, TN&gt;()(expr, state, data)
+ <classname>proto::when</classname>&lt;<classname>_</classname>, A<subscript>n</subscript>&gt;()(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&lt;_, T0&gt;()(expr, state, data),
+ <classname>proto::when</classname>&lt;<classname>_</classname>, A<subscript>0</subscript>&gt;()(expr, state, data),
   ...
- proto::when&lt;_, TN&gt;()(expr, state, data)
+ <classname>proto::when</classname>&lt;<classname>_</classname>, A<subscript>n</subscript>&gt;()(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&lt;&gt;</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&lt;&gt;</classname>,
- <classname alt="boost::proto::plus">proto::plus&lt;&gt;</classname> and
- <classname alt="boost::proto::nary_expr">proto::nary_expr&lt;&gt;</classname>.</para>
+ <para>Definition of the
+ <computeroutput><classname alt="boost::proto::pass_through">proto::pass_through&lt;&gt;</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&lt;&gt;</classname></computeroutput>,
+ <computeroutput><classname alt="boost::proto::plus">proto::plus&lt;&gt;</classname></computeroutput> and
+ <computeroutput><classname alt="boost::proto::nary_expr">proto::nary_expr&lt;&gt;</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&lt;0&gt;(expr),state,data),...GN()(proto::child_c&lt;N&gt;(expr),state,data))</computeroutput>
+ <programlisting>result_type::make(
+ G0()(<functionname>proto::child_c</functionname>&lt;0&gt;(expr), state, data),
+ ...
+ GN()(<functionname>proto::child_c</functionname>&lt;N&gt;(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&lt;&gt;</classname>
+ </computeroutput> and
+ <computeroutput>
+ <classname alt="boost::proto::otherwise">proto::otherwise&lt;&gt;</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_&lt;0&gt;().
 struct CountLeaves :
- proto::or_&lt;
- proto::when&lt;proto::terminal&lt;proto::_&gt;, mpl::next&lt;proto::_state&gt;()&gt;,
- proto::otherwise&lt;proto::fold&lt;proto::_, proto::_state, CountLeaves&gt; &gt;
+ <classname>proto::or_</classname>&lt;
+ proto::when&lt;<classname>proto::terminal</classname>&lt;<classname>proto::_</classname>&gt;, mpl::next&lt;<classname>proto::_state</classname>&gt;()&gt;,
+ proto::otherwise&lt;<classname>proto::fold</classname>&lt;<classname>proto::_</classname>, <classname>proto::_state</classname>, CountLeaves&gt; &gt;
   &gt;
 {};</programlisting>
           </para>
@@ -31,20 +39,27 @@
             In <computeroutput>proto::when&lt;G, T&gt;</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&lt;G,T&gt;::impl&lt;E,S,V&gt;::type</computeroutput> is the same as
- <computeroutput>T::impl&lt;E,S,V&gt;::type</computeroutput>.
- </para>
- <para>
- <computeroutput>proto::when&lt;G,T&gt;()(e,s,v)</computeroutput> is the same as
- <computeroutput>T()(e,s,v)</computeroutput>.
- </para>
+ <itemizedlist>
+ <listitem>
+ <para>
+ <computeroutput>boost::result_of&lt;proto::when&lt;G,T&gt;(E,S,V)&gt;::type</computeroutput> is the same as
+ <computeroutput>boost::result_of&lt;T(E,S,V)&gt;::type</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>proto::when&lt;G,T&gt;()(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&lt; Grammar, Fun &gt;</inherit>
+ <inherit><classname>proto::when</classname>&lt; Grammar, Fun &gt;</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&lt;&gt;</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_&lt;<classname>proto::is_callable</classname>&lt;R&gt;,call_,make_&gt;::type</type>
           </typedef>
           <typedef name="result_type">
- <type>typename which::template impl&lt; Expr, State, Data &gt;::result_type</type>
+ <type>typename boost::result_of&lt;which(Expr, State, Data)&gt;::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&lt;&gt;</classname></computeroutput> or with
                   <computeroutput><classname>proto::make&lt;&gt;</classname></computeroutput> depending
                   on whether <computeroutput><classname>proto::is_callable</classname>&lt;R&gt;::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_&lt;0&gt;().
 struct CountLeaves :
- proto::or_&lt;
- proto::when&lt;proto::terminal&lt;proto::_&gt;, mpl::next&lt;proto::_state&gt;()&gt;,
- proto::otherwise&lt;proto::fold&lt;proto::_, proto::_state, CountLeaves&gt; &gt;
+ <classname>proto::or_</classname>&lt;
+ proto::when&lt;<classname>proto::terminal</classname>&lt;<classname>proto::_</classname>&gt;, mpl::next&lt;<classname>proto::_state</classname>&gt;()&gt;,
+ proto::otherwise&lt;<classname>proto::fold</classname>&lt;<classname>proto::_</classname>, <classname>proto::_state</classname>, CountLeaves&gt; &gt;
   &gt;
 {};</programlisting>
           </para>


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk