Update of /cvsroot/boost/boost/libs/xpressive/proto/doc
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv13134
Modified Files:
grammars.qbk installation.qbk proto.qbk quick_start.qbk
Log Message:
documentation tweaks based on user feedback
Index: grammars.qbk
===================================================================
RCS file: /cvsroot/boost/boost/libs/xpressive/proto/doc/grammars.qbk,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- grammars.qbk 29 Apr 2007 03:38:49 -0000 1.8
+++ grammars.qbk 5 May 2007 06:27:40 -0000 1.9
@@ -251,9 +251,9 @@
The _if_ template is used together with an MPL lambda expression, which is
evaluated against expression types to find matches. The _and_ template is like
-_or_, except that each alternate must match in order for the _and_ to match.
-As an example, consider the definition of `CharString` above that uses _exact_.
-It could have been written without _exact_ as follows:
+_or_, except that each argument of the _and_ must match in order for the _and_
+to match. As an example, consider the definition of `CharString` above that
+uses _exact_. It could have been written without _exact_ as follows:
struct CharString
: and_<
Index: installation.qbk
===================================================================
RCS file: /cvsroot/boost/boost/libs/xpressive/proto/doc/installation.qbk,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- installation.qbk 15 Apr 2007 06:46:57 -0000 1.2
+++ installation.qbk 5 May 2007 06:27:40 -0000 1.3
@@ -31,6 +31,8 @@
* Visual C++ 7.1 and higher
* GNU C++ 3.2 and higher
+* Intel on Linun 8.1 and higher
+* Intel on Windows 9.1 and higher
[note Please send any questions, comments and bug reports to eric <at>
boost-consulting <dot> com.]
Index: proto.qbk
===================================================================
RCS file: /cvsroot/boost/boost/libs/xpressive/proto/doc/proto.qbk,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -d -r1.14 -r1.15
--- proto.qbk 30 Apr 2007 23:54:15 -0000 1.14
+++ proto.qbk 5 May 2007 06:27:40 -0000 1.15
@@ -38,7 +38,7 @@
[def _spirit_fx_ [EMAIL PROTECTED]://spirit.sourceforge.net Spirit
Parser Framework]]
[def _spirit_ [EMAIL PROTECTED]://spirit.sourceforge.net Spirit]]
[def _xpressive_ [EMAIL
PROTECTED]/../../libs/xpressive/doc/index.html Boost.Xpressive]]
-[def _expr_ `expr<>`]
+[def _expr_ [classref boost::proto::expr<Tag,Args,1> `expr<>`]]
[def _ref_ [classref boost::proto::ref_ `ref_<>`]]
[def _unref_ [classref boost::proto::op::unref `unref()`]]
[def _deep_copy_ [classref boost::proto::op::deep_copy
`deep_copy()`]]
Index: quick_start.qbk
===================================================================
RCS file: /cvsroot/boost/boost/libs/xpressive/proto/doc/quick_start.qbk,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -d -r1.9 -r1.10
--- quick_start.qbk 30 Apr 2007 23:54:15 -0000 1.9
+++ quick_start.qbk 5 May 2007 06:27:40 -0000 1.10
@@ -45,27 +45,38 @@
This program builds an object representing the output operation and passes
it to an `evaluate()` function, which then executes it.
-Notice that in order to build a Proto expression template, at least one
-argument in the expression must be a Proto-ified. In this case, that is done
-with the _terminal_ class template, which is used to wrap `std::cout`. That
-"infects" the expression, and brings Proto's operator overloads into
-consideration. Any literals in the expression are then Proto-ified by wrapping
-them in a Proto terminal before they are combined into larger Proto
-expressions. The use of _default_context_ assigns the standard meanings to the
-operators in the expression. (By using a different context, you could give
-the operators in your expressions different semantics. By default, Proto
-makes no assumptions about what operators actually /mean/.)
+The basic idea of expression templates is to overload all the operators so
+that, rather than evaluating the expression immediately, they build a tree-like
+representation of the expression so that it can be evaluated later. For each
+operator in an expression, at least one operand must be Proto-ified in order
+for Proto's operator overloads to be found. In the expression ...
+
+ cout_ << "hello" << ',' << " world"
+
+... the Proto-ified sub-expression is `cout_`, which is the Proto-ification of
+`std::cout`. The presence of `cout_` "infects" the expression, and brings
+Proto's tree-building operator overloads into consideration. Any literals in
+the expression are then Proto-ified by wrapping them in a Proto terminal before
+they are combined into larger Proto expressions.
+
+Once Proto's operator overloads have built the expression tree, the expression
+can be lazily evaluated later by walking the tree. That is what `proto::eval()`
+does. It is a general tree-walking expression evaluator, whose behavior is
+customizable via a /context/ parameter. The use of _default_context_ assigns
+the standard meanings to the operators in the expression. (By using a different
+context, you could give the operators in your expressions different semantics.
+By default, Proto makes no assumptions about what operators actually /mean/.)
+
+[note [*Proto Design Philosophy]
-[blurb [*Proto Design Philosophy]\n
-\n
Before we continue, let's use the above example to illustrate an important
design principle of Proto's. The expression template created in the ['hello
world] example is totally general and abstract. It is not tied in any way to
any particular domain or application, nor does it have any particular meaning
or behavior on its own, until it is evaluated in a /context/. Expression
templates are really just heterogeneous trees, which might mean something in
-one domain, and something else entirely in a different one.\n
-\n
+one domain, and something else entirely in a different one.
+
As we'll see later, there is a way to create Proto expression trees that are
['not] purely abstract, and that have meaning and behaviors independent of any
context. There is also a way to control which operators are overloaded for your
@@ -81,11 +92,11 @@
[[_expr_] [The structure from which Proto's expression
trees are built.]]
[[_arg_, _arg_c_] [For extracting the ['N]th child expression
- from a proto expression tree.]]
+ from a Proto expression tree.]]
[[_left_, _right_] [For extracting the left or right child
- expression from a binary proto expression
+ expression from a binary Proto expression
tree.]]
- [[_eval_] [A proto expression evaluator. Given an
+ [[_eval_] [A Proto expression evaluator. Given an
expression and a /context/, it evaluates
the expression in that context.]]
[[_default_context_] [An evaluation context for use with _eval_
@@ -137,7 +148,7 @@
expressions are in a Fusion sequence.]]
]
-Now that you know a bit about the tools proto provides, let's look at how to
+Now that you know a bit about the tools Proto provides, let's look at how to
use them to implement some domain-specific embedded languages.
[endsect]
-------------------------------------------------------------------------
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
