# Partial function evaluation

Many of the adaptors(such as partial or pipable) in the library supports optional partial evaluation of functions. For example, if we have the `sum` function adapted with the `partial` adaptor:

    auto sum = partial([](int x, int y)
    {
        return x+y;
    });

So if we write `sum(1, 2)` it will return 3, however, if we write `sum(1)` it will return a new function, which when called again, it will evaluate the function and return 3:

    int i = sum(1, 2); // Returns 3
    auto f = sum(1);
    int j = f(2); // returns 3

Of course due to limitations in C++, deciding whether evaluate the function or to partially evaluated it, is based on the callability of the function and not arity. So if we call `sum(1, 2, 3)`, it will return a function:

    auto f = sum(1, 2, 3);

However, this can get out of hande as the function `f` will never be evaluated. Plus, it would be nice to produce an error at the point of calling the function rather than a confusing error of trying to use a partial function. The limit decorator lets us annotate the function with the max arity:

    auto sum = partial(limit_c<2>([](int x, int y)
    {
        return x+y;
    }));

So now if we call `sum(1, 2, 3)`, we will get a compiler error. So this improves the situation, but it is not without its limitations. For example if we were to define a triple sum using the pipable adaptor:

    auto sum = pipable(limit_c<3>([](int x, int y, int z)
    {
        return x+y+z;
    }));

So if we call `sum(1)`, there is no compiler error, not until we try to pipe in a value:

    auto f = sum(1); // No error here
    auto i = 2 | f; // Compile error

Of course, the goal may not be to use the pipable call, which could lead to some confusing errors. Currently, there is not a good solution to this.