# Evaluating CLEF expressions¶

Forming expressions is nice, but completely useless unless one can *evaluate* them
by affecting some values to the placeholder and actually *do* the computation.

Expressions are evaluated with the eval function

```
eval ( expression , placeholder_1 = value_1, placeholder_2 = value_2, ...)
```

The evaluation can be :

*complete*: when a value has been affected to every placeholder, so the result is not an expression any more, but the result of the computation....*partial*: when some placeholder are still free (no value has been affected to them). The result is another expression where the parts that could be computed have been computed.

## Complete evaluation¶

```
#include <triqs/clef.hpp>
using namespace triqs::clef;
int main() {
placeholder<1> x_;
placeholder<2> y_;
std::cout << eval(x_ + 2 * y_, x_ = 1, y_ = 2) << std::endl;
std::cout << eval(x_ + 2 * y_, y_ = 2, x_ = 1) << std::endl;
}
---------- Result is -------
5
5
```

Note that:

- The order of placeholder does not matter in calling eval.
- It is an error to put the same placeholder twice.
- The correct version of eval is found by ADL (Argument Dependent Lookup) in the triqs::clef namespace.

## Partial evaluation¶

The evaluation can also be partial, in which case the compiler replaces the placeholder whose value is provided and rebuild a new expression tree.

Example

```
auto e1 = x_ + 2*y_;
// return type ---> value
auto r = eval( e1 , x_ =1); // expression ---> 1 + (2 * y_)
auto e2 = eval( e1 , x_ =x_ + y_); // expression ---> ((x_ + y_) + (2 * y_))
auto r = eval( e2, x_ = 1, y_ = 2); // int ---> 7
```

During the partial evaluation, all subtrees that can evaluated are evaluated. For example

```
eval(x_ + f(y_) , y_=1); // --> x + f(1)
```

In this case, the function f is called by eval.