Improved error handling with a Result class

[marinasundstrom]

Background

Half a year ago I discovered this programming language called Beef. In essence, it is a programming language that targets native code, and that borrows heavily on C#, but with some improvements. The base class library has been made to look like .NET:s. Namespaces and classes are largely named the same. It even has got Reflection-support!

Idea

One of the ideas that got me interested was their method of handling errors: Result enum ([docs] (Enums are different in Beef). The designers opted to follow this pattern instead of exceptions.

The consequence is that method returns an object that then can be pattern matched for the result.

Here is an example taken from the docs:

Since result is an enum, the type can be inferred, simply by .value. And enums may take args.

static Result<uint> GetMinusOne(uint i)
{
    if (i == 0)
        return .Err;
    return .Ok(i - 1);  
}

void Use()
{
    /* Handle result via a switch */
    switch (GetMinusOne(i))
    {
        case .Ok(let newVal): Console.WriteLine("Val: {}", newVal);
        case .Err: Console.WriteLine("Failed");
    }

    /* This invokes an implicit conversion operator, which will be fatal at runtime if an error is returned */
    int newVal = GetMinusOne(i);

    /* Result<T> contains a special "ReturnValueDiscarded" method which is invoked to facilitate failing fatally on ignored returned errors here */
    GetMinusOne(i);
}

Questions

• Can this be implemented in C# without any additions to the language?
  • Enums behave differently in Beef.

Enum in Beef (Data types):

They are more like discriminated unions.

enum Shape
{
    case None;
    case Square(int x, int y, int width, int height);
    case Circle(int x, int y, int radius);
}
Shape drawShape = .Circle(10, 20, 5);
...
switch (drawShape)
{
case .None:
case .Square(let x, let y, let width, let height): DrawSquare(x, y, width, height);
case .Circle(let x, let y, let radius): DrawCircle(x, y, radius); 
}
....
if (drawShape case .Square)
    Console.WriteLine("We drew a square");

[svick]

Can this be implemented in C# without any additions to the language?

It wouldn't be nearly as nice, because of limitations of C# type inference. You could fairly easily create a type like Result<T>, and even use deconstruction to make switch work. But the problem is, you would have to repeat the type T a lot, and your example code would look something like this:

static Result<uint> GetMinusOne(uint i)
{
    if (i == 0)
        return new Err<uint>();
    return new Ok<uint>(i - 1);  
}

void Use(uint i)
{
    /* Handle result via a switch */
    switch (GetMinusOne(i))
    {
        case Ok<uint>(var newVal): Console.WriteLine("Val: {}", newVal); break;
        case Err<uint>: Console.WriteLine("Failed"); break;
    }
}

In general, I think attempting to bolt a second error-handling mechanism onto a language that already has one is not worth it.

I think your Shape example would work much better, except for all the boilerplate code required to define discriminated unions in current C#. (That's not a problem for Result<T>, since that's a type that you define only once in a library, whereas you could have many Shape-like types.) Though there is a good chance C# will have explicit support discriminated unions in the near future, see #113.

[huoyaoyuan]

Result-based error handling isn't "better" than exception. It's just an alternative.