Template argument deduction from lambda

Question

I'm attempting to write a function that basically transforms an instance of a class templated on one type to an instance of the same class templated on a second type. I'd like to avoid having to explicitly state the template types when calling the function.

Here's a minimal compilable example of what I'm trying to do:

template<class T> class container {};

template <class A, class B, template <class C> class Container>
Container<B> transform(Container<A> c, B(func)(A))
{
  return Container<B>{};
}

int do_something(int in)
{
  return in + 1;
}

int main()
{
  container<int> c{};

  //this one doesn't work:
  //transform(c, [](int in) -> int { return in + 1; });
  //these are fine:
  transform<int, int>(c, [](int in) -> int { return in + 1; });
  transform(c, do_something);

  return 0;
}

Uncommenting out the first transform call results in compile errors:

Visual Studio 2017:

error C2784: 'Container<B> transform(Container<A>,B (__cdecl *)(A))': could not deduce template argument for 'B (__cdecl *)(A)' from 'test::<lambda_afc081691b59f849887abca17e74b763>'

Whichever version of g++ coliru.stacked-crooked.com uses by default:

main.cpp:4:14: note:   template argument deduction/substitution failed:
main.cpp:18:52: note:   mismatched types 'B (*)(A)' and 'main()::<lambda(int)>'
   transform(c, [](int in) -> int { return in + 1; });
                                                   ^

Does this mean that it is not possible for the compiler to deduce the signature of a lambda, even when it has been clearly defined like this?

I know I can rewrite my transform function like this:

template <class A, template <class C> class Container, class F>
auto transform(Container<A> c, F func)->Container<decltype(func(A{}))>
{
  return Container<decltype(func(A{}))>{};
}

but now the function signature is a little less readable and the error messages I get if I supply an inappropriate function are quite unfriendly. Using a std::function<B(A)> doesn't help either.

Is there a way to use the more tightly specified function argument with lambdas and without explicitly adding the template types?

score 4 · Accepted Answer · answered May 08 '17 at 09:00

4

You need to convert the capture-less lambda into the static function that preforms the operation. That conversion can actually be invoked fairly easily with an application of the unary + operator.

transform(c, +[](int in) -> int { return in + 1; });

Since the closure type of a capture-less lambda has a conversion operator to ret(*)(params), the compiler will invoke it when encountering +. That is because you can actually apply a + to pointer types.

[expr.unary.op/7]

The operand of the unary + operator shall have arithmetic, unscoped enumeration, or pointer type and the result is the value of the argument. Integral promotion is performed on integral or enumeration operands. The type of the result is the type of the promoted operand.

answered May 08 '17 at 09:00

StoryTeller - Unslander Monica

165,132
21
377
458

I had never heard of the `+` trick before. Nifty. Coliru's g++ will accept that just fine, but VS2015 and VS2017 fail with an interesting `'operator +' is ambiguous` error, being unable to distinguish between `` and ``, so unfortunately I can't use this trick. – Rook May 08 '17 at 09:06
@Rook - Of course MSVC would reject it... Sorry, I don't know how to get around that. – StoryTeller - Unslander Monica May 08 '17 at 09:07
since the parameter is a function shouldn't have the conversion of lambda to function pointer happen implicitly? – bolov May 08 '17 at 09:07
@bolov - Not in a deduced context. It's somewhere in the standard, but I'm having trouble finding it at the moment. – StoryTeller - Unslander Monica May 08 '17 at 09:09
1

Just found another reference to the same solution here: http://stackoverflow.com/questions/25038534/template-type-deduction-with-lambdas?rq=1 Seems like MSVC has been unable to do this for years. Bit disappointing that. – Rook May 08 '17 at 09:09
@bolov - Indeed. But in essence, it's the same principle by which we were all bitten when trying to do [this](https://ideone.com/Kw6JRJ). – StoryTeller - Unslander Monica May 08 '17 at 09:15
I've marked you as the answer because you've offered what appears to be the only workaround for the problem, even if it didn't work out for me. – Rook May 17 '17 at 12:18

score 2 · Answer 2 · answered May 08 '17 at 11:16

B and A cannot be deduced in B(func)(A) from lambda.

You might change your template to be more generic, something like:

template <template <typename...> class Container, typename Ts...>
auto transform(const Container<Ts...>& c, F f)
-> Container<std::decay_t<decltype(f(*c.begin())>>
{
    return {};
}

Template argument deduction from lambda

2 Answers2