# Passing a C++ Lambda to a GSL Function

The GNU Scientific Library is a C library that offers (among other things) an
integration routine. One does not pass a simple `double (*f)(double)`

function
parameter because there might be additional parameters needed. The article
Currying in C lists various possibilities, the GSL
implements the variant with the `void *`

. A *dummy* implementation of this
integration routine could look like this, for the purpose of this article:

```
double gsl_integrate(double (*f)(double, void *), void *param) {
std::cout << f(1.0, param) << std::endl;
return 0.0;
}
```

This is not the real function! The real thing is more complicated but is not directly needed to understand this approach.

We would like to pass a C++ lambda into this function. That is not directly possible because the types do not match. Therefore it would be great to have some wrapping mechanism that allows to call it with C++ lambdas, function pointers and functors.

The idea is to pass the lambda as the `void *`

and use a general function for
the parameter `f`

. The following unwrapping function has the signature required
by the GSL function but can unwrap a C++ lambda:

```
double unwrap(double x, void *p) {
auto fp = static_cast<std::function<double(double)> *>(p);
return (*fp)(x);
}
```

Using this, one can write an integration function that takes a C++ lambda and passes that to the GSL function:

```
double integrate(std::function<double(double)> ftor) {
return gsl_integrate(unwrap, &ftor);
}
```

In the user code, this might be used with a lambda that captures something:

```
int main(int argc, char **argv) {
double b = 5.4;
auto func = [&b](double x) { return x * x + b; };
integrate(func);
}
```

For the actual GSL function, one needs to define a `struct`

and a little more
elaborate wrapper. This should be enough to get you started.