Update of /cvsroot/boost/boost/libs/xpressive/proto/doc
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv27174
Modified Files:
Jamfile.v2 calculator.qbk proto.qbk protodoc.xml
Added Files:
construction.qbk
Log Message:
more work on docs
--- NEW FILE: construction.qbk ---
[/
/ Copyright (c) 2007 Eric Niebler
/
/ Distributed under the Boost Software License, Version 1.0. (See accompanying
/ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
/]
[section:expression_construction Expression Construction: Building Proto
Expression Trees]
We've seen some simple examples of how to use Proto, but we haven't really said
much about what is going on under the hood. How exactly does Proto build and
process expression trees? Now is the time to find out.
In the calculator example, we defined a placeholder terminal like this:
// Define a placeholder type
struct placeholder1 {};
// Define the Proto-ified placeholder terminal
terminal< placeholder1 >::type const _1 = {{}};
The actual type of `_1` looks like this:
expr< tag::terminal, args0< placeholder1 >, 0 >
The _expr_ template is the most important type in Proto. Although you will
rarely need to deal with it directly, it's always there behind the scenes
holding your expression trees together. In fact, _expr_ /is/ the expression
tree -- braches, leaves and all.
The _expr_ template makes up the nodes in expression trees. The first template
parameter is the node type; in this case, `proto::tag::terminal`. That means
that `_1` is a leaf-node in the expression tree. The second template parameter
is a list of children types. Terminals will always have only one type in the
type list. The last parameter is the arity of the expression. Terminals have
arity 0, unary expressions have arity 1, etc.
The _expr_ struct is defined as follows:
template< typename Tag, typename Args, long Arity = Args::size >
struct expr;
template< typename Tag, typename Args >
struct expr< Tag, Args, 1 >
{
typename Args::arg0 arg0;
// ...
};
The _expr_ struct does not define a constructor, or anything else that would
prevent static initialization. All _expr_ objects are initialized using
['aggregate initialization], with curly braces. In our example, `_1` is
initialized with the initializer `{{}}`. The outer braces is the initializer
for the _expr_ struct, and the inner braces are for the member `_1.arg0` which
is of type `placeholder1`. Note that we use braces to initialize `_1.arg0`
because `placeholder1` is also an aggregate.
[section:operator_overloads Proto's Operator Overloads]
Once we have some Proto terminals, expressions involving those terminals build
expression trees for us, as if by magic. It's not magic; Proto defines
overloads for each of C++'s overloadable operators to make it happen. As long
as one operand is a Proto expression, the result of the operation is a tree
node representing that operation.[footnote There are a couple of exceptions to
this. In ["`int x; x = _1`], the assignment isn't a Proto expression, even
though the right hand operand /is/ a Proto expression. That's just how C++
works.
The same is also true for the subscript operator and the function call
operator, as in ["`int *x; x[_1];`] and ["`std::sin(_1);`]. Them's the breaks,
as they say.]
[note The _expr_ struct lives in the `boost::proto` namespace, as do all of
Proto's operator overloads. The overloads are found via ADL (Argument-Dependent
Lookup). That is why expressions must be "tainted" with Proto-ness for Proto to
be able to build trees out of expressions.]
As a result of Proto's operator overloads, we can say:
-_1; // OK, build a unary-negate tree node
_1 + 42; // OK, build a binary-plus tree node
[endsect]
[section:expression_trees Building Expression Trees]
The `_1` node is an _expr_ type, and new nodes created with this type are
also _expr_ types. They look like this:
// typeof( -_1 )
expr<
tag::negate
, args1<
ref_< expr< tag::terminal, args0< placeholder1 >, 0 > >
>
, 1
>
// typeof( _1 + 42 )
expr<
tag::plus
, args2<
ref_< expr< tag::terminal, args0< placeholder1 >, 0 > >
, expr< tag::terminal, args0< int const & >, 0 >
>
, 2
>
There are a few things to note about these types:
# Terminals have arity 0, unary expressions have arity 1 and binary expressions
have arity 2.
# When one Proto expression is made a child node of another Proto expression,
it is wrapped in _ref_, which is a simple reference wrapper. That is, Proto
expressions hold their children by reference ['even if they are temporary
objects]. This last point becomes important later.
# Non-Proto expressions, such as the integer literal, are turned into Proto
expressions by making them Proto terminals. These terminal expressions
are /not/ wrapped in _ref_, but the object itself /is/ held by reference.
Notice that the type of the Proto-ified `42` literal is `int const &` -- held
by reference.
The types make it clear: everything in a Proto expression tree is held by
reference. That means that building an expression tree is exceptionally cheap.
It involves no copying at all.
[note To use Proto effectively, you won't have to bother yourself with the
actual types that Proto generates. These are details, but you're likely to
encounter these types in compiler error messages, so it's helpful to be familiar
with them.]
[endsect]
[section:tags_and_meta_functions Operator Tags and Meta-Functions]
// TODO make a table showing all of the operator tags and meta-functions
[endsect]
[section:construction_utils Expression Construction Utilities]
// TODO describe make_expr, unpack_expr and
BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE
[endsect]
[endsect]
Index: Jamfile.v2
===================================================================
RCS file: /cvsroot/boost/boost/libs/xpressive/proto/doc/Jamfile.v2,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- Jamfile.v2 18 Jun 2007 02:56:21 -0000 1.8
+++ Jamfile.v2 20 Jun 2007 06:30:39 -0000 1.9
@@ -31,7 +31,14 @@
# ../../../../boost/xpressive/proto/ref.hpp
# ../../../../boost/xpressive/proto/tags.hpp
# ../../../../boost/xpressive/proto/traits.hpp
-# [ glob ../../../../boost/xpressive/proto/transform/*.hpp ]
+# ../../../../boost/xpressive/proto/transform/arg.hpp
+# ../../../../boost/xpressive/proto/transform/branch.hpp
+# ../../../../boost/xpressive/proto/transform/compose.hpp
+# ../../../../boost/xpressive/proto/transform/construct.hpp
+# ../../../../boost/xpressive/proto/transform/fold.hpp
+# ../../../../boost/xpressive/proto/transform/fold_tree.hpp
+# ../../../../boost/xpressive/proto/transform/list.hpp
+# ../../../../boost/xpressive/proto/transform/pass_through.hpp
# :
# <doxygen:param>EXTRACT_ALL=YES
# <doxygen:param>HIDE_UNDOC_MEMBERS=NO
Index: calculator.qbk
===================================================================
RCS file: /cvsroot/boost/boost/libs/xpressive/proto/doc/calculator.qbk,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -d -r1.11 -r1.12
--- calculator.qbk 18 Jun 2007 02:56:21 -0000 1.11
+++ calculator.qbk 20 Jun 2007 06:30:39 -0000 1.12
@@ -5,18 +5,16 @@
/ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
/]
-[section Calculator]
-
-Let's use Proto to build a Domain Specific Embedded Language for a
-lazily-evaluated calculator. We'll see how to define the terminals in your
-mini-language, how Proto combines the terminals into larger expressions, and
-how to define an evaluation context so that your expressions can do useful
-work.
+[section Hello Calculator]
-When we're done, we'll have a mini-language that will allow us to declare a
-lazily-evaluated arithmetic expression, such as `(_2 - _1) / _2 * 100`, where
-`_1` and `_2` are placeholders for values to be passed in when the expression
-is evaluated.
+"Hello, world" is nice, but it doesn't get you very far. Let's use Proto to
+build a Domain Specific Embedded Language for a lazily-evaluated calculator.
+We'll see how to define the terminals in your mini-language, how Proto combines
+the terminals into larger expressions, and how to define an evaluation context
+so that your expressions can do useful work. When we're done, we'll have a
+mini-language that will allow us to declare a lazily-evaluated arithmetic
+expression, such as `(_2 - _1) / _2 * 100`, where `_1` and `_2` are
+placeholders for values to be passed in when the expression is evaluated.
[header Defining Terminals]
@@ -39,37 +37,6 @@
Initialization] section in the [link boost_proto.appendices.rationale
Rationale]
appendix for more information.
-The actual type of `_1` looks like this:
-
- proto::expr< proto::tag::terminal, proto::args0< placeholder1 >, 0 >
-
-The _expr_ template makes up the nodes in expression trees. The first template
-parameter is the node type; in this case, `proto::tag::terminal`. That means
-that `_1` is a leaf-node in the expression tree. The second template parameter
-is a list of children types. Terminals will always have only one type in the
-type list. The last parameter is the arity of the expression. Terminals have
-arity 0, unary expressions have arity 1, etc.
-
-The _expr_ struct is defined as follows:
-
- template< typename Tag, typename Args, long Arity = Args::size >
- struct expr;
-
- template< typename Tag, typename Args >
- struct expr< Tag, Args, 1 >
- {
- typename Args::arg0 arg0;
- // ...
- };
-
-The _expr_ struct does not define a constructor, or anything else that would
-prevent static initialization. All _expr_ objects are initialized using
-['aggregate initialization] -- with curly braces. In our example, `_1`
-is initialized with the initializer `{{}}`. The outer braces is the initializer
-for the _expr_ struct, and the inner braces are for the member `_1.arg0` which
-is of type `placeholder1`. Note that we use braces to initialize `_1.arg0`
-because `placeholder1` is also an aggregate.
-
[header Constructing Expression Trees]
Now that we have terminals, we can use Proto's operator overloads to combine
Index: proto.qbk
===================================================================
RCS file: /cvsroot/boost/boost/libs/xpressive/proto/doc/proto.qbk,v
retrieving revision 1.20
retrieving revision 1.21
diff -u -d -r1.20 -r1.21
--- proto.qbk 18 Jun 2007 02:56:21 -0000 1.20
+++ proto.qbk 20 Jun 2007 06:30:40 -0000 1.21
@@ -78,7 +78,7 @@
corresponding to the 5 major parts to Proto:
[variablelist
-[[Expression Construction]
+[[[link boost_proto.users_guide.expression_construction Expression
Construction]]
[Describes how to use Proto to build expression trees.]]
[[Expression Evaluation]
[Describes the tools Proto provides for making your expression trees do
@@ -91,7 +91,7 @@
into some other object.]]
[[[link boost_proto.users_guide.expression_extension Expression Extension]]
[Describes how to extend Proto expressions with additional behaviors and
- members.]]
+ members and how to selectively disable Proto's operator overloads.]]
]
But before we get started, let's have a look at some very simple Proto examples
@@ -103,6 +103,8 @@
[include calculator.qbk]
+[include construction.qbk]
+
[include grammars.qbk]
[include transforms.qbk]
Index: protodoc.xml
===================================================================
RCS file: /cvsroot/boost/boost/libs/xpressive/proto/doc/protodoc.xml,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- protodoc.xml 16 Jun 2007 09:21:17 -0000 1.8
+++ protodoc.xml 20 Jun 2007 06:30:40 -0000 1.9
@@ -1066,21 +1066,22 @@
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><parameter name="expr"><paramtype>Expr const
&</paramtype></parameter><parameter name="state"><paramtype>State const
&</paramtype></parameter><parameter name="visitor"><paramtype>Visitor
&</paramtype></parameter></method></method-group></struct><struct
name="if_"><template>
- <template-type-parameter name="Pred"/>
- </template><inherit
access="public">boost::proto::has_identity_transform</inherit><typedef
name="proto_base_expr"><type><classname>if_</classname></type></typedef></struct><struct
name="not_"><template>
+ </template><parameter name="expr"><paramtype>Expr const
&</paramtype></parameter><parameter name="state"><paramtype>State const
&</paramtype></parameter><parameter name="visitor"><paramtype>Visitor
&</paramtype></parameter></method></method-group></struct><struct
name="not_"><template>
<template-type-parameter name="Pred"/>
</template><inherit
access="public">boost::proto::has_identity_transform</inherit><typedef
name="proto_base_expr"><type><classname>not_</classname></type></typedef></struct><struct
name="vararg"><template>
<template-type-parameter name="Grammar"/>
- </template><typedef
name="proto_is_vararg_"><type>void</type></typedef></struct><struct
name="if_matches"><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="Grammar"/>
- <template-type-parameter name="Return"/>
- </template></struct><struct name="if_not_matches"><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="Grammar"/>
- <template-type-parameter name="Return"/>
- </template></struct><struct name="exact"><template>
+ </template><typedef
name="proto_is_vararg_"><type>void</type></typedef></struct><struct
name="exact"><template>
+ <template-type-parameter name="T"/>
+ </template></struct><struct name="if_"><template>
+ <template-type-parameter name="Condition"/>
+ <template-type-parameter name="Then"/>
+ <template-type-parameter name="Else"/>
+ </template><inherit access="public">boost::proto::or_< and_< if_<
Condition >, Then >, and_< not_< if_< Condition > >, Else
> ></inherit></struct><struct-specialization name="if_"><template>
+ <template-type-parameter name="Condition"/>
+ <template-type-parameter name="Then"/>
+
</template><specialization><template-arg>Condition</template-arg><template-arg>Then</template-arg><template-arg>void</template-arg></specialization><inherit
access="public">boost::proto::and_< if_< Condition >, Then
></inherit></struct-specialization><struct-specialization
name="if_"><template>
+ <template-type-parameter name="Condition"/>
+
</template><specialization><template-arg>Condition</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><inherit
access="public">boost::proto::has_identity_transform</inherit><typedef
name="proto_base_expr"><type><classname>if_</classname></type></typedef></struct-specialization><struct
name="convertible_to"><template>
<template-type-parameter name="T"/>
</template></struct></namespace></namespace></header><header
name="boost/xpressive/proto/operators.hpp"><para>Contains all the overloaded
operators that make it possible to build expression templates using proto
components </para><namespace name="boost"><namespace name="proto"><function
name="operator+"><type><emphasis>unspecified</emphasis></type><template>
<template-type-parameter name="Arg"/>
@@ -1765,11 +1766,15 @@
<template-type-parameter name="T"/>
<template-type-parameter name="Domain"/>
<template-type-parameter name="EnableIf"/>
- </template><typedef name="proto_arg0"><type>mpl::eval_if< mpl::or_<
boost::is_array< T >, is_function< T > >, add_reference< T
>, remove_cv< T >>::type</type></typedef><typedef
name="expr_type"><type>expr< <classname>proto::tag::terminal</classname>,
<classname>args0</classname>< proto_arg0 > ></type></typedef><typedef
name="type"><type>Domain::template apply< expr_type
>::type</type></typedef><typedef
name="result_type"><type>type</type></typedef><typedef
name="T2"><type>T</type></typedef><method-group name="public static
functions"><method name="call" cv=""><type>static result_type</type><parameter
name="t"><paramtype>T2
&</paramtype></parameter></method></method-group></struct><struct
name="as_arg"><template>
+ </template><typedef name="proto_arg0"><type>mpl::eval_if< mpl::or_<
boost::is_array< T >, is_function< T > >, add_reference< T
>, remove_cv< T >>::type</type></typedef><typedef
name="expr_type"><type>expr< <classname>proto::tag::terminal</classname>,
<classname>args0</classname>< proto_arg0 > ></type></typedef><typedef
name="type"><type>Domain::template apply< expr_type
>::type</type></typedef><typedef
name="result_type"><type>type</type></typedef><method-group name="public static
functions"><method name="call" cv=""><type>static result_type</type><template>
+ <template-type-parameter name="T2"/>
+ </template><parameter name="t"><paramtype>T2
&</paramtype></parameter></method></method-group></struct><struct
name="as_arg"><template>
<template-type-parameter name="T"/>
<template-type-parameter name="Domain"/>
<template-type-parameter name="EnableIf"/>
- </template><typedef name="expr_type"><type>expr<
<classname>proto::tag::terminal</classname>, <classname>args0</classname>< T
& > ></type></typedef><typedef name="type"><type>Domain::template
apply< expr_type >::type</type></typedef><typedef
name="T2"><type>T</type></typedef><method-group name="public static
functions"><method name="call" cv=""><type>static type</type><parameter
name="t"><paramtype>T2
&</paramtype></parameter></method></method-group></struct><struct
name="arg"><template>
+ </template><typedef name="expr_type"><type>expr<
<classname>proto::tag::terminal</classname>, <classname>args0</classname>< T
& > ></type></typedef><typedef name="type"><type>Domain::template
apply< expr_type >::type</type></typedef><method-group name="public
static functions"><method name="call" cv=""><type>static type</type><template>
+ <template-type-parameter name="T2"/>
+ </template><parameter name="t"><paramtype>T2
&</paramtype></parameter></method></method-group></struct><struct
name="arg"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="N"/>
</template><inherit access="public">arg_c< Expr, N::value
></inherit></struct><struct name="left"><template>
@@ -1803,10 +1808,14 @@
</template><specialization><template-arg>Expr
const</template-arg><template-arg>5</template-arg></specialization><inherit
access="public">boost::proto::result_of::arg_c< Expr, 5
></inherit></struct-specialization><struct-specialization
name="as_expr"><template>
<template-type-parameter name="T"/>
<template-type-parameter name="Domain"/>
-
</template><specialization><template-arg>T</template-arg><template-arg>Domain</template-arg><template-arg>typename
T::proto_is_expr_</template-arg></specialization><typedef
name="type"><type>T::proto_derived_expr</type></typedef><typedef
name="result_type"><type>T &</type></typedef><typedef
name="T2"><type>T</type></typedef><method-group name="public static
functions"><method name="call" cv=""><type>static result_type</type><parameter
name="t"><paramtype>T2
&</paramtype></parameter></method></method-group></struct-specialization><struct-specialization
name="as_arg"><template>
+
</template><specialization><template-arg>T</template-arg><template-arg>Domain</template-arg><template-arg>typename
T::proto_is_expr_</template-arg></specialization><typedef
name="type"><type>T::proto_derived_expr</type></typedef><typedef
name="result_type"><type>T &</type></typedef><method-group name="public
static functions"><method name="call" cv=""><type>static
result_type</type><template>
+ <template-type-parameter name="T2"/>
+ </template><parameter name="t"><paramtype>T2
&</paramtype></parameter></method></method-group></struct-specialization><struct-specialization
name="as_arg"><template>
<template-type-parameter name="T"/>
<template-type-parameter name="Domain"/>
-
</template><specialization><template-arg>T</template-arg><template-arg>Domain</template-arg><template-arg>typename
T::proto_is_expr_</template-arg></specialization><typedef
name="type"><type><classname>ref_</classname>< T
></type></typedef><typedef name="T2"><type>T</type></typedef><method-group
name="public static functions"><method name="call" cv=""><type>static
<classname>type</classname></type><parameter name="t"><paramtype>T2
&</paramtype></parameter></method></method-group></struct-specialization></namespace><data-member
name="left"><type><classname>functional::left</classname>
const</type></data-member><data-member
name="right"><type><classname>functional::right</classname>
const</type></data-member><overloaded-function
name="as_expr"><signature><type><classname>result_of::as_expr</classname>< T
>::result_type</type><template>
+
</template><specialization><template-arg>T</template-arg><template-arg>Domain</template-arg><template-arg>typename
T::proto_is_expr_</template-arg></specialization><typedef
name="type"><type><classname>ref_</classname>< T
></type></typedef><method-group name="public static functions"><method
name="call" cv=""><type>static <classname>type</classname></type><template>
+ <template-type-parameter name="T2"/>
+ </template><parameter name="t"><paramtype>T2
&</paramtype></parameter></method></method-group></struct-specialization></namespace><data-member
name="left"><type><classname>functional::left</classname>
const</type></data-member><data-member
name="right"><type><classname>functional::right</classname>
const</type></data-member><overloaded-function
name="as_expr"><signature><type><classname>result_of::as_expr</classname>< T
>::result_type</type><template>
<template-type-parameter name="T"/>
</template><parameter name="t"><paramtype>T
&</paramtype></parameter></signature><signature><type><classname>result_of::as_expr</classname><
T const >::result_type</type><template>
<template-type-parameter name="T"/>
@@ -1966,11 +1975,7 @@
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><parameter name="expr"><paramtype>Expr const
&</paramtype></parameter><parameter name="state"><paramtype>State const
&</paramtype></parameter><parameter name="visitor"><paramtype>Visitor
&</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header
name="boost/xpressive/proto/transform/conditional.hpp"><para>A special-purpose
proto transform for selecting between two transforms based on a compile-time
predicate. </para><namespace name="boost"><namespace name="proto"><namespace
name="transform"><struct name="conditional"><template>
- <template-type-parameter name="Predicate"/>
- <template-type-parameter name="Grammar0"/>
- <template-type-parameter name="Grammar1"/>
- </template><inherit access="public">boost::proto::or_< proto::and_<
proto::if_< Predicate >, Grammar0 >, proto::and_< proto::not_<
proto::if_< Predicate > >, Grammar1 >
></inherit></struct></namespace></namespace></namespace></header><header
name="boost/xpressive/proto/transform/construct.hpp"><para>For constructing an
arbitrary type from a bunch of transforms. </para><namespace
name="boost"><namespace name="proto"><namespace
name="transform"><struct-specialization name="construct"><template>
+ </template><parameter name="expr"><paramtype>Expr const
&</paramtype></parameter><parameter name="state"><paramtype>State const
&</paramtype></parameter><parameter name="visitor"><paramtype>Visitor
&</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header
name="boost/xpressive/proto/transform/construct.hpp"><para>For constructing an
arbitrary type from a bunch of transforms. </para><namespace
name="boost"><namespace name="proto"><namespace
name="transform"><struct-specialization name="construct"><template>
<template-type-parameter name="Grammar"/>
<template-type-parameter name="Result"/>
</template><specialization><template-arg>Grammar</template-arg><template-arg>Result()</template-arg></specialization><struct
name="apply"><template>
@@ -2071,7 +2076,7 @@
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Visitor"/>
- </template><parameter name="expr"><paramtype>Expr const
&</paramtype></parameter><parameter name="state"><paramtype>State const
&</paramtype></parameter><parameter name="visitor"><paramtype>Visitor
&</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header
name="boost/xpressive/proto/transform/fold_to_list.hpp"><para>A higher-level
transform that uses the fold, branch and list transforms to fold a binary tree
into a fusion cons-list. </para><namespace name="boost"><namespace
name="proto"><namespace name="transform"><struct name="fold_tree"><template>
+ </template><parameter name="expr"><paramtype>Expr const
&</paramtype></parameter><parameter name="state"><paramtype>State const
&</paramtype></parameter><parameter name="visitor"><paramtype>Visitor
&</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header
name="boost/xpressive/proto/transform/fold_tree.hpp"><para>A higher-level
transform that uses the fold, and branch transforms to recursively fold a tree.
</para><namespace name="boost"><namespace name="proto"><namespace
name="transform"><struct name="fold_tree"><template>
<template-type-parameter name="Tag"/>
<template-type-parameter name="Grammar"/>
<template-type-parameter
name="State"><default>void</default></template-type-parameter>
@@ -2085,11 +2090,7 @@
</template><description><para>reverse_fold_tree
</para></description></struct><struct-specialization
name="reverse_fold_tree"><template>
<template-type-parameter name="Tag"/>
<template-type-parameter name="Grammar"/>
-
</template><specialization><template-arg>Tag</template-arg><template-arg>Grammar</template-arg><template-arg>void</template-arg></specialization></struct-specialization><struct
name="fold_to_list"><template>
- <template-type-parameter name="Grammar"/>
- </template><inherit access="public">boost::proto::transform::fold_tree<
Grammar::proto_tag, transform::list< Grammar::proto_arg0 >, fusion::nil
></inherit><description><para>fold_to_list TODO Find a cleaner interface
</para></description><data-member name="mpl_assertion_in_line_95"
specifiers="static"><type>const
std::size_t</type></data-member></struct><struct
name="reverse_fold_to_list"><template>
- <template-type-parameter name="Grammar"/>
- </template><inherit
access="public">boost::proto::transform::reverse_fold_tree<
Grammar::proto_tag, transform::list< Grammar::proto_arg0 >, fusion::nil
></inherit><description><para>reverse_fold_to_list TODO Find a cleaner
interface </para></description><data-member name="mpl_assertion_in_line_113"
specifiers="static"><type>const
std::size_t</type></data-member></struct></namespace></namespace></namespace></header><header
name="boost/xpressive/proto/transform/list.hpp"><para>A special-purpose proto
transform for putting things into a fusion::cons<> list.
</para><namespace name="boost"><namespace name="proto"><namespace
name="transform"><struct name="list"><template>
+
</template><specialization><template-arg>Tag</template-arg><template-arg>Grammar</template-arg><template-arg>void</template-arg></specialization></struct-specialization></namespace></namespace></namespace></header><header
name="boost/xpressive/proto/transform/list.hpp"><para>A special-purpose proto
transform for putting things into a fusion::cons<> list.
</para><namespace name="boost"><namespace name="proto"><namespace
name="transform"><struct name="list"><template>
<template-type-parameter name="Grammar"/>
</template><struct name="apply"><template>
<template-type-parameter name="Expr"/>
-------------------------------------------------------------------------
This SF.net email is sponsored by DB2 Express
Download DB2 Express C - the FREE version of DB2 express and take
control of your XML. No limits. Just data. Click to get it now.
http://sourceforge.net/powerbar/db2/
_______________________________________________
Boost-cvs mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/boost-cvs
