This commit was manufactured by cvs2svn to create tag

'Version_1_28_0'. [SVN r13949]
adding dummy usages of some arugments to avoid unused argument warnings
2026-01-21 17:02:36 +00:00 · 2002-05-16 13:26:18 +00:00 · 2002-05-15 17:16:52 +00:00 · 2002-05-10 04:34:27 +00:00
49 changed files with 2718 additions and 1214 deletions
--- a/doc/apa.html
+++ b/doc/apa.html
@@ -5,7 +5,7 @@
      The Boost Lambda Library"><link rel="up" href="index.html" title="
      C++ BOOST

-      The Boost Lambda Library"><link rel="previous" href="ar01s09.html" title="9. Contributors"><link rel="next" href="bi01.html" title="Bibliography"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">A. Rationale for some of the design decisions</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s09.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="bi01.html">Next</a></td></tr></table><hr></div><div class="appendix"><h2 class="title" style="clear: both"><a name="id2808845"></a>A. Rationale for some of the design decisions</h2><div class="section"><div class="titlepage"><div><h3 class="title"><a name="sect:why_weak_arity"></a>1. 
+      The Boost Lambda Library"><link rel="previous" href="ar01s09.html" title="9. Contributors"><link rel="next" href="bi01.html" title="Bibliography"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">A. Rationale for some of the design decisions</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s09.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="bi01.html">Next</a></td></tr></table><hr></div><div class="appendix"><h2 class="title" style="clear: both"><a name="id2808790"></a>A. Rationale for some of the design decisions</h2><div class="section"><div class="titlepage"><div><h3 class="title"><a name="sect:why_weak_arity"></a>1. 
 Lambda functor arity
 </h3></div></div><p>
 The highest placeholder index in a lambda expression determines the arity of the resulting function object.
--- a/doc/ar01s02.html
+++ b/doc/ar01s02.html
@@ -8,7 +8,7 @@
      The Boost Lambda Library"><link rel="previous" href="index.html" title="
      C++ BOOST

-      The Boost Lambda Library"><link rel="next" href="ar01s03.html" title="3. Introduction"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">2. Getting Started</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="index.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="ar01s03.html">Next</a></td></tr></table><hr></div><div class="section"><div class="titlepage"><div><h2 class="title" style="clear: both"><a name="sect:getting_started"></a>2. Getting Started</h2></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2790118"></a>2.1. Installing the library</h3></div></div><p>
+      The Boost Lambda Library"><link rel="next" href="ar01s03.html" title="3. Introduction"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">2. Getting Started</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="index.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="ar01s03.html">Next</a></td></tr></table><hr></div><div class="section"><div class="titlepage"><div><h2 class="title" style="clear: both"><a name="sect:getting_started"></a>2. Getting Started</h2></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2790112"></a>2.1. Installing the library</h3></div></div><p>
 	The library consists of include files only, hence there is no
 	installation procedure. The <tt>boost</tt> include directory
 	must be on the include path.
@@ -44,7 +44,7 @@ Cast expressions
 	<span class="emphasis"><i>Tuple</i></span> [<a href="bi01.html#cit:boost::tuple" title="[tuple]">tuple</a>] and the <span class="emphasis"><i>type_traits</i></span> [<a href="bi01.html#cit:boost::type_traits" title="[type_traits]">type_traits</a>] libraries, and on the <tt>boost/ref.hpp</tt> header.
      </p><p>
 	All definitions are placed in the namespace <tt>boost::lambda</tt> and its subnamespaces.
-      </p></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2741945"></a>2.2. Conventions used in this document</h3></div></div><p>In most code examples, we omit the namespace prefixes for names in the <tt>std</tt> and <tt>boost::lambda</tt> namespaces.
+      </p></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2742981"></a>2.2. Conventions used in this document</h3></div></div><p>In most code examples, we omit the namespace prefixes for names in the <tt>std</tt> and <tt>boost::lambda</tt> namespaces.
 Implicit using declarations
 <pre class="programlisting">
 using namespace std;
--- a/doc/ar01s03.html
+++ b/doc/ar01s03.html
@@ -5,7 +5,7 @@
      The Boost Lambda Library"><link rel="up" href="index.html" title="
      C++ BOOST

-      The Boost Lambda Library"><link rel="previous" href="ar01s02.html" title="2. Getting Started"><link rel="next" href="ar01s04.html" title="4. Using the library"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">3. Introduction</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s02.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="ar01s04.html">Next</a></td></tr></table><hr></div><div class="section"><div class="titlepage"><div><h2 class="title" style="clear: both"><a name="id2741991"></a>3. Introduction</h2></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2741999"></a>3.1. Motivation</h3></div></div><p>The Standard Template Library (STL)
+      The Boost Lambda Library"><link rel="previous" href="ar01s02.html" title="2. Getting Started"><link rel="next" href="ar01s04.html" title="4. Using the library"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">3. Introduction</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s02.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="ar01s04.html">Next</a></td></tr></table><hr></div><div class="section"><div class="titlepage"><div><h2 class="title" style="clear: both"><a name="id2743023"></a>3. Introduction</h2></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2743030"></a>3.1. Motivation</h3></div></div><p>The Standard Template Library (STL)
 	[<a href="bi01.html#cit:stepanov:94" title="[STL94]">STL94</a>], now part of the C++ Standard Library [<a href="bi01.html#cit:c++:98" title="[C++98]">C++98</a>], is a generic container and algorithm library.
 Typically STL algorithms operate on container elements via <span class="emphasis"><i>function objects</i></span>. These function objects are passed as arguments to the algorithms.
 </p><p>
@@ -105,7 +105,7 @@ as function composition is supported implicitly.

 </p></li></ul></div>

-</p></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2742792"></a>3.2. Introduction to lambda expressions</h3></div></div><p>
+</p></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2741479"></a>3.2. Introduction to lambda expressions</h3></div></div><p>
 	Lambda expression are common in functional programming languages. 
 	Their syntax varies between languages (and between different forms of lambda calculus), but the basic form of a lambda expressions is:

--- a/doc/ar01s04.html
+++ b/doc/ar01s04.html
@@ -20,12 +20,12 @@ There are quite a lot of exceptions and special cases, but discussion of them is
 list&lt;int&gt; v(10);
 for_each(v.begin(), v.end(), _1 = 1);</pre>

-	The expression <tt>_1 = 1</tt> creates a lambda functor which assigns the value <tt>1</tt> to every element in <tt>v</tt>.<sup>[<a name="id2739596" href="#ftn.id2739596">1</a>]</sup>
+	The expression <tt>_1 = 1</tt> creates a lambda functor which assigns the value <tt>1</tt> to every element in <tt>v</tt>.<sup>[<a name="id2739736" href="#ftn.id2739736">1</a>]</sup>
      </p><p>
 	Next, we create a container of pointers and make them point to the elements in the first container <tt>v</tt>:

 	<pre class="programlisting">
-vector&lt;int*&gt; vp(10); 
+list&lt;int*&gt; vp(10); 
 transform(v.begin(), v.end(), vp.begin(), &amp;_1);</pre>

 The expression <tt>&amp;_1</tt> creates a function object for getting the address of each element in <tt>v</tt>.
@@ -122,18 +122,19 @@ in the lambda functor.
 This means that the value of a bound argument is fixed at the time of the 
 creation of the lambda function and remains constant during the lifetime 
 of the lambda function object.
+
 For example:
+
 <pre class="programlisting">
 int i = 1;
-(_1 = 2, _1 + i)(i);
+(_1 + i)(i = 2);
 </pre>
-The comma operator is overloaded to combine lambda expressions into a sequence;
-the resulting unary lambda functor first assigns 2 to its argument, 
-then adds the value of <tt>i</tt> to it.
+
 The value of the expression in the last line is 3, not 4. 
-In other words, the lambda expression that is created is
-<tt>lambda x.(x = 2, x + 1)</tt> rather than
-<tt>lambda x.(x = 2, x + i)</tt>.
+
+In other words, the lambda expression <tt>_1 + i</tt> creates 
+a lambda function <tt>lambda x.x+1</tt> rather than 
+<tt>lambda x.x+i</tt>.
      
 </p><p>

@@ -151,12 +152,12 @@ or as a reference to const respectively.

 For example, if we rewrite the previous example and wrap the variable 
 <tt>i</tt> with <tt>ref</tt>, 
-we are creating the lambda expression <tt>lambda x.(x = 2, x + i)</tt> 
+we are creating the lambda expression <tt>lambda x.x+i</tt> 
 and the value of the expression in the last line will be 4:

 <pre class="programlisting">
 i = 1;
-(_1 = 2, _1 + ref(i))(i);
+(_1 + ref(i))(i = 2);
 </pre>

 Note that <tt>ref</tt> and <tt>cref</tt> are different
@@ -205,7 +206,7 @@ This is to prevent pointer arithmetic making non-const arrays const.
 </p></li></ul></div>

 </p></li></ul></div>
-</p></div><div class="footnotes"><br><hr width="100" align="left"><div class="footnote"><p><sup>[<a name="ftn.id2739596" href="#id2739596">1</a>] </sup>
+</p></div><div class="footnotes"><br><hr width="100" align="left"><div class="footnote"><p><sup>[<a name="ftn.id2739736" href="#id2739736">1</a>] </sup>
 Strictly taken, the C++ standard defines <tt>for_each</tt> as a <span class="emphasis"><i>non-modifying sequence operation</i></span>, and the function object passed to <tt>for_each</tt> should not modify its argument. 
 The requirements for the arguments of <tt>for_each</tt> are unnecessary strict, since as long as the iterators are <span class="emphasis"><i>mutable</i></span>, <tt>for_each</tt> accepts a function object that can have side-effects on their argument.
 Nevertheless, it is straightforward to provide another function template with the functionality of<tt>std::for_each</tt> but more fine-grained requirements for its arguments.
--- a/doc/ar01s05.html
+++ b/doc/ar01s05.html
@@ -10,6 +10,7 @@ This section describes different categories of lambda expressions in details.
 We devote a separate section for each of the possible forms of a lambda expression.


+
 </p><div class="section"><div class="titlepage"><div><h3 class="title"><a name="sect:placeholders"></a>5.1. Placeholders</h3></div></div><p>
 The BLL defines three placeholder types: <tt>placeholder1_type</tt>, <tt>placeholder2_type</tt> and <tt>placeholder3_type</tt>. 
 BLL has a predefined placeholder variable for each placeholder type: <tt>_1</tt>, <tt>_2</tt> and <tt>_3</tt>. 
@@ -77,7 +78,7 @@ For example, the following is a valid lambda expression:
 <pre class="programlisting">cout &lt;&lt; _1, _2[_3] = _1 &amp;&amp; false</pre>
 </p><p>
 However, there are some restrictions that originate from the C++ operator overloading rules, and some special cases.
-</p><div class="section"><div class="titlepage"><div><h4 class="title"><a name="id2740648"></a>5.2.1. Operators that cannot be overloaded</h4></div></div><p>
+</p><div class="section"><div class="titlepage"><div><h4 class="title"><a name="id2740751"></a>5.2.1. Operators that cannot be overloaded</h4></div></div><p>
 Some operators cannot be overloaded at all (<tt>::</tt>, <tt>.</tt>, <tt>.*</tt>).
 For some operators, the requirements on return types prevent them to be overloaded to create lambda functors.
 These operators are <tt>-&gt;.</tt>, <tt>-&gt;</tt>, <tt>new</tt>, <tt>new[]</tt>, <tt>delete</tt>, <tt>delete[]</tt> and <tt>?:</tt> (the conditional operator).
@@ -242,7 +243,6 @@ This creates some asymmetry between the lambda functor and the original member f
 class A {
  int i; mutable int j;
 public:
-
  A(int ii, int jj) : i(ii), j(jj) {};
  void set_i(int x) { i = x; }; 
  void set_j(int x) const { j = x; }; 
@@ -281,59 +281,19 @@ A a(0,0);
 bind(&amp;A::set_i, _1, 1)(a); // a.i == 1
 bind(&amp;A::set_j, _1, 1)(a); // a.j == 1
 </pre>
-</p></div><div class="section"><div class="titlepage"><div><h4 class="title"><a name="sect:members_variables_as_targets"></a>5.3.3. Member variables as targets</h4></div></div><p>
-A pointer to a member variable is not really a function, but 
-the first argument to the <tt>bind</tt> function can nevertheless
-be a pointer to a member variable.
-Invoking such a bind expression returns a reference to the data member.
-For example:
-
-<pre class="programlisting">
-struct A { int data; };
-A a;
-bind(&amp;A::data, _1)(a) = 1;     // a.data == 1
-</pre>
-
-The cv-qualifiers of the object whose member is accessed are respected.
-For example, the following tries to write into a const location:
-<pre class="programlisting">
-const A ca = a;
-bind(&amp;A::data, _1)(ca) = 1;     // error
-</pre>
-
-</p></div><div class="section"><div class="titlepage"><div><h4 class="title"><a name="sect:function_objects_as_targets"></a>5.3.4. Function objects as targets</h4></div></div><p>
+</p></div><div class="section"><div class="titlepage"><div><h4 class="title"><a name="sect:function_objects_as_targets"></a>5.3.3. Function objects as targets</h4></div></div><p>

 Function objects, that is, class objects which have the function call 
 operator defined, can be used as target functions. 

 In general, BLL cannot deduce the return type of an arbitrary function object. 

-However, there are two methods for giving BLL this capability for a certain 
+However, there is a method for giving BLL this capability for a certain 
 function object class.

-</p><div class="simplesect"><div class="titlepage"><div><h5 class="title"><a name="id2803250"></a>The result_type typedef</h5></div></div><p>
-
-The BLL supports the standard library convention of declaring the return type
-of a function object with a member typedef named <tt>result_type</tt> in the
-function object class.
-
-Here is a simple example:
-<pre class="programlisting">
-struct A {
-  typedef B result_type;
-  B operator()(X, Y, Z); 
-};
-</pre>
-
-If a function object does not define a <tt>result_type</tt> typedef, 
-the method described below (<tt>sig</tt> template) 
-is attempted to resolve the return type of the
-function object. If a function object defines both <tt>result_type</tt>
-and <tt>sig</tt>, <tt>result_type</tt> takes precedence.
-
-</p></div><div class="simplesect"><div class="titlepage"><div><h5 class="title"><a name="id2803321"></a>The sig template</h5></div></div><p>
-Another mechanism that make BLL aware of the return type(s) of a function object is defining
-member template struct 
+</p><div class="simplesect"><div class="titlepage"><div><h5 class="title"><a name="id2803214"></a>The sig template</h5></div></div><p>
+To make BLL aware of the return type(s) of a function object one needs to 
+provide a member template struct 
 <tt>sig&lt;Args&gt;</tt> with a typedef 
 <tt>type</tt> that specifies the return type.

@@ -352,7 +312,9 @@ is the function
 object type itself, and the remaining elements are the types of 
 the arguments, with which the function object is being called.

-This may seem overly complex compared to defining the <tt>result_type</tt> typedef.
+This may seem overly complex compared to the Standard Library 
+convention for defining the return type of a function
+object with  the <tt>return_type</tt> typedef.
 Howver, there are two significant restrictions with using just a simple
 typedef to express the return type:
 <div class="orderedlist"><ol type="1"><li><p>
@@ -414,7 +376,25 @@ for tools that can aid in these tasks.
 The <tt>sig</tt> templates are a refined version of a similar
 mechanism first introduced in the FC++ library  
 [<a href="bi01.html#cit:fc++" title="[fc++]">fc++</a>].
-</p></div></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="sect:overriding_deduced_return_type"></a>5.4. Overriding the deduced return type</h3></div></div><p>
+</p></div><p>
+Earlier versions of the library supported the Standard Library convention
+as the default, and required special actions to make the library recognize
+the <tt>sig</tt> template. 
+Now the BLL has that reversed.
+
+If one needs to use a functor that adheres to the Standard Library
+convention in a bind expression, we provide the <tt>std_functor</tt>
+wrapper, that gives the function object a <tt>sig</tt>
+template based on the <tt>result_type</tt> typedef.
+For example:
+
+<pre class="programlisting">
+int i = 1;
+bind(plus&lt;int&gt;(), _1, 1)(i);              // error, no sig template
+bind(std_functor(plus&lt;int&gt;()), _1, 1)(i); // ok
+</pre>
+
+</p></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="sect:overriding_deduced_return_type"></a>5.4. Overriding the deduced return type</h3></div></div><p>
 The return type deduction system may not be able to deduce the return types of some user defined operators or bind expressions with class objects.

 A special lambda expression type is provided for stating the return type explicitly and overriding the deduction system. 
@@ -533,7 +513,7 @@ By using <tt>var</tt> to make <tt>index</tt> a lambda expression, we get the des
 In sum, <tt>var(x)</tt> creates a nullary lambda functor, 
 which stores a reference to the variable <tt>x</tt>. 
 When the lambda functor is invoked, a reference to <tt>x</tt> is returned.
-</p><div class="simplesect"><div class="titlepage"><div><h4 class="title"><a name="id2804115"></a>Naming delayed constants and variables</h4></div></div><p>
+</p><div class="simplesect"><div class="titlepage"><div><h4 class="title"><a name="id2804059"></a>Naming delayed constants and variables</h4></div></div><p>
 It is possible to predefine and name a delayed variable or constant outside a lambda expression. 
 The templates <tt>var_type</tt>, <tt>constant_type</tt> 
 and <tt>constant_ref_type</tt> serve for this purpose. 
@@ -562,7 +542,7 @@ Here is an example of naming a delayed constant:
 constant_type&lt;char&gt;::type space(constant(' '));
 for_each(a.begin(),a.end(), cout &lt;&lt; space &lt;&lt; _1);
 </pre>
-</p></div><div class="simplesect"><div class="titlepage"><div><h4 class="title"><a name="id2804238"></a>About assignment and subscript operators</h4></div></div><p>
+</p></div><div class="simplesect"><div class="titlepage"><div><h4 class="title"><a name="id2804183"></a>About assignment and subscript operators</h4></div></div><p>
 As described in <a href="ar01s05.html#sect:assignment_and_subscript" title="5.2.2. Assignment and subscript operators">Section 5.2.2</a>, assignment and subscripting operators are always defined as member functions.
 This means, that for expressions of the form
 <tt>x = y</tt> or <tt>x[y]</tt> to be interpreted as lambda expressions, the left-hand operand <tt>x</tt> must be a lambda expression. 
@@ -635,7 +615,13 @@ for_each(a, a+5,
 The BLL supports an alternative syntax for control expressions, suggested
 by Joel de Guzmann. 
 By overloading the <tt>operator[]</tt> we can
-get a closer resemblance with the built-in control structures:
+get a closer resemblance with the built-in control structures. 
+For example, using this syntax the <tt>if_then</tt> example above
+can be written as:
+<pre class="programlisting">
+for_each(a.begin(), a.end(), 
+         if(_1 % 2 == 0)[ cout &lt;&lt; _1 ])  
+</pre>

 <pre class="programlisting">
 if_(condition)[then_part]
@@ -645,13 +631,6 @@ do_[body].while_(condition)
 for_(init, condition, increment)[body]
 </pre>

-For example, using this syntax the <tt>if_then</tt> example above
-can be written as:
-<pre class="programlisting">
-for_each(a.begin(), a.end(), 
-         if_(_1 % 2 == 0)[ cout &lt;&lt; _1 ])  
-</pre>
-
 As more experience is gained, we may end up deprecating one or the other 
 of these syntaces. 

@@ -850,7 +829,7 @@ objects related to creating and destroying objects,
 showing the expression to create and call the function object, 
 and the effect of evaluating that expression.

-</p><div class="table"><p><a name="table:constructor_destructor_fos"></a><b>Table 1. Construction and destruction related function objects.</b></p><table summary="Construction and destruction related function objects." border="1"><colgroup><col><col></colgroup><thead><tr><th>Function object call</th><th>Wrapped expression</th></tr></thead><tbody><tr><td><tt>constructor&lt;T&gt;()(<i><tt>arg_list</tt></i>)</tt></td><td>T(<i><tt>arg_list</tt></i>)</td></tr><tr><td><tt>destructor()(a)</tt></td><td><tt>a.~A()</tt>, where <tt>a</tt> is of type <tt>A</tt></td></tr><tr><td><tt>destructor()(pa)</tt></td><td><tt>pa-&gt;~A()</tt>, where <tt>pa</tt> is of type <tt>A*</tt></td></tr><tr><td><tt>new_ptr&lt;T&gt;()(<i><tt>arg_list</tt></i>)</tt></td><td><tt>new T(<i><tt>arg_list</tt></i>)</tt></td></tr><tr><td><tt>new_array&lt;T&gt;()(sz)</tt></td><td><tt>new T[sz]</tt></td></tr><tr><td><tt>delete_ptr()(p)</tt></td><td><tt>delete p</tt></td></tr><tr><td><tt>delete_array()(p)</tt></td><td><tt>delete p[]</tt></td></tr></tbody></table></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2805507"></a>5.9. Special lambda expressions</h3></div></div><div class="section"><div class="titlepage"><div><h4 class="title"><a name="id2805514"></a>5.9.1. Preventing argument substitution</h4></div></div><p>
+</p><div class="table"><p><a name="table:constructor_destructor_fos"></a><b>Table 1. Construction and destruction related function objects.</b></p><table summary="Construction and destruction related function objects." border="1"><colgroup><col><col></colgroup><thead><tr><th>Function object call</th><th>Wrapped expression</th></tr></thead><tbody><tr><td><tt>constructor&lt;T&gt;()(<i><tt>arg_list</tt></i>)</tt></td><td>T(<i><tt>arg_list</tt></i>)</td></tr><tr><td><tt>destructor()(a)</tt></td><td><tt>a.~A()</tt>, where <tt>a</tt> is of type <tt>A</tt></td></tr><tr><td><tt>destructor()(pa)</tt></td><td><tt>pa.-&gt;A()</tt>, where <tt>pa</tt> is of type <tt>A*</tt></td></tr><tr><td><tt>new_ptr&lt;T&gt;()(<i><tt>arg_list</tt></i>)</tt></td><td><tt>new T(<i><tt>arg_list</tt></i>)</tt></td></tr><tr><td><tt>new_array&lt;T&gt;()(sz)</tt></td><td><tt>new T[sz]</tt></td></tr><tr><td><tt>delete_ptr()(p)</tt></td><td><tt>delete p</tt></td></tr><tr><td><tt>delete_array()(p)</tt></td><td><tt>delete p[]</tt></td></tr></tbody></table></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2805452"></a>5.9. Special lambda expressions</h3></div></div><div class="section"><div class="titlepage"><div><h4 class="title"><a name="id2805459"></a>5.9.1. Preventing argument substitution</h4></div></div><p>
 When a lambda functor is called, the default behavior is to substitute 
 the actual arguments for the placeholders within all subexpressions.

@@ -976,7 +955,7 @@ int nested(const F&amp; f) {
 }
 </pre>

-</p></div><div class="section"><div class="titlepage"><div><h5 class="title"><a name="id2805774"></a>5.9.1.2. Protect</h5></div></div><p>
+</p></div><div class="section"><div class="titlepage"><div><h5 class="title"><a name="id2805719"></a>5.9.1.2. Protect</h5></div></div><p>
 The <tt>protect</tt> function is related to unlambda. 

 It is also used to prevent the argument substitution taking place, 
@@ -1081,7 +1060,7 @@ since calls to sub lambda functors are made inside the BLL,
 and are not affected by the non-const rvalue problem.
 </p></li></ol></div>

-</p></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2806080"></a>5.10. Casts, sizeof and typeid</h3></div></div><div class="section"><div class="titlepage"><div><h4 class="title"><a name="sect:cast_expressions"></a>5.10.1. 
+</p></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2806025"></a>5.10. Casts, sizeof and typeid</h3></div></div><div class="section"><div class="titlepage"><div><h4 class="title"><a name="sect:cast_expressions"></a>5.10.1. 
 Cast expressions
 </h4></div></div><p>
 The BLL defines its counterparts for the four cast expressions 
@@ -1110,7 +1089,7 @@ int count = 0;
 for_each(a.begin(), a.end(), 
         if_then(ll_dynamic_cast&lt;derived*&gt;(_1), ++var(count)));
 </pre>
-</p></div><div class="section"><div class="titlepage"><div><h4 class="title"><a name="id2806181"></a>5.10.2. Sizeof and typeid</h4></div></div><p>
+</p></div><div class="section"><div class="titlepage"><div><h4 class="title"><a name="id2806127"></a>5.10.2. Sizeof and typeid</h4></div></div><p>
 The BLL counterparts for these expressions are named 
 <tt>ll_sizeof</tt> and <tt>ll_typeid</tt>.

--- a/doc/ar01s07.html
+++ b/doc/ar01s07.html
@@ -5,7 +5,7 @@
      The Boost Lambda Library"><link rel="up" href="index.html" title="
      C++ BOOST

-      The Boost Lambda Library"><link rel="previous" href="ar01s06.html" title="6. Extending return type deduction system"><link rel="next" href="ar01s08.html" title="8. Relation to other Boost libraries"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">7. Practical considerations</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s06.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="ar01s08.html">Next</a></td></tr></table><hr></div><div class="section"><div class="titlepage"><div><h2 class="title" style="clear: both"><a name="id2807588"></a>7. Practical considerations</h2></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2807595"></a>7.1. Performance</h3></div></div><p>In theory, all overhead of using STL algorithms and lambda functors 
+      The Boost Lambda Library"><link rel="previous" href="ar01s06.html" title="6. Extending return type deduction system"><link rel="next" href="ar01s08.html" title="8. Relation to other Boost libraries"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">7. Practical considerations</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s06.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="ar01s08.html">Next</a></td></tr></table><hr></div><div class="section"><div class="titlepage"><div><h2 class="title" style="clear: both"><a name="id2807534"></a>7. Practical considerations</h2></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2807540"></a>7.1. Performance</h3></div></div><p>In theory, all overhead of using STL algorithms and lambda functors 
 compared to hand written loops can be optimized away, just as the overhead 
 from standard STL function objects and binders can.

@@ -75,7 +75,7 @@ Note however, that evaluating a lambda functor consist of a sequence of calls to
 If the compiler fails to actually expand these functions inline, 
 the performance can suffer. 
 The running time can more than double if this happens.
-Although the above tests do not include such an expression, we have experienced
+Although the above tests do not include such an expression, we have experiensed
 this for some seemingly simple expressions.


@@ -97,7 +97,7 @@ The running times are expressed in arbitrary units." border="1"><colgroup><col><
 </p><p>Some additional performance testing with an earlier version of the
 library is described
 [<a href="bi01.html#cit:jarvi:00" title="[Jär00]">Jär00</a>].
-</p></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2808087"></a>7.2. About compiling</h3></div></div><p>The BLL uses templates rather heavily, performing numerous recursive instantiations of the same templates. 
+</p></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2808033"></a>7.2. About compiling</h3></div></div><p>The BLL uses templates rather heavily, performing numerous recursive instantiations of the same templates. 
 This has (at least) three implications:
 <div class="itemizedlist"><ul type="disc"><li><p>
 While it is possible to write incredibly complex lambda expressions, it probably isn't a good idea. 
@@ -111,7 +111,7 @@ This can make the error messages very long and difficult to interpret, particula
 The C++ Standard suggests a template nesting level of 17 to help detect infinite recursion. 
 Complex lambda templates can easily exceed this limit. 
 Most compilers allow a greater number of nested templates, but commonly require the limit explicitly increased with a command line argument.
-</p></li></ul></div></p></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2808149"></a>7.3. Portability</h3></div></div><p>
+</p></li></ul></div></p></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2808094"></a>7.3. Portability</h3></div></div><p>
 The BLL works with the following compilers, that is, the compilers are capable of compiling the test cases that are included with the BLL:

      <div class="itemizedlist"><ul type="disc"><li>GCC 3.0.4
@@ -120,7 +120,7 @@ The BLL works with the following compilers, that is, the compilers are capable o
 )

 	</li></ul></div>
-</p><div class="section"><div class="titlepage"><div><h4 class="title"><a name="id2808188"></a>7.3.1. Test coverage</h4></div></div><p>The following list describes the test files included and the features that each file covers:
+</p><div class="section"><div class="titlepage"><div><h4 class="title"><a name="id2808133"></a>7.3.1. Test coverage</h4></div></div><p>The following list describes the test files included and the features that each file covers:

 <div class="itemizedlist"><ul type="disc"><li><p>
 <tt>bind_tests_simple.cpp</tt> : Bind expressions of different arities and types of target functions: function pointers, function objects and member functions.
--- a/doc/ar01s08.html
+++ b/doc/ar01s08.html
@@ -5,7 +5,7 @@
      The Boost Lambda Library"><link rel="up" href="index.html" title="
      C++ BOOST

-      The Boost Lambda Library"><link rel="previous" href="ar01s07.html" title="7. Practical considerations"><link rel="next" href="ar01s09.html" title="9. Contributors"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">8. Relation to other Boost libraries</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s07.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="ar01s09.html">Next</a></td></tr></table><hr></div><div class="section"><div class="titlepage"><div><h2 class="title" style="clear: both"><a name="id2808533"></a>8. Relation to other Boost libraries</h2></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2808540"></a>8.1. Boost Function</h3></div></div><p>Sometimes it is convenient to store lambda functors in variables.
+      The Boost Lambda Library"><link rel="previous" href="ar01s07.html" title="7. Practical considerations"><link rel="next" href="ar01s09.html" title="9. Contributors"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">8. Relation to other Boost libraries</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s07.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="ar01s09.html">Next</a></td></tr></table><hr></div><div class="section"><div class="titlepage"><div><h2 class="title" style="clear: both"><a name="id2808478"></a>8. Relation to other Boost libraries</h2></div></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2808486"></a>8.1. Boost Function</h3></div></div><p>Sometimes it is convenient to store lambda functors in variables.
 However, the types of even the simplest lambda functors are long and unwieldy, and it is in general unfeasible to declare variables with lambda functor types.
 <span class="emphasis"><i>The Boost Function library</i></span> [<a href="bi01.html#cit:boost::function" title="[function]">function</a>] defines wrappers for arbitrary function objects, for example 
 lambda functors; and these wrappers have types that are easy to type out.
@@ -13,14 +13,14 @@ lambda functors; and these wrappers have types that are easy to type out.
 For example:

 <pre class="programlisting">
-boost::function&lt;int(int, int)&gt; f = _1 + _2;
-boost::function&lt;int&amp;(int&amp;)&gt; g = (_1 += 10);
+boost::function&lt;int, int, int&gt; f = _1 + _2;
+boost::function&lt;int&amp;, int&amp;&gt; g = unlambda(_1 += 10);
 int i = 1, j = 2;
-f(i, j); // returns 3
-g(i);    // sets i to = 11;
+f(i); // returns 3
+g(i); // sets i to = 11;
 </pre>

-The return and parameter types of the wrapped function object must be written explicilty as the template argument to the wrapper template <tt>boost::function</tt>; even when lambda functors, which otherwise have generic parameters, are wrapped.
+The return and parameter types of the wrapped function object must be written explicilty as template arguments to the wrapper template <tt>boost::function</tt>; even when lambda functors, which otherwise have generic parameters, are wrapped.
 Wrapping a function object with <tt>boost::function</tt> introduces a performance cost comparable to virtual function dispatch, though virtual functions are not actually used.

 Note that storing lambda functors inside <tt>boost::function</tt> 
@@ -38,13 +38,13 @@ For example:
 <pre class="programlisting">
 int* sum = new int();
 *sum = 0;
-boost::function&lt;int&amp;(int)&gt; counter = *sum += _1;
+boost::function&lt;int&amp;, int&gt; counter = *sum += _1;
 counter(5); // ok, *sum = 5;
 delete sum; 
 counter(3); // error, *sum does not exist anymore
 </pre>

-</p></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2808644"></a>8.2. Boost Bind</h3></div></div><p>
+</p></div><div class="section"><div class="titlepage"><div><h3 class="title"><a name="id2808590"></a>8.2. Boost Bind</h3></div></div><p>
 <span class="emphasis"><i>The Boost Bind</i></span> [<a href="bi01.html#cit:boost::bind" title="[bind]">bind</a>] library has partially overlapping functionality with the BLL. 
 Basically, the Boost Bind library (BB in the sequel) implements the bind expression part of BLL.
 There are, however, some semantical differerences.
@@ -63,7 +63,7 @@ a larger set of compilers.
 </p><p>
 The following two sections describe what are the semantic differences 
 between the bind expressions in BB and BLL.
-</p><div class="section"><div class="titlepage"><div><h4 class="title"><a name="id2808709"></a>8.2.1. First argument of bind expression</h4></div></div>
+</p><div class="section"><div class="titlepage"><div><h4 class="title"><a name="id2808654"></a>8.2.1. First argument of bind expression</h4></div></div>

 In BB the first argument of the bind expression, the target function, 
 is treated differently from the other arguments, 
--- a/doc/ar01s09.html
+++ b/doc/ar01s09.html
@@ -5,7 +5,7 @@
      The Boost Lambda Library"><link rel="up" href="index.html" title="
      C++ BOOST

-      The Boost Lambda Library"><link rel="previous" href="ar01s08.html" title="8. Relation to other Boost libraries"><link rel="next" href="apa.html" title="A. Rationale for some of the design decisions"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">9. Contributors</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s08.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="apa.html">Next</a></td></tr></table><hr></div><div class="section"><div class="titlepage"><div><h2 class="title" style="clear: both"><a name="id2808824"></a>9. Contributors</h2></div></div>
+      The Boost Lambda Library"><link rel="previous" href="ar01s08.html" title="8. Relation to other Boost libraries"><link rel="next" href="apa.html" title="A. Rationale for some of the design decisions"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">9. Contributors</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ar01s08.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="apa.html">Next</a></td></tr></table><hr></div><div class="section"><div class="titlepage"><div><h2 class="title" style="clear: both"><a name="id2808769"></a>9. Contributors</h2></div></div>

 The main body of the library was written by Jaakko Järvi and Gary Powell.
 We've got outside help, suggestions and ideas from Jeremy Siek, Peter Higley, Peter Dimov, Valentin Bonnard, William Kempf.
--- a/doc/bi01.html
+++ b/doc/bi01.html
@@ -5,21 +5,12 @@
      The Boost Lambda Library"><link rel="up" href="index.html" title="
      C++ BOOST

-      The Boost Lambda Library"><link rel="previous" href="apa.html" title="A. Rationale for some of the design decisions"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Bibliography</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="apa.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> </td></tr></table><hr></div><div id="id2808997" class="bibliography"><div class="titlepage"><div><h2 class="title"><a name="id2808997"></a>Bibliography</h2></div></div><div class="biblioentry"><a name="cit:stepanov:94"></a><p>[STL94] <span class="authorgroup">A. A. Stepanov and M. Lee. </span><span class="title"><I>The Standard Template Library</I>. </span><span class="orgname">Hewlett-Packard Laboratories. </span><span class="pubdate">1994. </span><span class="bibliomisc">
+      The Boost Lambda Library"><link rel="previous" href="apa.html" title="A. Rationale for some of the design decisions"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Bibliography</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="apa.html">Prev</a> </td><th width="60%" align="center"> </th><td width="20%" align="right"> </td></tr></table><hr></div><div id="id2808943" class="bibliography"><div class="titlepage"><div><h2 class="title"><a name="id2808943"></a>Bibliography</h2></div></div><div class="biblioentry"><a name="cit:stepanov:94"></a><p>[STL94] <span class="authorgroup">A. A. Stepanov and M. Lee. </span><span class="title"><I>The Standard Template Library</I>. </span><span class="orgname">Hewlett-Packard Laboratories. </span><span class="pubdate">1994. </span><span class="bibliomisc">
 <a href="http://www.hpl.hp.com/techreports" target="_top">www.hpl.hp.com/techreports</a>
 . </span></p></div><div class="biblioentry"><a name="cit:sgi:02"></a><p>[SGI02] <span class="title"><I>The SGI Standard Template Library</I>. </span><span class="pubdate">2002. </span><span class="bibliomisc"><a href="http://www.sgi.com/tech/stl/" target="_top">www.sgi.com/tech/stl/</a>. </span></p></div><div class="biblioentry"><a name="cit:c++:98"></a><p>[C++98] <span class="title"><I>International Standard, Programming Languages &#8211; C++</I>. </span><span class="subtitle">ISO/IEC:14882. </span><span class="pubdate">1998. </span></p></div><div class="biblioentry"><a name="cit:jarvi:99"></a><p>[Jär99] <span class="articleinfo">
 <span class="author">Jaakko Järvi. </span>
 <span class="title"><I>C++ Function Object Binders Made Easy</I>. </span>
-. </span><span class="title"><I>Lecture Notes in Computer Science</I>. </span><span class="volumenum">1977. </span><span class="publishername">Springer. </span><span class="pubdate">2000. </span></p></div><div class="biblioentry"><a name="cit:jarvi:00"></a><p>[Jär00] <span class="author">Jaakko Järvi. </span><span class="author">Gary Powell. </span><span class="title"><I>The Lambda Library : Lambda Abstraction in C++</I>. </span><span class="orgname">Turku Centre for Computer Science. </span><span class="bibliomisc">Technical Report . </span><span class="issuenum">378. </span><span class="pubdate">2000. </span><span class="bibliomisc"><a href="http://www.tucs.fi/Publications/techreports/TR378.php" target="_top">www.tucs.fi/publications</a>. </span></p></div><div class="biblioentry"><a name="cit:jarvi:01"></a><p>[Jär01] <span class="author">Jaakko Järvi. </span><span class="author">Gary Powell. </span><span class="title"><I>The Lambda Library : Lambda Abstraction in C++</I>. </span><span class="confgroup"><span class="conftitle">Second  Workshop on C++ Template Programming. </span><span class="address">Tampa Bay, OOPSLA'01. </span>. </span><span class="pubdate">2001. </span><span class="bibliomisc"><a href="http://www.oonumerics.org/tmpw01/" target="_top">www.oonumerics.org/tmpw01/</a>. </span></p></div><div class="biblioentry"><a name="cit:jarvi:03"></a><p>[Jär03] <span class="articleinfo">
-
-<span class="author">Jaakko Järvi. </span>
-
-<span class="author">Gary Powell. </span>
-
-<span class="author">Andrew Lumsdaine. </span>
-<span class="title"><I>The Lambda Library : unnamed functions in C++</I>. </span>
-
-. </span><span class="title"><I>Software - Practice and Expreience</I>. </span><span class="volumenum">33:259-291. </span><span class="pubdate">2003. </span></p></div><div class="biblioentry"><a name="cit:boost::tuple"></a><p>[tuple] <span class="title"><I>The Boost Tuple Library</I>. </span><span class="bibliomisc"><a href="http://www.boost.org/libs/tuple/doc/tuple_users_guide.html" target="_top">www.boost.org/libs/tuple/doc/tuple_users_guide.html</a>
+. </span><span class="title"><I>Lecture Notes in Computer Science</I>. </span><span class="volumenum">1977. </span><span class="publishername">Springer. </span><span class="pubdate">2000. </span></p></div><div class="biblioentry"><a name="cit:jarvi:00"></a><p>[Jär00] <span class="author">Jaakko Järvi. </span><span class="author">Gary Powell. </span><span class="title"><I>The Lambda Library : Lambda Abstraction in C++</I>. </span><span class="orgname">Turku Centre for Computer Science. </span><span class="bibliomisc">Technical Report . </span><span class="issuenum">378. </span><span class="pubdate">2000. </span><span class="bibliomisc"><a href="http://www.tucs.fi/Publications/techreports/TR378.php" target="_top">www.tucs.fi/publications</a>. </span></p></div><div class="biblioentry"><a name="cit:jarvi:01"></a><p>[Jär01] <span class="author">Jaakko Järvi. </span><span class="author">Gary Powell. </span><span class="title"><I>The Lambda Library : Lambda Abstraction in C++</I>. </span><span class="confgroup"><span class="conftitle">Second  Workshop on C++ Template Programming. </span><span class="address">Tampa Bay, OOPSLA'01. </span>. </span><span class="pubdate">2001. </span><span class="bibliomisc"><a href="http://www.oonumerics.org/tmpw01/" target="_top">www.oonumerics.org/tmpw01/</a>. </span></p></div><div class="biblioentry"><a name="cit:boost::tuple"></a><p>[tuple] <span class="title"><I>The Boost Tuple Library</I>. </span><span class="bibliomisc"><a href="http://www.boost.org/libs/tuple/doc/tuple_users_guide.html" target="_top">www.boost.org/libs/tuple/doc/tuple_users_guide.html</a>
 . </span><span class="pubdate">2002. </span></p></div><div class="biblioentry"><a name="cit:boost::type_traits"></a><p>[type_traits] <span class="title"><I>The Boost type_traits</I>. </span><span class="bibliomisc"><a href="http://www.boost.org/libs/type_traits/index.htm" target="_top">www.boost.org/libs/type_traits/</a>
 . </span><span class="pubdate">2002. </span></p></div><div class="biblioentry"><a name="cit:boost::ref"></a><p>[ref] <span class="title"><I>Boost ref</I>. </span><span class="bibliomisc"><a href="http://www.boost.org/libs/bind/ref.html" target="_top">www.boost.org/libs/bind/ref.html</a>
 . </span><span class="pubdate">2002. </span></p></div><div class="biblioentry"><a name="cit:boost::bind"></a><p>[bind] <span class="title"><I>Boost Bind Library</I>. </span><span class="bibliomisc"><a href="http://www.boost.org/libs/bind/bind.html" target="_top">www.boost.org/libs/bind/bind.html</a>
--- a/doc/detail/README
+++ b/doc/detail/README
@@ -2,6 +2,6 @@
 generated
 - lambda_doc_chunks.xsl loads the stylesheets that generate a separate
 html-file for each section
- lambda_doc.xsl loads stylesheets that generate one big html-file
+- lambda_doc.html loads stylesheets that generate one big html-file
 (you need to edit the paths in these files to make them work)

--- a/doc/detail/lambda_doc.xml
+++ b/doc/detail/lambda_doc.xml
@@ -44,7 +44,6 @@

  <!--  -->

-  <ulink url="lambda_docs_as_one_file.html">Documentation as a one big HTML-file</ulink>

  <section id="introduction">

@@ -445,7 +444,7 @@ Nevertheless, it is straightforward to provide another function template with th
 	Next, we create a container of pointers and make them point to the elements in the first container <literal>v</literal>:

 	<programlisting>
-<![CDATA[vector<int*> vp(10); 
+<![CDATA[list<int*> vp(10); 
 transform(v.begin(), v.end(), vp.begin(), &_1);]]></programlisting>

 The expression <literal><![CDATA[&_1]]></literal> creates a function object for getting the address of each element in <literal>v</literal>.
@@ -588,18 +587,19 @@ in the lambda functor.
 This means that the value of a bound argument is fixed at the time of the 
 creation of the lambda function and remains constant during the lifetime 
 of the lambda function object.
+
 For example:
+
 <programlisting>
 int i = 1;
-(_1 = 2, _1 + i)(i);
+(_1 + i)(i = 2);
 </programlisting>
-The comma operator is overloaded to combine lambda expressions into a sequence;
-the resulting unary lambda functor first assigns 2 to its argument, 
-then adds the value of <literal>i</literal> to it.
+
 The value of the expression in the last line is 3, not 4. 
-In other words, the lambda expression that is created is
-<literal>lambda x.(x = 2, x + 1)</literal> rather than
-<literal>lambda x.(x = 2, x + i)</literal>.
+
+In other words, the lambda expression <literal>_1 + i</literal> creates 
+a lambda function <literal>lambda x.x+1</literal> rather than 
+<literal>lambda x.x+i</literal>.
      
 </para>

@@ -623,12 +623,12 @@ or as a reference to const respectively.

 For example, if we rewrite the previous example and wrap the variable 
 <literal>i</literal> with <literal>ref</literal>, 
-we are creating the lambda expression <literal>lambda x.(x = 2, x + i)</literal> 
+we are creating the lambda expression <literal>lambda x.x+i</literal> 
 and the value of the expression in the last line will be 4:

 <programlisting>
 i = 1;
-(_1 = 2, _1 + ref(i))(i);
+(_1 + ref(i))(i = 2);
 </programlisting>

 Note that <literal>ref</literal> and <literal>cref</literal> are different
@@ -1074,7 +1074,6 @@ This creates some asymmetry between the lambda functor and the original member f
 class A {
  int i; mutable int j;
 public:
-
  A(int ii, int jj) : i(ii), j(jj) {};
  void set_i(int x) { i = x; }; 
  void set_j(int x) const { j = x; }; 
@@ -1120,32 +1119,6 @@ bind(&A::set_j, _1, 1)(a); // a.j == 1]]>
 </para>
 </section>

-<section id="sect:members_variables_as_targets">
-<title>Member variables as targets</title>
-
-<para>
-A pointer to a member variable is not really a function, but 
-the first argument to the <literal>bind</literal> function can nevertheless
-be a pointer to a member variable.
-Invoking such a bind expression returns a reference to the data member.
-For example:
-
-<programlisting>
-<![CDATA[struct A { int data; };
-A a;
-bind(&A::data, _1)(a) = 1;     // a.data == 1]]>
-</programlisting>
-
-The cv-qualifiers of the object whose member is accessed are respected.
-For example, the following tries to write into a const location:
-<programlisting>
-<![CDATA[const A ca = a;
-bind(&A::data, _1)(ca) = 1;     // error]]>
-</programlisting>
-
-</para>
-</section>
-
 <section id="sect:function_objects_as_targets">
 <title>Function objects as targets</title>

@@ -1156,46 +1129,18 @@ operator defined, can be used as target functions.

 In general, BLL cannot deduce the return type of an arbitrary function object. 

-However, there are two methods for giving BLL this capability for a certain 
+However, there is a method for giving BLL this capability for a certain 
 function object class.

 </para>

 <simplesect>

-<title>The result_type typedef</title>
-
-<para>
-
-The BLL supports the standard library convention of declaring the return type
-of a function object with a member typedef named <literal>result_type</literal> in the
-function object class.
-
-Here is a simple example:
-<programlisting>
-<![CDATA[struct A {
-  typedef B result_type;
-  B operator()(X, Y, Z); 
-};]]>
-</programlisting>
-
-If a function object does not define a <literal>result_type</literal> typedef, 
-the method described below (<literal>sig</literal> template) 
-is attempted to resolve the return type of the
-function object. If a function object defines both <literal>result_type</literal>
-and <literal>sig</literal>, <literal>result_type</literal> takes precedence.
-
-</para>
-
-</simplesect>
-
-<simplesect>
-
 <title>The sig template</title>

 <para>
-Another mechanism that make BLL aware of the return type(s) of a function object is defining
-member template struct 
+To make BLL aware of the return type(s) of a function object one needs to 
+provide a member template struct 
 <literal><![CDATA[sig<Args>]]></literal> with a typedef 
 <literal>type</literal> that specifies the return type.

@@ -1214,7 +1159,9 @@ is the function
 object type itself, and the remaining elements are the types of 
 the arguments, with which the function object is being called.

-This may seem overly complex compared to defining the <literal>result_type</literal> typedef.
+This may seem overly complex compared to the Standard Library 
+convention for defining the return type of a function
+object with  the <literal>return_type</literal> typedef.
 Howver, there are two significant restrictions with using just a simple
 typedef to express the return type:
 <orderedlist>
@@ -1289,6 +1236,27 @@ mechanism first introduced in the FC++ library

 </simplesect>

+<para>
+Earlier versions of the library supported the Standard Library convention
+as the default, and required special actions to make the library recognize
+the <literal>sig</literal> template. 
+Now the BLL has that reversed.
+
+If one needs to use a functor that adheres to the Standard Library
+convention in a bind expression, we provide the <literal>std_functor</literal>
+wrapper, that gives the function object a <literal>sig</literal>
+template based on the <literal>result_type</literal> typedef.
+For example:
+
+<programlisting>
+<![CDATA[int i = 1;
+bind(plus<int>(), _1, 1)(i);              // error, no sig template
+bind(std_functor(plus<int>()), _1, 1)(i); // ok]]>
+</programlisting>
+
+</para>
+
+
 </section>


@@ -1583,7 +1551,13 @@ for_each(a, a+5,
 The BLL supports an alternative syntax for control expressions, suggested
 by Joel de Guzmann. 
 By overloading the <literal>operator[]</literal> we can
-get a closer resemblance with the built-in control structures:
+get a closer resemblance with the built-in control structures. 
+For example, using this syntax the <literal>if_then</literal> example above
+can be written as:
+<programlisting>
+<![CDATA[for_each(a.begin(), a.end(), 
+         if(_1 % 2 == 0)[ cout << _1 ])]]>  
+</programlisting>

 <programlisting>
 <![CDATA[if_(condition)[then_part]
@@ -1593,13 +1567,6 @@ do_[body].while_(condition)
 for_(init, condition, increment)[body]]]>
 </programlisting>

-For example, using this syntax the <literal>if_then</literal> example above
-can be written as:
-<programlisting>
-<![CDATA[for_each(a.begin(), a.end(), 
-         if_(_1 % 2 == 0)[ cout << _1 ])]]>  
-</programlisting>
-
 As more experience is gained, we may end up deprecating one or the other 
 of these syntaces. 

@@ -1862,7 +1829,7 @@ and the effect of evaluating that expression.
 </row>
 <row>
 <entry><literal>destructor()(pa)</literal></entry>
-<entry><literal>pa->~A()</literal>, where <literal>pa</literal> is of type <literal>A*</literal></entry>
+<entry><literal>pa.->A()</literal>, where <literal>pa</literal> is of type <literal>A*</literal></entry>
 </row>
 <row>
 <entry><literal>new_ptr&lt;T&gt;()(<parameter>arg_list</parameter>)</literal></entry>
@@ -2725,7 +2692,7 @@ Note however, that evaluating a lambda functor consist of a sequence of calls to
 If the compiler fails to actually expand these functions inline, 
 the performance can suffer. 
 The running time can more than double if this happens.
-Although the above tests do not include such an expression, we have experienced
+Although the above tests do not include such an expression, we have experiensed
 this for some seemingly simple expressions.


@@ -3035,14 +3002,14 @@ lambda functors; and these wrappers have types that are easy to type out.
 For example:

 <programlisting>
-<![CDATA[boost::function<int(int, int)> f = _1 + _2;
-boost::function<int&(int&)> g = (_1 += 10);
+<![CDATA[boost::function<int, int, int> f = _1 + _2;
+boost::function<int&, int&> g = unlambda(_1 += 10);
 int i = 1, j = 2;
-f(i, j); // returns 3
-g(i);    // sets i to = 11;]]>
+f(i); // returns 3
+g(i); // sets i to = 11;]]>
 </programlisting>

-The return and parameter types of the wrapped function object must be written explicilty as the template argument to the wrapper template <literal>boost::function</literal>; even when lambda functors, which otherwise have generic parameters, are wrapped.
+The return and parameter types of the wrapped function object must be written explicilty as template arguments to the wrapper template <literal>boost::function</literal>; even when lambda functors, which otherwise have generic parameters, are wrapped.
 Wrapping a function object with <literal>boost::function</literal> introduces a performance cost comparable to virtual function dispatch, though virtual functions are not actually used.

 Note that storing lambda functors inside <literal>boost::function</literal> 
@@ -3060,7 +3027,7 @@ For example:
 <programlisting>
 <![CDATA[int* sum = new int();
 *sum = 0;
-boost::function<int&(int)> counter = *sum += _1;
+boost::function<int&, int> counter = *sum += _1;
 counter(5); // ok, *sum = 5;
 delete sum; 
 counter(3); // error, *sum does not exist anymore]]>
@@ -3354,37 +3321,6 @@ was dropped.
 <bibliomisc><ulink url="http://www.oonumerics.org/tmpw01/">www.oonumerics.org/tmpw01/</ulink></bibliomisc>
 </biblioentry>

-<biblioentry id="cit:jarvi:03">
-<abbrev>Jär03</abbrev>
-
-<articleinfo>
-
-<author>
-<surname>Järvi</surname>
-<firstname>Jaakko</firstname>
-</author>
-
-<author>
-<firstname>Gary</firstname>
-<surname>Powell</surname>
-</author>
-
-<author>
-<firstname>Andrew</firstname>
-<surname>Lumsdaine</surname>
-</author>
-<title>The Lambda Library : unnamed functions in C++</title>
-
-</articleinfo>
-
-<title>Software - Practice and Expreience</title>
-<volumenum>33:259-291</volumenum>
-
-
-<pubdate>2003</pubdate>
-</biblioentry>
-
-
 <biblioentry id="cit:boost::tuple">
 <abbrev>tuple</abbrev>
 <title>The Boost Tuple Library</title>
--- a/doc/index.html
+++ b/doc/index.html
@@ -8,16 +8,16 @@
      The Boost Lambda Library"><link rel="next" href="ar01s02.html" title="2. Getting Started"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">
      C++ BOOST

-      The Boost Lambda Library</th></tr><tr><td width="20%" align="left"> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="ar01s02.html">Next</a></td></tr></table><hr></div><div class="article"><div class="titlepage"><div><h1 class="title"><a name="id2733457"></a>
+      The Boost Lambda Library</th></tr><tr><td width="20%" align="left"> </td><th width="60%" align="center"> </th><td width="20%" align="right"> <a accesskey="n" href="ar01s02.html">Next</a></td></tr></table><hr></div><div class="article"><div class="titlepage"><div><h1 class="title"><a name="id2733458"></a>
      <span class="inlinemediaobject"><img src="../../../c++boost.gif" alt="C++ BOOST"></span>

      The Boost Lambda Library</h1></div><div><p class="copyright">Copyright © 1999-2002 Jaakko Järvi, Gary Powell</p></div><div><div class="legalnotice"><p>
        The Boost Lambda Library is free software; Permission to copy,
        use, modify and distribute this software and its documentation is granted, provided this copyright
        notice appears in all copies. 
-      </p></div></div><hr></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt>1. <a href="index.html#introduction">In a nutshell</a></dt><dt>2. <a href="ar01s02.html">Getting Started</a></dt><dd><dl><dt>2.1. <a href="ar01s02.html#id2790118">Installing the library</a></dt><dt>2.2. <a href="ar01s02.html#id2741945">Conventions used in this document</a></dt></dl></dd><dt>3. <a href="ar01s03.html">Introduction</a></dt><dd><dl><dt>3.1. <a href="ar01s03.html#id2741999">Motivation</a></dt><dt>3.2. <a href="ar01s03.html#id2742792">Introduction to lambda expressions</a></dt></dl></dd><dt>4. <a href="ar01s04.html">Using the library</a></dt><dd><dl><dt>4.1. <a href="ar01s04.html#sect:introductory_examples">Introductory Examples</a></dt><dt>4.2. <a href="ar01s04.html#sect:parameter_and_return_types">Parameter and return types of lambda functors</a></dt><dt>4.3. <a href="ar01s04.html#sect:actual_arguments_to_lambda_functors">About actual arguments to lambda functors</a></dt><dt>4.4. <a href="ar01s04.html#sect:storing_bound_arguments">Storing bound arguments in lambda functions</a></dt></dl></dd><dt>5. <a href="ar01s05.html">Lambda expressions in details</a></dt><dd><dl><dt>5.1. <a href="ar01s05.html#sect:placeholders">Placeholders</a></dt><dt>5.2. <a href="ar01s05.html#sect:operator_expressions">Operator expressions</a></dt><dt>5.3. <a href="ar01s05.html#sect:bind_expressions">Bind expressions</a></dt><dt>5.4. <a href="ar01s05.html#sect:overriding_deduced_return_type">Overriding the deduced return type</a></dt><dt>5.5. <a href="ar01s05.html#sect:delaying_constants_and_variables">Delaying constants and variables</a></dt><dt>5.6. <a href="ar01s05.html#sect:lambda_expressions_for_control_structures">Lambda expressions for control structures</a></dt><dt>5.7. <a href="ar01s05.html#sect:exceptions">Exceptions</a></dt><dt>5.8. <a href="ar01s05.html#sect:construction_and_destruction">Construction and destruction</a></dt><dt>5.9. <a href="ar01s05.html#id2805507">Special lambda expressions</a></dt><dt>5.10. <a href="ar01s05.html#id2806080">Casts, sizeof and typeid</a></dt><dt>5.11. <a href="ar01s05.html#sect:nested_stl_algorithms">Nesting STL algorithm invocations</a></dt></dl></dd><dt>6. <a href="ar01s06.html">Extending return type deduction system</a></dt><dt>7. <a href="ar01s07.html">Practical considerations</a></dt><dd><dl><dt>7.1. <a href="ar01s07.html#id2807595">Performance</a></dt><dt>7.2. <a href="ar01s07.html#id2808087">About compiling</a></dt><dt>7.3. <a href="ar01s07.html#id2808149">Portability</a></dt></dl></dd><dt>8. <a href="ar01s08.html">Relation to other Boost libraries</a></dt><dd><dl><dt>8.1. <a href="ar01s08.html#id2808540">Boost Function</a></dt><dt>8.2. <a href="ar01s08.html#id2808644">Boost Bind</a></dt></dl></dd><dt>9. <a href="ar01s09.html">Contributors</a></dt><dt>A. <a href="apa.html">Rationale for some of the design decisions</a></dt><dd><dl><dt>1. <a href="apa.html#sect:why_weak_arity">
+      </p></div></div><hr></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt>1. <a href="index.html#introduction">In a nutshell</a></dt><dt>2. <a href="ar01s02.html">Getting Started</a></dt><dd><dl><dt>2.1. <a href="ar01s02.html#id2790112">Installing the library</a></dt><dt>2.2. <a href="ar01s02.html#id2742981">Conventions used in this document</a></dt></dl></dd><dt>3. <a href="ar01s03.html">Introduction</a></dt><dd><dl><dt>3.1. <a href="ar01s03.html#id2743030">Motivation</a></dt><dt>3.2. <a href="ar01s03.html#id2741479">Introduction to lambda expressions</a></dt></dl></dd><dt>4. <a href="ar01s04.html">Using the library</a></dt><dd><dl><dt>4.1. <a href="ar01s04.html#sect:introductory_examples">Introductory Examples</a></dt><dt>4.2. <a href="ar01s04.html#sect:parameter_and_return_types">Parameter and return types of lambda functors</a></dt><dt>4.3. <a href="ar01s04.html#sect:actual_arguments_to_lambda_functors">About actual arguments to lambda functors</a></dt><dt>4.4. <a href="ar01s04.html#sect:storing_bound_arguments">Storing bound arguments in lambda functions</a></dt></dl></dd><dt>5. <a href="ar01s05.html">Lambda expressions in details</a></dt><dd><dl><dt>5.1. <a href="ar01s05.html#sect:placeholders">Placeholders</a></dt><dt>5.2. <a href="ar01s05.html#sect:operator_expressions">Operator expressions</a></dt><dt>5.3. <a href="ar01s05.html#sect:bind_expressions">Bind expressions</a></dt><dt>5.4. <a href="ar01s05.html#sect:overriding_deduced_return_type">Overriding the deduced return type</a></dt><dt>5.5. <a href="ar01s05.html#sect:delaying_constants_and_variables">Delaying constants and variables</a></dt><dt>5.6. <a href="ar01s05.html#sect:lambda_expressions_for_control_structures">Lambda expressions for control structures</a></dt><dt>5.7. <a href="ar01s05.html#sect:exceptions">Exceptions</a></dt><dt>5.8. <a href="ar01s05.html#sect:construction_and_destruction">Construction and destruction</a></dt><dt>5.9. <a href="ar01s05.html#id2805452">Special lambda expressions</a></dt><dt>5.10. <a href="ar01s05.html#id2806025">Casts, sizeof and typeid</a></dt><dt>5.11. <a href="ar01s05.html#sect:nested_stl_algorithms">Nesting STL algorithm invocations</a></dt></dl></dd><dt>6. <a href="ar01s06.html">Extending return type deduction system</a></dt><dt>7. <a href="ar01s07.html">Practical considerations</a></dt><dd><dl><dt>7.1. <a href="ar01s07.html#id2807540">Performance</a></dt><dt>7.2. <a href="ar01s07.html#id2808033">About compiling</a></dt><dt>7.3. <a href="ar01s07.html#id2808094">Portability</a></dt></dl></dd><dt>8. <a href="ar01s08.html">Relation to other Boost libraries</a></dt><dd><dl><dt>8.1. <a href="ar01s08.html#id2808486">Boost Function</a></dt><dt>8.2. <a href="ar01s08.html#id2808590">Boost Bind</a></dt></dl></dd><dt>9. <a href="ar01s09.html">Contributors</a></dt><dt>A. <a href="apa.html">Rationale for some of the design decisions</a></dt><dd><dl><dt>1. <a href="apa.html#sect:why_weak_arity">
 Lambda functor arity
-</a></dt></dl></dd><dt><a href="bi01.html">Bibliography</a></dt></dl></div><a href="lambda_docs_as_one_file.html" target="_top">Documentation as a one big HTML-file</a><div class="section"><div class="titlepage"><div><h2 class="title" style="clear: both"><a name="introduction"></a>1. In a nutshell</h2></div></div><p>
+</a></dt></dl></dd><dt><a href="bi01.html">Bibliography</a></dt></dl></div><div class="section"><div class="titlepage"><div><h2 class="title" style="clear: both"><a name="introduction"></a>1. In a nutshell</h2></div></div><p>

      The Boost Lambda Library (BLL in the sequel) is a C++ template
      library, which implements form of <span class="emphasis"><i>lambda abstractions</i></span> for C++.
--- a/doc/lambda_docs_as_one_file.html
+++ b/doc/lambda_docs_as_one_file.html
--- a/include/boost/lambda/algorithm.hpp
+++ b/include/boost/lambda/algorithm.hpp
--- a/include/boost/lambda/casts.hpp
+++ b/include/boost/lambda/casts.hpp
@@ -1,6 +1,6 @@
 // - casts.hpp -- BLambda Library -------------
 //
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
+// Copyright (C) 2000 Gary Powell (gary.powell@sierra.com)
 // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
 //
 // Permission to copy, use, sell and distribute this software is granted
@@ -91,7 +91,7 @@ public:

 // return types of casting lambda_functors (all "T" type.)

-template<template <class> class cast_type, class T, class A>
+template<template <class T> class cast_type, class T, class A>
 struct return_type_N<cast_action< cast_type<T> >, A> { 
  typedef T type;
 };
--- a/include/boost/lambda/construct.hpp
+++ b/include/boost/lambda/construct.hpp
@@ -1,6 +1,6 @@
 // - construct.hpp -- Lambda Library -------------
 //
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
+// Copyright (C) 2000 Gary Powell (gary.powell@sierra.com)
 // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
 //
 // Permission to copy, use, sell and distribute this software is granted
--- a/include/boost/lambda/core.hpp
+++ b/include/boost/lambda/core.hpp
@@ -1,18 +1,4 @@
 // -- core.hpp -- Boost Lambda Library -------------------------------------
-//
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
-// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
 // 
 // Includes the core of LL, without any real features for client:
 // 
--- a/include/boost/lambda/detail/control_constructs_common.hpp
+++ b/include/boost/lambda/detail/control_constructs_common.hpp
@@ -1,7 +1,7 @@
 // Boost Lambda Library -- control_constructs_common.hpp -------------------

 // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
+// Copyright (C) 2000 Gary Powell (gary.powell@sierra.com)
 //
 // Permission to copy, use, sell and distribute this software is granted
 // provided this copyright notice appears in all copies. 
@@ -39,7 +39,7 @@ public:
    : lambda_functor<Args>(a) {}

  // for the no body cases in control structures.
-  tagged_lambda_functor() : lambda_functor<Args>() {}
+  explicit tagged_lambda_functor() : lambda_functor<Args>( null_type() ) {}
 };

 } // lambda
--- a/include/boost/lambda/detail/control_structures_impl.hpp
+++ b/include/boost/lambda/detail/control_structures_impl.hpp
@@ -1,7 +1,7 @@
 // Boost Lambda Library -- control_structures_impl.hpp ---------------------

 // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
+// Copyright (C) 2000 Gary Powell (gary.powell@sierra.com)
 //
 // Permission to copy, use, sell and distribute this software is granted
 // provided this copyright notice appears in all copies. 
--- a/include/boost/lambda/detail/function_adaptors.hpp
+++ b/include/boost/lambda/detail/function_adaptors.hpp
@@ -24,18 +24,8 @@ namespace lambda {

 template <class Func> struct function_adaptor {

-  // we do not know the return type off-hand, we must ask it from Func
-  template <class Args> class sig { 
-    typedef typename Args::head_type F; 
-    typedef typename detail::remove_reference_and_cv<Func>::type plainF;
-  public:
-    // To sig we pass a cons list, where the head is the function object type
-    // itself (potentially cv-qualified)
-    // and the tail contains the types of the actual arguments to be passed
-    // to the function object. The arguments can be cv qualified
-    // as well.
-    typedef typename plainF::template sig<Args>::type type;
-  };
+  typedef detail::unspecified type;
+  template <class T> struct sig { typedef detail::unspecified type; };

  template<class RET, class A1>
  static RET apply(A1& a1) {
@@ -89,74 +79,11 @@ template <class Func> struct function_adaptor {

 template <class Func> struct function_adaptor<const Func>; // error 

-// -- function adaptors with data member access
-template <class Object, class T>
-struct function_adaptor<T Object::*> {
-
-  //  typedef detail::unspecified type;
-
-  // T can have qualifiers and can be a reference type
-  // We get the return type by adding const, if the object through which
-  // the data member is accessed is const, and finally adding a reference
-  template<class Args> class sig { 
-    typedef typename boost::tuples::element<1, Args>::type argument_type;
-
-    typedef typename detail::IF<boost::is_const<argument_type>::value,
-      typename boost::add_const<T>::type,
-      T
-    >::RET properly_consted_return_type;
-
-    typedef typename detail::IF<
-        boost::is_volatile<properly_consted_return_type>::value,
-      typename boost::add_volatile<properly_consted_return_type>::type,
-      properly_consted_return_type
-    >::RET properly_cvd_return_type;
-
-
-  public:
-    typedef typename 
-      boost::add_reference<properly_cvd_return_type>::type type;
-  };
-
-  template <class RET>
-  static RET apply( T Object::*data, Object& o) {
-    return o.*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, const Object& o) {
-    return o.*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, volatile Object& o) {
-    return o.*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, const volatile Object& o) {
-    return o.*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, Object* o) {
-    return o->*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, const Object* o) {
-    return o->*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, volatile Object* o) {
-    return o->*data;
-  }
-  template <class RET>
-  static RET apply( T Object::*data, const volatile Object* o) {
-    return o->*data;
-  }
-};
-
 // -- function adaptors with 1 argument apply
   
 template <class Result>
 struct function_adaptor<Result (void)> {
-  
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET>
  static Result apply(Result (*func)()) {
@@ -166,7 +93,7 @@ struct function_adaptor<Result (void)> {

 template <class Result>
 struct function_adaptor<Result (*)(void)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET>
  static Result apply(Result (*func)()) {
@@ -178,7 +105,7 @@ struct function_adaptor<Result (*)(void)> {
 // -- function adaptors with 2 argument apply
 template <class Object, class Result>
 struct function_adaptor<Result (Object::*)() const> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET>
  static Result apply( Result (Object::*func)() const, const Object* o) {
@@ -192,7 +119,7 @@ struct function_adaptor<Result (Object::*)() const> {

 template <class Object, class Result>
 struct function_adaptor<Result (Object::*)()> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET>
  static Result apply( Result (Object::*func)(), Object* o) {
@@ -206,7 +133,7 @@ struct function_adaptor<Result (Object::*)()> {

 template <class Arg1, class Result>
 struct function_adaptor<Result (Arg1)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1>
  static Result apply(Result (*func)(Arg1), A1& a1) {
@@ -216,7 +143,7 @@ struct function_adaptor<Result (Arg1)> {

 template <class Arg1, class Result>
 struct function_adaptor<Result (*)(Arg1)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1>
  static Result apply(Result (*func)(Arg1), A1& a1) {
@@ -228,7 +155,7 @@ struct function_adaptor<Result (*)(Arg1)> {
 // -- function adaptors with 3 argument apply
 template <class Object, class Arg1, class Result>
 struct function_adaptor<Result (Object::*)(Arg1) const> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1>
  static Result apply( Result (Object::*func)(Arg1) const, const Object* o, 
@@ -244,7 +171,7 @@ struct function_adaptor<Result (Object::*)(Arg1) const> {

 template <class Object, class Arg1, class Result>
 struct function_adaptor<Result (Object::*)(Arg1)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1>
  static Result apply( Result (Object::*func)(Arg1), Object* o, A1& a1) {
@@ -258,7 +185,7 @@ struct function_adaptor<Result (Object::*)(Arg1)> {

 template <class Arg1, class Arg2, class Result>
 struct function_adaptor<Result (Arg1, Arg2)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2>
  static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
@@ -268,7 +195,7 @@ struct function_adaptor<Result (Arg1, Arg2)> {

 template <class Arg1, class Arg2, class Result>
 struct function_adaptor<Result (*)(Arg1, Arg2)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2>
  static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
@@ -280,7 +207,7 @@ struct function_adaptor<Result (*)(Arg1, Arg2)> {
 // -- function adaptors with 4 argument apply
 template <class Object, class Arg1, class Arg2, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2) const> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2>
  static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object* o, A1& a1, A2& a2) {
@@ -294,7 +221,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2) const> {

 template <class Object, class Arg1, class Arg2, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2>
  static Result apply( Result (Object::*func)(Arg1, Arg2), Object* o, A1& a1, A2& a2) {
@@ -308,7 +235,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2)> {

 template <class Arg1, class Arg2, class Arg3, class Result>
 struct function_adaptor<Result (Arg1, Arg2, Arg3)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
@@ -318,7 +245,7 @@ struct function_adaptor<Result (Arg1, Arg2, Arg3)> {

 template <class Arg1, class Arg2, class Arg3, class Result>
 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
@@ -330,7 +257,7 @@ struct function_adaptor<Result (*)(Arg1, Arg2, Arg3)> {
 // -- function adaptors with 5 argument apply
 template <class Object, class Arg1, class Arg2, class Arg3, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3) const> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3>
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object* o, A1& a1, A2& a2, A3& a3) {
@@ -344,8 +271,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3) const> {

 template <class Object, class Arg1, class Arg2, class Arg3, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3)> {
-
-  template<class T> struct sig { typedef Result type; };
+  typedef Result type;
  template <class RET, class A1, class A2, class A3>
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object* o, A1& a1, A2& a2, A3& a3) {
    return (o->*func)(a1, a2, a3);
@@ -358,7 +284,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3)> {

 template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
@@ -368,7 +294,7 @@ struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4)> {

 template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
@@ -380,7 +306,7 @@ struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4)> {
 // -- function adaptors with 6 argument apply
 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4) const> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4>
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
@@ -394,7 +320,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4) const> {

 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4>
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
@@ -408,7 +334,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4)> {

 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
@@ -418,7 +344,7 @@ struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5)> {

 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
@@ -430,7 +356,7 @@ struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
 // -- function adaptors with 7 argument apply
 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5) const> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5>
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
@@ -444,7 +370,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5) const>

 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5>
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
@@ -458,7 +384,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {

 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
@@ -468,7 +394,7 @@ struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {

 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
@@ -480,7 +406,7 @@ struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
 // -- function adaptors with 8 argument apply
 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
@@ -494,7 +420,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) c

 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
@@ -508,7 +434,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)>

 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
@@ -518,7 +444,7 @@ struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {

 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
@@ -530,7 +456,7 @@ struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
 // -- function adaptors with 9 argument apply
 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
@@ -544,7 +470,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, A

 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
@@ -558,7 +484,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, A

 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
@@ -568,7 +494,7 @@ struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)>

 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
@@ -580,7 +506,7 @@ struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg
 // -- function adaptors with 10 argument apply
 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
@@ -594,7 +520,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, A

 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
@@ -608,7 +534,7 @@ struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, A

 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
-
+  typedef Result type;
  template<class T> struct sig { typedef Result type; };
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) {
@@ -618,14 +544,54 @@ struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8,

 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
-
-  template<class T> struct sig { typedef Result type; };
+  typedef Result type;
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) {
    return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);
  }
 };

+namespace detail {
+
+template <class Args> class get_sig_result_type {
+  typedef typename Args::head_type Func; 
+  typedef typename detail::remove_reference_and_cv<Func>::type plainF;
+public:
+  // To sig we pass a cons list, where the head is the function object type
+  // itself (potentially cv-qualified)
+  // and the tail contains the types of the actual arguments to be passed
+  // to the function object. The arguments can be cv qualified
+  // as well.
+  typedef typename plainF::template sig<Args>::type type;
+};
+
+} // end detail
+
+
+template <class Args> 
+class function_adaptor_with_actuals 
+{
+  typedef typename Args::head_type Func;
+  typedef typename detail::remove_reference_and_cv<Func>::type plain_Func;
+
+  // get the return type from the function adaptor class
+  // this succeeds for func.pointers, member functions etc.
+  typedef typename function_adaptor<plain_Func>::type type1;
+
+public: 
+
+  // if we get unspecified, Func is a function object class
+  // thus it is ok to try the sig template
+  typedef typename 
+    detail::IF_type<
+      boost::is_same<type1, detail::unspecified>::value,
+      detail::get_sig_result_type<Args>, 
+      function_adaptor<plain_Func> 
+    >::type type;
+  
+};
+
+
 } // namespace lambda
 } // namespace boost

--- a/include/boost/lambda/detail/is_instance_of.hpp
+++ b/include/boost/lambda/detail/is_instance_of.hpp
@@ -43,9 +43,9 @@
 // Now we only have one version of is_instance_of templates, which delagate
 // all the nasty compiler tricks to is_convertible. 

-#define BOOST_LAMBDA_CLASS(z, N,A) BOOST_PP_COMMA_IF(N) class
-#define BOOST_LAMBDA_CLASS_ARG(z, N,A) BOOST_PP_COMMA_IF(N) class A##N 
-#define BOOST_LAMBDA_ARG(z, N,A) BOOST_PP_COMMA_IF(N) A##N 
+#define BOOST_LAMBDA_CLASS(N,A) BOOST_PP_COMMA_IF(N) class
+#define BOOST_LAMBDA_CLASS_ARG(N,A) BOOST_PP_COMMA_IF(N) class A##N 
+#define BOOST_LAMBDA_ARG(N,A) BOOST_PP_COMMA_IF(N) A##N 

 #define BOOST_LAMBDA_CLASS_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_CLASS, NAME)

@@ -83,7 +83,7 @@ public:                                                                     \
 };


-#define BOOST_LAMBDA_HELPER(z, N, A) BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE( BOOST_PP_INC(N) )
+#define BOOST_LAMBDA_HELPER(N, A) BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE( BOOST_PP_INC(N) )

 // Generate the traits for 1-4 argument templates

--- a/include/boost/lambda/detail/lambda_functor_base.hpp
+++ b/include/boost/lambda/detail/lambda_functor_base.hpp
@@ -310,12 +310,10 @@ template<class Args>
 class lambda_functor_base<do_nothing_action, Args> {
  //  Args args;
 public:
-  //  explicit lambda_functor_base(const Args& a) {}
-  lambda_functor_base() {}
-
+  explicit lambda_functor_base(const Args& a) {}

  template<class RET, CALL_TEMPLATE_ARGS> RET call(CALL_FORMAL_ARGS) const {
-    return CALL_USE_ARGS;
+    CALL_USE_ARGS;
  }

  template<class SigArgs> struct sig { typedef void type; };
--- a/include/boost/lambda/detail/member_ptr.hpp
+++ b/include/boost/lambda/detail/member_ptr.hpp
@@ -436,10 +436,10 @@ namespace detail {

 template<class RET, class A, class B>
 class member_pointer_caller {
-  A a; B b;
-
+  A a;
+  B b;
 public:
-  member_pointer_caller(const A& aa, const B& bb) : a(aa), b(bb) {}
+  member_pointer_caller(A aa, B bb) : a(aa), b(bb) {}

  RET operator()() const { return (a->*b)(); } 

@@ -589,24 +589,29 @@ struct member_pointer_action_helper<false, true> {

  template<class RET, class A, class B>
  static RET apply(A& a, B& b) { 
+
    typedef typename ::boost::remove_cv<B>::type plainB;
    typedef typename detail::member_pointer<plainB>::type ret_t; 
-    typedef typename ::boost::remove_cv<A>::type plainA;

-    // we always strip cv:s to 
-    // make the two routes (calling and type deduction)
+    // we always add const (it is just the pointer types, not the types
+    // pointed to) to make the to routes (calling and type deduction)
    // to give the same results (and the const does not make any functional
    // difference)
-    return detail::member_pointer_caller<ret_t, plainA, plainB>(a, b); 
+    return detail::member_pointer_caller<ret_t, const A&, const B&>(a, b); 
  }

  template<class A, class B>
  struct return_type {
    typedef typename detail::remove_reference_and_cv<B>::type plainB;
    typedef typename detail::member_pointer<plainB>::type ret_t; 
-    typedef typename detail::remove_reference_and_cv<A>::type plainA; 

-    typedef detail::member_pointer_caller<ret_t, plainA, plainB> type; 
+    // we always add const (it is just the pointer types, not the types
+    // pointed to)
+    typedef detail::member_pointer_caller<
+      ret_t, 
+      typename boost::add_reference<const A>::type, 
+      typename boost::add_reference<const B>::type
+    > type;  
  };
 };

@@ -616,10 +621,12 @@ template<> class other_action<member_pointer_action>  {
 public:
  template<class RET, class A, class B>
  static RET apply(A& a, B& b) {
+
    typedef typename 
      ::boost::remove_cv<B>::type plainB;

-    return detail::member_pointer_action_helper<
+    return 
+      detail::member_pointer_action_helper<
        boost::is_pointer<A>::value && 
          detail::member_pointer<plainB>::is_data_member,
        boost::is_pointer<A>::value && 
--- a/include/boost/lambda/detail/operator_return_type_traits.hpp
+++ b/include/boost/lambda/detail/operator_return_type_traits.hpp
@@ -19,8 +19,6 @@
 #include "boost/lambda/detail/is_instance_of.hpp"
 #include "boost/type_traits/same_traits.hpp"

-#include "boost/indirect_reference.hpp"
-
 #include <cstddef> // needed for the ptrdiff_t
 #include <iosfwd>  // for istream and ostream

@@ -223,7 +221,7 @@ namespace detail {

  // A is a nonreference type
 template <class A> struct contentsof_type {
-  typedef typename boost::indirect_reference<A>::type type; 
+  typedef typename std::iterator_traits<A>::reference type; 
 };

  // this is since the nullary () in lambda_functor is always instantiated
@@ -494,6 +492,7 @@ struct promotion_of_unsigned_int
 {
        typedef
        detail::IF<sizeof(long) <= sizeof(unsigned int),        
+// I had the logic reversed but ">" messes up the parsing.
                unsigned long,
                long>::RET type; 
 };
@@ -867,20 +866,10 @@ namespace std {
 template <class Key, class T, class Cmp, class Allocator> class map;
 template <class Key, class T, class Cmp, class Allocator> class multimap;
 template <class T, class Allocator> class vector;
+ template <class T, class Allocator> class deque;
 template <class Char, class Traits, class Allocator> class basic_string;
 }

-// The GCC 2.95.x uses a non-conformant deque
-#if BOOST_WORKAROUND(__GNUC__, == 2) && __GNUC_MINOR__ <= 96
-#include <deque>
-#else
-
-namespace std {
-  template <class T, class Allocator> class deque;
-}
-
-#endif
-

 namespace boost { 
 namespace lambda {
--- a/include/boost/lambda/detail/operators.hpp
+++ b/include/boost/lambda/detail/operators.hpp
@@ -27,31 +27,22 @@ namespace lambda {
 #error "Multiple defines of BOOST_LAMBDA_BE1"
 #endif

-  // For all BOOSTA_LAMBDA_BE* macros:
-
-  // CONSTA must be either 'A' or 'const A'
-  // CONSTB must be either 'B' or 'const B'
-
-  // It is stupid to have the names A and B as macro arguments, but it avoids
-  // the need to pass in emtpy macro arguments, which gives warnings on some
-  // compilers
-
 #define BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION)      \
 template<class Arg, class B>                                                 \
 inline const                                                                 \
 lambda_functor<                                                              \
  lambda_functor_base<                                                       \
    ACTION,                                                                  \
-    tuple<lambda_functor<Arg>, typename CONVERSION <CONSTB>::type>         \
+    tuple<lambda_functor<Arg>, typename CONVERSION <CONSTB B>::type>         \
  >                                                                          \
 >                                                                            \
-OPER_NAME (const lambda_functor<Arg>& a, CONSTB& b) {                      \
+OPER_NAME (const lambda_functor<Arg>& a, CONSTB B& b) {                      \
  return                                                                     \
    lambda_functor_base<                                                     \
      ACTION,                                                                \
-      tuple<lambda_functor<Arg>, typename CONVERSION <CONSTB>::type>       \
+      tuple<lambda_functor<Arg>, typename CONVERSION <CONSTB B>::type>       \
    >                                                                        \
-   (tuple<lambda_functor<Arg>, typename CONVERSION <CONSTB>::type>(a, b)); \
+   (tuple<lambda_functor<Arg>, typename CONVERSION <CONSTB B>::type>(a, b)); \
 }


@@ -65,16 +56,16 @@ inline const                                                                 \
 lambda_functor<                                                              \
  lambda_functor_base<                                                       \
    ACTION,                                                                  \
-    tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >        \
+    tuple<typename CONVERSION <CONSTA A>::type, lambda_functor<Arg> >        \
  >                                                                          \
 >                                                                            \
-OPER_NAME (CONSTA& a, const lambda_functor<Arg>& b) {                      \
+OPER_NAME (CONSTA A& a, const lambda_functor<Arg>& b) {                      \
  return                                                                     \
    lambda_functor_base<                                                     \
      ACTION,                                                                \
-      tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >      \
+      tuple<typename CONVERSION <CONSTA A>::type, lambda_functor<Arg> >      \
    >                                                                        \
-  (tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >(a, b)); \
+  (tuple<typename CONVERSION <CONSTA A>::type, lambda_functor<Arg> >(a, b)); \
 }


@@ -109,37 +100,36 @@ BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)        \
 BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)        \
 BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)

-#define BOOST_LAMBDA_EMPTY() 

-BOOST_LAMBDA_BE(operator+, arithmetic_action<plus_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator-, arithmetic_action<minus_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator*, arithmetic_action<multiply_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator/, arithmetic_action<divide_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator%, arithmetic_action<remainder_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator<<, bitwise_action<leftshift_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator>>, bitwise_action<rightshift_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator&, bitwise_action<and_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator|, bitwise_action<or_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator^, bitwise_action<xor_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator&&, logical_action<and_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator||, logical_action<or_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator<, relational_action<less_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator>, relational_action<greater_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator<=, relational_action<lessorequal_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator>=, relational_action<greaterorequal_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator==, relational_action<equal_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE(operator!=, relational_action<notequal_action>, const A, const B, const_copy_argument)
+BOOST_LAMBDA_BE(operator+, arithmetic_action<plus_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator-, arithmetic_action<minus_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator*, arithmetic_action<multiply_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator/, arithmetic_action<divide_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator%, arithmetic_action<remainder_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator<<, bitwise_action<leftshift_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator>>, bitwise_action<rightshift_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator&, bitwise_action<and_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator|, bitwise_action<or_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator^, bitwise_action<xor_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator&&, logical_action<and_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator||, logical_action<or_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator<, relational_action<less_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator>, relational_action<greater_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator<=, relational_action<lessorequal_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator>=, relational_action<greaterorequal_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator==, relational_action<equal_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE(operator!=, relational_action<notequal_action>, const, const, const_copy_argument)

-BOOST_LAMBDA_BE(operator+=, arithmetic_assignment_action<plus_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator-=, arithmetic_assignment_action<minus_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator*=, arithmetic_assignment_action<multiply_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator/=, arithmetic_assignment_action<divide_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator%=, arithmetic_assignment_action<remainder_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator<<=, bitwise_assignment_action<leftshift_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator>>=, bitwise_assignment_action<rightshift_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator&=, bitwise_assignment_action<and_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator|=, bitwise_assignment_action<or_action>, A, const B, reference_argument)
-BOOST_LAMBDA_BE(operator^=, bitwise_assignment_action<xor_action>, A, const B, reference_argument)
+BOOST_LAMBDA_BE(operator+=, arithmetic_assignment_action<plus_action>, , const, reference_argument)
+BOOST_LAMBDA_BE(operator-=, arithmetic_assignment_action<minus_action>, , const, reference_argument)
+BOOST_LAMBDA_BE(operator*=, arithmetic_assignment_action<multiply_action>, , const, reference_argument)
+BOOST_LAMBDA_BE(operator/=, arithmetic_assignment_action<divide_action>, , const, reference_argument)
+BOOST_LAMBDA_BE(operator%=, arithmetic_assignment_action<remainder_action>, , const, reference_argument)
+BOOST_LAMBDA_BE(operator<<=, bitwise_assignment_action<leftshift_action>, , const, reference_argument)
+BOOST_LAMBDA_BE(operator>>=, bitwise_assignment_action<rightshift_action>, , const, reference_argument)
+BOOST_LAMBDA_BE(operator&=, bitwise_assignment_action<and_action>, , const, reference_argument)
+BOOST_LAMBDA_BE(operator|=, bitwise_assignment_action<or_action>, , const, reference_argument)
+BOOST_LAMBDA_BE(operator^=, bitwise_assignment_action<xor_action>, , const, reference_argument)


 // A special trick for comma operator for correct preprocessing
@@ -149,9 +139,9 @@ BOOST_LAMBDA_BE(operator^=, bitwise_assignment_action<xor_action>, A, const B, r

 #define BOOST_LAMBDA_COMMA_OPERATOR_NAME operator,

-BOOST_LAMBDA_BE1(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE2(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
-BOOST_LAMBDA_BE3(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
+BOOST_LAMBDA_BE1(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE2(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const, const, const_copy_argument)
+BOOST_LAMBDA_BE3(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const, const, const_copy_argument)



@@ -207,8 +197,8 @@ template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default {

 } // detail

-BOOST_LAMBDA_BE2(operator<<, bitwise_action< leftshift_action>, A, const B, detail::convert_ostream_to_ref_others_to_c_plain_by_default)
-BOOST_LAMBDA_BE2(operator>>, bitwise_action< rightshift_action>, A, const B, detail::convert_istream_to_ref_others_to_c_plain_by_default)      
+BOOST_LAMBDA_BE2(operator<<, bitwise_action< leftshift_action>, , const, detail::convert_ostream_to_ref_others_to_c_plain_by_default)
+BOOST_LAMBDA_BE2(operator>>, bitwise_action< rightshift_action>, , const, detail::convert_istream_to_ref_others_to_c_plain_by_default)      


 // special case for io_manipulators.
@@ -263,17 +253,17 @@ operator>>(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
 #error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E1"
 #endif

-#define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB)            \
+#define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONST)            \
 template<class Arg, int N, class B>                                         \
 inline const                                                                \
 lambda_functor<                                                             \
-  lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >   \
+  lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONST B(&)[N]> >   \
 >                                                                           \
-OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N])                    \
+OPER_NAME (const lambda_functor<Arg>& a, CONST B(&b)[N])                    \
 {                                                                           \
  return lambda_functor<                                                    \
-    lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> > \
-  >(tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b));                       \
+    lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONST B(&)[N]> > \
+  >(tuple<lambda_functor<Arg>, CONST B(&)[N]>(a, b));                       \
 }


@@ -281,31 +271,31 @@ OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N])                    \
 #error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E2"
 #endif

-#define BOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONSTA)             \
+#define BOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONST)             \
 template<int N, class A, class Arg>                                          \
 inline const                                                                 \
 lambda_functor<                                                              \
-  lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > >   \
+  lambda_functor_base<ACTION, tuple<CONST A(&)[N], lambda_functor<Arg> > >   \
 >                                                                            \
-OPER_NAME (CONSTA(&a)[N], const lambda_functor<Arg>& b)                     \
+OPER_NAME (CONST A(&a)[N], const lambda_functor<Arg>& b)                     \
 {                                                                            \
  return                                                                     \
-    lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \
-    (tuple<CONSTA(&)[N], lambda_functor<Arg> >(a, b));                      \
+    lambda_functor_base<ACTION, tuple<CONST A(&)[N], lambda_functor<Arg> > > \
+    (tuple<CONST A(&)[N], lambda_functor<Arg> >(a, b));                      \
 }


-BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>, B)
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>, A)
-BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>,const B)
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>,const A)
+BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>,)
+BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>,)
+BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>,const)
+BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>,const)


 //BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator-, arithmetic_action<minus_action>)
 // This is not needed, since the result of ptr-ptr is an rvalue anyway

-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, A)
-BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, const A)
+BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, )
+BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, const)


 #undef BOOST_LAMBDA_BE1
--- a/include/boost/lambda/detail/ret.hpp
+++ b/include/boost/lambda/detail/ret.hpp
@@ -257,7 +257,7 @@ const_parameters(const lambda_functor<Arg>& lf)
 // the wrapped lambda functor is evaluated, but we just don't do anything
 // with the result.
 struct voidifier_action {
-  template<class Ret, class A> static void apply(A&) {}
+  template<class Ret, class A> static Ret apply(A&) {}
 };

 template<class Args> struct return_type_N<voidifier_action, Args> {
@@ -291,7 +291,7 @@ lambda_functor<
 > 
 make_void(const Arg1& a1) { 
 return 
-    lambda_functor_base<do_nothing_action, null_type>();
+    lambda_functor_base<do_nothing_action, null_type>(null_type());
 }

 // std_functor -----------------------------------------------------
--- a/include/boost/lambda/detail/return_type_traits.hpp
+++ b/include/boost/lambda/detail/return_type_traits.hpp
@@ -17,8 +17,6 @@
 #ifndef BOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP
 #define BOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP

-#include "boost/mpl/aux_/has_xxx.hpp"
-
 #include <cstddef> // needed for the ptrdiff_t

 namespace boost { 
@@ -241,42 +239,10 @@ struct return_type_N<function_action<I, Ret>, Args> {
  typedef Ret type;
 };

-// ::result_type support
-
-namespace detail
-{
-
-BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
-
-template<class F> struct get_result_type
-{
-  typedef typename F::result_type type;
-};
-
-template<class F, class A> struct get_sig
-{
-  typedef typename function_adaptor<F>::template sig<A>::type type;
-};
-
-} // namespace detail
-
  // Ret is detail::unspecified, so try to deduce return type
 template<int I, class Args> 
 struct return_type_N<function_action<I, detail::unspecified>, Args > { 
-
-  // in the case of function action, the first element in Args is 
-  // some type of function
-  typedef typename Args::head_type Func;
-  typedef typename detail::remove_reference_and_cv<Func>::type plain_Func;
-
-public: 
-  // pass the function to function_adaptor, and get the return type from 
-  // that
-  typedef typename detail::IF<
-    detail::has_result_type<plain_Func>::value,
-	detail::get_result_type<plain_Func>,
-	detail::get_sig<plain_Func, Args>
-  >::RET::type type;
+  typedef typename function_adaptor_with_actuals<Args>::type type;
 };


--- a/include/boost/lambda/detail/select_functions.hpp
+++ b/include/boost/lambda/detail/select_functions.hpp
@@ -30,16 +30,16 @@ inline Any& select(Any& any, CALL_FORMAL_ARGS) { CALL_USE_ARGS; return any; }
 template<class Arg, CALL_TEMPLATE_ARGS>
 inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
 select ( const lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) { 
-  return op.template call<
-    typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
-  >(CALL_ACTUAL_ARGS); 
+    return op.template call<
+      typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
+    >(CALL_ACTUAL_ARGS); 
 }
 template<class Arg, CALL_TEMPLATE_ARGS>
 inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
 select ( lambda_functor<Arg>& op, CALL_FORMAL_ARGS) { 
-  return op.template call<
-    typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
-  >(CALL_ACTUAL_ARGS); 
+    return op.template call<
+      typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
+    >(CALL_ACTUAL_ARGS); 
 }

 // ------------------------------------------------------------------------
--- a/include/boost/lambda/exceptions.hpp
+++ b/include/boost/lambda/exceptions.hpp
@@ -307,7 +307,7 @@ catch_exception(const lambda_functor<Arg>& a) {
 }

 // catch and do nothing case.
-template <class CatchType>
+template <class CatchType, class Arg>
 inline const 
 tagged_lambda_functor<
  detail::exception_catch_tag<detail::catch_block<CatchType> >, 
@@ -328,7 +328,7 @@ catch_exception() {
          null_type
        > 
      >
-    > ();
+    > (null_type());
 }

 // create catch(...) blocks
@@ -349,6 +349,7 @@ catch_all(const lambda_functor<Arg>& a) {
 }

 // catch(...) and do nothing case.
+template <class CatchType, class Arg>
 inline const 
 tagged_lambda_functor<
  detail::exception_catch_tag<detail::catch_all_block>, 
@@ -369,7 +370,7 @@ catch_all() {
          null_type
        > 
      > 
-    > ();
+    > (null_type());
 }

 // try_catch functions --------------------------------
--- a/include/boost/lambda/if.hpp
+++ b/include/boost/lambda/if.hpp
@@ -1,7 +1,7 @@
 // Boost Lambda Library -- if.hpp ------------------------------------------

 // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
+// Copyright (C) 2000 Gary Powell (gary.powell@sierra.com)
 // Copyright (C) 2001-2002 Joel de Guzman
 //
 // Permission to copy, use, sell and distribute this software is granted
--- a/include/boost/lambda/loops.hpp
+++ b/include/boost/lambda/loops.hpp
@@ -1,7 +1,7 @@
 // Boost Lambda Library -- loops.hpp ----------------------------------------

 // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
+// Copyright (C) 2000 Gary Powell (gary.powell@sierra.com)
 //
 // Permission to copy, use, sell and distribute this software is granted
 // provided this copyright notice appears in all copies. 
--- a/include/boost/lambda/switch.hpp
+++ b/include/boost/lambda/switch.hpp
@@ -1,6 +1,6 @@
 // Boost Lambda Library -- switch.hpp -----------------------------------
 //
-// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
+// Copyright (C) 2000 Gary Powell (gary.powell@sierra.com)
 // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
 //
 // Permission to copy, use, sell and distribute this software is granted
@@ -129,7 +129,7 @@ return
      lambda_functor_base< 
        do_nothing_action, 
        null_type 
-      > () ;
+      > (cnull_type()) ;
 }


@@ -287,10 +287,10 @@ public:
 // BOOST_LAMBDA_A_I_LIST(N, X) is a list of form X0, X1, ..., XN
 // BOOST_LAMBDA_A_I_B_LIST(N, X, Y) is a list of form X0 Y, X1 Y, ..., XN Y

-#define BOOST_LAMBDA_A_I(z, i, A) \
+#define BOOST_LAMBDA_A_I(i, A) \
 BOOST_PP_COMMA_IF(i) BOOST_PP_CAT(A,i)

-#define BOOST_LAMBDA_A_I_B(z, i, T) \
+#define BOOST_LAMBDA_A_I_B(i, T) \
 BOOST_PP_COMMA_IF(i) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,0,T),i) BOOST_PP_TUPLE_ELEM(2,1,T)

 #define BOOST_LAMBDA_A_I_LIST(i, A) \
@@ -301,7 +301,7 @@ BOOST_PP_REPEAT(i,BOOST_LAMBDA_A_I_B, (A,B))


 // Switch related macros -------------------------------------------
-#define BOOST_LAMBDA_SWITCH_CASE_BLOCK(z, N, A) \
+#define BOOST_LAMBDA_SWITCH_CASE_BLOCK(N, A) \
  case Case##N: \
  detail::select(::boost::tuples::get<BOOST_PP_INC(N)>(args), CALL_ACTUAL_ARGS); \
  break;
@@ -392,7 +392,7 @@ switch_statement() {
        do_nothing_action, 
        null_type
      > 
-  ();
+  ( null_type());
 }

 // 1 argument case, this is useless as well, just the condition part
@@ -414,7 +414,7 @@ switch_statement(const lambda_functor<TestArg>& a1) {
 }


-#define HELPER(z, N, FOO)                                      \
+#define HELPER(N, FOO)                                         \
 BOOST_PP_COMMA_IF(N)                                           \
 BOOST_PP_CAT(                                                  \
  const tagged_lambda_functor<detail::switch_case_tag<TagData, \
@@ -463,11 +463,11 @@ BOOST_LAMBDA_SWITCH_NO_DEFAULT_CASE(N)   \
 BOOST_LAMBDA_SWITCH_WITH_DEFAULT_CASE(N)        

 // Use this to avoid case 0, these macros work only from case 1 upwards
-#define BOOST_LAMBDA_SWITCH_HELPER(z, N, A) \
+#define BOOST_LAMBDA_SWITCH_HELPER(N, A) \
 BOOST_LAMBDA_SWITCH( BOOST_PP_INC(N) )

 // Use this to avoid cases 0 and 1, these macros work only from case 2 upwards
-#define BOOST_LAMBDA_SWITCH_STATEMENT_HELPER(z, N, A) \
+#define BOOST_LAMBDA_SWITCH_STATEMENT_HELPER(N, A) \
 BOOST_LAMBDA_SWITCH_STATEMENT(BOOST_PP_INC(N))


--- a/index.html
+++ b/index.html
@@ -1,8 +0,0 @@
-<html>
-<head>
-<meta http-equiv="refresh" content="0; URL=doc/index.html">
-</head>
-<body>
-Automatic redirection failed, please go to <a href="doc/index.html">doc/index.html</a>
-</body>
-</html>
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -1,93 +0,0 @@
-subproject libs/lambda/test ;
-
-unit-test is_instance_of_test
-    : is_instance_of_test.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test algortihm_test
-    : algorithm_test.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-    
-unit-test operator_tests_simple
-    : operator_tests_simple.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test member_pointer_test
-    : member_pointer_test.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test control_structures
-    : control_structures.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test switch_construct 
-    : switch_construct.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test bind_tests_simple
-    : bind_tests_simple.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test bind_tests_advanced  
-    : bind_tests_advanced.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test bll_and_function
-    : bll_and_function.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test constructor_tests
-    : constructor_tests.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test extending_rt_traits
-    : extending_rt_traits.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test bind_tests_simple_f_refs
-    : bind_tests_simple_f_refs.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test cast_test
-    : cast_test.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test phoenix_control_structures
-    : phoenix_control_structures.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test exception_test
-    : exception_test.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-
--- a/test/algorithm_test.cpp
+++ b/test/algorithm_test.cpp
@@ -1,66 +0,0 @@
-//  bll_and_function.cpp  - The Boost Lambda Library -----------------------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// test using BLL and boost::function
-
-//#include <boost/test/minimal.hpp>    // see "Header Implementation Option"
-#include <boost/test/test_tools.hpp>
-
-#include "boost/lambda/lambda.hpp"
-#include "boost/lambda/bind.hpp"
-#include "boost/lambda/algorithm.hpp"
-
-#include <vector>
-#include <map>
-#include <set>
-#include <string>
-
-#include <iostream>
-
-
-
-void test_foreach() {
-  using namespace boost::lambda;
-  
-  int a[10][20];
-  int sum = 0;
-
-  std::for_each(a, a + 10, 
-                bind(ll::for_each(), _1, _1 + 20, 
-                     protect((_1 = var(sum), ++var(sum)))));
-
-  sum = 0;
-  std::for_each(a, a + 10, 
-                bind(ll::for_each(), _1, _1 + 20, 
-                     protect((sum += _1))));
-
-  BOOST_TEST(sum == (199 + 1)/ 2 * 199);
-}
-
-// More tests needed (for all algorithms)
-
-int test_main(int, char *[]) {
-
-  test_foreach();
-
-  return 0;
-}
-
-
-
-
-
-
--- a/test/bind_tests_advanced.cpp
+++ b/test/bind_tests_advanced.cpp
@@ -1,21 +1,4 @@
-//  bind_tests_advanced.cpp  -- The Boost Lambda Library ------------------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// -----------------------------------------------------------------------
-
+//  bind_tests_advanced.cpp  --------------------------------

 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
--- a/test/bind_tests_simple.cpp
+++ b/test/bind_tests_simple.cpp
@@ -1,21 +1,4 @@
-//  bind_tests_simple.cpp  -- The Boost Lambda Library ------------------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// -----------------------------------------------------------------------
-
+//  bind_tests_simple.cpp  --------------------------------

 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
@@ -48,18 +31,6 @@ class A {
 public:
  A(int n) : i(n) {};
  int add(const int& j) { return i + j; }
-  int add2(int a1, int a2) { return i + a1 + a2; }
-  int add3(int a1, int a2, int a3) { return i + a1 + a2 + a3; }
-  int add4(int a1, int a2, int a3, int a4) { return i + a1 + a2 + a3 + a4; }
-  int add5(int a1, int a2, int a3, int a4, int a5) 
-  { return i + a1 + a2 + a3 + a4 + a5; }
-  int add6(int a1, int a2, int a3, int a4, int a5, int a6) 
-  { return i + a1 + a2 + a3 + a4 + a5 + a6; }
-  int add7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) 
-  { return i + a1 + a2 + a3 + a4 + a5 + a6 + a7; }
-  int add8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) 
-  { return i + a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8; }
-
 };

 void test_member_functions()
@@ -76,14 +47,6 @@ void test_member_functions()
    BOOST_TEST(bind(&A::add, _1, 1)(a) == 11);
    BOOST_TEST(bind(&A::add, _1, 1)(make_const(&a)) == 11);

-    BOOST_TEST(bind(&A::add2, _1, 1, 1)(a) == 12);
-    BOOST_TEST(bind(&A::add3, _1, 1, 1, 1)(a) == 13);
-    BOOST_TEST(bind(&A::add4, _1, 1, 1, 1, 1)(a) == 14);
-    BOOST_TEST(bind(&A::add5, _1, 1, 1, 1, 1, 1)(a) == 15);
-    BOOST_TEST(bind(&A::add6, _1, 1, 1, 1, 1, 1, 1)(a) == 16);
-    BOOST_TEST(bind(&A::add7, _1, 1, 1, 1, 1, 1, 1, 1)(a) == 17);
-    BOOST_TEST(bind(&A::add8, _1, 1, 1, 1, 1, 1, 1, 1, 1)(a) == 18);
-
  // This should fail, as lambda functors store arguments as const
  // bind(&A::add, a, _1); 
 }
--- a/test/bind_tests_simple_f_refs.cpp
+++ b/test/bind_tests_simple_f_refs.cpp
@@ -1,21 +1,4 @@
-//  bind_tests_simple.cpp  -- The Boost Lambda Library ------------------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// -----------------------------------------------------------------------
-
+//  bind_tests_simple.cpp  --------------------------------

 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
--- a/test/bll_and_function.cpp
+++ b/test/bll_and_function.cpp
@@ -1,18 +1,4 @@
-//  bll_and_function.cpp  - The Boost Lambda Library -----------------------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
+//  bll_and_function.cpp  --------------------------------

 // test using BLL and boost::function

@@ -35,13 +21,13 @@ using namespace std;

 void test_function() {

-  boost::function<int (int, int)> f;
+  boost::function<int, int, int> f;
  f = _1 + _2;

 BOOST_TEST(f(1, 2)== 3);

 int i=1; int j=2;
- boost::function<int& (int&, int)> g = _1 += _2;
+ boost::function<int&, int&, int> g = _1 += _2;
 g(i, j);
 BOOST_TEST(i==3);

@@ -49,7 +35,7 @@ void test_function() {

  int* sum = new int();
  *sum = 0;
-  boost::function<int& (int)> counter = *sum += _1;
+  boost::function<int&, int> counter = *sum += _1;
  counter(5); // ok, sum* = 5;
  BOOST_TEST(*sum == 5);
  delete sum; 
--- a/test/cast_test.cpp
+++ b/test/cast_test.cpp
@@ -1,21 +1,4 @@
-//  cast_tests.cpp  -- The Boost Lambda Library ------------------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// -----------------------------------------------------------------------
-
+//  cast_tests.cpp  --------------------------------

 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
--- a/test/constructor_tests.cpp
+++ b/test/constructor_tests.cpp
@@ -1,21 +1,4 @@
-//  constructor_tests.cpp  -- The Boost Lambda Library ------------------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// -----------------------------------------------------------------------
-
+//  constructor_tests.cpp  --------------------------------

 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
--- a/test/control_structures.cpp
+++ b/test/control_structures.cpp
@@ -1,21 +1,3 @@
-// -- control_structures.cpp -- The Boost Lambda Library ------------------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// -----------------------------------------------------------------------
-
 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"

--- a/test/exception_test.cpp
+++ b/test/exception_test.cpp
@@ -1,21 +1,3 @@
-// -- exception_test.cpp -- The Boost Lambda Library ------------------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// -----------------------------------------------------------------------
-
 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"

@@ -530,19 +512,6 @@ void test_different_number_of_catch_blocks() {
  BOOST_TEST(ecount == 9);
 }

-void test_empty_catch_blocks() {
-  try_catch(
-    bind(throw_AX, _1), 
-    catch_exception<A1>()
-  )(make_const(1));
-
-  try_catch(
-    bind(throw_AX, _1), 
-    catch_all()
-  )(make_const(1));
-
-}
-

 void return_type_matching() {

@@ -607,7 +576,6 @@ int test_main(int, char *[]) {
  {
    test_different_number_of_catch_blocks();
    return_type_matching();
-    test_empty_catch_blocks();
  }
  catch (int x)
  {
--- a/test/extending_rt_traits.cpp
+++ b/test/extending_rt_traits.cpp
@@ -1,21 +1,4 @@
-//  extending_return_type_traits.cpp  -- The Boost Lambda Library --------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// -----------------------------------------------------------------------
-
+//  extending_return_type_traits.cpp  --------------------------------

 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
--- a/test/is_instance_of_test.cpp
+++ b/test/is_instance_of_test.cpp
@@ -1,21 +1,4 @@
-// is_instance_of_test.cpp -- The Boost Lambda Library ------------------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// -----------------------------------------------------------------------
-
+// is_convertible_to_template_test.cpp ----------------------------

 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
--- a/test/member_pointer_test.cpp
+++ b/test/member_pointer_test.cpp
@@ -1,21 +1,4 @@
-//  member_pointer_test.cpp  -- The Boost Lambda Library ------------------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// -----------------------------------------------------------------------
-
+//  member_pointer_test.cpp  --------------------------------

 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
--- a/test/operator_tests_simple.cpp
+++ b/test/operator_tests_simple.cpp
@@ -1,21 +1,4 @@
-//  operator_tests_simple.cpp  -- The Boost Lambda Library ---------------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// -----------------------------------------------------------------------
-
+//  operator_tests_simple.cpp  --------------------------------

 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
@@ -112,7 +95,7 @@ void bitwise_operators() {
  BOOST_TEST((_1 & 1)(ui)==(2 & 1));
  BOOST_TEST((_1 | 1)(ui)==(2 | 1));
  BOOST_TEST((_1 ^ 1)(ui)==(2 ^ 1));
-  BOOST_TEST((~_1)(ui)==~2u);
+  BOOST_TEST((~_1)(ui)==~2);
 }

 void comparison_operators() {
--- a/test/phoenix_control_structures.cpp
+++ b/test/phoenix_control_structures.cpp
@@ -1,21 +1,4 @@
-//  phoenix_style_control_structures.cpp  -- The Boost Lambda Library ------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// -----------------------------------------------------------------------
-
+//  phoenix_style_control_structures.cpp  --------------------------------

 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
@@ -38,9 +21,11 @@ using namespace boost::lambda;
 using namespace std;


-
-//  If-else, while, do-while, for statements
-
+///////////////////////////////////////////////////////////////////////////////
+//
+//  If-else, while, do-while, for tatements
+//
+///////////////////////////////////////////////////////////////////////////////

 int test_main(int, char *[]) {

--- a/test/switch_construct.cpp
+++ b/test/switch_construct.cpp
@@ -1,21 +1,4 @@
-//  switch_test.cpp  -- The Boost Lambda Library --------------------------
-//
-// Copyright (C) 2000-2003 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see www.boost.org
-
-// -----------------------------------------------------------------------
-
+//  switch_test.cpp  --------------------------------

 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
@@ -368,30 +351,11 @@ void do_switch_yes_defaults_tests() {

 }

-void test_empty_cases() {
-
-  using namespace boost::lambda;  
-
-  // ---
-  switch_statement( 
-      _1,
-      default_statement()
-  )(make_const(1));
-
-  switch_statement( 
-      _1,
-      case_statement<1>()
-  )(make_const(1));
-
-}
-
 int test_main(int, char* []) {

  do_switch_no_defaults_tests();
  do_switch_yes_defaults_tests();

-  test_empty_cases();
-
  return EXIT_SUCCESS;

 }
Author	SHA1	Message	Date
nobody	f31a02bbf4	This commit was manufactured by cvs2svn to create tag 'Version_1_28_0'. [SVN r13949]	2002-05-16 13:26:18 +00:00
Jaakko Järvi	4bdba37066	adding dummy usages of some arugments to avoid unused argument warnings [SVN r13923]	2002-05-15 17:16:52 +00:00
nobody	aa3bf071a8	This commit was manufactured by cvs2svn to create branch 'RC_1_28_0'. [SVN r13795]	2002-05-10 04:34:27 +00:00