std::optional::value_or() - lazy argument evaluation

Question

Is it possible to evaluate std::optional::value_or(expr) argument in a lazy way, so the expr were calculated only in the case of having no value?

If not, what would be a proper replacement?

score 25 · Answer 1 · answered Aug 05 '18 at 15:56

25

#include <optional>

template <typename F>
struct Lazy
{
    F f;  

    operator decltype(f())() const
    {
        return f();
    }
};

template <typename F>
Lazy(F f) -> Lazy<F>;

int main()
{
    std::optional<int> o;

    int i = o.value_or(Lazy{[]{return 0;}});
}

DEMO

answered Aug 05 '18 at 15:56

Piotr Skotnicki

46,953
7
118
160

4

What kind of construct is `template Lazy(F f) -> Lazy;` ? It looks like a forward declaration of a function template with trailing return type, but it isn't... – Ben Voigt Aug 05 '18 at 21:09
9

@BenVoigt it's a template deduction guide – Piotr Skotnicki Aug 05 '18 at 21:22
3

`operator decltype(auto)() const` is nicer IMO (less parens). :) – Rakete1111 Aug 05 '18 at 23:34
3

@Rakete1111 oh god this breaks my brain... "Hey here's a conversion for... um... well we'll see!" – Quentin Aug 06 '18 at 08:11
2

@Rakete1111 There's also `operator invoke_result_t()` – Barry Aug 06 '18 at 13:20

Matteo Italia · Answer 2 · 2018-08-05T22:21:02.817

11

You may write your helper function:

template<typename T, typename F>
T lazy_value_or(const std::optional<T> &opt, F fn) {
    if(opt) return opt.value();
    return fn();
}

which can then be used as:

T t = lazy_value_or(opt, [] { return expensive_computation();});

If that's significantly less typing than doing it explicitly that's up to you to judge; still, you can make it shorter with a macro:

#define LAZY_VALUE_OR(opt, expr) \
    lazy_value_or((opt), [&] { return (expr);})

to be used as

T t = LAZY_VALUE_OR(opt, expensive_calculation());

This is closest to what I think you want, but may be frowned upon as it hides a bit too much stuff.

edited Aug 05 '18 at 22:21

answered Aug 05 '18 at 15:26

Matteo Italia

123,740
17
206
299

3

"you can ease this up with some macros" - please don't advocate the use of macros. – Jesper Juhl Aug 05 '18 at 15:38
16

@JesperJuhl just like `goto`, macros are a tool and have their place, even in modern C++; demonizing them tout court, as for any "absolute" judgment, is wrong and shortsighted. This case is a bit borderline, as it hides quite some stuff (and I even warned about this), but that's up to OP to judge. – Matteo Italia Aug 05 '18 at 15:47
2

They are a tool in the toolbox, sure. And they have their uses. But, I don't think we should go around advocating their use since *most* use of macros is bad or inappropriate - *most* things can be done better without the use of macros. So yes, they exist. They serve a purpose. Just don't mention them unless they are the last and *only* resort (IMHO). – Jesper Juhl Aug 05 '18 at 15:52
1

As a naming note, some languages (e.g. Rust) call this `value_or_else`. – Barry Aug 05 '18 at 21:09

Robert Andrzejuk · Answer 3 · 2018-08-05T15:44:50.920

0

Make an optional of function type.

Then a lambda can be passed in, which when called will calculate the correct value at the requested moment.

std::optional<std::function<int()>> opt;

int a = 42;
opt = [=] { return a; }

int b = 4;

int c = opt.value_or([=] { return b * 10 + 2;}) ();

edited Aug 05 '18 at 15:44

answered Aug 05 '18 at 15:28

Robert Andrzejuk

5,076
2
22
31

std::optional::value_or() - lazy argument evaluation

3 Answers3

Linked