BLL 定義了三個佔位符類型：placeholder1_type，placeholder2_type 和 placeholder3_type。BLL 為每一個佔位符類型提供了一個預定義的佔位符變量：_1，_2 和 _3。然而，用戶並沒有被強制使用這些變量，定義其它名字的佔位符也很簡單。可以通過定義新的佔位符類型的變量來做到這一點。例如：

boost::lambda::placeholder1_type X;
boost::lambda::placeholder2_type Y;
boost::lambda::placeholder3_type Z;

有了這些變量定義，那麼 X += Y * Z 就等價於 _1 += _2 * _3。

佔位符在 lambda 表達式中的使用決定了結果函數是無元的，一元的，二元的還是三元的。這由最高的佔位符索引決定。例如：

_1 + 5              // unary
_1 * _1 + _1        // unary
_1 + _2             // binary
bind(f, _1, _2, _3) // 3-ary
_3 + 10             // 3-ary

注意，最後一行創建了一個三元函數，它在它的第三個參數上加 10。不去理會前兩個參數。而且，lambda 仿函數只有一個最小的數量。它總能提供真正需要的更多的參數（增加支持佔位符的數量）。多餘的參數只是被丟棄。例如：

int i, j, k; 
_1(i, j, k)        // returns i, discards j and k
(_2 + _2)(i, j, k) // returns j+j, discards i and k

如果要瞭解這一功能背後的設計原理，參見 「Lambda functor arity」 部分。

除了這三個佔位符類型之外，還有第四個佔位符類型 placeholderE_type。這個佔位符的作用是定義 「Exceptions」 部分描述的 lambda 表達式中的異常處理。

為一個佔位符提供真正的參數的時候，參數傳遞的方式總是傳引用。這就意味著任何影響佔位符的副作用都會反映到實際參數上。例如：

int i = 1; 
(_1 += 2)(i);         // i is now 3
(++_1, cout << _1)(i) // i is now 4, outputs 4

基本規則是任何 C++ 操作符調用，只要它的參數中至少有一個是 lambda 表達式，則這個調用本身也是 lambda 表達式。幾乎所有的能重載操作符都已被支持。例如，下面就是一個合法的 lambda 表達式：

cout << _1, _2[_3] = _1 && false

然而，有一些來自於 C++ 操作符重載規則的限制，以及一些特殊情況。

int i; 
_1 = i;      // ok
i = _1;      // not ok. i is not a lambda expression

var(i) = _1; // ok

bool flag = true; int i = 0;
(_1 || ++_2)(flag, i);

for_each(a.begin(), a.end(), (++_1, cout << _1));

bind 表達式可以有兩種形式：

bind(target-function, bind-argument-list)
bind(target-member-function, object-argument, bind-argument-list)

一個 bind 表達式延遲了一個函數的調用。如果這個 target function 是 n 元的，那麼 bind-argument-list 也必須同樣包含 n 個參數。在 BLL 的當前版本中，必須保證 0 <= n <= 9。對於成員函數來說，參數的數目最高為 8，因為對像參數要佔有一個參數位置。總的來說，除了任何一個參數都能被一個佔位符（更一般地說，是 lambda 表達式）取代之外，還要求 bind-argument-list 對於目標函數來說必須是一個合法的參數列表。注意，目標函數也可以是一個 lambda 表達式。根據在 bind-argument-list 中佔位符的使用，一個 bind 表達式的結果可以是無元的，一元的，二元的或三元的函數對像（參見 「Placeholders」 部分）。

bind 表達式創建的 lambda 仿函數的返回類型可以由顯式特化的模板參數給定，就像下面的示例：

bind<RET>(target-function, bind-argument-list)

這一方法只有在目標函數的返回類型不能被推演出來的情況下才是必要的。

以下部分描述 bind 表達式的不同類型。

X foo(A, B, C); A a; B b; C c;
bind(foo, _1, _2, c)(a, b);
bind(&foo, _1, _2, c)(a, b);
bind(_1, a, b, c)(foo);

void foo(int);
void foo(float);
int i; 
  ...
bind(&foo, _1)(i);                            // error 
  ...
void (*pf1)(int) = &foo;
bind(pf1, _1)(i);                             // ok
bind(static_cast<void(*)(int)>(&foo), _1)(i); // ok

bind(target-member-function, object-argument, bind-argument-list)

bool A::foo(int) const; 
A a;
vector<int> ints; 
  ...
find_if(ints.begin(), ints.end(), bind(&A::foo, a, _1)); 
find_if(ints.begin(), ints.end(), bind(&A::foo, &a, _1));

bool A::foo(int); 
list<A> refs; 
list<A*> pointers; 
  ...
find_if(refs.begin(), refs.end(), bind(&A::foo, _1, 1)); 
find_if(pointers.begin(), pointers.end(), bind(&A::foo, _1, 1));

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; }; 
};

A a(0,0); int k = 1;
bind(&A::set_i, &a, _1)(k); // a.i == 1
bind(&A::set_j, &a, _1)(k); // a.j == 1

A a(0,0); int k = 1;
bind(&A::set_i, a, _1)(k); // error; a const copy of a is stored. 
                           // Cannot call a non-const function set_i
bind(&A::set_j, a, _1)(k); // a.j == 0, as a copy of a is modified

bind(&A::set_i, ref(a), _1)(k); // a.j == 1
bind(&A::set_j, cref(a), _1)(k); // a.j == 1

A a(0,0);
bind(&A::set_i, _1, 1)(a); // a.i == 1
bind(&A::set_j, _1, 1)(a); // a.j == 1

struct A { int data; };
A a;
bind(&A::data, _1)(a) = 1;     // a.data == 1

const A ca = a;
bind(&A::data, _1)(ca) = 1;     // error

struct A {
  typedef B result_type;
  B operator()(X, Y, Z); 
};

struct A {
  template <class Args> struct sig { typedef B type; }
  B operator()(X, Y, Z); 
};

struct A {

  // the return type equals the third argument type:
  template<class T1, class T2, class T3>
  T3 operator()(const T1& t1, const T2& t2, const T3& t3) const;

  template <class Args> 
  class sig {
    // get the third argument type (4th element)
    typedef typename 
      boost::tuples::element<3, Args>::type T3;
  public:
    typedef typename 
      boost::remove_cv<T3>::type type;
  };
};

返回類型推演系統可能不能推演某些用戶定義操作符或帶有類對象的 bind 表達式的返回類型。有一種特殊的 lambda 表達式類型被提供，用於顯式表述返回類型和越過推演系統。為了表述由 lambda 表達式 e 定義的 lambda 仿函數的返回值的類型為 T，你可以這樣寫：

ret<T>(e);

這樣的效果是對這個 lambda 表達式 e 的返回類型推演根本就不被執行，改為使用 T 作為返回類型。很明顯，T 不能是任意類型，那個 lambda 仿函數的真正的返回類型必須能夠被隱式轉換到 T。例如：

A a; B b;
C operator+(A, B);
int operator*(A, B); 
  ...
ret<D>(_1 + _2)(a, b);     // error (C cannot be converted to D)
ret<C>(_1 + _2)(a, b);     // ok
ret<float>(_1 * _2)(a, b); // ok (int can be converted to float)
  ...
struct X {
  Y operator(int)();   
};
  ...
X x; int i;
bind(x, _1)(i);            // error, return type cannot be deduced
ret<Y>(bind(x, _1))(i);    // ok

對於 bind 表達式，有一個簡單的記法用來代替 ret。最後一行可以用這種寫法：

bind<Z>(x, _1)(i);

這一特性是模仿了 Boost Bind 庫 [[bind]。

注意，在嵌套 lambda 表達式中，ret 必須被用於每一個推演被捨棄的子表達式。例如：

A a; B b;
C operator+(A, B); D operator-(C);
  ...
ret<D>( - (_1 + _2))(a, b); // error 
ret<D>( - ret<C>(_1 + _2))(a, b); // ok

如果你發現你在相同的類型上重複使用 ret，那就值得擴展返回類型推演（參見 「Extending return type deduction system」 部分）。

struct F { int operator()(int i) const; }; 
F f;
  ...
bind(f, _1);           // fails, cannot deduce the return type
ret<int>(bind(f, _1)); // ok
  ...
bind(f, 1);            // fails, cannot deduce the return type
ret<int>(bind(f, 1));  // fails as well!

bind<int>(f, 1);       // ok

一元函數 constant，constant_ref 和 var 將它們的參數變成一個實現恆等映射的 lambda 仿函數，前兩個用於常量，後面的用於變量。為了明確 lambda 表達式的語法，這些延遲常量和變量的使用有時是有必要的。例如：

for_each(a.begin(), a.end(), cout << _1 << ' ');
for_each(a.begin(), a.end(), cout << ' ' << _1);

第一行輸出以逗號分隔的 a 的元素，第二行輸出一個空格，後面跟著沒有任何分隔符的 a 的元素。這裡的原因在於 cout << ' ' 中的兩個操作數都不是 lambda 表達式，因此 cout << ' ' 被立即求值。為了延遲 cout << ' ' 的求值，其中一個操作數必須被顯式標記為一個 lambda 表達式。這正是 constant 函數的用武之地：

for_each(a.begin(), a.end(), cout << constant(' ') << _1);

調用 constant(' ') 創建了一個無元 lambda 仿函數，它存儲著字符常量 ' ' ，並在被調用時返回這個字符常量的一個引用。函數 constant_ref 與此類似，只不過它存儲的是它的參數的一個 constant reference（常引用）。constant 和 consant_ref 只有在操作符調用有副作用的時候才需要使用，就像上面的那個例子一樣。

有時我們需要延遲一個變量的求值。假設我們要輸出一個容器中的元素到一個帶有編號的列表中：

int index = 0; 
for_each(a.begin(), a.end(), cout << ++index << ':' << _1 << '\n');
for_each(a.begin(), a.end(), cout << ++var(index) << ':' << _1 << '\n');

第一個 for_each 調用不會做出我們想要的東西，index 被增加的次數只有一次，而且它的值被寫到輸出流中的次數也只有一次。通過使用 var 使 index 變成一個 lambda 表達式，我們可以得到想要的效果。

總的來說，var(x) 創建一個無元 lambda 仿函數，它存儲一個引向變量 x 的引用。當這個 lambda 仿函數被調用時，返回一個引向 x 的引用。

var_type<T>::type delayed_i(var(i));
constant_type<T>::type delayed_c(constant(c));

int i = 0; int j;
for_each(a.begin(), a.end(), (var(j) = _1, _1 = var(i), var(i) = var(j))); 

int i = 0; int j;
var_type<int>::type vi(var(i)), vj(var(j));
for_each(a.begin(), a.end(), (vj = _1, _1 = vi, vi = vj));

constant_type<char>::type space(constant(' '));
for_each(a.begin(),a.end(), cout << space << _1);

int i; 
i = _1;       // error
var(i) = _1;  // ok

BLL 定義了幾個函數用來創建代替控制結構的 lambda 仿函數。它們都以 lambda 仿函數作為參數並返回 void。我們以一個例子開始，下面的代碼輸出某個容器 a 的全部偶數元素：

for_each(a.begin(), a.end(), 
         if_then(_1 % 2 == 0, cout << _1));  

BLL 支持以下用於控制結構的函數模板：

if_then(condition, then_part)
if_then_else(condition, then_part, else_part)
if_then_else_return(condition, then_part, else_part)
while_loop(condition, body)
while_loop(condition) // no body case
do_while_loop(condition, body)
do_while_loop(condition) // no body case 
for_loop(init, condition, increment, body)
for_loop(init, condition, increment) // no body case
switch_statement(...)

所有控制結構 lambda 仿函數的返回類型都是 void，但 if_then_else_return 除外，它包裝一個條件操作符的調用

condition ? then_part : else_part

這個操作符的返回類型規則多少有些複雜。主要的是，如果分支有相同的類型，這個類型就是返回類型。如果分支的返回類型不同，一個分支，比方說是類型 A，必須能夠轉換到另一個分支，比方說是類型 B。在這種情況下，結果類型是 B。更進一步，如果通用類型是一個左值，則返回類型也是一個左值。

延遲變量在控制結構 lambda 表達式中隨處可見。例如，這裡我們用 var 函數將 for_loop 的參數變成 lambda 表達式。代碼的作用是為一個二維數組的每一個元素加 1：

int a[5][10]; int i;
for_each(a, a+5, 
  for_loop(var(i)=0, var(i)<10, ++var(i), 
           _1[var(i)] += 1));  

BLL 還支持另外一種控制機構的語法，這個建議由 Joel de Guzmann 提出。通過重載 operator[] 我們可以得到一種和內建控制結構非常類似的形式：

if_(condition)[then_part]
if_(condition)[then_part].else_[else_part]
while_(condition)[body]
do_[body].while_(condition)
for_(init, condition, increment)[body]

例如，如果使用這種語法，上面的 if_then 的例子可以寫成：

for_each(a.begin(), a.end(), 
         if_(_1 % 2 == 0)[ cout << _1 ])  

通過獲得更多的經驗，我們最終可能會拋棄這些語法中的一種。

switch 控制結構的 lambda 表達式更加複雜，因為 cases 的數量是可以變化的。一個 switch lambda 表達式的常規形式是：

switch_statement(condition, 
  case_statement<label>(lambda expression),
  case_statement<label>(lambda expression),
  ...
  default_statement(lambda expression)
)

condition 參數必須是一個創建帶有一個整型返回值的 lambda 仿函數的 lambda 表達式。各種不同的 cases 通過 case_statement 函數創建，可選的 default case 通過 default_statement 函數創建。case 標籤通過顯式特化 case_statement 函數的模板參數給定，而 break 語句是每一種 case 的隱含部分。例如，case_statement<1>(a)，這裡 a 是某一個lambda 仿函數，以上語句生成如下代碼：

case 1: 
  evaluate lambda functor a; 
  break;

switch_statement 函數最多可以指定 9 個 case 語句。

舉一個具體的例子，下面的代碼迭代遍歷某個容器 v 並針對每一個 0 輸出 「zero」，針對每一個 1 輸出 「one」，針對其它的任意值 n 輸出 「other: n」。注意，依次排列在 switch_statement 後面的另一個 lambda 表達式在每一個元素後輸出一行 break：

std::for_each(v.begin(), v.end(),
  ( 
    switch_statement(
      _1,
      case_statement<0>(std::cout << constant("zero")),
      case_statement<1>(std::cout << constant("one")),
      default_statement(cout << constant("other: ") << _1)
    ), 
    cout << constant("\n") 
  )
);

BLL 提供拋出和捕獲異常的 lambda 仿函數。用於拋出異常的 lambda 仿函數由一元函數 throw_exception 創建。傳給這個函數的參數是想要拋出的異常，或者是創建想要拋出的異常的 lambda 仿函數。用於重新拋出異常的 lambda 仿函數由一元的 rethrow 函數創建。

用於處理異常的 lambda 表達式更加複雜。一個 try catch 塊的 lambda 表達式的常規形式如下：

try_catch(
  lambda expression,
  catch_exception<type>(lambda expression),
  catch_exception<type>(lambda expression),
  ...
  catch_all(lambda expression)
)

第一個 lambda 表達式是 try 塊。每一個 catch_exception 定義一個 catch 塊，其中的顯示特化模板參數定義被捕獲的異常的類型。在 catch_exception 內的 lambda 表達式定義了異常被捕獲到時的動作。注意，最終異常處理器捕捉到的異常是引用，例如，catch_exception<T>(...) 導致的 chatch 塊如下：

catch(T& e) { ... }

最後一個 chatch 塊可以在 catch_exception<type> 或 catch_all（這一 lambda 表達式等價於 catch(...)）這兩個調用之中選擇一個。

Example 8.1 「在 lambda 表達式中拋出和處理異常」示範了 BLL 的異常處理工具的使用。第一個 handler（處理器）捕捉 foo_exception 類型的異常。注意 handler（處理器）體內 _1 佔位符的使用。

第二個 handler（處理器）展示如何拋出異常，並示範了 exception placeholder（異常佔位符）_e 的使用。這是一個特殊的佔位符，它與在 handler（處理器）體內捕捉到的異常對像相關。這裡我們處理一個類型為 std::exception 的異常，它帶有一個解釋異常原因的字符串。這一解釋可以用無參數成員函數 what 進行查詢。表達式 bind(&std::exception::what, _e) 創建能產生這個調用的 lambda 函數。注意，_e 不能在一個異常處理器 lambda 表達式之外使用。第二個 handler（處理器）的最後一行構造一個新的異常對象並通過 throw exception 將它拋出。在 lambda 表達式中構造和析構對像在 「Construction and destruction」 部分進行了說明。

最後，第三個 handler（處理器）(catch_all) 示範重新拋出異常。

for_each(
  a.begin(), a.end(),
  try_catch(
    bind(foo, _1),                 // foo may throw
    catch_exception<foo_exception>(
      cout << constant("Caught foo_exception: ") 
           << "foo was called with argument = " << _1
    ),
    catch_exception<std::exception>(
      cout << constant("Caught std::exception: ") 
           << bind(&std::exception::what, _e),
      throw_exception(bind(constructor<bar_exception>(), _1)))
    ),      
    catch_all(
      (cout << constant("Unknown"), rethrow())
    )
  )
);

操作符 new 和 delete 能被重載，但它們的返回類型是固定的。特別是，返回類型不能是 lambda 表達式，以防止它們為 lambda 表達式重載。持有一個構造函數的地址是不可能的，因此構造函數不能在 bind 表達式中作為目標函數使用。這些對於析構函數也同樣成立。為了繞過這些限制，BLL 提供了 new 和 delete 的包裝類，也提供了構造函數和析構函數的包裝類。這些函數的實例是函數對象，它們可以在bind 表達式中作為目標函數使用。例如：

int* a[10];
for_each(a, a+10, _1 = bind(new_ptr<int>())); 
for_each(a, a+10, bind(delete_ptr(), _1));

new_ptr<int>() 表達式被調用時就會創建了一個調用 new int() 的函數對象，並將它包裝在 bind 中做成一個 lambda 仿函數。用同樣的方法，表達式 delete_ptr() 創建一個在其參數上調用 delete 的函數對象。注意，new_ptr<T>() 同樣可以持有參數。它們被直接傳送給構造函數調用，並因此而允許調用持有參數的構造函數。

舉一個在 lambda 表達式中調用構造函數的例子，下面的代碼從兩個容器 x 和 y 中讀取整數，用這兩個整數創建 pairs，並把它們插入到第三個容器中：

vector<pair<int, int> > v;
transform(x.begin(), x.end(), y.begin(), back_inserter(v),
          bind(constructor<pair<int, int> >(), _1, _2));

Table 11.1 「構造函數和析構函數相關函數對像」列出了所有與創建和銷毀對像相關的函數對象，展示了被創建的表達式和調用的函數對象，以及對表達式求值的效果。

BLL 將通常的 STL 算法解釋為函數對像類，它們的實例可以被用作 bind 表達式中的目標函數。例如，下面的代碼遍歷一個二維數組中的元素，並計算它們的和。

int a[100][200];
int sum = 0;

std::for_each(a, a + 100, 
	      bind(ll::for_each(), _1, _1 + 200, protect(sum += _1)));

STL 算法的 BLL 版本是這樣一些類，它們定義了函數調用操作符（或者它的各種重載）用來調用 std 名字空間中的相應的函數模板。所有這些結構位於子名字空間 boost::lambda:ll 中。

注意，沒有容易的方法表達一個 lambda 表達式中重載成員函數的調用。這限制了嵌套 STL 算法的用處，例如，begin 函數在容器模板中有不止一個重載定義。通常，等效於下面偽碼的代碼是寫不出來的：

std::for_each(a.begin(), a.end(), 
	      bind(ll::for_each(), _1.begin(), _1.end(), protect(sum += _1)));

不過，對於通常的特定情況還是能夠提供一些幫助。BLL 定義了兩個輔助函數對像類，call_begin 和 call_end，分別用於包裝一個容器的 begin 和 end 的調用，並返回容器的 const_iterator 類型。使用這些輔助模板，上面的代碼可以寫成：

std::for_each(a.begin(), a.end(), 
	      bind(ll::for_each(), 
                   bind(call_begin(), _1), bind(call_end(), _1),
                        protect(sum += _1)));