Gfrktyl

I'm currently in the process of rewritting a http-client class. When it comes to the error-handling I see the three options:

1. Throwing an exception


2. Passing an error-type by reference


3. Returning a std::variant<SuccessType, ErrorType>
   

Given the following success / error types

struct HttpSuccess {

  int status;

  std::string body;

};

struct HttpError {

  std::string error_description;

};

The function signatures for each of the three cases would look roughly like the following

1. 
   HttpSuccess get(const std::string& uri); (HttpErrror would inerhit from an exception type in this case)


2. 
   HttpSuccess get(const std::string& uri, HttpError& error) (also std::optional<HttpError>& error possible)


3. std::variant<HttpSuccess, HttpError> get(const std::string& uri)

Here is my reasoning why I dislike option 1 + 2:

1. Since errors are to be expected (timeouts, internet hiccups etc), I don't want to use 1. The errors the client is dealing with are no execptions semantically.


2. There is for me no way to ensure that the error-type is properly queried (afaik google uses rules to ensure this behaviour). So users might skip the error and proceed with the garabge return type.

This reasoning alone leaves me with option 3. The upsides that I see are the following:

1. I can introduce different error categories easily (failure to contact the a server might be represented by a different error type than a server response error e.g.)


2. Enforces error checking (with an admitably somewhat akward use of std::visit) but establishes reasoning about the error behaviour


3. Allows for HttpSuccess to be non-default constructible which might be relevant in cases where a complex server response is deserialized before passing it on to the client.

The downsides that I see are mainly:

1. More complex code on the library consumer side


2. Overhead in the non-error case due to variant wrapper

However, all-in-all the third approach feels quite unidiomatic. Are there any opinions by the experts on whether any of the approaches is superior to the others?