Allow implicit conversion from result<T, E> to result<void, E>

[an-inconspicuous-semicolon]

I was making a project using the results, and its working fantastic so far. However, since my project is a library and I don't want to "expose" third party code to the client, so I use macros for certain types.

result happens to be one of these types, and because it is a template that requires a generic case, I have a macro called VEN_RESULT which looks like this

#define VEN_RESULT external::cpp::result<void, VEN_ERROR>
#define VEN_RESULT_TYPED(type) external::cpp::result<type, VEN_ERROR>

auto may_fail(int x) -> VEN_RESULT_TYPED(int);

but since I don't want the client (or me), to use the VEN_RESULT_TYPED if they only care if a function succeeds or not. so they can use VEN_RESULT instead.

Now the problem. There is no implicit conversion from result<T, E> to result<void, E> which means that I have to write calls to the function as follows:

 VEN_RESULT result = VEN_RESULT(may_fail(5));
or
 auto result = may_fail(5); // Is no longer generic
or
 auto result = VEN_RESULT(may_fail(5)); // a bit better, but would like the type on the left

The solution for this would be to allow implicit conversion in the result class to result<void, E>

doing this is simple, its just changing a couple of definitions to remove explicit

If this is done, the code above could be written as:

VEN_RESULT result = may_fail(5); // looks much cleaner now

which I think is cleaner and easier to read.

[operator-name]

Implicit discarding seems a bit odd in my opinion, is there a reason you aren't map/flat_mapping the result type to void?

I've also found a section in the tutorial: https://github.com/bitwizeshift/result/blob/master/doc/tutorial.md#type-erasure-with-resultvoide

Note: Erasure with result<void,E> requires explicit construction for both construction and assignment, since result<void,E> is meant to model the behavior and semantics of a void cast, which requires explicitness.

[an-inconspicuous-semicolon]

The reason I am not mapping the result type to void is that I use a void result in a macro when calling a non void function so often that I feel that there should be a shorter way to discard the type.

I also don't see a downside of allowing implicit conversions to result<void, E>. Since we can remove the explicit in the partial specialization only, which will allow going from a type to void, but not back.

To keep consistency with current code, a macro could be introduced that is set to use explicit by default, which can then be disabled by a client. I see this as the best of both worlds as then it is up to the user of the code to decide whether they want to be able to use implicit conversions or not.