/Src/Dependencies/Boost/libs/phoenix/doc/html/phoenix/modules/scope/lambda.html

http://hadesmem.googlecode.com/ · HTML · 194 lines · 190 code · 4 blank · 0 comment · 0 complexity · 83f3d79780d615a361e25df558df653f MD5 · raw file 

    

  1. <html>
    2. 

  2. <head>
    3. 

  3. <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
    4. 

  4. <title>lambda</title>
    5. 

  5. <link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
    6. 

  6. <meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
    7. 

  7. <link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Phoenix 3.0">
    8. 

  8. <link rel="up" href="../scope.html" title="Scope">
    9. 

  9. <link rel="prev" href="let.html" title="let">
    10. 

  10. <link rel="next" href="../bind.html" title="Bind">
    11. 

  11. </head>
    12. 

  12. <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
    13. 

  13. <table cellpadding="2" width="100%"><tr>
    14. 

  14. <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
    15. 

  15. <td align="center"><a href="../../../../../../../index.html">Home</a></td>
    16. 

  16. <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
    17. 

  17. <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
    18. 

  18. <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
    19. 

  19. <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
    20. 

  20. </tr></table>
    21. 

  21. <hr>
    22. 

  22. <div class="spirit-nav">
    23. 

  23. <a accesskey="p" href="let.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../scope.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../bind.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
    24. 

  24. </div>
    25. 

  25. <div class="section">
    26. 

  26. <div class="titlepage"><div><div><h4 class="title">
    27. 

  27. <a name="phoenix.modules.scope.lambda"></a><a class="link" href="lambda.html" title="lambda">lambda</a>
    28. 

  28. </h4></div></div></div>
    29. 

  29. <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">scope</span><span class="special">/</span><span class="identifier">lambda</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
    30. 

  30. </pre>
    31. 

  31. <p>
    32. 

  32.           A lot of times, you'd want to write a lazy function that accepts one or
    33. 

  33.           more functions (higher order functions). STL algorithms come to mind, for
    34. 

  34.           example. Consider a lazy version of <code class="computeroutput"><span class="identifier">stl</span><span class="special">::</span><span class="identifier">for_each</span></code>:
    35. 

  35.         </p>
    36. 

  36. <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">for_each_impl</span>
    37. 

  37. <span class="special">{</span>
    38. 

  38.     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span>
    39. 

  39.     <span class="keyword">struct</span> <span class="identifier">result</span>
    40. 

  40.     <span class="special">{</span>
    41. 

  41.         <span class="keyword">typedef</span> <span class="keyword">void</span> <span class="identifier">type</span><span class="special">;</span>
    42. 

  42.     <span class="special">};</span>
    43. 

  43. 

  44.     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">F</span><span class="special">&gt;</span>
    45. 

  45.     <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">C</span><span class="special">&amp;</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">F</span> <span class="identifier">f</span><span class="special">)</span> <span class="keyword">const</span>
    46. 

  46.     <span class="special">{</span>
    47. 

  47.         <span class="identifier">std</span><span class="special">::</span><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">f</span><span class="special">);</span>
    48. 

  48.     <span class="special">}</span>
    49. 

  49. <span class="special">};</span>
    50. 

  50. 

  51. <span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">for_each_impl</span><span class="special">&gt;</span> <span class="keyword">const</span> <span class="identifier">for_each</span> <span class="special">=</span> <span class="identifier">for_each_impl</span><span class="special">();</span>
    52. 

  52. </pre>
    53. 

  53. <p>
    54. 

  54.           Notice that the function accepts another function, <code class="computeroutput"><span class="identifier">f</span></code>
    55. 

  55.           as an argument. The scope of this function, <code class="computeroutput"><span class="identifier">f</span></code>,
    56. 

  56.           is limited within the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>. When <code class="computeroutput"><span class="identifier">f</span></code>
    57. 

  57.           is called inside <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">for_each</span></code>, it exists in a new scope, along
    58. 

  58.           with new arguments and, possibly, local variables. This new scope is not
    59. 

  59.           at all related to the outer scopes beyond the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>.
    60. 

  60.         </p>
    61. 

  61. <p>
    62. 

  62.           Simple syntax:
    63. 

  63.         </p>
    64. 

  64. <pre class="programlisting"><span class="identifier">lambda</span>
    65. 

  65. <span class="special">[</span>
    66. 

  66.     <span class="identifier">lambda</span><span class="special">-</span><span class="identifier">body</span>
    67. 

  67. <span class="special">]</span>
    68. 

  68. </pre>
    69. 

  69. <p>
    70. 

  70.           Like <code class="computeroutput"><span class="identifier">let</span></code>, local variables
    71. 

  71.           may be declared, allowing 1..N local variable declarations (where N ==
    72. 

  72.           <code class="computeroutput"><span class="identifier">BOOST_PHOENIX_LOCAL_LIMIT</span></code>):
    73. 

  73.         </p>
    74. 

  74. <pre class="programlisting"><span class="identifier">lambda</span><span class="special">(</span><span class="identifier">local</span><span class="special">-</span><span class="identifier">declarations</span><span class="special">)</span>
    75. 

  75. <span class="special">[</span>
    76. 

  76.     <span class="identifier">lambda</span><span class="special">-</span><span class="identifier">body</span>
    77. 

  77. <span class="special">]</span>
    78. 

  78. </pre>
    79. 

  79. <p>
    80. 

  80.           The same restrictions apply with regard to scope and visibility. The RHS
    81. 

  81.           (right hand side lambda-expression) of each local-declaration cannot refer
    82. 

  82.           to any LHS local-id. The local-ids are not in scope yet; they will be in
    83. 

  83.           scope only in the lambda-body:
    84. 

  84.         </p>
    85. 

  85. <pre class="programlisting"><span class="identifier">lambda</span><span class="special">(</span>
    86. 

  86.     <span class="identifier">_a</span> <span class="special">=</span> <span class="number">1</span>
    87. 

  87.   <span class="special">,</span> <span class="identifier">_b</span> <span class="special">=</span> <span class="identifier">_a</span> <span class="comment">// Error: _a is not in scope yet
    88. 

  88. </span><span class="special">)</span>
    89. 

  89. </pre>
    90. 

  90. <p>
    91. 

  91.           See <a class="link" href="let.html#phoenix.modules.scope.let.visibility"><code class="computeroutput"><span class="identifier">let</span></code> Visibility</a> for more information.
    92. 

  92.         </p>
    93. 

  93. <p>
    94. 

  94.           Example: Using our lazy <code class="computeroutput"><span class="identifier">for_each</span></code>
    95. 

  95.           let's print all the elements in a container:
    96. 

  96.         </p>
    97. 

  97. <pre class="programlisting"><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">lambda</span><span class="special">[</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">arg1</span><span class="special">])</span>
    98. 

  98. </pre>
    99. 

  99. <p>
    100. 

  100.           As far as the arguments are concerned (arg1..argN), the scope in which
    101. 

  101.           the lambda-body exists is totally new. The left <code class="computeroutput"><span class="identifier">arg1</span></code>
    102. 

  102.           refers to the argument passed to <code class="computeroutput"><span class="identifier">for_each</span></code>
    103. 

  103.           (a container). The right <code class="computeroutput"><span class="identifier">arg1</span></code>
    104. 

  104.           refers to the argument passed by <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">for_each</span></code>
    105. 

  105.           when we finally get to call <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> in our <code class="computeroutput"><span class="identifier">for_each_impl</span></code>
    106. 

  106.           above (a container element).
    107. 

  107.         </p>
    108. 

  108. <p>
    109. 

  109.           Yet, we may wish to get information from outer scopes. While we do not
    110. 

  110.           have access to arguments in outer scopes, what we still have is access
    111. 

  111.           to local variables from outer scopes. We may only be able to pass argument
    112. 

  112.           related information from outer <code class="computeroutput"><span class="identifier">lambda</span></code>
    113. 

  113.           scopes through the local variables.
    114. 

  114.         </p>
    115. 

  115. <div class="note"><table border="0" summary="Note">
    116. 

  116. <tr>
    117. 

  117. <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
    118. 

  118. <th align="left">Note</th>
    119. 

  119. </tr>
    120. 

  120. <tr><td align="left" valign="top"><p>
    121. 

  121.             This is a crucial difference between <code class="computeroutput"><span class="identifier">let</span></code>
    122. 

  122.             and <code class="computeroutput"><span class="identifier">lambda</span></code>: <code class="computeroutput"><span class="identifier">let</span></code> does not introduce new arguments;
    123. 

  123.             <code class="computeroutput"><span class="identifier">lambda</span></code> does.
    124. 

  124.           </p></td></tr>
    125. 

  125. </table></div>
    126. 

  126. <p>
    127. 

  127.           Another example: Using our lazy <code class="computeroutput"><span class="identifier">for_each</span></code>,
    128. 

  128.           and a lazy <code class="computeroutput"><span class="identifier">push_back</span></code>:
    129. 

  129.         </p>
    130. 

  130. <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">push_back_impl</span>
    131. 

  131. <span class="special">{</span>
    132. 

  132.     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
    133. 

  133.     <span class="keyword">struct</span> <span class="identifier">result</span>
    134. 

  134.     <span class="special">{</span>
    135. 

  135.         <span class="keyword">typedef</span> <span class="keyword">void</span> <span class="identifier">type</span><span class="special">;</span>
    136. 

  136.     <span class="special">};</span>
    137. 

  137. 

  138.     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
    139. 

  139.     <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">C</span><span class="special">&amp;</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span>
    140. 

  140.     <span class="special">{</span>
    141. 

  141.         <span class="identifier">c</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
    142. 

  142.     <span class="special">}</span>
    143. 

  143. <span class="special">};</span>
    144. 

  144. 

  145. <span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">push_back_impl</span><span class="special">&gt;</span> <span class="keyword">const</span> <span class="identifier">push_back</span> <span class="special">=</span> <span class="identifier">push_back_impl</span><span class="special">();</span>
    146. 

  146. </pre>
    147. 

  147. <p>
    148. 

  148.           write a lambda expression that accepts:
    149. 

  149.         </p>
    150. 

  150. <div class="orderedlist"><ol class="orderedlist" type="1">
    151. 

  151. <li class="listitem">
    152. 

  152.               a 2-dimensional container (e.g. <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>)
    153. 

  153.             </li>
    154. 

  154. <li class="listitem">
    155. 

  155.               a container element (e.g. <code class="computeroutput"><span class="keyword">int</span></code>)
    156. 

  156.             </li>
    157. 

  157. </ol></div>
    158. 

  158. <p>
    159. 

  159.           and pushes-back the element to each of the <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></code>.
    160. 

  160.         </p>
    161. 

  161. <p>
    162. 

  162.           Solution:
    163. 

  163.         </p>
    164. 

  164. <pre class="programlisting"><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">,</span>
    165. 

  165.     <span class="identifier">lambda</span><span class="special">(</span><span class="identifier">_a</span> <span class="special">=</span> <span class="identifier">arg2</span><span class="special">)</span>
    166. 

  166.     <span class="special">[</span>
    167. 

  167.         <span class="identifier">push_back</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">_a</span><span class="special">)</span>
    168. 

  168.     <span class="special">]</span>
    169. 

  169. <span class="special">)</span>
    170. 

  170. </pre>
    171. 

  171. <p>
    172. 

  172.           Since we do not have access to the arguments of the outer scopes beyond
    173. 

  173.           the lambda-body, we introduce a local variable <code class="computeroutput"><span class="identifier">_a</span></code>
    174. 

  174.           that captures the second outer argument: <code class="computeroutput"><span class="identifier">arg2</span></code>.
    175. 

  175.           Hence: _a = arg2. This local variable is visible inside the lambda scope.
    176. 

  176.         </p>
    177. 

  177. <p>
    178. 

  178.           (See <a href="../../../../../example/lambda.cpp" target="_top">lambda.cpp</a>)
    179. 

  179.         </p>
    180. 

  180. </div>
    181. 

  181. <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
    182. 

  182. <td align="left"></td>
    183. 

  183. <td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005, 2010 Joel de Guzman, Dan Marsden, Thomas Heller<p>
    184. 

  184.         Distributed under the Boost Software License, Version 1.0. (See accompanying
    185. 

  185.         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
    186. 

  186.       </p>
    187. 

  187. </div></td>
    188. 

  188. </tr></table>
    189. 

  189. <hr>
    190. 

  190. <div class="spirit-nav">
    191. 

  191. <a accesskey="p" href="let.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../scope.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../bind.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
    192. 

  192. </div>
    193. 

  193. </body>
    194. 

  194. </html>
    195.