A simple C# implementation of a Result Pattern

Result.cs

using System;
using System.Threading.Tasks;

namespace Rbit.Application.Common;

public class Result<TValue, TError> : IHaveError<TError>
{
    public TValue? Value { get; }
    public TError? Error { get; }

    public bool IsSuccess => !IsFailure;

    public bool IsFailure { get; }

    private Result(TValue value)
    {
        Value = value;
        Error = default;
        IsFailure = false;
    }

    private Result(TError error)
    {
        IsFailure = true;
        Value = default;
        Error = error;
    }

    public static IHaveError<TError> WithFailure(TError error) => new Result<TValue, TError>(error);

    public static Result<TValue, TError> Failure(TError error) => new(error);

    public static Result<TValue, TError> Success(TValue value) => new(value);

    public TFinal Match<TFinal>(Func<TValue, TFinal> onSuccess, Func<TError, TFinal> onFailure) =>
        IsSuccess ? onSuccess(Value!) : onFailure(Error!);

    public async Task<Result<TNewValue, TError>> Map<TNewValue>(Func<TValue, Task<Result<TNewValue, TError>>> mapper) =>
        IsSuccess ? await mapper(Value!) : new Result<TNewValue, TError>(Error!);

    public Result<TNewValue, TError> Map<TNewValue>(Func<TValue, Result<TNewValue, TError>> mapper) =>
        IsSuccess ? mapper(Value!) : new Result<TNewValue, TError>(Error!);
}

public interface IHaveError<in TError>
{
    static abstract IHaveError<TError> WithFailure(TError error);
}