User-defined deduction guide for lambda

Question

today I'm struggling with C++ templates. This is my simple code for convenient exception handling in JNI code.

template<typename T>
std::optional<T> handleNativeCrash(JNIEnv *env, std::function<T(void)> f) {
    try {
        return std::optional<T>(f());
    }
    catch (const std::exception &e) {
        jniThrowException(env, e.what());
        return {};
    }
}

When I try to use it without specifying T, Clang fails roughly with this error

no matching function for call to 'handleNativeCrash'
      return my_namespace::handleNativeCrash(env, [&]{
             ^~~~~~~~~~~~~~~~~~~~~
  /......../jni.cpp:116:39)'
      std::optional<T> handleNativeCrash(JNIEnv *env, std::function<T(void)> f) {
                       ^
  1 error generated.

I would like to infer T automatically from lambda return type. I tried to write deduction guide, but it seems that I'm unable to write it for global function. I tried to create simple template struct which contained only this function, but I failed too. It seems I don't really understand C++ template metaprogramming.

My first attempt was like this, but Clang just crashed complaining about illegal syntax and printing it's backtrace. I will report bug soon, but I need to finish this job first.

template<typename T>
handleNativeCrash(JNIEnv *env, std::function<T(void)> f) -> handleNativeCrash<decltype(f())>;

How can I achieve my goal?

A lambda is not a std::function. Better use a generic Callable type. — Fureeish
– Fureeish, Commented Feb 1, 2019 at 12:43
About your clang crash: clang is right it's illegal (missing auto), wrong to crash. — YSC
– YSC, Commented Feb 1, 2019 at 12:49

YSC · Accepted Answer · 2019-02-01 12:43:12Z

9

You cannot use template deduction for that, it's not smart enough and only works on matching.

But you can manually infer it:

template<class Callable>
auto handleNativeCrash(JNIEnv *env, Callable f)
-> std::optional<decltype(f())>
{
    try {
        return f();
    }
    catch (const std::exception &e) {
        jniThrowException(env, e.what());
        return {};
    }
}

Simplified live demo

answered Feb 1, 2019 at 12:43

YSC

40.4k11 gold badges103 silver badges160 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Deduplicator Over a year ago

Why not use automatic return-type-deduction? Do you actually want to use SFINAE?

YSC Over a year ago

@dedup that's an option but basically I didn't want to hide the return type (an noptional) inside the function impl.

Werner Henze · Accepted Answer · 2019-02-02 14:11:56Z

0

The problem is that a lambda can be converted to a std::function but isn't a std::function.

So the T type can't be deduced because you don't have a std::function and a std::function can't be obtained because you don't know T.

A sort of chicken and egg problem.

So you have to pass a std::function to handleNativeCrash()

return my_namespace::handleNativeCrash(env, std::function{[&]{/*...*/}});

or you have to receive a generic callable as in YSC answer or, by example, something as follows (thanks to Holt for pointing my original error):

template <typename R = void, typename F,
          typename T = std::conditional_t<std::is_same_v<void, R>,
                          decltype(std::declval<F>()()), R>>
std::optional<T> handleNativeCrash(JNIEnv *env, F f) {
    try {
        return std::optional<T>(f());
    }
    catch (const std::exception &e) {
        jniThrowException(env, e.what());
        return {};
    }
}

The YSC solution (detecting returned type using decltype() in trailing return type) impose the type returned by the functional; using additionals (with default values) template parameters permit also to "hijack" the returned type explicating it.

Suppose you have a l lambda that return an int but you want a std::optional<long>, you can write something as

return my_namespace::handleNativeCrash<long>(env, l);

edited Feb 2, 2019 at 14:11

Werner Henze

16.8k12 gold badges47 silver badges70 bronze badges

answered Feb 1, 2019 at 12:47

max66

67k11 gold badges76 silver badges121 bronze badges

2 Comments

Holt Over a year ago

You cannot put T before F since the default value for T depends on F so you cannot specify only long in your last example.

max66 Over a year ago

@Holt - D'oh! You're right. I have to make it a little more complicated. Corrected; thanks.

Collectives™ on Stack Overflow

User-defined deduction guide for lambda

2 Answers 2

2 Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related