Let’s recount you are looking for to jot down an algorithm that given any range returns the first element in it (the purpose right here isn’t explicit to Ranges, however Ranges does obtain for fair exact, familiar examples). If we now obtain a precondition that the diversity is no longer empty, we are able to also write that algorithm this fashion:

template 
constexpr auto front(R&& r) -> ranges::range_reference_t {
    return *ranges::originate up(r);
}

Now, despite the name, the reference form of a range need no longer in fact be a language reference. If I passed in a vector, I’d get abet an int& that refers back to the first element. But if I passed in one thing esteem views::iota(0, 10), I’d get abet an int (no longer a reference) with cost 0.

Let’s recount as an different of getting a precondition that the diversity is non-empty, I are looking for to handle that case too. I are looking for to jot down a total feature as an different of a partial feature. The very most realistic blueprint to acquire that is both return some cost (if I will) or no cost (if I will’t). That’s an no longer compulsory, that’s what it’s for: to handle returning one thing or nothing.

The style to spell that is:

template 
constexpr auto try_front(R&& r)
    -> no longer compulsory>
{
    auto first = ranges::originate up(r);
    auto closing  = ranges::end(r);
    if (first != closing) {
        return *first;
    } else {
        return nullopt;
    }
}

This would return an no longer compulsory for the views::iota case, which is okay. However it can presumably per chance per chance strive to return an no longer compulsory for the vector case, since the reference kind is int& there. This doesn’t work with std::no longer compulsory.

Now, the argument goes that we don’t need no longer compulsory to exist because of we now obtain int*. So let’s strive to metaprogram our blueprint out of this box:

template 
the expend of workaround = conditional_t<
    is_reference_v,
    add_pointer_t, // add_pointer_t is intoptional>;

template 
constexpr auto try_front(R&& r)
    -> workaround>
{
    auto first = ranges::originate up(r);
    auto closing  = ranges::end(r);
    if (first != closing) {
        return *first;
    } else {
        return {};
    }
}

Does this work? No, it doesn’t.

Initially there’s the shriek that it’s doable that even spelling no longer compulsory is sick-shaped (which I mediate it is allowed for the implementation to acquire). So the categorical implementation of workaround would need to be more complicated, however let’s favorable ignore that piece.

The motive that this doesn’t work is that int* in fact has many tremendously varied semantics from no longer compulsory, and a form of importantly varied semantics is: building. An no longer compulsory may presumably per chance per chance be constructible from an lvalue of kind int, however an int* is no longer – pointers require explicit building syntax, whereas references obtain implicit building syntax.

In uncover to return an int* for the vector case, I will’t obtain *originate up(v), I in fact must obtain &*originate up(v). But I will’t obtain that for the views::iota trigger, because of there dereferencing the iterator supplies me a prvalue. There I obtain must obtain *originate up(v).

Meaning the true implementation would must behold more esteem:

template 
the expend of workaround = mp_eval_if_c<
    is_reference_v,
    add_pointer_t,
    optional, T>;

template 
constexpr auto try_front(R&& r)
    -> workaround>
{
    auto first = ranges::originate up(r);
    auto closing  = ranges::end(r);
    if (first != closing) {
        if constexpr (std::is_reference_v>) {
            return &*first;
        } else {
            return *first;
        }
    } else {
        return {};
    }
}

Here’s already, I mediate, in fact pretty unpleasant.

Now let’s strive to make expend of it! If I are looking for to deal with the first element in a range or provide a default cost to handle the empty case (which is a extraordinarily classic thing to are looking for to acquire, take note what number of cases you’ve presumably accomplished this in the case of scheme lookup the set you’ve gotten it == m.end() ? one thing : it->2nd), I could presumably per chance per chance strive to jot down:

int cost = try_front(r).value_or(-1);

And that works. For the views::iota case anyway, since try_front(views::iota(~)) will give me an no longer compulsory.

But passing in a vector right here received’t bring together, because of we made that case return an int* as an different of an no longer compulsory and there’s now not always a value_or member on a pointer (or, indeed, every other roughly member both). We’d wish to produce but every other workaround right here.

Which… we are able to. It’s no longer that onerous to jot down a non-member value_or that works for every no longer compulsory and T*:

template 
constexpr auto value_or(P&& ptrish, U&& dflt) {
    return ptrish ? *FWD(ptrish) : FWD(dflt);
}

And now we are able to as an different write:

int cost = N::value_or(try_front(r), -1);

Up to now, we’ve made ourselves obtain a worse implementation of try_front() in uncover to return T*, which in flip ended in a worse implementation of the utilization of try_front to handle the T* case. At this point you may presumably per chance per chance presumably bring up one thing esteem the pipeline operator (|>, which may presumably per chance well enable try_front(r) |> N::value_or(-1), which as a minimum has the identical form of the specified expression) or unified feature name syntax (which, if you clutch the genuine version, as a minimum helps you to jot down try_front(r).N::value_or(-1), assuming an excellent name is supported there). But we restful obtain the shriek the set we now must write our obtain value_or() which has to handle every no longer compulsory and T*.

Let’s behold at a varied instance. In my CppNow 2021 talk and again in my recent CPPP 2021 talk (video pending), I prove what the Rust iterator model appears to be like esteem if obtain been to place in force it in C++. In Rust, an Iterator is:

trait Iterator {
    kind Merchandise;
    fn subsequent(&mut self) -> Option;
}

which in C++20 ideas would translate into one thing esteem:

template 
thought rust_iterator = requires (I i) {
    // for some motive in my talks, I caught with the C++
    // naming of 'reference' right here as an different of as an different
    // the expend of the significantly higher name 'item_type'
    typename I::item_type;
    { i.subsequent() } -> same_as>;
};

And certainly one of the important examples that I show is put in force a scheme iterator (what in C++20 we name views::turn out to be), which appears to be like esteem this:

template  F>
struct map_iterator {
    I irascible;
    F func;

    the expend of item_type = invoke_result_t;

    auto subsequent() -> no longer compulsory {
        return irascible.subsequent().scheme(func);
    }
};

It’s possible you’ll presumably per chance per chance presumably look this in action in Tristan Brindle’s float library (the supreme disagreement there, out of doorways of the names of issues, is that his library has particular treatment for limitless ranges). This, to me, is a extraordinarily fine implementation that has a fine form of symmetry: scheme for iterators is conducted by blueprint of scheme for no longer compulsory.

Other than clearly, we don’t obtain no longer compulsory – which is in fact important to acquire in this model. It’s no longer favorable important to shield a long way from copying objects that you just favorable are looking for to iterate over, however semantically it will also very wisely be important that you just focus on with that T as an different of merely some T. So all people knows already that we now must switch our uses of no longer compulsory (every in the thought and in the implementation of map_iterator) to make expend of workaround as an different. But favorable esteem T* didn’t obtain a value_or member feature, it also does no longer esteem a scheme member feature.

And so, again, we are able to also write a workaround for that (the set we again must be cautious about the more than a few kinds of building that we now must obtain):

template 
constexpr auto scheme(P&& ptrish, F f)
{
    the expend of U = decltype(invoke(f, *FWD(ptrish)));
    the expend of Ret = workaround;

    if (ptrish) {
        if constexpr (is_reference_v) {
            return &invoke(f, *FWD(ptrish));
        } else {
            return Ret(invoke(f, *FWD(ptrish)));
        }
    } else {
        return Ret();
    }
}

template  F>
struct map_iterator {
    I irascible;
    F func;

    the expend of item_type = invoke_result_t;

    auto subsequent() -> workaround {
        return scheme(irascible.subsequent(), func);
    }
};

template 
void f(vector& v) {
    for (auto& elem : v) {
        // expend elem
    }
}

template 
auto scheme(no longer compulsory, F) -> no longer compulsory>

template 
auto scheme(no longer compulsory, F)     -> workaround>

template 
auto scheme(optional_ref, F) -> workaround>