There is no real reason that lambdas can't have default arguments. However, there are two main ways to use lambdas, and only one of them would allow default arguments without changing the type system.

1. You can call the lambda directly, or through a template. Default parameters would work fine in this case.

2. You can call the lambda through std::function. Default parameters would not work without changing the type system.

My guess is that new functions that people write in C++11 will usually take std::function parameters because this way, the function won't have to be a template, or it won't have to be instantiated for every single lambda and functor that gets passed to it.

Why can't a std::function (or function pointer) take defaults?

It's not obvious what the type of such a function would be.

• If it's std::function<int(bool)>, then how do you call it with the defaults? (You can't.)

• If it's std::function<int(bool=false)>, then what types is it compatible with, and how does conversion work? Can you convert it to std::function<int()>? What about std::function<int(bool=true)>?

• If it's something new like std::function<int(bool=default)>, then what types is it compatible with, and how does conversion work?

Basically, this isn't just a switch you can flip in the standard and make function pointers / std::function handle default arguments. Default arguments in normal functions are handled using information from the function's declaration, which is not available at the call site for a lambda or function pointer. So you would have to encode information about the defaults into the function type, and then work out all of the non-obvious rules for conversion and compatibility.

So you would have to come up with a compelling case for why such a feature would be added, and convince the committee.

So, why can't lambdas take defaults?

I haven't answered this question. But I don't think it would be a very useful feature to add. I would delete this answer if I could, but it's been accepted. I would downvote it if I could, but it's mine. C'est la vie.

You could use overloading:

int foo(int i)
{
    return foo(i, [](int x) -> int { return x / 2; });
}

int foo(int i, std::function<int(int)> f)
{
    return f(i);
}

Section 5.1.2 paragraph 5 specifically says that you can not have default values for the parameters.

Default arguments (8.3.6) shall not be specified in the parameter-declaration-clause of a lambda-declarator.

Yes. In this respect lambda expressions are no different from other expressions (like, say, 0). But note that deduction is not used with defaulted parameters. In other words, if you declare

template<typename T>
void foo(T = 0);

then foo(0); will call foo<int> but foo() is ill-formed. You'd need to call foo<int>() explicitly. Since in your case you're using a lambda expression nobody can call foo since the type of the expression (at the site of the default parameter) is unique. However you can do:

// perhaps hide in a detail namespace or some such
auto default_parameter = [](int x) { return x; };

template<
    typename Functor = decltype(default_parameter)
>
void foo(Functor f = default_parameter);

Use function overloading instead of the default argument feature. Create a non-template function that takes no arguments in addition to the template function:

void DoUntil() ;

template <typename P>
void DoUntil(P predicate) ;

The no-argument version can simply invoke the template version with the lambda you want to use as the default predicate:

void DoUntil() { DoUntil([] { return false; }); }

The problem with your original approach is that you're trying to provide a default template specialization by specifying a default argument value, but without specifying a default template-type. Even without involving lambdas, the following won't work because T doesn't have a default type, even though t has a default value:

template <typename T>
void Foo(T t = 3);

What's needed is to specify a default type for T using <typename T = int>.

As noted in WhiZTiM's answer, the default type for the case involving the lambda function must be deduced using decltype. This is of course because lambdas have unique types known only to the compiler.

Lambda's take the same signature as regular functions, and you can give reg a default:

f = lambda X, model, reg=1e3: cost(X, model, reg=reg, sparse=np.random.rand(10,10))

What default you give it depends on what default the cost function has assigned to that same parameter. These defaults are stored on that function in the cost.__defaults__ structure, matching the argument names. It is perhaps easiest to use the inspect.getargspec() function to introspect that info:

from inspect import getargspec

spec = getargspec(cost)
cost_defaults = dict(zip(spec.args[-len(defaults:], spec.defaults))
f = lambda X, model, reg=cost_defaults['reg']: cost(X, model, reg=reg, sparse=np.random.rand(10,10))

Alternatively, you could just pass on any extra keyword argument:

f = lambda X, model, **kw: cost(X, model, sparse=np.random.rand(10,10), **kw)