I'm really enjoying the concept of discriminated unions, but I'm thinking perhaps my understanding of OneOf's implementation is somewhat lacking. In my codebase, I have implemented OneOf in several packages that are common between projects. Some consuming classes have dependencies on more than one of these common packages, and each one returns relevant types in each their public methods. In multiple places in my codebase now, I'm having to implement conditional checking using IsTn because it's no longer semantically possible to use Match or Switch. I've prepared a (very much simplified) example:

    public class OneOfExample
    {
        public OneOf<NotFound, Error, Expired, Success> PerformSomeActionOrOther(string id)
        {
            OneOf<NotFound, B2CUser> getUserResult = GetUser(id);
            if (getUserResult.IsT0)
            {
                return getUserResult.AsT0;
            }

            B2CUser user = getUserResult.AsT1;
            user.AccountEnabled = true;
            user.RequiresMigration = false;

            OneOf<Error, Success> updateResult = UpdateUser(user);
            if (updateResult.IsT0)
            {
                return updateResult.AsT0;
            }

            return updateResult.AsT1;
        }

        private OneOf<NotFound, B2CUser> GetUser(string id)
        {
            B2CUser? user = ExternalRepository.GetUser(id);
            if (null == user)
            {
                return new NotFound();
            }

            return user;
        }

        private OneOf<Error, Success> UpdateUser(B2CUser user)
        {
            bool updated = ExternalRepository.UpdateUser(user);

            return updated ? new Success() : new Error();
        }
    }

Here we can see that the return values from the three methods are unique. Even if it made sense to do so, return getUserResult won't compile because OneOf<NotFound, B2CUser> does not match OneOf<NotFound, Error, Expired, Success>. But because I need to return early, it means I have to use TryPickn or IsTn, as shown in this example.

In my real codebase, due to the nature of the dependencies and their possible return types, this has led to an explosion of conditional returns that visually pollute the codebase and make it less readable.

So, my question is... Is there something I am missing, some concept or feature that would simplify my multitude of conditions? Or is this just a price of using discriminated unions in a statically-typed language?