Feature req: parse_error and write_error convertible to std::error_code

[jbbjarnason]

It would be really nice to being easily transposable to std::error_code, for example a member function of a class/struct:

  auto from_string(std::string_view value) -> std::error_code {
    return glz::read_json<storage_t>(storage_, value);
  }

[stephenberry]

This is a nice suggestion, but I'm not sure its the best idea.
For one, std::error_code is 16 bytes:
static_assert(sizeof(std::error_code) == 16);
There are potential performance implications to using std::error_code due to its size. Probably negligible, but needs to be tested.

[stephenberry]

We could make glaze's error code convertible to std::error_code. But, I'd need some more motivation as to why this is so helpful. I'd rather not add <system_error> to our include requirements for all users. I think it might be a conversion that users should add if needed.

[jbbjarnason]

@stephenberry The use case I am thinking of is boost asio, but it could me made in user code like you mention or a separate header which would provide the conversions.

For example (https://github.com/stephenberry/glaze/blob/main/include/glaze/ext/glaze_asio.hpp),

struct asio_client {
// ...

auto async_call(const repe::header& header, Params&& params, auto&& completion_token) {
enum struct state_e : std::uint8_t { send, receive, complete };
return asio::async_compose([this, buff = std::string{}, state = state_e::send, &header, &params](auto& self, std::error_code socket_err = {}, std::size_t bytes_sent = {}) mutable {
  using namespace repe; 
  if (socket_err) {
    self.complete(socket_err, {});
    return;
  } 
  if (state == state_e::send) {
    state = state_e::receive;  
    request<Opts>(header, std::forward<Params>(params), buffer);
    async_send(socket, buff, std::move(self));
    return;
  }
  if (state == state_e::receive) {
    state = state_e::complete;
    async_receive(socket, buff, std::move(self));
    return;
  }
  
  Result result{};
  auto glz_err{ decode_response<Opts>(result, buff); };
  self.complete(result, std::error_code(glz_err));

}, completion_token);

}

};

// when using

asio_client my_client{};

my_client.async_call(header, params, [](
std::error_code err /*can be socket error or glaze error, different category */, Result result) {
});

[stephenberry]

Thanks for the example. I will keep this in mind as we continue to develop the REPE code.