Modern C++ - how to implement FirstOrDefault with std::optional and references - c++

Question

I've picked up C++ again after spending years with C# and Javascript/Typescript.
I've gotten very used to writing code that manipulates and queries containers with algorithms, such as:
C#
var mocData = Enumerable.Range(0, 100)
.Where(n => n % 2 == 1)
.Select(n => new Item(n))
.ToList();
Javascript (using Lodash <3 )
const mocData = _.chain(_.range(0, 100))
.filter(n => n % 2 == 1)
.map(n => ({ n: `Item #${n}` }))
.value();
Now, C++ is a very different beast and what I'm trying to do, without much success (from a clean syntax/low verbosity point of view), is write a wrapper for STL's functions that allow me to work on items inside the container, instead of their copies, using value semantics, while also accounting for "nullability (ie std::optional wrapped values). For example, a find function if quite easy to write if you don't care about nullability. Here is how I want to use it, and how it is implemented:
template<typename T, typename Predicate>
auto find(const std::vector<T>& items, Predicate pred) -> T& {
auto it = std::find_if(items.begin(), items.end(), pred);
if (it == items.end()) {
throw std::runtime_error{ "Sequence contains no matching elements." };
}
return *it;
}
std::vector<MyClass> items = { ... };
const auto& item = find(items, [](const MyClass& o) { return o... });
++item.count; // Modifies the item inside of the container
Now, if I wanted to account for nullability, as in C# or javascript:
C#
var item = items.FirstOrDefault(o => o...);
item?.DoSomething();
Javascript
const item = _.find(items, o => o...);
item?.doSomething();
I have to use, in C++, std::optional. And to avoid a copy (so as to be able to modify the item in the container!!), I have to return std::optional. But std::optional can't be used with T& directly, so I have to use std::reference_wrapper as its type:
template<typename T>
using Ref = std::reference_wrapper<T>;
template<typename T, typename Predicate>
auto firstOrDefault(std::vector<T>& vec, Predicate pred) -> std::optional<Ref<T>> {
auto it = std::find_if(vec.begin(), vec.end(), pred);
if (it == vec.end()) {
return std::nullopt;
}
return std::ref(*it);
}
Now, the ugly part is using the returned value:
const auto item = firstOrDefault(items, predicate...);
if (item.has_value()) {
item
.value() // unwrap the ref from std::optional
.get() // unwrap T& from std::reference_wrapper<T>
.do_something() // jeeeez so hard to use it!!
}
I know I could use pointers, and that there's nothing bad with using non owning pointers as references, maybe using the C++ Core Guidelines's type... but references were made for maintaining value semantics, and I'd like to use them even though they don't play well with containers and wrappers in the STL.
Is there a good way to achieve this?
EDIT: I've modified the title to better express that I do not want a LINQ-like library, I'm trying to understand if with modern C++20 it is possible to work with nullability and references (not pointers) with a decent syntax.