Question: Here's a lamba wrapper expression defined:

```
function <int(double)> f = 
     [](double x) -> int{ return static_cast <int> (x*x); };

```

It is used like this:

```
f(someintvalue);

```

What is the difference between normal functions and wrapped lambdas?

Answer: 
> 
> question is - what is the difference between normal function and wrapped lambda?
> 
> 
> 

Normal function is a normal function and what you call "wrapped lambda" is actually a function object.

By the way, why use `std::function`? You could simply write this:

```
auto f = [](double x) { return static_cast <int> (x*x); };

//call
int result = f(100.0);

```

Also, I omitted the return type, as it is implicitly known to the compiler from the return expression. No need to write `-> int` in the lambda expression.
Lambdas can capture surrounding scope ([=] or [&]) resulting in anonymous structs that contain a member function.

Certain tasks, like accessing lambda (types) across Translation Units, or taking standard pointer-to-memberfunction addresses from lambdas may prove hard/useless because the actual type of the automatically generated 'anonymous' type cannot be known (and is in fact implementation defined).

`std::function<>` was designed to alleviate exactly *that* problem: being able to bind a function pointer (semantically) to a lambda (or indeed, whatever [*callable object*](http://en.wikipedia.org/wiki/C++_Technical_Report_1#Polymorphic_function_wrapper))

---

> 
> 1: in fact the type can have external linkage, but you cannot *portably* refer to that from another translation unit because the actual type is implementation defined (and need not even be expressible in C++ code; within the original TU you'd be able to use `decltype` to get the *magic type*. Thanks, Luc for the good precisions about this)
> 
> 
>