Best way to have a function return py::bytes or py::none

[BenBE]

I have a function that does some conversion of its input arguments:

#include <cstdint>
#include <string>
#include <vector>

#include <pybind11/pybind11.h>
#include <pybind11/pytypes.h>
#include <pybind11/stl.h>

#include "lib/foo.h"

namespace py = pybind11;

namespace glue {
py::bytes foo(py::bytes input) {
    const std::string instr(input);
    size_t outsize = instr.size(); // Plus some processing … (checked in ::internal_foo)
    std::vector<char> buf(outsize, 0);

    bool result = ::internal_foo(instr.data(), instr.size(), buf.data(), &outsize);
    if (result) {
        return py::bytes(buf.data(), outsize);
    } else {
        return py::bytes(); // Should actually return py::none
    }
}
}

PYBIND11_MODULE(foo_module, m) {
    m.doc() = "Foo functions";

    m.def("foo", &glue::foo, "Process foo data");
}

The current version works™, but as an empty array is a valid return value from ::internal_foo I'd like to return bytes on success, but None on failure. AFAIC I could use std::optional<py::bytes>, but this would require at least C++14 (if using std::experimental::optional<>), which I'd like to avoid.

As far as I understand it right now, I could do this by changing the return type to py::object, but this would change the generated docstring to indicate the return type as any (???), which is not what I intent for it. On the other hand, if I leave the realms of C++11, I could mark the return value as std::optional<py::bytes>, which should (in theory???) indicate the return value correctly to be py::bytes or None.

Is there some way to both properly indicate this py::bytes vs. None return value (in the docstring), allowing for empty py::bytes (zero-sized) being returned, and still have a sane/descriptive C++11 return type?

NB: py::bytes is intentional as the internal function operates on binary data blobs.

[BenBE]

Changing to py::bytes* foo(py::bytes input) (explicit pointer) allows to properly return nullptr to encode None, but the produced function signature is off (only showing foo(input: bytes) -> bytes, instead of the expected foo(input: bytes) -> bytes | None/foo(input: bytes) -> Optional[bytes]).

[VelocityRa]

Bump? It's been 3 years.

Pointers in C can be null. Seems rather a basic aspect to support.
In C++ people often rely on that and intentionally choose pointers over references for that specific purpose.
Why don't pybind types reflect this (even as an option)?

Not to mention std::function and other STL types that can be empty.

Relevant issue: #3175

[Lamarqe]

3 years later.
So expecting user to switch to C++14 nowadays is a equal to use C++11 in 2021. Go with std::optional...