Return values from auto function

[James Blachly]

On 11/6/20 5:51 AM, Andrey Zherikov wrote:
> I have auto function 'f' that might return either an error (with some 
> text) or a result (with some value). The problem is that the type of the 
> error is not the same as the type of result so compilation fails.
> 
...
> How can I make the original code compilable without templatizing 
> `failure` function?

Paul Backus has already replied to you so I am surprised he did not plug 
is own package "SumType". Maybe it is modesty? This seems like an ideal 
time to use this.

All of that being said, I tried to solve this for you using Paul's 
SumType package and myself was initially stymied by the fact that the 
implicit conversion of a `Success(T)` or `Failure` type did not work 
within the ternary op expression*. I rewrote it with if/else which works 
great and is only slightly more verbose than with ternary op.

```D
alias Result = SumType!(Success!int, Failure);

auto f(int i)
{
     Result retval;
     if (i > 0)
         retval = Success!int(i);
     else
         retval = Failure("Sorry!");
     return retval;
}
```

the above relies on suitable definition of `Success(T)` and `Failure` 
structs, obviously.

* This fails due to different types within the same expression:

```
retval = i > 0 ? Success!int(i) : Failure("Sorry");
```

casting each to `Result` compiles, but is verbose:

```
     return i > 0 ? cast(Result) Success!int(i) : cast(Result) 
Failure("Sorry");
```

** Could someone more knowledgeable than me explain why implicit 
conversion does not happen with the ternary op, but works fine with 
if/else? Presumably, it is because the op returns a single type and 
implicit conversion is performed after computing the expression's return 
type? If this somehow worked, it would make the SumType package much 
more ergonomic **