Caveat using Option<T>.Case (object)

[StefanBertels]

I stumbled upon a problem while using Option<T>.Case

This feature was changed (returns object) in https://github.com/louthy/language-ext/releases/tag/v3.5.24-beta.

Look at this test:

var x = Some(("test", 42));
// ...
var y = x.Case is (string a, int b) ? a + b : "oh no";
Assert.Equal("test42", y);

This test will succeed. If you change the type of x, e.g. by adding another member code still compiles but test will fail:

var x = Some(("test", 42, "another info"));
// ...
var y = x.Case is (string a, int b) ? a + b : "oh no";
Assert.Equal("test42", y);

This is no suprise (different type => no match) but can cause undetected bugs if you use generics / type inference or for other reasons change one code line and forget to change the other line, too. IMHO we should avoid the need to have two identical (matching) type definitions (kind of DRY).

Having object here is even worse because analyzers (IDE) have no chance to produce a warning.
Question: Is there a chance to improve here? Maybe using T? as return type for Option<T>.Case?
(Would be no option for Either etc.)

Should I void tuple types but declare custom types (classes/structs)? Any other idea/"solution"?

This is somewhat related to #939 (tuple matching).

[StefanBertels]

I built these extensions methods to help me avoid type errors like the error above:

    public static class Extensions1
    {
        public static L? LeftAsNullable<L, R>(this Either<L, R> either) where L : struct => either.MatchUnsafe<L?>(_ => null, _ => _);
        public static R? RightAsNullable<L, R>(this Either<L, R> either) where R : struct => either.MatchUnsafe<R?>(_ => _, _ => null);
    }

    public static class Extensions2
    {
        public static T? ToNullable<T>(this Option<T> maybe) where T : class => maybe.Case is T some ? some : null;
        public static L? LeftAsNullable<L, R>(this Either<L, R> either) where L : class => either.MatchUnsafe<L?>(_ => null, _ => _);
        public static R? RightAsNullable<L, R>(this Either<L, R> either) where R : class => either.MatchUnsafe<R?>(_ => _, _ => null);
    }    

Replacing .Case by these alternative methods obviously won't work with switch but at least can give type safety for if / ternary operator.